Skip to content

L
linux-davinci
Commit 0b65d3cc authored by Lior Dotan's avatar Lior Dotan Committed by Greg Kroah-Hartman
Browse files
Options

Staging: Fixes for me4000 pci data collection driver 

Following Andrew Morton's review for this patch I made a patch that
fixes most of the remarks.
I've converted the sleep_on_timeout to wait_event_timeout but I
probably not in the right way.
Also I don't know what's the problem with the calls for get_user() so
I left them untouched.
Signed-off-by: default avatarLior Dotan <liodot@gmail.com>
Cc: Andrew Morton <akpm@linuxfoundation.org>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent b4c0ed11
Show whitespace changes
Inline Side-by-side
Showing with 545 additions and 545 deletions
drivers/staging/me4000/me4000.c
View file @ 0b65d3cc
......@@ -25,24 +25,21 @@
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/unistd.h>
#include <linux/list.h>
#include <linux/proc_fs.h>
#include <linux/types.h>
#include <linux/poll.h>
#include <linux/vmalloc.h>
#include <linux/slab.h>
#include <asm/pgtable.h>
#include <asm/uaccess.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
/* Include-File for the Meilhaus ME-4000 I/O board */
#include "me4000.h"
......@@ -57,14 +54,14 @@ MODULE_SUPPORTED_DEVICE("Meilhaus ME-4000 Multi I/O boards");
MODULE_LICENSE("GPL");
/* Board specific data are kept in a global list */
LIST_HEAD(me4000_board_info_list);
static LIST_HEAD(me4000_board_info_list);
/* Major Device Numbers. 0 means to get it automatically from the System */
static int me4000_ao_major_driver_no = 0;
static int me4000_ai_major_driver_no = 0;
static int me4000_dio_major_driver_no = 0;
static int me4000_cnt_major_driver_no = 0;
static int me4000_ext_int_major_driver_no = 0;
static int me4000_ao_major_driver_no;
static int me4000_ai_major_driver_no;
static int me4000_dio_major_driver_no;
static int me4000_cnt_major_driver_no;
static int me4000_ext_int_major_driver_no;
/* Let the user specify a custom major driver number */
module_param(me4000_ao_major_driver_no, int, 0);
......@@ -87,37 +84,23 @@ module_param(me4000_ext_int_major_driver_no, int, 0);
MODULE_PARM_DESC(me4000_ext_int_major_driver_no,
"Major driver number for external interrupt (default 0)");
/*-----------------------------------------------------------------------------
Module stuff
---------------------------------------------------------------------------*/
int init_module(void);
void cleanup_module(void);
/*-----------------------------------------------------------------------------
Board detection and initialization
---------------------------------------------------------------------------*/
static int me4000_probe(struct pci_dev *dev, const struct pci_device_id *id);
static int me4000_xilinx_download(me4000_info_t *);
static int me4000_reset_board(me4000_info_t *);
static int me4000_xilinx_download(struct me4000_info *);
static int me4000_reset_board(struct me4000_info *);
static void clear_board_info_list(void);
static int get_registers(struct pci_dev *dev, me4000_info_t * info);
static int init_board_info(struct pci_dev *dev, me4000_info_t * board_info);
static int alloc_ao_contexts(me4000_info_t * info);
static void release_ao_contexts(me4000_info_t * board_info);
static int alloc_ai_context(me4000_info_t * info);
static int alloc_dio_context(me4000_info_t * info);
static int alloc_cnt_context(me4000_info_t * info);
static int alloc_ext_int_context(me4000_info_t * info);
static void release_ao_contexts(struct me4000_info *board_info);
/*-----------------------------------------------------------------------------
Stuff used by all device parts
---------------------------------------------------------------------------*/
static int me4000_open(struct inode *, struct file *);
static int me4000_release(struct inode *, struct file *);
static int me4000_get_user_info(me4000_user_info_t *,
me4000_info_t * board_info);
static int me4000_get_user_info(struct me4000_user_info *,
struct me4000_info *board_info);
static int me4000_read_procmem(char *, char **, off_t, int, int *, void *);
/*-----------------------------------------------------------------------------
......@@ -140,40 +123,42 @@ static int me4000_ao_ioctl_cont(struct inode *, struct file *, unsigned int,
static unsigned int me4000_ao_poll_cont(struct file *, poll_table *);
static int me4000_ao_fsync_cont(struct file *, struct dentry *, int);
static int me4000_ao_start(unsigned long *, me4000_ao_context_t *);
static int me4000_ao_stop(me4000_ao_context_t *);
static int me4000_ao_immediate_stop(me4000_ao_context_t *);
static int me4000_ao_timer_set_divisor(u32 *, me4000_ao_context_t *);
static int me4000_ao_preload(me4000_ao_context_t *);
static int me4000_ao_preload_update(me4000_ao_context_t *);
static int me4000_ao_ex_trig_set_edge(int *, me4000_ao_context_t *);
static int me4000_ao_ex_trig_enable(me4000_ao_context_t *);
static int me4000_ao_ex_trig_disable(me4000_ao_context_t *);
static int me4000_ao_prepare(me4000_ao_context_t * ao_info);
static int me4000_ao_reset(me4000_ao_context_t * ao_info);
static int me4000_ao_enable_do(me4000_ao_context_t *);
static int me4000_ao_disable_do(me4000_ao_context_t *);
static int me4000_ao_fsm_state(int *, me4000_ao_context_t *);
static int me4000_ao_simultaneous_ex_trig(me4000_ao_context_t * ao_context);
static int me4000_ao_simultaneous_sw(me4000_ao_context_t * ao_context);
static int me4000_ao_simultaneous_disable(me4000_ao_context_t * ao_context);
static int me4000_ao_simultaneous_update(me4000_ao_channel_list_t * channels,
me4000_ao_context_t * ao_context);
static int me4000_ao_synchronous_ex_trig(me4000_ao_context_t * ao_context);
static int me4000_ao_synchronous_sw(me4000_ao_context_t * ao_context);
static int me4000_ao_synchronous_disable(me4000_ao_context_t * ao_context);
static int me4000_ao_start(unsigned long *, struct me4000_ao_context *);
static int me4000_ao_stop(struct me4000_ao_context *);
static int me4000_ao_immediate_stop(struct me4000_ao_context *);
static int me4000_ao_timer_set_divisor(u32 *, struct me4000_ao_context *);
static int me4000_ao_preload(struct me4000_ao_context *);
static int me4000_ao_preload_update(struct me4000_ao_context *);
static int me4000_ao_ex_trig_set_edge(int *, struct me4000_ao_context *);
static int me4000_ao_ex_trig_enable(struct me4000_ao_context *);
static int me4000_ao_ex_trig_disable(struct me4000_ao_context *);
static int me4000_ao_prepare(struct me4000_ao_context *ao_info);
static int me4000_ao_reset(struct me4000_ao_context *ao_info);
static int me4000_ao_enable_do(struct me4000_ao_context *);
static int me4000_ao_disable_do(struct me4000_ao_context *);
static int me4000_ao_fsm_state(int *, struct me4000_ao_context *);
static int me4000_ao_simultaneous_ex_trig(struct me4000_ao_context *ao_context);
static int me4000_ao_simultaneous_sw(struct me4000_ao_context *ao_context);
static int me4000_ao_simultaneous_disable(struct me4000_ao_context *ao_context);
static int me4000_ao_simultaneous_update(
struct me4000_ao_channel_list *channels,
struct me4000_ao_context *ao_context);
static int me4000_ao_synchronous_ex_trig(struct me4000_ao_context *ao_context);
static int me4000_ao_synchronous_sw(struct me4000_ao_context *ao_context);
static int me4000_ao_synchronous_disable(struct me4000_ao_context *ao_context);
static int me4000_ao_ex_trig_timeout(unsigned long *arg,
me4000_ao_context_t * ao_context);
struct me4000_ao_context *ao_context);
static int me4000_ao_get_free_buffer(unsigned long *arg,
me4000_ao_context_t * ao_context);
struct me4000_ao_context *ao_context);
/*-----------------------------------------------------------------------------
Analog input stuff
---------------------------------------------------------------------------*/
static int me4000_ai_single(me4000_ai_single_t *, me4000_ai_context_t *);
static int me4000_ai_single(struct me4000_ai_single *,
struct me4000_ai_context *);
static int me4000_ai_ioctl_sing(struct inode *, struct file *, unsigned int,
unsigned long);
......@@ -186,68 +171,69 @@ static int me4000_ai_fasync(int fd, struct file *file_p, int mode);
static int me4000_ai_ioctl_ext(struct inode *, struct file *, unsigned int,
unsigned long);
static int me4000_ai_prepare(me4000_ai_context_t * ai_context);
static int me4000_ai_reset(me4000_ai_context_t * ai_context);
static int me4000_ai_config(me4000_ai_config_t *, me4000_ai_context_t *);
static int me4000_ai_start(me4000_ai_context_t *);
static int me4000_ai_start_ex(unsigned long *, me4000_ai_context_t *);
static int me4000_ai_stop(me4000_ai_context_t *);
static int me4000_ai_immediate_stop(me4000_ai_context_t *);
static int me4000_ai_ex_trig_enable(me4000_ai_context_t *);
static int me4000_ai_ex_trig_disable(me4000_ai_context_t *);
static int me4000_ai_ex_trig_setup(me4000_ai_trigger_t *,
me4000_ai_context_t *);
static int me4000_ai_sc_setup(me4000_ai_sc_t * arg,
me4000_ai_context_t * ai_context);
static int me4000_ai_offset_enable(me4000_ai_context_t * ai_context);
static int me4000_ai_offset_disable(me4000_ai_context_t * ai_context);
static int me4000_ai_fullscale_enable(me4000_ai_context_t * ai_context);
static int me4000_ai_fullscale_disable(me4000_ai_context_t * ai_context);
static int me4000_ai_fsm_state(int *arg, me4000_ai_context_t * ai_context);
static int me4000_ai_prepare(struct me4000_ai_context *ai_context);
static int me4000_ai_reset(struct me4000_ai_context *ai_context);
static int me4000_ai_config(struct me4000_ai_config *,
struct me4000_ai_context *);
static int me4000_ai_start(struct me4000_ai_context *);
static int me4000_ai_start_ex(unsigned long *, struct me4000_ai_context *);
static int me4000_ai_stop(struct me4000_ai_context *);
static int me4000_ai_immediate_stop(struct me4000_ai_context *);
static int me4000_ai_ex_trig_enable(struct me4000_ai_context *);
static int me4000_ai_ex_trig_disable(struct me4000_ai_context *);
static int me4000_ai_ex_trig_setup(struct me4000_ai_trigger *,
struct me4000_ai_context *);
static int me4000_ai_sc_setup(struct me4000_ai_sc *arg,
struct me4000_ai_context *ai_context);
static int me4000_ai_offset_enable(struct me4000_ai_context *ai_context);
static int me4000_ai_offset_disable(struct me4000_ai_context *ai_context);
static int me4000_ai_fullscale_enable(struct me4000_ai_context *ai_context);
static int me4000_ai_fullscale_disable(struct me4000_ai_context *ai_context);
static int me4000_ai_fsm_state(int *arg, struct me4000_ai_context *ai_context);
static int me4000_ai_get_count_buffer(unsigned long *arg,
me4000_ai_context_t * ai_context);
struct me4000_ai_context *ai_context);
/*-----------------------------------------------------------------------------
EEPROM stuff
---------------------------------------------------------------------------*/
static int me4000_eeprom_read(me4000_eeprom_t * arg,
me4000_ai_context_t * ai_context);
static int me4000_eeprom_write(me4000_eeprom_t * arg,
me4000_ai_context_t * ai_context);
static unsigned short eeprom_read_cmd(me4000_ai_context_t * ai_context,
unsigned long cmd, int length);
static int eeprom_write_cmd(me4000_ai_context_t * ai_context, unsigned long cmd,
int length);
static int me4000_eeprom_read(struct me4000_eeprom *arg,
struct me4000_ai_context *ai_context);
static int me4000_eeprom_write(struct me4000_eeprom *arg,
struct me4000_ai_context *ai_context);
/*-----------------------------------------------------------------------------
Digital I/O stuff
---------------------------------------------------------------------------*/
static int me4000_dio_ioctl(struct inode *, struct file *, unsigned int,
unsigned long);
static int me4000_dio_config(me4000_dio_config_t *, me4000_dio_context_t *);
static int me4000_dio_get_byte(me4000_dio_byte_t *, me4000_dio_context_t *);
static int me4000_dio_set_byte(me4000_dio_byte_t *, me4000_dio_context_t *);
static int me4000_dio_reset(me4000_dio_context_t *);
static int me4000_dio_config(struct me4000_dio_config *,
struct me4000_dio_context *);
static int me4000_dio_get_byte(struct me4000_dio_byte *,
struct me4000_dio_context *);
static int me4000_dio_set_byte(struct me4000_dio_byte *,
struct me4000_dio_context *);
static int me4000_dio_reset(struct me4000_dio_context *);
/*-----------------------------------------------------------------------------
Counter stuff
---------------------------------------------------------------------------*/
static int me4000_cnt_ioctl(struct inode *, struct file *, unsigned int,
unsigned long);
static int me4000_cnt_config(me4000_cnt_config_t *, me4000_cnt_context_t *);
static int me4000_cnt_read(me4000_cnt_t *, me4000_cnt_context_t *);
static int me4000_cnt_write(me4000_cnt_t *, me4000_cnt_context_t *);
static int me4000_cnt_reset(me4000_cnt_context_t *);
static int me4000_cnt_config(struct me4000_cnt_config *,
struct me4000_cnt_context *);
static int me4000_cnt_read(struct me4000_cnt *, struct me4000_cnt_context *);
static int me4000_cnt_write(struct me4000_cnt *, struct me4000_cnt_context *);
static int me4000_cnt_reset(struct me4000_cnt_context *);
/*-----------------------------------------------------------------------------
External interrupt routines
---------------------------------------------------------------------------*/
static int me4000_ext_int_ioctl(struct inode *, struct file *, unsigned int,
unsigned long);
static int me4000_ext_int_enable(me4000_ext_int_context_t *);
static int me4000_ext_int_disable(me4000_ext_int_context_t *);
static int me4000_ext_int_enable(struct me4000_ext_int_context *);
static int me4000_ext_int_disable(struct me4000_ext_int_context *);
static int me4000_ext_int_count(unsigned long *arg,
me4000_ext_int_context_t * ext_int_context);
struct me4000_ext_int_context *ext_int_context);
static int me4000_ext_int_fasync(int fd, struct file *file_ptr, int mode);
/*-----------------------------------------------------------------------------
......@@ -260,27 +246,18 @@ static irqreturn_t me4000_ext_int_isr(int, void *);
/*-----------------------------------------------------------------------------
Inline functions
---------------------------------------------------------------------------*/
static int inline me4000_buf_count(me4000_circ_buf_t, int);
static int inline me4000_buf_space(me4000_circ_buf_t, int);
static int inline me4000_space_to_end(me4000_circ_buf_t, int);
static int inline me4000_values_to_end(me4000_circ_buf_t, int);
static void inline me4000_outb(unsigned char value, unsigned long port);
static void inline me4000_outl(unsigned long value, unsigned long port);
static unsigned long inline me4000_inl(unsigned long port);
static unsigned char inline me4000_inb(unsigned long port);
static int me4000_buf_count(me4000_circ_buf_t buf, int size)
static int inline me4000_buf_count(struct me4000_circ_buf buf, int size)
{
return ((buf.head - buf.tail) & (size - 1));
}
static int me4000_buf_space(me4000_circ_buf_t buf, int size)
static int inline me4000_buf_space(struct me4000_circ_buf buf, int size)
{
return ((buf.tail - (buf.head + 1)) & (size - 1));
}
static int me4000_values_to_end(me4000_circ_buf_t buf, int size)
static int inline me4000_values_to_end(struct me4000_circ_buf buf, int size)
{
int end;
int n;
......@@ -289,7 +266,7 @@ static int me4000_values_to_end(me4000_circ_buf_t buf, int size)
return (n < end) ? n : end;
}
static int me4000_space_to_end(me4000_circ_buf_t buf, int size)
static int inline me4000_space_to_end(struct me4000_circ_buf buf, int size)
{
int end;
int n;
......@@ -299,19 +276,19 @@ static int me4000_space_to_end(me4000_circ_buf_t buf, int size)
return (n <= end) ? n : (end + 1);
}
static void me4000_outb(unsigned char value, unsigned long port)
static void inline me4000_outb(unsigned char value, unsigned long port)
{
PORT_PDEBUG("--> 0x%02X port 0x%04lX\n", value, port);
outb(value, port);
}
static void me4000_outl(unsigned long value, unsigned long port)
static void inline me4000_outl(unsigned long value, unsigned long port)
{
PORT_PDEBUG("--> 0x%08lX port 0x%04lX\n", value, port);
outl(value, port);
}
static unsigned long me4000_inl(unsigned long port)
static unsigned long inline me4000_inl(unsigned long port)
{
unsigned long value;
value = inl(port);
......@@ -319,7 +296,7 @@ static unsigned long me4000_inl(unsigned long port)
return value;
}
static unsigned char me4000_inb(unsigned long port)
static unsigned char inline me4000_inb(unsigned long port)
{
unsigned char value;
value = inb(port);
......@@ -327,102 +304,102 @@ static unsigned char me4000_inb(unsigned long port)
return value;
}
struct pci_driver me4000_driver = {
static struct pci_driver me4000_driver = {
.name = ME4000_NAME,
.id_table = me4000_pci_table,
.probe = me4000_probe
};
static struct file_operations me4000_ao_fops_sing = {
owner:THIS_MODULE,
write:me4000_ao_write_sing,
ioctl:me4000_ao_ioctl_sing,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.write = me4000_ao_write_sing,
.ioctl = me4000_ao_ioctl_sing,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_ao_fops_wrap = {
owner:THIS_MODULE,
write:me4000_ao_write_wrap,
ioctl:me4000_ao_ioctl_wrap,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.write = me4000_ao_write_wrap,
.ioctl = me4000_ao_ioctl_wrap,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_ao_fops_cont = {
owner:THIS_MODULE,
write:me4000_ao_write_cont,
poll:me4000_ao_poll_cont,
ioctl:me4000_ao_ioctl_cont,
open:me4000_open,
release:me4000_release,
fsync:me4000_ao_fsync_cont,
.owner = THIS_MODULE,
.write = me4000_ao_write_cont,
.poll = me4000_ao_poll_cont,
.ioctl = me4000_ao_ioctl_cont,
.open = me4000_open,
.release = me4000_release,
.fsync = me4000_ao_fsync_cont,
};
static struct file_operations me4000_ai_fops_sing = {
owner:THIS_MODULE,
ioctl:me4000_ai_ioctl_sing,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.ioctl = me4000_ai_ioctl_sing,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_ai_fops_cont_sw = {
owner:THIS_MODULE,
read:me4000_ai_read,
poll:me4000_ai_poll,
ioctl:me4000_ai_ioctl_sw,
open:me4000_open,
release:me4000_release,
fasync:me4000_ai_fasync,
.owner = THIS_MODULE,
.read = me4000_ai_read,
.poll = me4000_ai_poll,
.ioctl = me4000_ai_ioctl_sw,
.open = me4000_open,
.release = me4000_release,
.fasync = me4000_ai_fasync,
};
static struct file_operations me4000_ai_fops_cont_et = {
owner:THIS_MODULE,
read:me4000_ai_read,
poll:me4000_ai_poll,
ioctl:me4000_ai_ioctl_ext,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.read = me4000_ai_read,
.poll = me4000_ai_poll,
.ioctl = me4000_ai_ioctl_ext,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_ai_fops_cont_et_value = {
owner:THIS_MODULE,
read:me4000_ai_read,
poll:me4000_ai_poll,
ioctl:me4000_ai_ioctl_ext,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.read = me4000_ai_read,
.poll = me4000_ai_poll,
.ioctl = me4000_ai_ioctl_ext,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_ai_fops_cont_et_chanlist = {
owner:THIS_MODULE,
read:me4000_ai_read,
poll:me4000_ai_poll,
ioctl:me4000_ai_ioctl_ext,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.read = me4000_ai_read,
.poll = me4000_ai_poll,
.ioctl = me4000_ai_ioctl_ext,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_dio_fops = {
owner:THIS_MODULE,
ioctl:me4000_dio_ioctl,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.ioctl = me4000_dio_ioctl,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_cnt_fops = {
owner:THIS_MODULE,
ioctl:me4000_cnt_ioctl,
open:me4000_open,
release:me4000_release,
.owner = THIS_MODULE,
.ioctl = me4000_cnt_ioctl,
.open = me4000_open,
.release = me4000_release,
};
static struct file_operations me4000_ext_int_fops = {
owner:THIS_MODULE,
ioctl:me4000_ext_int_ioctl,
open:me4000_open,
release:me4000_release,
fasync:me4000_ext_int_fasync,
.owner = THIS_MODULE,
.ioctl = me4000_ext_int_ioctl,
.open = me4000_open,
.release = me4000_release,
.fasync = me4000_ext_int_fasync,
};
static struct file_operations *me4000_ao_fops_array[] = {
......@@ -439,9 +416,9 @@ static struct file_operations *me4000_ai_fops_array[] = {
&me4000_ai_fops_cont_et_chanlist, // work through one channel list by external trigger
};
int __init me4000_init_module(void)
static int __init me4000_init_module(void)
{
int result = 0;
int result;
CALL_PDEBUG("init_module() is executed\n");
......@@ -533,26 +510,26 @@ int __init me4000_init_module(void)
return 0;
INIT_ERROR_7:
INIT_ERROR_7:
unregister_chrdev(me4000_ext_int_major_driver_no, ME4000_EXT_INT_NAME);
INIT_ERROR_6:
INIT_ERROR_6:
unregister_chrdev(me4000_cnt_major_driver_no, ME4000_CNT_NAME);
INIT_ERROR_5:
INIT_ERROR_5:
unregister_chrdev(me4000_dio_major_driver_no, ME4000_DIO_NAME);
INIT_ERROR_4:
INIT_ERROR_4:
unregister_chrdev(me4000_ai_major_driver_no, ME4000_AI_NAME);
INIT_ERROR_3:
INIT_ERROR_3:
unregister_chrdev(me4000_ao_major_driver_no, ME4000_AO_NAME);
INIT_ERROR_2:
INIT_ERROR_2:
pci_unregister_driver(&me4000_driver);
clear_board_info_list();
INIT_ERROR_1:
INIT_ERROR_1:
return result;
}
......@@ -562,18 +539,18 @@ static void clear_board_info_list(void)
{
struct list_head *board_p;
struct list_head *dac_p;
me4000_info_t *board_info;
me4000_ao_context_t *ao_context;
struct me4000_info *board_info;
struct me4000_ao_context *ao_context;
/* Clear context lists */
for (board_p = me4000_board_info_list.next;
board_p != &me4000_board_info_list; board_p = board_p->next) {
board_info = list_entry(board_p, me4000_info_t, list);
board_info = list_entry(board_p, struct me4000_info, list);
/* Clear analog output context list */
while (!list_empty(&board_info->ao_context_list)) {
dac_p = board_info->ao_context_list.next;
ao_context =
list_entry(dac_p, me4000_ao_context_t, list);
list_entry(dac_p, struct me4000_ao_context, list);
me4000_ao_reset(ao_context);
free_irq(ao_context->irq, ao_context);
if (ao_context->circ_buf.buf)
......@@ -600,14 +577,14 @@ static void clear_board_info_list(void)
/* Clear the board info list */
while (!list_empty(&me4000_board_info_list)) {
board_p = me4000_board_info_list.next;
board_info = list_entry(board_p, me4000_info_t, list);
board_info = list_entry(board_p, struct me4000_info, list);
pci_release_regions(board_info->pci_dev_p);
list_del(board_p);
kfree(board_info);
}
}
static int get_registers(struct pci_dev *dev, me4000_info_t * board_info)
static int get_registers(struct pci_dev *dev, struct me4000_info *board_info)
{
/*--------------------------- plx regbase ---------------------------------*/
......@@ -667,20 +644,20 @@ static int get_registers(struct pci_dev *dev, me4000_info_t * board_info)
}
static int init_board_info(struct pci_dev *pci_dev_p,
me4000_info_t * board_info)
struct me4000_info *board_info)
{
int i;
int result;
struct list_head *board_p;
board_info->pci_dev_p = pci_dev_p;
for (i = 0; i < ME4000_BOARD_VERSIONS; i++) {
for (i = 0; i < ARRAY_SIZE(me4000_boards); i++) {
if (me4000_boards[i].device_id == pci_dev_p->device) {
board_info->board_p = &me4000_boards[i];
break;
}
}
if (i == ME4000_BOARD_VERSIONS) {
if (i == ARRAY_SIZE(me4000_boards)) {
printk(KERN_ERR
"ME4000:init_board_info():Device ID not valid\n");
return -ENODEV;
......@@ -755,21 +732,21 @@ static int init_board_info(struct pci_dev *pci_dev_p,
return 0;
}
static int alloc_ao_contexts(me4000_info_t * info)
static int alloc_ao_contexts(struct me4000_info *info)
{
int i;
int err;
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
for (i = 0; i < info->board_p->ao.count; i++) {
ao_context = kmalloc(sizeof(me4000_ao_context_t), GFP_KERNEL);
ao_context = kzalloc(sizeof(struct me4000_ao_context),
GFP_KERNEL);
if (!ao_context) {
printk(KERN_ERR
"alloc_ao_contexts():Can't get memory for ao context\n");
release_ao_contexts(info);
return -ENOMEM;
}
memset(ao_context, 0, sizeof(me4000_ao_context_t));
spin_lock_init(&ao_context->use_lock);
spin_lock_init(&ao_context->int_lock);
......@@ -780,15 +757,13 @@ static int alloc_ao_contexts(me4000_info_t * info)
if (info->board_p->ao.fifo_count) {
/* Allocate circular buffer */
ao_context->circ_buf.buf =
kmalloc(ME4000_AO_BUFFER_SIZE, GFP_KERNEL);
kzalloc(ME4000_AO_BUFFER_SIZE, GFP_KERNEL);
if (!ao_context->circ_buf.buf) {
printk(KERN_ERR
"alloc_ao_contexts():Can't get circular buffer\n");
release_ao_contexts(info);
return -ENOMEM;
}
memset(ao_context->circ_buf.buf, 0,
ME4000_AO_BUFFER_SIZE);
/* Clear the circular buffer */
ao_context->circ_buf.head = 0;
......@@ -872,8 +847,7 @@ static int alloc_ao_contexts(me4000_info_t * info)
ME4000_NAME, ao_context);
if (err) {
printk(KERN_ERR
"alloc_ao_contexts():Can't get interrupt line");
if (ao_context->circ_buf.buf)
"%s:Can't get interrupt line", __func__);
kfree(ao_context->circ_buf.buf);
kfree(ao_context);
release_ao_contexts(info);
......@@ -888,35 +862,34 @@ static int alloc_ao_contexts(me4000_info_t * info)
return 0;
}
static void release_ao_contexts(me4000_info_t * board_info)
static void release_ao_contexts(struct me4000_info *board_info)
{
struct list_head *dac_p;
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
/* Clear analog output context list */
while (!list_empty(&board_info->ao_context_list)) {
dac_p = board_info->ao_context_list.next;
ao_context = list_entry(dac_p, me4000_ao_context_t, list);
ao_context = list_entry(dac_p, struct me4000_ao_context, list);
free_irq(ao_context->irq, ao_context);
if (ao_context->circ_buf.buf)
kfree(ao_context->circ_buf.buf);
list_del(dac_p);
kfree(ao_context);
}
}
static int alloc_ai_context(me4000_info_t * info)
static int alloc_ai_context(struct me4000_info *info)
{
me4000_ai_context_t *ai_context;
struct me4000_ai_context *ai_context;
if (info->board_p->ai.count) {
ai_context = kmalloc(sizeof(me4000_ai_context_t), GFP_KERNEL);
ai_context = kzalloc(sizeof(struct me4000_ai_context),
GFP_KERNEL);
if (!ai_context) {
printk(KERN_ERR
"ME4000:alloc_ai_context():Can't get memory for ai context\n");
return -ENOMEM;
}
memset(ai_context, 0, sizeof(me4000_ai_context_t));
info->ai_context = ai_context;
......@@ -958,18 +931,18 @@ static int alloc_ai_context(me4000_info_t * info)
return 0;
}
static int alloc_dio_context(me4000_info_t * info)
static int alloc_dio_context(struct me4000_info *info)
{
me4000_dio_context_t *dio_context;
struct me4000_dio_context *dio_context;
if (info->board_p->dio.count) {
dio_context = kmalloc(sizeof(me4000_dio_context_t), GFP_KERNEL);
dio_context = kzalloc(sizeof(struct me4000_dio_context),
GFP_KERNEL);
if (!dio_context) {
printk(KERN_ERR
"ME4000:alloc_dio_context():Can't get memory for dio context\n");
return -ENOMEM;
}
memset(dio_context, 0, sizeof(me4000_dio_context_t));
info->dio_context = dio_context;
......@@ -995,18 +968,18 @@ static int alloc_dio_context(me4000_info_t * info)
return 0;
}
static int alloc_cnt_context(me4000_info_t * info)
static int alloc_cnt_context(struct me4000_info *info)
{
me4000_cnt_context_t *cnt_context;
struct me4000_cnt_context *cnt_context;
if (info->board_p->cnt.count) {
cnt_context = kmalloc(sizeof(me4000_cnt_context_t), GFP_KERNEL);
cnt_context = kzalloc(sizeof(struct me4000_cnt_context),
GFP_KERNEL);
if (!cnt_context) {
printk(KERN_ERR
"ME4000:alloc_cnt_context():Can't get memory for cnt context\n");
return -ENOMEM;
}
memset(cnt_context, 0, sizeof(me4000_cnt_context_t));
info->cnt_context = cnt_context;
......@@ -1026,19 +999,18 @@ static int alloc_cnt_context(me4000_info_t * info)
return 0;
}
static int alloc_ext_int_context(me4000_info_t * info)
static int alloc_ext_int_context(struct me4000_info *info)
{
me4000_ext_int_context_t *ext_int_context;
struct me4000_ext_int_context *ext_int_context;
if (info->board_p->cnt.count) {
ext_int_context =
kmalloc(sizeof(me4000_ext_int_context_t), GFP_KERNEL);
kzalloc(sizeof(struct me4000_ext_int_context), GFP_KERNEL);
if (!ext_int_context) {
printk(KERN_ERR
"ME4000:alloc_ext_int_context():Can't get memory for cnt context\n");
return -ENOMEM;
}
memset(ext_int_context, 0, sizeof(me4000_ext_int_context_t));
info->ext_int_context = ext_int_context;
......@@ -1060,19 +1032,18 @@ static int alloc_ext_int_context(me4000_info_t * info)
static int me4000_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
int result = 0;
me4000_info_t *board_info;
struct me4000_info *board_info;
CALL_PDEBUG("me4000_probe() is executed\n");
/* Allocate structure for board context */
board_info = kmalloc(sizeof(me4000_info_t), GFP_KERNEL);
board_info = kzalloc(sizeof(struct me4000_info), GFP_KERNEL);
if (!board_info) {
printk(KERN_ERR
"ME4000:Can't get memory for board info structure\n");
result = -ENOMEM;
goto PROBE_ERROR_1;
}
memset(board_info, 0, sizeof(me4000_info_t));
/* Add to global linked list */
list_add_tail(&board_info->list, &me4000_board_info_list);
......@@ -1080,70 +1051,70 @@ static int me4000_probe(struct pci_dev *dev, const struct pci_device_id *id)
/* Get the PCI base registers */
result = get_registers(dev, board_info);
if (result) {
printk(KERN_ERR "me4000_probe():Cannot get registers\n");
printk(KERN_ERR "%s:Cannot get registers\n", __func__);
goto PROBE_ERROR_2;
}
/* Enable the device */
result = pci_enable_device(dev);
if (result < 0) {
printk(KERN_ERR "me4000_probe():Cannot enable PCI device\n");
printk(KERN_ERR "%s:Cannot enable PCI device\n", __func__);
goto PROBE_ERROR_2;
}
/* Request the PCI register regions */
result = pci_request_regions(dev, ME4000_NAME);
if (result < 0) {
printk(KERN_ERR "me4000_probe():Cannot request I/O regions\n");
printk(KERN_ERR "%s:Cannot request I/O regions\n", __func__);
goto PROBE_ERROR_2;
}
/* Initialize board info */
result = init_board_info(dev, board_info);
if (result) {
printk(KERN_ERR "me4000_probe():Cannot init baord info\n");
printk(KERN_ERR "%s:Cannot init baord info\n", __func__);
goto PROBE_ERROR_3;
}
/* Download the xilinx firmware */
result = me4000_xilinx_download(board_info);
if (result) {
printk(KERN_ERR "me4000_probe:Can't download firmware\n");
printk(KERN_ERR "%s:Can't download firmware\n", __func__);
goto PROBE_ERROR_3;
}
/* Make a hardware reset */
result = me4000_reset_board(board_info);
if (result) {
printk(KERN_ERR "me4000_probe:Can't reset board\n");
printk(KERN_ERR "%s :Can't reset board\n", __func__);
goto PROBE_ERROR_3;
}
/* Allocate analog output context structures */
result = alloc_ao_contexts(board_info);
if (result) {
printk(KERN_ERR "me4000_probe():Cannot allocate ao contexts\n");
printk(KERN_ERR "%s:Cannot allocate ao contexts\n", __func__);
goto PROBE_ERROR_3;
}
/* Allocate analog input context */
result = alloc_ai_context(board_info);
if (result) {
printk(KERN_ERR "me4000_probe():Cannot allocate ai context\n");
printk(KERN_ERR "%s:Cannot allocate ai context\n", __func__);
goto PROBE_ERROR_4;
}
/* Allocate digital I/O context */
result = alloc_dio_context(board_info);
if (result) {
printk(KERN_ERR "me4000_probe():Cannot allocate dio context\n");
printk(KERN_ERR "%s:Cannot allocate dio context\n", __func__);
goto PROBE_ERROR_5;
}
/* Allocate counter context */
result = alloc_cnt_context(board_info);
if (result) {
printk(KERN_ERR "me4000_probe():Cannot allocate cnt context\n");
printk(KERN_ERR "%s:Cannot allocate cnt context\n", __func__);
goto PROBE_ERROR_6;
}
......@@ -1151,36 +1122,36 @@ static int me4000_probe(struct pci_dev *dev, const struct pci_device_id *id)
result = alloc_ext_int_context(board_info);
if (result) {
printk(KERN_ERR
"me4000_probe():Cannot allocate ext_int context\n");
"%s:Cannot allocate ext_int context\n", __func__);
goto PROBE_ERROR_7;
}
return 0;
PROBE_ERROR_7:
PROBE_ERROR_7:
kfree(board_info->cnt_context);
PROBE_ERROR_6:
PROBE_ERROR_6:
kfree(board_info->dio_context);
PROBE_ERROR_5:
PROBE_ERROR_5:
kfree(board_info->ai_context);
PROBE_ERROR_4:
PROBE_ERROR_4:
release_ao_contexts(board_info);
PROBE_ERROR_3:
PROBE_ERROR_3:
pci_release_regions(dev);
PROBE_ERROR_2:
PROBE_ERROR_2:
list_del(&board_info->list);
kfree(board_info);
PROBE_ERROR_1:
PROBE_ERROR_1:
return result;
}
static int me4000_xilinx_download(me4000_info_t * info)
static int me4000_xilinx_download(struct me4000_info *info)
{
int size = 0;
u32 value = 0;
......@@ -1211,7 +1182,7 @@ static int me4000_xilinx_download(me4000_info_t * info)
/* Wait until /INIT pin is set */
udelay(20);
if (!inl(info->plx_regbase + PLX_INTCSR) & 0x20) {
printk(KERN_ERR "me4000_xilinx_download():Can't init Xilinx\n");
printk(KERN_ERR "%s:Can't init Xilinx\n", __func__);
return -EIO;
}
......@@ -1232,7 +1203,7 @@ static int me4000_xilinx_download(me4000_info_t * info)
/* Check if BUSY flag is low */
if (inl(info->plx_regbase + PLX_ICR) & 0x20) {
printk(KERN_ERR
"me4000_xilinx_download():Xilinx is still busy (idx = %d)\n",
"%s:Xilinx is still busy (idx = %d)\n", __func__,
idx);
return -EIO;
}
......@@ -1246,9 +1217,9 @@ static int me4000_xilinx_download(me4000_info_t * info)
PDEBUG("me4000_xilinx_download():Download was successful\n");
} else {
printk(KERN_ERR
"ME4000:me4000_xilinx_download():DONE flag is not set\n");
"ME4000:%s:DONE flag is not set\n", __func__);
printk(KERN_ERR
"ME4000:me4000_xilinx_download():Download not succesful\n");
"ME4000:%s:Download not succesful\n", __func__);
return -EIO;
}
......@@ -1260,7 +1231,7 @@ static int me4000_xilinx_download(me4000_info_t * info)
return 0;
}
static int me4000_reset_board(me4000_info_t * info)
static int me4000_reset_board(struct me4000_info *info)
{
unsigned long icr;
......@@ -1314,12 +1285,12 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
int err = 0;
int i;
struct list_head *ptr;
me4000_info_t *board_info = NULL;
me4000_ao_context_t *ao_context = NULL;
me4000_ai_context_t *ai_context = NULL;
me4000_dio_context_t *dio_context = NULL;
me4000_cnt_context_t *cnt_context = NULL;
me4000_ext_int_context_t *ext_int_context = NULL;
struct me4000_info *board_info = NULL;
struct me4000_ao_context *ao_context = NULL;
struct me4000_ai_context *ai_context = NULL;
struct me4000_dio_context *dio_context = NULL;
struct me4000_cnt_context *cnt_context = NULL;
struct me4000_ext_int_context *ext_int_context = NULL;
CALL_PDEBUG("me4000_open() is executed\n");
......@@ -1335,7 +1306,7 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
/* Search for the board context */
for (ptr = me4000_board_info_list.next, i = 0;
ptr != &me4000_board_info_list; ptr = ptr->next, i++) {
board_info = list_entry(ptr, me4000_info_t, list);
board_info = list_entry(ptr, struct me4000_info, list);
if (i == board)
break;
}
......@@ -1351,7 +1322,8 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
for (ptr = board_info->ao_context_list.next, i = 0;
ptr != &board_info->ao_context_list;
ptr = ptr->next, i++) {
ao_context = list_entry(ptr, me4000_ao_context_t, list);
ao_context = list_entry(ptr, struct me4000_ao_context,
list);
if (i == dev)
break;
}
......@@ -1415,7 +1387,7 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
/* Search for the board context */
for (ptr = me4000_board_info_list.next, i = 0;
ptr != &me4000_board_info_list; ptr = ptr->next, i++) {
board_info = list_entry(ptr, me4000_info_t, list);
board_info = list_entry(ptr, struct me4000_info, list);
if (i == board)
break;
}
......@@ -1469,7 +1441,7 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
/* Search for the board context */
for (ptr = me4000_board_info_list.next;
ptr != &me4000_board_info_list; ptr = ptr->next) {
board_info = list_entry(ptr, me4000_info_t, list);
board_info = list_entry(ptr, struct me4000_info, list);
if (board_info->board_count == board)
break;
}
......@@ -1514,7 +1486,7 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
/* Search for the board context */
for (ptr = me4000_board_info_list.next;
ptr != &me4000_board_info_list; ptr = ptr->next) {
board_info = list_entry(ptr, me4000_info_t, list);
board_info = list_entry(ptr, struct me4000_info, list);
if (board_info->board_count == board)
break;
}
......@@ -1557,7 +1529,7 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
/* Search for the board context */
for (ptr = me4000_board_info_list.next;
ptr != &me4000_board_info_list; ptr = ptr->next) {
board_info = list_entry(ptr, me4000_info_t, list);
board_info = list_entry(ptr, struct me4000_info, list);
if (board_info->board_count == board)
break;
}
......@@ -1613,11 +1585,11 @@ static int me4000_open(struct inode *inode_p, struct file *file_p)
static int me4000_release(struct inode *inode_p, struct file *file_p)
{
me4000_ao_context_t *ao_context;
me4000_ai_context_t *ai_context;
me4000_dio_context_t *dio_context;
me4000_cnt_context_t *cnt_context;
me4000_ext_int_context_t *ext_int_context;
struct me4000_ao_context *ao_context;
struct me4000_ai_context *ai_context;
struct me4000_dio_context *dio_context;
struct me4000_cnt_context *cnt_context;
struct me4000_ext_int_context *ext_int_context;
CALL_PDEBUG("me4000_release() is executed\n");
......@@ -1677,7 +1649,7 @@ static int me4000_release(struct inode *inode_p, struct file *file_p)
/*------------------------------- Analog output stuff --------------------------------------*/
static int me4000_ao_prepare(me4000_ao_context_t * ao_context)
static int me4000_ao_prepare(struct me4000_ao_context *ao_context)
{
unsigned long flags;
......@@ -1756,7 +1728,7 @@ static int me4000_ao_prepare(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_reset(me4000_ao_context_t * ao_context)
static int me4000_ao_reset(struct me4000_ao_context *ao_context)
{
u32 tmp;
wait_queue_head_t queue;
......@@ -1777,9 +1749,10 @@ static int me4000_ao_reset(me4000_ao_context_t * ao_context)
tmp |= ME4000_AO_CTRL_BIT_IMMEDIATE_STOP;
me4000_outl(tmp, ao_context->ctrl_reg);
while (inl(ao_context->status_reg) & ME4000_AO_STATUS_BIT_FSM) {
sleep_on_timeout(&queue, 1);
}
wait_event_timeout(queue,
(inl(ao_context->status_reg) &
ME4000_AO_STATUS_BIT_FSM) == 0,
1);
/* Set to transparent mode */
me4000_ao_simultaneous_disable(ao_context);
......@@ -1812,9 +1785,10 @@ static int me4000_ao_reset(me4000_ao_context_t * ao_context)
me4000_outl(tmp, ao_context->ctrl_reg);
spin_unlock_irqrestore(&ao_context->int_lock, flags);
while (inl(ao_context->status_reg) & ME4000_AO_STATUS_BIT_FSM) {
sleep_on_timeout(&queue, 1);
}
wait_event_timeout(queue,
(inl(ao_context->status_reg) &
ME4000_AO_STATUS_BIT_FSM) == 0,
1);
/* Clear the circular buffer */
ao_context->circ_buf.head = 0;
......@@ -1853,9 +1827,9 @@ static int me4000_ao_reset(me4000_ao_context_t * ao_context)
}
static ssize_t me4000_ao_write_sing(struct file *filep, const char *buff,
size_t cnt, loff_t * offp)
size_t cnt, loff_t *offp)
{
me4000_ao_context_t *ao_context = filep->private_data;
struct me4000_ao_context *ao_context = filep->private_data;
u32 value;
const u16 *buffer = (const u16 *)buff;
......@@ -1863,13 +1837,13 @@ static ssize_t me4000_ao_write_sing(struct file *filep, const char *buff,
if (cnt != 2) {
printk(KERN_ERR
"me4000_ao_write_sing():Write count is not 2\n");
"%s:Write count is not 2\n", __func__);
return -EINVAL;
}
if (get_user(value, buffer)) {
printk(KERN_ERR
"me4000_ao_write_sing():Cannot copy data from user\n");
"%s:Cannot copy data from user\n", __func__);
return -EFAULT;
}
......@@ -1879,9 +1853,9 @@ static ssize_t me4000_ao_write_sing(struct file *filep, const char *buff,
}
static ssize_t me4000_ao_write_wrap(struct file *filep, const char *buff,
size_t cnt, loff_t * offp)
size_t cnt, loff_t *offp)
{
me4000_ao_context_t *ao_context = filep->private_data;
struct me4000_ao_context *ao_context = filep->private_data;
size_t i;
u32 value;
u32 tmp;
......@@ -1893,13 +1867,13 @@ static ssize_t me4000_ao_write_wrap(struct file *filep, const char *buff,
/* Check if a conversion is already running */
if (inl(ao_context->status_reg) & ME4000_AO_STATUS_BIT_FSM) {
printk(KERN_ERR
"ME4000:me4000_ao_write_wrap():There is already a conversion running\n");
"%s:There is already a conversion running\n", __func__);
return -EBUSY;
}
if (count > ME4000_AO_FIFO_COUNT) {
printk(KERN_ERR
"me4000_ao_write_wrap():Can't load more than %d values\n",
"%s:Can't load more than %d values\n", __func__,
ME4000_AO_FIFO_COUNT);
return -ENOSPC;
}
......@@ -1914,7 +1888,7 @@ static ssize_t me4000_ao_write_wrap(struct file *filep, const char *buff,
for (i = 0; i < count; i++) {
if (get_user(value, buffer + i)) {
printk(KERN_ERR
"me4000_ao_write_single():Cannot copy data from user\n");
"%s:Cannot copy data from user\n", __func__);
return -EFAULT;
}
if (((ao_context->fifo_reg & 0xFF) == ME4000_AO_01_FIFO_REG)
......@@ -1928,9 +1902,9 @@ static ssize_t me4000_ao_write_wrap(struct file *filep, const char *buff,
}
static ssize_t me4000_ao_write_cont(struct file *filep, const char *buff,
size_t cnt, loff_t * offp)
size_t cnt, loff_t *offp)
{
me4000_ao_context_t *ao_context = filep->private_data;
struct me4000_ao_context *ao_context = filep->private_data;
const u16 *buffer = (const u16 *)buff;
size_t count = cnt / 2;
unsigned long flags;
......@@ -2154,9 +2128,9 @@ static ssize_t me4000_ao_write_cont(struct file *filep, const char *buff,
return 2 * ret;
}
static unsigned int me4000_ao_poll_cont(struct file *file_p, poll_table * wait)
static unsigned int me4000_ao_poll_cont(struct file *file_p, poll_table *wait)
{
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
unsigned long mask = 0;
CALL_PDEBUG("me4000_ao_poll_cont() is executed\n");
......@@ -2177,7 +2151,7 @@ static unsigned int me4000_ao_poll_cont(struct file *file_p, poll_table * wait)
static int me4000_ao_fsync_cont(struct file *file_p, struct dentry *dentry_p,
int datasync)
{
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
wait_queue_head_t queue;
CALL_PDEBUG("me4000_ao_fsync_cont() is executed\n");
......@@ -2187,15 +2161,19 @@ static int me4000_ao_fsync_cont(struct file *file_p, struct dentry *dentry_p,
while (inl(ao_context->status_reg) & ME4000_AO_STATUS_BIT_FSM) {
interruptible_sleep_on_timeout(&queue, 1);
wait_event_interruptible_timeout(queue,
!(inl(ao_context->status_reg) & ME4000_AO_STATUS_BIT_FSM),
1);
if (ao_context->pipe_flag) {
printk(KERN_ERR
"me4000_ao_fsync_cont():Broken pipe detected\n");
"%s:Broken pipe detected\n", __func__);
return -EPIPE;
}
if (signal_pending(current)) {
printk(KERN_ERR
"me4000_ao_fsync_cont():Wait on state machine interrupted\n");
"%s:Wait on state machine interrupted\n",
__func__);
return -EINTR;
}
}
......@@ -2206,7 +2184,7 @@ static int me4000_ao_fsync_cont(struct file *file_p, struct dentry *dentry_p,
static int me4000_ao_ioctl_sing(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
CALL_PDEBUG("me4000_ao_ioctl_sing() is executed\n");
......@@ -2229,7 +2207,7 @@ static int me4000_ao_ioctl_sing(struct inode *inode_p, struct file *file_p,
case ME4000_AO_PRELOAD_UPDATE:
return me4000_ao_preload_update(ao_context);
case ME4000_GET_USER_INFO:
return me4000_get_user_info((me4000_user_info_t *) arg,
return me4000_get_user_info((struct me4000_user_info *)arg,
ao_context->board_info);
case ME4000_AO_SIMULTANEOUS_EX_TRIG:
return me4000_ao_simultaneous_ex_trig(ao_context);
......@@ -2239,8 +2217,9 @@ static int me4000_ao_ioctl_sing(struct inode *inode_p, struct file *file_p,
return me4000_ao_simultaneous_disable(ao_context);
case ME4000_AO_SIMULTANEOUS_UPDATE:
return
me4000_ao_simultaneous_update((me4000_ao_channel_list_t *)
arg, ao_context);
me4000_ao_simultaneous_update(
(struct me4000_ao_channel_list *)arg,
ao_context);
case ME4000_AO_EX_TRIG_TIMEOUT:
return me4000_ao_ex_trig_timeout((unsigned long *)arg,
ao_context);
......@@ -2258,7 +2237,7 @@ static int me4000_ao_ioctl_sing(struct inode *inode_p, struct file *file_p,
static int me4000_ao_ioctl_wrap(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
CALL_PDEBUG("me4000_ao_ioctl_wrap() is executed\n");
......@@ -2287,7 +2266,7 @@ static int me4000_ao_ioctl_wrap(struct inode *inode_p, struct file *file_p,
case ME4000_AO_EX_TRIG_DISABLE:
return me4000_ao_ex_trig_disable(ao_context);
case ME4000_GET_USER_INFO:
return me4000_get_user_info((me4000_user_info_t *) arg,
return me4000_get_user_info((struct me4000_user_info *)arg,
ao_context->board_info);
case ME4000_AO_FSM_STATE:
return me4000_ao_fsm_state((int *)arg, ao_context);
......@@ -2310,7 +2289,7 @@ static int me4000_ao_ioctl_wrap(struct inode *inode_p, struct file *file_p,
static int me4000_ao_ioctl_cont(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
CALL_PDEBUG("me4000_ao_ioctl_cont() is executed\n");
......@@ -2345,7 +2324,7 @@ static int me4000_ao_ioctl_cont(struct inode *inode_p, struct file *file_p,
case ME4000_AO_FSM_STATE:
return me4000_ao_fsm_state((int *)arg, ao_context);
case ME4000_GET_USER_INFO:
return me4000_get_user_info((me4000_user_info_t *) arg,
return me4000_get_user_info((struct me4000_user_info *)arg,
ao_context->board_info);
case ME4000_AO_SYNCHRONOUS_EX_TRIG:
return me4000_ao_synchronous_ex_trig(ao_context);
......@@ -2362,7 +2341,8 @@ static int me4000_ao_ioctl_cont(struct inode *inode_p, struct file *file_p,
return 0;
}
static int me4000_ao_start(unsigned long *arg, me4000_ao_context_t * ao_context)
static int me4000_ao_start(unsigned long *arg,
struct me4000_ao_context *ao_context)
{
u32 tmp;
wait_queue_head_t queue;
......@@ -2412,7 +2392,7 @@ static int me4000_ao_start(unsigned long *arg, me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_stop(me4000_ao_context_t * ao_context)
static int me4000_ao_stop(struct me4000_ao_context *ao_context)
{
u32 tmp;
wait_queue_head_t queue;
......@@ -2445,7 +2425,7 @@ static int me4000_ao_stop(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_immediate_stop(me4000_ao_context_t * ao_context)
static int me4000_ao_immediate_stop(struct me4000_ao_context *ao_context)
{
u32 tmp;
wait_queue_head_t queue;
......@@ -2477,8 +2457,8 @@ static int me4000_ao_immediate_stop(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_timer_set_divisor(u32 * arg,
me4000_ao_context_t * ao_context)
static int me4000_ao_timer_set_divisor(u32 *arg,
struct me4000_ao_context *ao_context)
{
u32 divisor;
u32 tmp;
......@@ -2518,7 +2498,7 @@ static int me4000_ao_timer_set_divisor(u32 * arg,
}
static int me4000_ao_ex_trig_set_edge(int *arg,
me4000_ao_context_t * ao_context)
struct me4000_ao_context *ao_context)
{
int mode;
u32 tmp;
......@@ -2569,7 +2549,7 @@ static int me4000_ao_ex_trig_set_edge(int *arg,
return 0;
}
static int me4000_ao_ex_trig_enable(me4000_ao_context_t * ao_context)
static int me4000_ao_ex_trig_enable(struct me4000_ao_context *ao_context)
{
u32 tmp;
unsigned long flags;
......@@ -2593,7 +2573,7 @@ static int me4000_ao_ex_trig_enable(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_ex_trig_disable(me4000_ao_context_t * ao_context)
static int me4000_ao_ex_trig_disable(struct me4000_ao_context *ao_context)
{
u32 tmp;
unsigned long flags;
......@@ -2617,7 +2597,7 @@ static int me4000_ao_ex_trig_disable(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_simultaneous_disable(me4000_ao_context_t * ao_context)
static int me4000_ao_simultaneous_disable(struct me4000_ao_context *ao_context)
{
u32 tmp;
......@@ -2643,7 +2623,7 @@ static int me4000_ao_simultaneous_disable(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_simultaneous_ex_trig(me4000_ao_context_t * ao_context)
static int me4000_ao_simultaneous_ex_trig(struct me4000_ao_context *ao_context)
{
u32 tmp;
......@@ -2659,7 +2639,7 @@ static int me4000_ao_simultaneous_ex_trig(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_simultaneous_sw(me4000_ao_context_t * ao_context)
static int me4000_ao_simultaneous_sw(struct me4000_ao_context *ao_context)
{
u32 tmp;
......@@ -2675,13 +2655,13 @@ static int me4000_ao_simultaneous_sw(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_preload(me4000_ao_context_t * ao_context)
static int me4000_ao_preload(struct me4000_ao_context *ao_context)
{
CALL_PDEBUG("me4000_ao_preload() is executed\n");
return me4000_ao_simultaneous_sw(ao_context);
}
static int me4000_ao_preload_update(me4000_ao_context_t * ao_context)
static int me4000_ao_preload_update(struct me4000_ao_context *ao_context)
{
u32 tmp;
u32 ctrl;
......@@ -2705,10 +2685,12 @@ static int me4000_ao_preload_update(me4000_ao_context_t * ao_context)
if (!
(tmp &
(0x1 <<
(((me4000_ao_context_t *) entry)->index + 16)))) {
(((struct me4000_ao_context *)entry)->index
+ 16)))) {
tmp &=
~(0x1 <<
(((me4000_ao_context_t *) entry)->index));
(((struct me4000_ao_context *)entry)->
index));
}
}
}
......@@ -2718,18 +2700,19 @@ static int me4000_ao_preload_update(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_simultaneous_update(me4000_ao_channel_list_t * arg,
me4000_ao_context_t * ao_context)
static int me4000_ao_simultaneous_update(struct me4000_ao_channel_list *arg,
struct me4000_ao_context *ao_context)
{
int err;
int i;
u32 tmp;
me4000_ao_channel_list_t channels;
struct me4000_ao_channel_list channels;
CALL_PDEBUG("me4000_ao_simultaneous_update() is executed\n");
/* Copy data from user */
err = copy_from_user(&channels, arg, sizeof(me4000_ao_channel_list_t));
err = copy_from_user(&channels, arg,
sizeof(struct me4000_ao_channel_list));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ao_simultaneous_update():Can't copy command\n");
......@@ -2737,13 +2720,12 @@ static int me4000_ao_simultaneous_update(me4000_ao_channel_list_t * arg,
}
channels.list =
kmalloc(sizeof(unsigned long) * channels.count, GFP_KERNEL);
kzalloc(sizeof(unsigned long) * channels.count, GFP_KERNEL);
if (!channels.list) {
printk(KERN_ERR
"ME4000:me4000_ao_simultaneous_update():Can't get buffer\n");
return -ENOMEM;
}
memset(channels.list, 0, sizeof(unsigned long) * channels.count);
/* Copy channel list from user */
err =
......@@ -2777,7 +2759,7 @@ static int me4000_ao_simultaneous_update(me4000_ao_channel_list_t * arg,
return 0;
}
static int me4000_ao_synchronous_ex_trig(me4000_ao_context_t * ao_context)
static int me4000_ao_synchronous_ex_trig(struct me4000_ao_context *ao_context)
{
u32 tmp;
unsigned long flags;
......@@ -2813,7 +2795,7 @@ static int me4000_ao_synchronous_ex_trig(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_synchronous_sw(me4000_ao_context_t * ao_context)
static int me4000_ao_synchronous_sw(struct me4000_ao_context *ao_context)
{
u32 tmp;
unsigned long flags;
......@@ -2848,13 +2830,13 @@ static int me4000_ao_synchronous_sw(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_synchronous_disable(me4000_ao_context_t * ao_context)
static int me4000_ao_synchronous_disable(struct me4000_ao_context *ao_context)
{
return me4000_ao_simultaneous_disable(ao_context);
}
static int me4000_ao_get_free_buffer(unsigned long *arg,
me4000_ao_context_t * ao_context)
struct me4000_ao_context *ao_context)
{
unsigned long c;
int err;
......@@ -2864,7 +2846,7 @@ static int me4000_ao_get_free_buffer(unsigned long *arg,
err = copy_to_user(arg, &c, sizeof(unsigned long));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ao_get_free_buffer():Can't copy to user space\n");
"%s:Can't copy to user space\n", __func__);
return -EFAULT;
}
......@@ -2872,7 +2854,7 @@ static int me4000_ao_get_free_buffer(unsigned long *arg,
}
static int me4000_ao_ex_trig_timeout(unsigned long *arg,
me4000_ao_context_t * ao_context)
struct me4000_ao_context *ao_context)
{
u32 tmp;
wait_queue_head_t queue;
......@@ -2928,7 +2910,7 @@ static int me4000_ao_ex_trig_timeout(unsigned long *arg,
return 0;
}
static int me4000_ao_enable_do(me4000_ao_context_t * ao_context)
static int me4000_ao_enable_do(struct me4000_ao_context *ao_context)
{
u32 tmp;
unsigned long flags;
......@@ -2959,7 +2941,7 @@ static int me4000_ao_enable_do(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_disable_do(me4000_ao_context_t * ao_context)
static int me4000_ao_disable_do(struct me4000_ao_context *ao_context)
{
u32 tmp;
unsigned long flags;
......@@ -2989,7 +2971,7 @@ static int me4000_ao_disable_do(me4000_ao_context_t * ao_context)
return 0;
}
static int me4000_ao_fsm_state(int *arg, me4000_ao_context_t * ao_context)
static int me4000_ao_fsm_state(int *arg, struct me4000_ao_context *ao_context)
{
unsigned long tmp;
......@@ -3012,9 +2994,9 @@ static int me4000_ao_fsm_state(int *arg, me4000_ao_context_t * ao_context)
return 0;
}
/*------------------------------- Analog input stuff --------------------------------------*/
/*------------------------- Analog input stuff -------------------------------*/
static int me4000_ai_prepare(me4000_ai_context_t * ai_context)
static int me4000_ai_prepare(struct me4000_ai_context *ai_context)
{
wait_queue_head_t queue;
int err;
......@@ -3057,14 +3039,13 @@ static int me4000_ai_prepare(me4000_ai_context_t * ai_context)
/* Allocate circular buffer */
ai_context->circ_buf.buf =
kmalloc(ME4000_AI_BUFFER_SIZE, GFP_KERNEL);
kzalloc(ME4000_AI_BUFFER_SIZE, GFP_KERNEL);
if (!ai_context->circ_buf.buf) {
printk(KERN_ERR
"ME4000:me4000_ai_prepare():Can't get circular buffer\n");
free_irq(ai_context->irq, ai_context);
return -ENOMEM;
}
memset(ai_context->circ_buf.buf, 0, ME4000_AI_BUFFER_SIZE);
/* Clear the circular buffer */
ai_context->circ_buf.head = 0;
......@@ -3074,7 +3055,7 @@ static int me4000_ai_prepare(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_reset(me4000_ai_context_t * ai_context)
static int me4000_ai_reset(struct me4000_ai_context *ai_context)
{
wait_queue_head_t queue;
u32 tmp;
......@@ -3139,7 +3120,7 @@ static int me4000_ai_reset(me4000_ai_context_t * ai_context)
static int me4000_ai_ioctl_sing(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_ai_context_t *ai_context;
struct me4000_ai_context *ai_context;
CALL_PDEBUG("me4000_ai_ioctl_sing() is executed\n");
......@@ -3157,16 +3138,17 @@ static int me4000_ai_ioctl_sing(struct inode *inode_p, struct file *file_p,
switch (service) {
case ME4000_AI_SINGLE:
return me4000_ai_single((me4000_ai_single_t *) arg, ai_context);
return me4000_ai_single((struct me4000_ai_single *)arg,
ai_context);
case ME4000_AI_EX_TRIG_ENABLE:
return me4000_ai_ex_trig_enable(ai_context);
case ME4000_AI_EX_TRIG_DISABLE:
return me4000_ai_ex_trig_disable(ai_context);
case ME4000_AI_EX_TRIG_SETUP:
return me4000_ai_ex_trig_setup((me4000_ai_trigger_t *) arg,
return me4000_ai_ex_trig_setup((struct me4000_ai_trigger *)arg,
ai_context);
case ME4000_GET_USER_INFO:
return me4000_get_user_info((me4000_user_info_t *) arg,
return me4000_get_user_info((struct me4000_user_info *)arg,
ai_context->board_info);
case ME4000_AI_OFFSET_ENABLE:
return me4000_ai_offset_enable(ai_context);
......@@ -3177,9 +3159,11 @@ static int me4000_ai_ioctl_sing(struct inode *inode_p, struct file *file_p,
case ME4000_AI_FULLSCALE_DISABLE:
return me4000_ai_fullscale_disable(ai_context);
case ME4000_AI_EEPROM_READ:
return me4000_eeprom_read((me4000_eeprom_t *) arg, ai_context);
return me4000_eeprom_read((struct me4000_eeprom *)arg,
ai_context);
case ME4000_AI_EEPROM_WRITE:
return me4000_eeprom_write((me4000_eeprom_t *) arg, ai_context);
return me4000_eeprom_write((struct me4000_eeprom *)arg,
ai_context);
default:
printk(KERN_ERR
"me4000_ai_ioctl_sing():Invalid service number\n");
......@@ -3188,10 +3172,10 @@ static int me4000_ai_ioctl_sing(struct inode *inode_p, struct file *file_p,
return 0;
}
static int me4000_ai_single(me4000_ai_single_t * arg,
me4000_ai_context_t * ai_context)
static int me4000_ai_single(struct me4000_ai_single *arg,
struct me4000_ai_context *ai_context)
{
me4000_ai_single_t cmd;
struct me4000_ai_single cmd;
int err;
u32 tmp;
wait_queue_head_t queue;
......@@ -3202,7 +3186,7 @@ static int me4000_ai_single(me4000_ai_single_t * arg,
init_waitqueue_head(&queue);
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_ai_single_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_ai_single));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ai_single():Can't copy from user space\n");
......@@ -3301,7 +3285,7 @@ static int me4000_ai_single(me4000_ai_single_t * arg,
cmd.value = me4000_inl(ai_context->data_reg) & 0xFFFF;
/* Copy result back to user */
err = copy_to_user(arg, &cmd, sizeof(me4000_ai_single_t));
err = copy_to_user(arg, &cmd, sizeof(struct me4000_ai_single));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ai_single():Can't copy to user space\n");
......@@ -3314,7 +3298,7 @@ static int me4000_ai_single(me4000_ai_single_t * arg,
static int me4000_ai_ioctl_sw(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_ai_context_t *ai_context;
struct me4000_ai_context *ai_context;
CALL_PDEBUG("me4000_ai_ioctl_sw() is executed\n");
......@@ -3332,9 +3316,11 @@ static int me4000_ai_ioctl_sw(struct inode *inode_p, struct file *file_p,
switch (service) {
case ME4000_AI_SC_SETUP:
return me4000_ai_sc_setup((me4000_ai_sc_t *) arg, ai_context);
return me4000_ai_sc_setup((struct me4000_ai_sc *)arg,
ai_context);
case ME4000_AI_CONFIG:
return me4000_ai_config((me4000_ai_config_t *) arg, ai_context);
return me4000_ai_config((struct me4000_ai_config *)arg,
ai_context);
case ME4000_AI_START:
return me4000_ai_start(ai_context);
case ME4000_AI_STOP:
......@@ -3344,19 +3330,20 @@ static int me4000_ai_ioctl_sw(struct inode *inode_p, struct file *file_p,
case ME4000_AI_FSM_STATE:
return me4000_ai_fsm_state((int *)arg, ai_context);
case ME4000_GET_USER_INFO:
return me4000_get_user_info((me4000_user_info_t *) arg,
return me4000_get_user_info((struct me4000_user_info *)arg,
ai_context->board_info);
case ME4000_AI_EEPROM_READ:
return me4000_eeprom_read((me4000_eeprom_t *) arg, ai_context);
return me4000_eeprom_read((struct me4000_eeprom *)arg,
ai_context);
case ME4000_AI_EEPROM_WRITE:
return me4000_eeprom_write((me4000_eeprom_t *) arg, ai_context);
return me4000_eeprom_write((struct me4000_eeprom *)arg,
ai_context);
case ME4000_AI_GET_COUNT_BUFFER:
return me4000_ai_get_count_buffer((unsigned long *)arg,
ai_context);
default:
printk(KERN_ERR
"ME4000:me4000_ai_ioctl_sw():Invalid service number %d\n",
service);
"%s:Invalid service number %d\n", __func__, service);
return -ENOTTY;
}
return 0;
......@@ -3365,7 +3352,7 @@ static int me4000_ai_ioctl_sw(struct inode *inode_p, struct file *file_p,
static int me4000_ai_ioctl_ext(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_ai_context_t *ai_context;
struct me4000_ai_context *ai_context;
CALL_PDEBUG("me4000_ai_ioctl_ext() is executed\n");
......@@ -3383,9 +3370,11 @@ static int me4000_ai_ioctl_ext(struct inode *inode_p, struct file *file_p,
switch (service) {
case ME4000_AI_SC_SETUP:
return me4000_ai_sc_setup((me4000_ai_sc_t *) arg, ai_context);
return me4000_ai_sc_setup((struct me4000_ai_sc *)arg,
ai_context);
case ME4000_AI_CONFIG:
return me4000_ai_config((me4000_ai_config_t *) arg, ai_context);
return me4000_ai_config((struct me4000_ai_config *)arg,
ai_context);
case ME4000_AI_START:
return me4000_ai_start_ex((unsigned long *)arg, ai_context);
case ME4000_AI_STOP:
......@@ -3397,20 +3386,19 @@ static int me4000_ai_ioctl_ext(struct inode *inode_p, struct file *file_p,
case ME4000_AI_EX_TRIG_DISABLE:
return me4000_ai_ex_trig_disable(ai_context);
case ME4000_AI_EX_TRIG_SETUP:
return me4000_ai_ex_trig_setup((me4000_ai_trigger_t *) arg,
return me4000_ai_ex_trig_setup((struct me4000_ai_trigger *)arg,
ai_context);
case ME4000_AI_FSM_STATE:
return me4000_ai_fsm_state((int *)arg, ai_context);
case ME4000_GET_USER_INFO:
return me4000_get_user_info((me4000_user_info_t *) arg,
return me4000_get_user_info((struct me4000_user_info *)arg,
ai_context->board_info);
case ME4000_AI_GET_COUNT_BUFFER:
return me4000_ai_get_count_buffer((unsigned long *)arg,
ai_context);
default:
printk(KERN_ERR
"ME4000:me4000_ai_ioctl_ext():Invalid service number %d\n",
service);
"%s:Invalid service number %d\n", __func__ , service);
return -ENOTTY;
}
return 0;
......@@ -3418,7 +3406,7 @@ static int me4000_ai_ioctl_ext(struct inode *inode_p, struct file *file_p,
static int me4000_ai_fasync(int fd, struct file *file_p, int mode)
{
me4000_ai_context_t *ai_context;
struct me4000_ai_context *ai_context;
CALL_PDEBUG("me4000_ao_fasync_cont() is executed\n");
......@@ -3426,10 +3414,10 @@ static int me4000_ai_fasync(int fd, struct file *file_p, int mode)
return fasync_helper(fd, file_p, mode, &ai_context->fasync_p);
}
static int me4000_ai_config(me4000_ai_config_t * arg,
me4000_ai_context_t * ai_context)
static int me4000_ai_config(struct me4000_ai_config *arg,
struct me4000_ai_context *ai_context)
{
me4000_ai_config_t cmd;
struct me4000_ai_config cmd;
u32 *list = NULL;
u32 mode;
int i;
......@@ -3451,7 +3439,7 @@ static int me4000_ai_config(me4000_ai_config_t * arg,
}
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_ai_config_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_ai_config));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ai_config():Can't copy from user space\n");
......@@ -3671,7 +3659,7 @@ static int me4000_ai_config(me4000_ai_config_t * arg,
return 0;
AI_CONFIG_ERR:
AI_CONFIG_ERR:
/* Reset the timers */
ai_context->chan_timer = 66;
......@@ -3699,7 +3687,7 @@ static int me4000_ai_config(me4000_ai_config_t * arg,
}
static int ai_common_start(me4000_ai_context_t * ai_context)
static int ai_common_start(struct me4000_ai_context *ai_context)
{
u32 tmp;
CALL_PDEBUG("ai_common_start() is executed\n");
......@@ -3762,7 +3750,7 @@ static int ai_common_start(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_start(me4000_ai_context_t * ai_context)
static int me4000_ai_start(struct me4000_ai_context *ai_context)
{
int err;
CALL_PDEBUG("me4000_ai_start() is executed\n");
......@@ -3779,7 +3767,7 @@ static int me4000_ai_start(me4000_ai_context_t * ai_context)
}
static int me4000_ai_start_ex(unsigned long *arg,
me4000_ai_context_t * ai_context)
struct me4000_ai_context *ai_context)
{
int err;
wait_queue_head_t queue;
......@@ -3834,7 +3822,7 @@ static int me4000_ai_start_ex(unsigned long *arg,
return 0;
}
static int me4000_ai_stop(me4000_ai_context_t * ai_context)
static int me4000_ai_stop(struct me4000_ai_context *ai_context)
{
wait_queue_head_t queue;
u32 tmp;
......@@ -3871,7 +3859,7 @@ static int me4000_ai_stop(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_immediate_stop(me4000_ai_context_t * ai_context)
static int me4000_ai_immediate_stop(struct me4000_ai_context *ai_context)
{
wait_queue_head_t queue;
u32 tmp;
......@@ -3908,7 +3896,7 @@ static int me4000_ai_immediate_stop(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_ex_trig_enable(me4000_ai_context_t * ai_context)
static int me4000_ai_ex_trig_enable(struct me4000_ai_context *ai_context)
{
u32 tmp;
unsigned long flags;
......@@ -3924,7 +3912,7 @@ static int me4000_ai_ex_trig_enable(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_ex_trig_disable(me4000_ai_context_t * ai_context)
static int me4000_ai_ex_trig_disable(struct me4000_ai_context *ai_context)
{
u32 tmp;
unsigned long flags;
......@@ -3940,10 +3928,10 @@ static int me4000_ai_ex_trig_disable(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_ex_trig_setup(me4000_ai_trigger_t * arg,
me4000_ai_context_t * ai_context)
static int me4000_ai_ex_trig_setup(struct me4000_ai_trigger *arg,
struct me4000_ai_context *ai_context)
{
me4000_ai_trigger_t cmd;
struct me4000_ai_trigger cmd;
int err;
u32 tmp;
unsigned long flags;
......@@ -3951,7 +3939,7 @@ static int me4000_ai_ex_trig_setup(me4000_ai_trigger_t * arg,
CALL_PDEBUG("me4000_ai_ex_trig_setup() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_ai_trigger_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_ai_trigger));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ai_ex_trig_setup():Can't copy from user space\n");
......@@ -4000,16 +3988,16 @@ static int me4000_ai_ex_trig_setup(me4000_ai_trigger_t * arg,
return 0;
}
static int me4000_ai_sc_setup(me4000_ai_sc_t * arg,
me4000_ai_context_t * ai_context)
static int me4000_ai_sc_setup(struct me4000_ai_sc *arg,
struct me4000_ai_context *ai_context)
{
me4000_ai_sc_t cmd;
struct me4000_ai_sc cmd;
int err;
CALL_PDEBUG("me4000_ai_sc_setup() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_ai_sc_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_ai_sc));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ai_sc_setup():Can't copy from user space\n");
......@@ -4023,9 +4011,9 @@ static int me4000_ai_sc_setup(me4000_ai_sc_t * arg,
}
static ssize_t me4000_ai_read(struct file *filep, char *buff, size_t cnt,
loff_t * offp)
loff_t *offp)
{
me4000_ai_context_t *ai_context = filep->private_data;
struct me4000_ai_context *ai_context = filep->private_data;
s16 *buffer = (s16 *) buff;
size_t count = cnt / 2;
unsigned long flags;
......@@ -4150,9 +4138,9 @@ static ssize_t me4000_ai_read(struct file *filep, char *buff, size_t cnt,
return ret * 2;
}
static unsigned int me4000_ai_poll(struct file *file_p, poll_table * wait)
static unsigned int me4000_ai_poll(struct file *file_p, poll_table *wait)
{
me4000_ai_context_t *ai_context;
struct me4000_ai_context *ai_context;
unsigned long mask = 0;
CALL_PDEBUG("me4000_ai_poll() is executed\n");
......@@ -4171,7 +4159,7 @@ static unsigned int me4000_ai_poll(struct file *file_p, poll_table * wait)
return mask;
}
static int me4000_ai_offset_enable(me4000_ai_context_t * ai_context)
static int me4000_ai_offset_enable(struct me4000_ai_context *ai_context)
{
unsigned long tmp;
......@@ -4184,7 +4172,7 @@ static int me4000_ai_offset_enable(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_offset_disable(me4000_ai_context_t * ai_context)
static int me4000_ai_offset_disable(struct me4000_ai_context *ai_context)
{
unsigned long tmp;
......@@ -4197,7 +4185,7 @@ static int me4000_ai_offset_disable(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_fullscale_enable(me4000_ai_context_t * ai_context)
static int me4000_ai_fullscale_enable(struct me4000_ai_context *ai_context)
{
unsigned long tmp;
......@@ -4210,7 +4198,7 @@ static int me4000_ai_fullscale_enable(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_fullscale_disable(me4000_ai_context_t * ai_context)
static int me4000_ai_fullscale_disable(struct me4000_ai_context *ai_context)
{
unsigned long tmp;
......@@ -4223,7 +4211,7 @@ static int me4000_ai_fullscale_disable(me4000_ai_context_t * ai_context)
return 0;
}
static int me4000_ai_fsm_state(int *arg, me4000_ai_context_t * ai_context)
static int me4000_ai_fsm_state(int *arg, struct me4000_ai_context *ai_context)
{
unsigned long tmp;
......@@ -4242,7 +4230,7 @@ static int me4000_ai_fsm_state(int *arg, me4000_ai_context_t * ai_context)
}
static int me4000_ai_get_count_buffer(unsigned long *arg,
me4000_ai_context_t * ai_context)
struct me4000_ai_context *ai_context)
{
unsigned long c;
int err;
......@@ -4252,7 +4240,7 @@ static int me4000_ai_get_count_buffer(unsigned long *arg,
err = copy_to_user(arg, &c, sizeof(unsigned long));
if (err) {
printk(KERN_ERR
"ME4000:me4000_ai_get_count_buffer():Can't copy to user space\n");
"%s:Can't copy to user space\n", __func__);
return -EFAULT;
}
......@@ -4261,7 +4249,7 @@ static int me4000_ai_get_count_buffer(unsigned long *arg,
/*---------------------------------- EEPROM stuff ---------------------------*/
static int eeprom_write_cmd(me4000_ai_context_t * ai_context, unsigned long cmd,
static int eeprom_write_cmd(struct me4000_ai_context *ai_context, unsigned long cmd,
int length)
{
int i;
......@@ -4318,7 +4306,7 @@ static int eeprom_write_cmd(me4000_ai_context_t * ai_context, unsigned long cmd,
return 0;
}
static unsigned short eeprom_read_cmd(me4000_ai_context_t * ai_context,
static unsigned short eeprom_read_cmd(struct me4000_ai_context *ai_context,
unsigned long cmd, int length)
{
int i;
......@@ -4397,11 +4385,11 @@ static unsigned short eeprom_read_cmd(me4000_ai_context_t * ai_context,
return id;
}
static int me4000_eeprom_write(me4000_eeprom_t * arg,
me4000_ai_context_t * ai_context)
static int me4000_eeprom_write(struct me4000_eeprom *arg,
struct me4000_ai_context *ai_context)
{
int err;
me4000_eeprom_t setup;
struct me4000_eeprom setup;
unsigned long cmd;
unsigned long date_high;
unsigned long date_low;
......@@ -4594,12 +4582,12 @@ static int me4000_eeprom_write(me4000_eeprom_t * arg,
return 0;
}
static int me4000_eeprom_read(me4000_eeprom_t * arg,
me4000_ai_context_t * ai_context)
static int me4000_eeprom_read(struct me4000_eeprom *arg,
struct me4000_ai_context *ai_context)
{
int err;
unsigned long cmd;
me4000_eeprom_t setup;
struct me4000_eeprom setup;
CALL_PDEBUG("me4000_eeprom_read() is executed\n");
......@@ -4687,7 +4675,7 @@ static int me4000_eeprom_read(me4000_eeprom_t * arg,
static int me4000_dio_ioctl(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_dio_context_t *dio_context;
struct me4000_dio_context *dio_context;
CALL_PDEBUG("me4000_dio_ioctl() is executed\n");
......@@ -4704,13 +4692,13 @@ static int me4000_dio_ioctl(struct inode *inode_p, struct file *file_p,
switch (service) {
case ME4000_DIO_CONFIG:
return me4000_dio_config((me4000_dio_config_t *) arg,
return me4000_dio_config((struct me4000_dio_config *)arg,
dio_context);
case ME4000_DIO_SET_BYTE:
return me4000_dio_set_byte((me4000_dio_byte_t *) arg,
return me4000_dio_set_byte((struct me4000_dio_byte *)arg,
dio_context);
case ME4000_DIO_GET_BYTE:
return me4000_dio_get_byte((me4000_dio_byte_t *) arg,
return me4000_dio_get_byte((struct me4000_dio_byte *)arg,
dio_context);
case ME4000_DIO_RESET:
return me4000_dio_reset(dio_context);
......@@ -4723,17 +4711,17 @@ static int me4000_dio_ioctl(struct inode *inode_p, struct file *file_p,
return 0;
}
static int me4000_dio_config(me4000_dio_config_t * arg,
me4000_dio_context_t * dio_context)
static int me4000_dio_config(struct me4000_dio_config *arg,
struct me4000_dio_context *dio_context)
{
me4000_dio_config_t cmd;
struct me4000_dio_config cmd;
u32 tmp;
int err;
CALL_PDEBUG("me4000_dio_config() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_dio_config_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_dio_config));
if (err) {
printk(KERN_ERR
"ME4000:me4000_dio_config():Can't copy from user space\n");
......@@ -4964,16 +4952,16 @@ static int me4000_dio_config(me4000_dio_config_t * arg,
return 0;
}
static int me4000_dio_set_byte(me4000_dio_byte_t * arg,
me4000_dio_context_t * dio_context)
static int me4000_dio_set_byte(struct me4000_dio_byte *arg,
struct me4000_dio_context *dio_context)
{
me4000_dio_byte_t cmd;
struct me4000_dio_byte cmd;
int err;
CALL_PDEBUG("me4000_dio_set_byte() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_dio_byte_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_dio_byte));
if (err) {
printk(KERN_ERR
"ME4000:me4000_dio_set_byte():Can't copy from user space\n");
......@@ -5030,16 +5018,16 @@ static int me4000_dio_set_byte(me4000_dio_byte_t * arg,
return 0;
}
static int me4000_dio_get_byte(me4000_dio_byte_t * arg,
me4000_dio_context_t * dio_context)
static int me4000_dio_get_byte(struct me4000_dio_byte *arg,
struct me4000_dio_context *dio_context)
{
me4000_dio_byte_t cmd;
struct me4000_dio_byte cmd;
int err;
CALL_PDEBUG("me4000_dio_get_byte() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_dio_byte_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_dio_byte));
if (err) {
printk(KERN_ERR
"ME4000:me4000_dio_get_byte():Can't copy from user space\n");
......@@ -5070,7 +5058,7 @@ static int me4000_dio_get_byte(me4000_dio_byte_t * arg,
}
/* Copy result back to user */
err = copy_to_user(arg, &cmd, sizeof(me4000_dio_byte_t));
err = copy_to_user(arg, &cmd, sizeof(struct me4000_dio_byte));
if (err) {
printk(KERN_ERR
"ME4000:me4000_dio_get_byte():Can't copy to user space\n");
......@@ -5080,7 +5068,7 @@ static int me4000_dio_get_byte(me4000_dio_byte_t * arg,
return 0;
}
static int me4000_dio_reset(me4000_dio_context_t * dio_context)
static int me4000_dio_reset(struct me4000_dio_context *dio_context)
{
CALL_PDEBUG("me4000_dio_reset() is executed\n");
......@@ -5101,7 +5089,7 @@ static int me4000_dio_reset(me4000_dio_context_t * dio_context)
static int me4000_cnt_ioctl(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_cnt_context_t *cnt_context;
struct me4000_cnt_context *cnt_context;
CALL_PDEBUG("me4000_cnt_ioctl() is executed\n");
......@@ -5118,11 +5106,11 @@ static int me4000_cnt_ioctl(struct inode *inode_p, struct file *file_p,
switch (service) {
case ME4000_CNT_READ:
return me4000_cnt_read((me4000_cnt_t *) arg, cnt_context);
return me4000_cnt_read((struct me4000_cnt *)arg, cnt_context);
case ME4000_CNT_WRITE:
return me4000_cnt_write((me4000_cnt_t *) arg, cnt_context);
return me4000_cnt_write((struct me4000_cnt *)arg, cnt_context);
case ME4000_CNT_CONFIG:
return me4000_cnt_config((me4000_cnt_config_t *) arg,
return me4000_cnt_config((struct me4000_cnt_config *)arg,
cnt_context);
case ME4000_CNT_RESET:
return me4000_cnt_reset(cnt_context);
......@@ -5135,10 +5123,10 @@ static int me4000_cnt_ioctl(struct inode *inode_p, struct file *file_p,
return 0;
}
static int me4000_cnt_config(me4000_cnt_config_t * arg,
me4000_cnt_context_t * cnt_context)
static int me4000_cnt_config(struct me4000_cnt_config *arg,
struct me4000_cnt_context *cnt_context)
{
me4000_cnt_config_t cmd;
struct me4000_cnt_config cmd;
u8 counter;
u8 mode;
int err;
......@@ -5146,7 +5134,7 @@ static int me4000_cnt_config(me4000_cnt_config_t * arg,
CALL_PDEBUG("me4000_cnt_config() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_cnt_config_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_cnt_config));
if (err) {
printk(KERN_ERR
"ME4000:me4000_cnt_config():Can't copy from user space\n");
......@@ -5204,17 +5192,17 @@ static int me4000_cnt_config(me4000_cnt_config_t * arg,
return 0;
}
static int me4000_cnt_read(me4000_cnt_t * arg,
me4000_cnt_context_t * cnt_context)
static int me4000_cnt_read(struct me4000_cnt *arg,
struct me4000_cnt_context *cnt_context)
{
me4000_cnt_t cmd;
struct me4000_cnt cmd;
u8 tmp;
int err;
CALL_PDEBUG("me4000_cnt_read() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_cnt_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_cnt));
if (err) {
printk(KERN_ERR
"ME4000:me4000_cnt_read():Can't copy from user space\n");
......@@ -5249,7 +5237,7 @@ static int me4000_cnt_read(me4000_cnt_t * arg,
}
/* Copy result back to user */
err = copy_to_user(arg, &cmd, sizeof(me4000_cnt_t));
err = copy_to_user(arg, &cmd, sizeof(struct me4000_cnt));
if (err) {
printk(KERN_ERR
"ME4000:me4000_cnt_read():Can't copy to user space\n");
......@@ -5259,17 +5247,17 @@ static int me4000_cnt_read(me4000_cnt_t * arg,
return 0;
}
static int me4000_cnt_write(me4000_cnt_t * arg,
me4000_cnt_context_t * cnt_context)
static int me4000_cnt_write(struct me4000_cnt *arg,
struct me4000_cnt_context *cnt_context)
{
me4000_cnt_t cmd;
struct me4000_cnt cmd;
u8 tmp;
int err;
CALL_PDEBUG("me4000_cnt_write() is executed\n");
/* Copy data from user */
err = copy_from_user(&cmd, arg, sizeof(me4000_cnt_t));
err = copy_from_user(&cmd, arg, sizeof(struct me4000_cnt));
if (err) {
printk(KERN_ERR
"ME4000:me4000_cnt_write():Can't copy from user space\n");
......@@ -5306,7 +5294,7 @@ static int me4000_cnt_write(me4000_cnt_t * arg,
return 0;
}
static int me4000_cnt_reset(me4000_cnt_context_t * cnt_context)
static int me4000_cnt_reset(struct me4000_cnt_context *cnt_context)
{
CALL_PDEBUG("me4000_cnt_reset() is executed\n");
......@@ -5333,7 +5321,7 @@ static int me4000_cnt_reset(me4000_cnt_context_t * cnt_context)
static int me4000_ext_int_ioctl(struct inode *inode_p, struct file *file_p,
unsigned int service, unsigned long arg)
{
me4000_ext_int_context_t *ext_int_context;
struct me4000_ext_int_context *ext_int_context;
CALL_PDEBUG("me4000_ext_int_ioctl() is executed\n");
......@@ -5366,7 +5354,7 @@ static int me4000_ext_int_ioctl(struct inode *inode_p, struct file *file_p,
return 0;
}
static int me4000_ext_int_enable(me4000_ext_int_context_t * ext_int_context)
static int me4000_ext_int_enable(struct me4000_ext_int_context *ext_int_context)
{
unsigned long tmp;
......@@ -5379,7 +5367,7 @@ static int me4000_ext_int_enable(me4000_ext_int_context_t * ext_int_context)
return 0;
}
static int me4000_ext_int_disable(me4000_ext_int_context_t * ext_int_context)
static int me4000_ext_int_disable(struct me4000_ext_int_context *ext_int_context)
{
unsigned long tmp;
......@@ -5393,7 +5381,7 @@ static int me4000_ext_int_disable(me4000_ext_int_context_t * ext_int_context)
}
static int me4000_ext_int_count(unsigned long *arg,
me4000_ext_int_context_t * ext_int_context)
struct me4000_ext_int_context *ext_int_context)
{
CALL_PDEBUG("me4000_ext_int_count() is executed\n");
......@@ -5404,10 +5392,10 @@ static int me4000_ext_int_count(unsigned long *arg,
/*------------------------------------ General stuff ------------------------------------*/
static int me4000_get_user_info(me4000_user_info_t * arg,
me4000_info_t * board_info)
static int me4000_get_user_info(struct me4000_user_info *arg,
struct me4000_info *board_info)
{
me4000_user_info_t user_info;
struct me4000_user_info user_info;
CALL_PDEBUG("me4000_get_user_info() is executed\n");
......@@ -5437,7 +5425,7 @@ static int me4000_get_user_info(me4000_user_info_t * arg,
user_info.cnt_count = board_info->board_p->cnt.count;
if (copy_to_user(arg, &user_info, sizeof(me4000_user_info_t)))
if (copy_to_user(arg, &user_info, sizeof(struct me4000_user_info)))
return -EFAULT;
return 0;
......@@ -5448,7 +5436,7 @@ static int me4000_get_user_info(me4000_user_info_t * arg,
static int me4000_ext_int_fasync(int fd, struct file *file_ptr, int mode)
{
int result = 0;
me4000_ext_int_context_t *ext_int_context;
struct me4000_ext_int_context *ext_int_context;
CALL_PDEBUG("me4000_ext_int_fasync() is executed\n");
......@@ -5465,7 +5453,7 @@ static irqreturn_t me4000_ao_isr(int irq, void *dev_id)
{
u32 tmp;
u32 value;
me4000_ao_context_t *ao_context;
struct me4000_ao_context *ao_context;
int i;
int c = 0;
int c1 = 0;
......@@ -5589,7 +5577,7 @@ static irqreturn_t me4000_ao_isr(int irq, void *dev_id)
static irqreturn_t me4000_ai_isr(int irq, void *dev_id)
{
u32 tmp;
me4000_ai_context_t *ai_context;
struct me4000_ai_context *ai_context;
int i;
int c = 0;
int c1 = 0;
......@@ -5933,7 +5921,7 @@ static irqreturn_t me4000_ai_isr(int irq, void *dev_id)
static irqreturn_t me4000_ext_int_isr(int irq, void *dev_id)
{
me4000_ext_int_context_t *ext_int_context;
struct me4000_ext_int_context *ext_int_context;
unsigned long tmp;
ISR_PDEBUG("me4000_ext_int_isr() is executed\n");
......@@ -5969,10 +5957,10 @@ static irqreturn_t me4000_ext_int_isr(int irq, void *dev_id)
return IRQ_HANDLED;
}
void __exit me4000_module_exit(void)
static void __exit me4000_module_exit(void)
{
struct list_head *board_p;
me4000_info_t *board_info;
struct me4000_info *board_info;
CALL_PDEBUG("cleanup_module() is executed\n");
......@@ -5993,7 +5981,7 @@ void __exit me4000_module_exit(void)
/* Reset the boards */
for (board_p = me4000_board_info_list.next;
board_p != &me4000_board_info_list; board_p = board_p->next) {
board_info = list_entry(board_p, me4000_info_t, list);
board_info = list_entry(board_p, struct me4000_info, list);
me4000_reset_board(board_info);
}
......@@ -6007,7 +5995,7 @@ static int me4000_read_procmem(char *buf, char **start, off_t offset, int count,
{
int len = 0;
int limit = count - 1000;
me4000_info_t *board_info;
struct me4000_info *board_info;
struct list_head *ptr;
len += sprintf(buf + len, "\nME4000 DRIVER VERSION %X.%X.%X\n\n",
......@@ -6019,7 +6007,7 @@ static int me4000_read_procmem(char *buf, char **start, off_t offset, int count,
for (ptr = me4000_board_info_list.next;
(ptr != &me4000_board_info_list) && (len < limit);
ptr = ptr->next) {
board_info = list_entry(ptr, me4000_info_t, list);
board_info = list_entry(ptr, struct me4000_info, list);
len +=
sprintf(buf + len, "Board number %d:\n",
......
drivers/staging/me4000/me4000.h
View file @ 0b65d3cc
......@@ -329,46 +329,46 @@
Circular buffer used for analog input/output reads/writes.
===========================================================================*/
typedef struct me4000_circ_buf {
struct me4000_circ_buf {
s16 *buf;
int volatile head;
int volatile tail;
} me4000_circ_buf_t;
};
/*=============================================================================
Information about the hardware capabilities
===========================================================================*/
typedef struct me4000_ao_info {
struct me4000_ao_info {
int count;
int fifo_count;
} me4000_ao_info_t;
};
typedef struct me4000_ai_info {
struct me4000_ai_info {
int count;
int sh_count;
int diff_count;
int ex_trig_analog;
} me4000_ai_info_t;
};
typedef struct me4000_dio_info {
struct me4000_dio_info {
int count;
} me4000_dio_info_t;
};
typedef struct me4000_cnt_info {
struct me4000_cnt_info {
int count;
} me4000_cnt_info_t;
};
typedef struct me4000_board {
struct me4000_board {
u16 vendor_id;
u16 device_id;
me4000_ao_info_t ao;
me4000_ai_info_t ai;
me4000_dio_info_t dio;
me4000_cnt_info_t cnt;
} me4000_board_t;
struct me4000_ao_info ao;
struct me4000_ai_info ai;
struct me4000_dio_info dio;
struct me4000_cnt_info cnt;
};
static me4000_board_t me4000_boards[] = {
static struct me4000_board me4000_boards[] = {
{PCI_VENDOR_ID_MEILHAUS, 0x4610, {0, 0}, {16, 0, 0, 0}, {4}, {3}},
{PCI_VENDOR_ID_MEILHAUS, 0x4650, {0, 0}, {16, 0, 0, 0}, {4}, {0}},
......@@ -391,8 +391,6 @@ static me4000_board_t me4000_boards[] = {
{0},
};
#define ME4000_BOARD_VERSIONS (sizeof(me4000_boards) / sizeof(me4000_board_t) - 1)
/*=============================================================================
PCI device table.
This is used by modprobe to translate PCI IDs to drivers.
......@@ -427,19 +425,19 @@ MODULE_DEVICE_TABLE(pci, me4000_pci_table);
Global board and subdevice information structures
===========================================================================*/
typedef struct me4000_info {
struct me4000_info {
struct list_head list; // List of all detected boards
int board_count; // Index of the board after detection
unsigned long plx_regbase; // PLX configuration space base address
unsigned long me4000_regbase; // Base address of the ME4000
unsigned long timer_regbase; // Base address of the timer circuit
unsigned long program_regbase; // Base address to set the program pin for the xilinx
resource_size_t me4000_regbase; // Base address of the ME4000
resource_size_t timer_regbase; // Base address of the timer circuit
resource_size_t program_regbase; // Base address to set the program pin for the xilinx
unsigned long plx_regbase_size; // PLX register set space
unsigned long me4000_regbase_size; // ME4000 register set space
unsigned long timer_regbase_size; // Timer circuit register set space
unsigned long program_regbase_size; // Size of program base address of the ME4000
resource_size_t me4000_regbase_size; // ME4000 register set space
resource_size_t timer_regbase_size; // Timer circuit register set space
resource_size_t program_regbase_size; // Size of program base address of the ME4000
unsigned int serial_no; // Serial number of the board
unsigned char hw_revision; // Hardware revision of the board
......@@ -451,7 +449,7 @@ typedef struct me4000_info {
int pci_func_no; // PCI function number
struct pci_dev *pci_dev_p; // General PCI information
me4000_board_t *board_p; // Holds the board capabilities
struct me4000_board *board_p; // Holds the board capabilities
unsigned int irq; // IRQ assigned from the PCI BIOS
unsigned int irq_count; // Count of external interrupts
......@@ -464,18 +462,18 @@ typedef struct me4000_info {
struct me4000_dio_context *dio_context; // Digital I/O specific context
struct me4000_cnt_context *cnt_context; // Counter specific context
struct me4000_ext_int_context *ext_int_context; // External interrupt specific context
} me4000_info_t;
};
typedef struct me4000_ao_context {
struct me4000_ao_context {
struct list_head list; // linked list of me4000_ao_context_t
int index; // Index in the list
int mode; // Indicates mode (0 = single, 1 = wraparound, 2 = continous)
int dac_in_use; // Indicates if already opend
spinlock_t use_lock; // Guards in_use
spinlock_t int_lock; // Used when locking out interrupts
me4000_circ_buf_t circ_buf; // Circular buffer
struct me4000_circ_buf circ_buf; // Circular buffer
wait_queue_head_t wait_queue; // Wait queue to sleep while blocking write
me4000_info_t *board_info;
struct me4000_info *board_info;
unsigned int irq; // The irq associated with this ADC
int volatile pipe_flag; // Indicates broken pipe set from me4000_ao_isr()
unsigned long ctrl_reg;
......@@ -486,9 +484,9 @@ typedef struct me4000_ao_context {
unsigned long irq_status_reg;
unsigned long preload_reg;
struct fasync_struct *fasync_p; // Queue for asynchronous notification
} me4000_ao_context_t;
};
typedef struct me4000_ai_context {
struct me4000_ai_context {
struct list_head list; // linked list of me4000_ai_info_t
int mode; // Indicates mode
int in_use; // Indicates if already opend
......@@ -496,9 +494,9 @@ typedef struct me4000_ai_context {
spinlock_t int_lock; // Used when locking out interrupts
int number; // Number of the DAC
unsigned int irq; // The irq associated with this ADC
me4000_circ_buf_t circ_buf; // Circular buffer
struct me4000_circ_buf circ_buf; // Circular buffer
wait_queue_head_t wait_queue; // Wait queue to sleep while blocking read
me4000_info_t *board_info;
struct me4000_info *board_info;
struct fasync_struct *fasync_p; // Queue for asynchronous notification
......@@ -523,48 +521,48 @@ typedef struct me4000_ai_context {
unsigned long channel_list_count;
unsigned long sample_counter;
int sample_counter_reload;
} me4000_ai_context_t;
};
typedef struct me4000_dio_context {
struct me4000_dio_context {
struct list_head list; // linked list of me4000_dio_context_t
int in_use; // Indicates if already opend
spinlock_t use_lock; // Guards in_use
int number;
int dio_count;
me4000_info_t *board_info;
struct me4000_info *board_info;
unsigned long dir_reg;
unsigned long ctrl_reg;
unsigned long port_0_reg;
unsigned long port_1_reg;
unsigned long port_2_reg;
unsigned long port_3_reg;
} me4000_dio_context_t;
};
typedef struct me4000_cnt_context {
struct me4000_cnt_context {
struct list_head list; // linked list of me4000_dio_context_t
int in_use; // Indicates if already opend
spinlock_t use_lock; // Guards in_use
int number;
int cnt_count;
me4000_info_t *board_info;
struct me4000_info *board_info;
unsigned long ctrl_reg;
unsigned long counter_0_reg;
unsigned long counter_1_reg;
unsigned long counter_2_reg;
} me4000_cnt_context_t;
};
typedef struct me4000_ext_int_context {
struct me4000_ext_int_context {
struct list_head list; // linked list of me4000_dio_context_t
int in_use; // Indicates if already opend
spinlock_t use_lock; // Guards in_use
int number;
me4000_info_t *board_info;
struct me4000_info *board_info;
unsigned int irq;
unsigned long int_count;
struct fasync_struct *fasync_ptr;
unsigned long ctrl_reg;
unsigned long irq_status_reg;
} me4000_ext_int_context_t;
};
#endif
......@@ -745,12 +743,12 @@ typedef struct me4000_ext_int_context {
General type definitions
----------------------------------------------------------------------------*/
typedef struct me4000_user_info {
struct me4000_user_info {
int board_count; // Index of the board after detection
unsigned long plx_regbase; // PLX configuration space base address
unsigned long me4000_regbase; // Base address of the ME4000
resource_size_t me4000_regbase; // Base address of the ME4000
unsigned long plx_regbase_size; // PLX register set space
unsigned long me4000_regbase_size; // ME4000 register set space
resource_size_t me4000_regbase_size; // ME4000 register set space
unsigned long serial_no; // Serial number of the board
unsigned char hw_revision; // Hardware revision of the board
unsigned short vendor_id; // Meilhaus vendor id (0x1402)
......@@ -773,62 +771,62 @@ typedef struct me4000_user_info {
int dio_count; // Count of digital I/O ports
int cnt_count; // Count of counters
} me4000_user_info_t;
};
/*-----------------------------------------------------------------------------
Type definitions for analog output
----------------------------------------------------------------------------*/
typedef struct me4000_ao_channel_list {
struct me4000_ao_channel_list {
unsigned long count;
unsigned long *list;
} me4000_ao_channel_list_t;
};
/*-----------------------------------------------------------------------------
Type definitions for analog input
----------------------------------------------------------------------------*/
typedef struct me4000_ai_channel_list {
struct me4000_ai_channel_list {
unsigned long count;
unsigned long *list;
} me4000_ai_channel_list_t;
};
typedef struct me4000_ai_timer {
struct me4000_ai_timer {
unsigned long pre_chan;
unsigned long chan;
unsigned long scan_low;
unsigned long scan_high;
} me4000_ai_timer_t;
};
typedef struct me4000_ai_config {
me4000_ai_timer_t timer;
me4000_ai_channel_list_t channel_list;
struct me4000_ai_config {
struct me4000_ai_timer timer;
struct me4000_ai_channel_list channel_list;
int sh;
} me4000_ai_config_t;
};
typedef struct me4000_ai_single {
struct me4000_ai_single {
int channel;
int range;
int mode;
short value;
unsigned long timeout;
} me4000_ai_single_t;
};
typedef struct me4000_ai_trigger {
struct me4000_ai_trigger {
int mode;
int edge;
} me4000_ai_trigger_t;
};
typedef struct me4000_ai_sc {
struct me4000_ai_sc {
unsigned long value;
int reload;
} me4000_ai_sc_t;
};
/*-----------------------------------------------------------------------------
Type definitions for eeprom
----------------------------------------------------------------------------*/
typedef struct me4000_eeprom {
struct me4000_eeprom {
unsigned long date;
short uni_10_offset;
short uni_10_fullscale;
......@@ -842,45 +840,45 @@ typedef struct me4000_eeprom {
short diff_10_fullscale;
short diff_2_5_offset;
short diff_2_5_fullscale;
} me4000_eeprom_t;
};
/*-----------------------------------------------------------------------------
Type definitions for digital I/O
----------------------------------------------------------------------------*/
typedef struct me4000_dio_config {
struct me4000_dio_config {
int port;
int mode;
int function;
} me4000_dio_config_t;
};
typedef struct me4000_dio_byte {
struct me4000_dio_byte {
int port;
unsigned char byte;
} me4000_dio_byte_t;
};
/*-----------------------------------------------------------------------------
Type definitions for counters
----------------------------------------------------------------------------*/
typedef struct me4000_cnt {
struct me4000_cnt {
int counter;
unsigned short value;
} me4000_cnt_t;
};
typedef struct me4000_cnt_config {
struct me4000_cnt_config {
int counter;
int mode;
} me4000_cnt_config_t;
};
/*-----------------------------------------------------------------------------
Type definitions for external interrupt
----------------------------------------------------------------------------*/
typedef struct {
struct me4000_int {
int int1_count;
int int2_count;
} me4000_int_type;
};
/*-----------------------------------------------------------------------------
The ioctls of the board
......@@ -888,7 +886,8 @@ typedef struct {
#define ME4000_IOCTL_MAXNR 50
#define ME4000_MAGIC 'y'
#define ME4000_GET_USER_INFO _IOR (ME4000_MAGIC, 0, me4000_user_info_t)
#define ME4000_GET_USER_INFO _IOR (ME4000_MAGIC, 0, \
struct me4000_user_info)
#define ME4000_AO_START _IOW (ME4000_MAGIC, 1, unsigned long)
#define ME4000_AO_STOP _IO (ME4000_MAGIC, 2)
......@@ -904,25 +903,35 @@ typedef struct {
#define ME4000_AO_DISABLE_DO _IO (ME4000_MAGIC, 12)
#define ME4000_AO_FSM_STATE _IOR (ME4000_MAGIC, 13, int)
#define ME4000_AI_SINGLE _IOR (ME4000_MAGIC, 14, me4000_ai_single_t)
#define ME4000_AI_SINGLE _IOR (ME4000_MAGIC, 14, \
struct me4000_ai_single)
#define ME4000_AI_START _IOW (ME4000_MAGIC, 15, unsigned long)
#define ME4000_AI_STOP _IO (ME4000_MAGIC, 16)
#define ME4000_AI_IMMEDIATE_STOP _IO (ME4000_MAGIC, 17)
#define ME4000_AI_EX_TRIG_ENABLE _IO (ME4000_MAGIC, 18)
#define ME4000_AI_EX_TRIG_DISABLE _IO (ME4000_MAGIC, 19)
#define ME4000_AI_EX_TRIG_SETUP _IOW (ME4000_MAGIC, 20, me4000_ai_trigger_t)
#define ME4000_AI_CONFIG _IOW (ME4000_MAGIC, 21, me4000_ai_config_t)
#define ME4000_AI_SC_SETUP _IOW (ME4000_MAGIC, 22, me4000_ai_sc_t)
#define ME4000_AI_EX_TRIG_SETUP _IOW (ME4000_MAGIC, 20, \
struct me4000_ai_trigger)
#define ME4000_AI_CONFIG _IOW (ME4000_MAGIC, 21, \
struct me4000_ai_config)
#define ME4000_AI_SC_SETUP _IOW (ME4000_MAGIC, 22, \
struct me4000_ai_sc)
#define ME4000_AI_FSM_STATE _IOR (ME4000_MAGIC, 23, int)
#define ME4000_DIO_CONFIG _IOW (ME4000_MAGIC, 24, me4000_dio_config_t)
#define ME4000_DIO_GET_BYTE _IOR (ME4000_MAGIC, 25, me4000_dio_byte_t)
#define ME4000_DIO_SET_BYTE _IOW (ME4000_MAGIC, 26, me4000_dio_byte_t)
#define ME4000_DIO_CONFIG _IOW (ME4000_MAGIC, 24, \
struct me4000_dio_config)
#define ME4000_DIO_GET_BYTE _IOR (ME4000_MAGIC, 25, \
struct me4000_dio_byte)
#define ME4000_DIO_SET_BYTE _IOW (ME4000_MAGIC, 26, \
struct me4000_dio_byte)
#define ME4000_DIO_RESET _IO (ME4000_MAGIC, 27)
#define ME4000_CNT_READ _IOR (ME4000_MAGIC, 28, me4000_cnt_t)
#define ME4000_CNT_WRITE _IOW (ME4000_MAGIC, 29, me4000_cnt_t)
#define ME4000_CNT_CONFIG _IOW (ME4000_MAGIC, 30, me4000_cnt_config_t)
#define ME4000_CNT_READ _IOR (ME4000_MAGIC, 28, \
struct me4000_cnt)
#define ME4000_CNT_WRITE _IOW (ME4000_MAGIC, 29, \
struct me4000_cnt)
#define ME4000_CNT_CONFIG _IOW (ME4000_MAGIC, 30, \
struct me4000_cnt_config)
#define ME4000_CNT_RESET _IO (ME4000_MAGIC, 31)
#define ME4000_EXT_INT_DISABLE _IO (ME4000_MAGIC, 32)
......@@ -934,13 +943,16 @@ typedef struct {
#define ME4000_AI_FULLSCALE_ENABLE _IO (ME4000_MAGIC, 37)
#define ME4000_AI_FULLSCALE_DISABLE _IO (ME4000_MAGIC, 38)
#define ME4000_AI_EEPROM_READ _IOR (ME4000_MAGIC, 39, me4000_eeprom_t)
#define ME4000_AI_EEPROM_WRITE _IOW (ME4000_MAGIC, 40, me4000_eeprom_t)
#define ME4000_AI_EEPROM_READ _IOR (ME4000_MAGIC, 39, \
struct me4000_eeprom)
#define ME4000_AI_EEPROM_WRITE _IOW (ME4000_MAGIC, 40, \
struct me4000_eeprom)
#define ME4000_AO_SIMULTANEOUS_EX_TRIG _IO (ME4000_MAGIC, 41)
#define ME4000_AO_SIMULTANEOUS_SW _IO (ME4000_MAGIC, 42)
#define ME4000_AO_SIMULTANEOUS_DISABLE _IO (ME4000_MAGIC, 43)
#define ME4000_AO_SIMULTANEOUS_UPDATE _IOW (ME4000_MAGIC, 44, me4000_ao_channel_list_t)
#define ME4000_AO_SIMULTANEOUS_UPDATE _IOW (ME4000_MAGIC, 44, \
struct me4000_ao_channel_list)
#define ME4000_AO_SYNCHRONOUS_EX_TRIG _IO (ME4000_MAGIC, 45)
#define ME4000_AO_SYNCHRONOUS_SW _IO (ME4000_MAGIC, 46)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment