From: Mariusz Kozlowski Date: Mon, 16 Feb 2009 20:31:28 +0000 (+0100) Subject: Staging: comedi: usbduxfast: fix checkpatch issues plus some style cleanups etc. X-Git-Url: https://git.karo-electronics.de/?a=commitdiff_plain;h=4e8ad0dca9bbd9724ffa395b9ab425c4f22e1346;p=linux-beck.git Staging: comedi: usbduxfast: fix checkpatch issues plus some style cleanups etc. This patch is a major code rewrite to make checkpatch.pl happy and also other minor things are fixed. Signed-off-by: Mariusz Kozlowski Cc: Bernd Porr Cc: David Schleef Cc: Frank Mori Hess Cc: Ian Abbott Signed-off-by: Greg Kroah-Hartman --- diff --git a/drivers/staging/comedi/drivers/usbduxfast.c b/drivers/staging/comedi/drivers/usbduxfast.c index 3439a0591e92..c6d34703a344 100644 --- a/drivers/staging/comedi/drivers/usbduxfast.c +++ b/drivers/staging/comedi/drivers/usbduxfast.c @@ -1,33 +1,20 @@ -#define DRIVER_VERSION "v0.99a" -#define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com" -#define DRIVER_DESC "USB-DUXfast, BerndPorr@f2s.com" /* - comedi/drivers/usbduxfast.c - Copyright (C) 2004 Bernd Porr, Bernd.Porr@f2s.com - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. -*/ - -/* -Driver: usbduxfast -Description: ITL USB-DUXfast -Devices: [ITL] USB-DUX (usbduxfast.o) -Author: Bernd Porr -Updated: 04 Dec 2006 -Status: testing -*/ + * Copyright (C) 2004 Bernd Porr, Bernd.Porr@f2s.com + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ /* * I must give credit here to Chris Baugher who @@ -42,7 +29,8 @@ Status: testing * 0.9: Dropping the first data packet which seems to be from the last transfer. * Buffer overflows in the FX2 are handed over to comedi. * 0.92: Dropping now 4 packets. The quad buffer has to be emptied. - * Added insn command basically for testing. Sample rate is 1MHz/16ch=62.5kHz + * Added insn command basically for testing. Sample rate is + * 1MHz/16ch=62.5kHz * 0.99: Ian Abbott pointed out a bug which has been corrected. Thanks! * 0.99a: added external trigger. */ @@ -59,522 +47,560 @@ Status: testing #include "comedi_fc.h" #include "../comedidev.h" + +#define DRIVER_VERSION "v0.99a" +#define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com" +#define DRIVER_DESC "USB-DUXfast, BerndPorr@f2s.com" #define BOARDNAME "usbduxfast" -// timeout for the USB-transfer -#define EZTIMEOUT 30 +/* + * timeout for the USB-transfer + */ +#define EZTIMEOUT 30 -// constants for "firmware" upload and download -#define USBDUXFASTSUB_FIRMWARE 0xA0 -#define VENDOR_DIR_IN 0xC0 -#define VENDOR_DIR_OUT 0x40 +/* + * constants for "firmware" upload and download + */ +#define USBDUXFASTSUB_FIRMWARE 0xA0 +#define VENDOR_DIR_IN 0xC0 +#define VENDOR_DIR_OUT 0x40 -// internal adresses of the 8051 processor -#define USBDUXFASTSUB_CPUCS 0xE600 +/* + * internal adresses of the 8051 processor + */ +#define USBDUXFASTSUB_CPUCS 0xE600 -// max lenghth of the transfer-buffer for software upload -#define TB_LEN 0x2000 +/* + * max lenghth of the transfer-buffer for software upload + */ +#define TB_LEN 0x2000 -// Input endpoint number -#define BULKINEP 6 +/* + * input endpoint number + */ +#define BULKINEP 6 -// Endpoint for the A/D channellist: bulk OUT -#define CHANNELLISTEP 4 +/* + * endpoint for the A/D channellist: bulk OUT + */ +#define CHANNELLISTEP 4 -// Number of channels -#define NUMCHANNELS 32 +/* + * number of channels + */ +#define NUMCHANNELS 32 -// size of the waveform descriptor -#define WAVESIZE 0x20 +/* + * size of the waveform descriptor + */ +#define WAVESIZE 0x20 -// Size of one A/D value -#define SIZEADIN ((sizeof(int16_t))) +/* + * size of one A/D value + */ +#define SIZEADIN (sizeof(int16_t)) -// Size of the input-buffer IN BYTES -#define SIZEINBUF 512 +/* + * size of the input-buffer IN BYTES + */ +#define SIZEINBUF 512 -// 16 bytes. -#define SIZEINSNBUF 512 +/* + * 16 bytes + */ +#define SIZEINSNBUF 512 -// Size of the buffer for the dux commands -#define SIZEOFDUXBUFFER 256 // bytes +/* + * size of the buffer for the dux commands in bytes + */ +#define SIZEOFDUXBUFFER 256 -// Number of in-URBs which receive the data: min=5 -#define NUMOFINBUFFERSHIGH 10 +/* + * number of in-URBs which receive the data: min=5 + */ +#define NUMOFINBUFFERSHIGH 10 -// Total number of usbduxfast devices -#define NUMUSBDUXFAST 16 +/* + * total number of usbduxfast devices + */ +#define NUMUSBDUXFAST 16 -// Number of subdevices -#define N_SUBDEVICES 1 +/* + * number of subdevices + */ +#define N_SUBDEVICES 1 -// Analogue in subdevice -#define SUBDEV_AD 0 +/* + * analogue in subdevice + */ +#define SUBDEV_AD 0 -// min delay steps for more than one channel -// basically when the mux gives up. ;-) -#define MIN_SAMPLING_PERIOD 9 // steps at 30MHz in the FX2 +/* + * min delay steps for more than one channel + * basically when the mux gives up ;-) + * + * steps at 30MHz in the FX2 + */ +#define MIN_SAMPLING_PERIOD 9 -// Max number of 1/30MHz delay steps: -#define MAX_SAMPLING_PERIOD 500 +/* + * max number of 1/30MHz delay steps + */ +#define MAX_SAMPLING_PERIOD 500 -// Number of received packets to ignore before we start handing data over to comedi. -// It's quad buffering and we have to ignore 4 packets. -#define PACKETS_TO_IGNORE 4 +/* + * number of received packets to ignore before we start handing data + * over to comedi, it's quad buffering and we have to ignore 4 packets + */ +#define PACKETS_TO_IGNORE 4 -///////////////////////////////////////////// -// comedi constants -static const comedi_lrange range_usbduxfast_ai_range = { 2, { - BIP_RANGE(0.75), - BIP_RANGE(0.5), - } +/* + * comedi constants + */ +static const comedi_lrange range_usbduxfast_ai_range = { + 2, { BIP_RANGE(0.75), BIP_RANGE(0.5) } }; /* * private structure of one subdevice + * + * this is the structure which holds all the data of this driver + * one sub device just now: A/D */ - -// This is the structure which holds all the data of this driver -// one sub device just now: A/D -typedef struct { - // attached? - int attached; - // is it associated with a subdevice? - int probed; - // pointer to the usb-device - struct usb_device *usbdev; - // BULK-transfer handling: urb - struct urb *urbIn; +struct usbduxfastsub_s { + int attached; /* is attached? */ + int probed; /* is it associated with a subdevice? */ + struct usb_device *usbdev; /* pointer to the usb-device */ + struct urb *urbIn; /* BULK-transfer handling: urb */ int8_t *transfer_buffer; - // input buffer for single insn - int16_t *insnBuffer; - // interface number - int ifnum; - // interface structure - struct usb_interface *interface; - // comedi device for the interrupt context - comedi_device *comedidev; - // asynchronous command is running - short int ai_cmd_running; - // continous aquisition - short int ai_continous; - // number of samples to aquire - long int ai_sample_count; - // commands - uint8_t *dux_commands; - // counter which ignores the first buffers - int ignore; + int16_t *insnBuffer; /* input buffer for single insn */ + int ifnum; /* interface number */ + struct usb_interface *interface; /* interface structure */ + comedi_device *comedidev; /* comedi device for the interrupt + context */ + short int ai_cmd_running; /* asynchronous command is running */ + short int ai_continous; /* continous aquisition */ + long int ai_sample_count; /* number of samples to aquire */ + uint8_t *dux_commands; /* commands */ + int ignore; /* counter which ignores the first + buffers */ struct semaphore sem; -} usbduxfastsub_t; +}; -// The pointer to the private usb-data of the driver -// is also the private data for the comedi-device. -// This has to be global as the usb subsystem needs -// global variables. The other reason is that this -// structure must be there _before_ any comedi -// command is issued. The usb subsystem must be -// initialised before comedi can access it. -static usbduxfastsub_t usbduxfastsub[NUMUSBDUXFAST]; +/* + * The pointer to the private usb-data of the driver + * is also the private data for the comedi-device. + * This has to be global as the usb subsystem needs + * global variables. The other reason is that this + * structure must be there _before_ any comedi + * command is issued. The usb subsystem must be + * initialised before comedi can access it. + */ +static struct usbduxfastsub_s usbduxfastsub[NUMUSBDUXFAST]; static DECLARE_MUTEX(start_stop_sem); -// bulk transfers to usbduxfast - +/* + * bulk transfers to usbduxfast + */ #define SENDADCOMMANDS 0 #define SENDINITEP6 1 -static int send_dux_commands(usbduxfastsub_t * this_usbduxfastsub, int cmd_type) +static int send_dux_commands(struct usbduxfastsub_s *udfs, int cmd_type) { int tmp, nsent; - this_usbduxfastsub->dux_commands[0] = cmd_type; + udfs->dux_commands[0] = cmd_type; #ifdef CONFIG_COMEDI_DEBUG printk(KERN_DEBUG "comedi%d: usbduxfast: dux_commands: ", - this_usbduxfastsub->comedidev->minor); + udfs->comedidev->minor); for (tmp = 0; tmp < SIZEOFDUXBUFFER; tmp++) - printk(" %02x", this_usbduxfastsub->dux_commands[tmp]); + printk(" %02x", udfs->dux_commands[tmp]); printk("\n"); #endif - tmp = usb_bulk_msg(this_usbduxfastsub->usbdev, - usb_sndbulkpipe(this_usbduxfastsub->usbdev, - CHANNELLISTEP), - this_usbduxfastsub->dux_commands, SIZEOFDUXBUFFER, - &nsent, 10000); + tmp = usb_bulk_msg(udfs->usbdev, + usb_sndbulkpipe(udfs->usbdev, CHANNELLISTEP), + udfs->dux_commands, SIZEOFDUXBUFFER, &nsent, 10000); if (tmp < 0) printk(KERN_ERR "comedi%d: could not transmit dux_commands to" - "the usb-device, err=%d\n", - this_usbduxfastsub->comedidev->minor, tmp); - + "the usb-device, err=%d\n", udfs->comedidev->minor, tmp); return tmp; } -// Stops the data acquision -// It should be safe to call this function from any context -static int usbduxfastsub_unlink_InURBs(usbduxfastsub_t * usbduxfastsub_tmp) +/* + * Stops the data acquision. + * It should be safe to call this function from any context. + */ +static int usbduxfastsub_unlink_InURBs(struct usbduxfastsub_s *udfs) { int j = 0; int err = 0; - if (usbduxfastsub_tmp && usbduxfastsub_tmp->urbIn) { - usbduxfastsub_tmp->ai_cmd_running = 0; - // waits until a running transfer is over - usb_kill_urb(usbduxfastsub_tmp->urbIn); + if (udfs && udfs->urbIn) { + udfs->ai_cmd_running = 0; + /* waits until a running transfer is over */ + usb_kill_urb(udfs->urbIn); j = 0; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi: usbduxfast: unlinked InURB: res=%d\n", j); + printk(KERN_DEBUG "comedi: usbduxfast: unlinked InURB: res=%d\n", j); #endif return err; } -/* This will stop a running acquisition operation */ -// Is called from within this driver from both the -// interrupt context and from comedi -static int usbduxfast_ai_stop(usbduxfastsub_t * this_usbduxfastsub, +/* + * This will stop a running acquisition operation. + * Is called from within this driver from both the + * interrupt context and from comedi. + */ +static int usbduxfast_ai_stop(struct usbduxfastsub_s *udfs, int do_unlink) { int ret = 0; - if (!this_usbduxfastsub) { - printk("comedi?: usbduxfast_ai_stop: this_usbduxfastsub=NULL!\n"); + if (!udfs) { + printk(KERN_ERR "comedi?: usbduxfast_ai_stop: udfs=NULL!\n"); return -EFAULT; } + #ifdef CONFIG_COMEDI_DEBUG - printk("comedi: usbduxfast_ai_stop\n"); + printk(KERN_DEBUG "comedi: usbduxfast_ai_stop\n"); #endif - this_usbduxfastsub->ai_cmd_running = 0; + udfs->ai_cmd_running = 0; - if (do_unlink) { - // stop aquistion - ret = usbduxfastsub_unlink_InURBs(this_usbduxfastsub); - } + if (do_unlink) + ret = usbduxfastsub_unlink_InURBs(udfs); /* stop aquistion */ return ret; } -// This will cancel a running acquisition operation. -// This is called by comedi but never from inside the -// driver. -static int usbduxfast_ai_cancel(comedi_device * dev, comedi_subdevice * s) +/* + * This will cancel a running acquisition operation. + * This is called by comedi but never from inside the driver. + */ +static int usbduxfast_ai_cancel(comedi_device *dev, comedi_subdevice *s) { - usbduxfastsub_t *this_usbduxfastsub; - int res = 0; + struct usbduxfastsub_s *udfs; + int ret; - // force unlink of all urbs + /* force unlink of all urbs */ #ifdef CONFIG_COMEDI_DEBUG - printk("comedi: usbduxfast_ai_cancel\n"); + printk(KERN_DEBUG "comedi: usbduxfast_ai_cancel\n"); #endif - this_usbduxfastsub = dev->private; - if (!this_usbduxfastsub) { - printk("comedi: usbduxfast_ai_cancel: this_usbduxfastsub=NULL\n"); + udfs = dev->private; + if (!udfs) { + printk(KERN_ERR "comedi: usbduxfast_ai_cancel: udfs=NULL\n"); return -EFAULT; } - down(&this_usbduxfastsub->sem); - if (!(this_usbduxfastsub->probed)) { - up(&this_usbduxfastsub->sem); + down(&udfs->sem); + if (!udfs->probed) { + up(&udfs->sem); return -ENODEV; } - // unlink - res = usbduxfast_ai_stop(this_usbduxfastsub, 1); - up(&this_usbduxfastsub->sem); + /* unlink */ + ret = usbduxfast_ai_stop(udfs, 1); + up(&udfs->sem); - return res; + return ret; } -// analogue IN -// interrupt service routine +/* + * analogue IN + * interrupt service routine + */ static void usbduxfastsub_ai_Irq(struct urb *urb PT_REGS_ARG) { int n, err; - usbduxfastsub_t *this_usbduxfastsub; + struct usbduxfastsub_s *udfs; comedi_device *this_comedidev; comedi_subdevice *s; uint16_t *p; - // sanity checks - // is the urb there? + /* sanity checks - is the urb there? */ if (!urb) { - printk("comedi_: usbduxfast_: ao int-handler called with urb=NULL!\n"); + printk(KERN_ERR "comedi_: usbduxfast_: ao int-handler called " + "with urb=NULL!\n"); return; } - // the context variable points to the subdevice + /* the context variable points to the subdevice */ this_comedidev = urb->context; if (!this_comedidev) { - printk("comedi_: usbduxfast_: urb context is a NULL pointer!\n"); + printk(KERN_ERR "comedi_: usbduxfast_: urb context is a NULL " + "pointer!\n"); return; } - // the private structure of the subdevice is usbduxfastsub_t - this_usbduxfastsub = this_comedidev->private; - if (!this_usbduxfastsub) { - printk("comedi_: usbduxfast_: private of comedi subdev is a NULL pointer!\n"); + /* the private structure of the subdevice is usbduxfastsub_s */ + udfs = this_comedidev->private; + if (!udfs) { + printk(KERN_ERR "comedi_: usbduxfast_: private of comedi " + "subdev is a NULL pointer!\n"); return; } - // are we running a command? - if (unlikely(!(this_usbduxfastsub->ai_cmd_running))) { - // not running a command - // do not continue execution if no asynchronous command is running - // in particular not resubmit + /* are we running a command? */ + if (unlikely(!udfs->ai_cmd_running)) { + /* + * not running a command + * do not continue execution if no asynchronous command + * is running in particular not resubmit + */ return; } - if (unlikely(!(this_usbduxfastsub->attached))) { - // no comedi device there + if (unlikely(!udfs->attached)) { + /* no comedi device there */ return; } - // subdevice which is the AD converter + /* subdevice which is the AD converter */ s = this_comedidev->subdevices + SUBDEV_AD; - // first we test if something unusual has just happened + /* first we test if something unusual has just happened */ switch (urb->status) { case 0: break; - // happens after an unlink command or when the device is plugged out + /* + * happens after an unlink command or when the device + * is plugged out + */ case -ECONNRESET: case -ENOENT: case -ESHUTDOWN: case -ECONNABORTED: - // tell this comedi + /* tell this comedi */ s->async->events |= COMEDI_CB_EOA; s->async->events |= COMEDI_CB_ERROR; - comedi_event(this_usbduxfastsub->comedidev, s); - // stop the transfer w/o unlink - usbduxfast_ai_stop(this_usbduxfastsub, 0); + comedi_event(udfs->comedidev, s); + /* stop the transfer w/o unlink */ + usbduxfast_ai_stop(udfs, 0); return; default: - printk("comedi%d: usbduxfast: non-zero urb status received in ai intr context: %d\n", this_usbduxfastsub->comedidev->minor, urb->status); + printk("comedi%d: usbduxfast: non-zero urb status received in " + "ai intr context: %d\n", + udfs->comedidev->minor, urb->status); s->async->events |= COMEDI_CB_EOA; s->async->events |= COMEDI_CB_ERROR; - comedi_event(this_usbduxfastsub->comedidev, s); - usbduxfast_ai_stop(this_usbduxfastsub, 0); + comedi_event(udfs->comedidev, s); + usbduxfast_ai_stop(udfs, 0); return; } p = urb->transfer_buffer; - if (!this_usbduxfastsub->ignore) { - if (!(this_usbduxfastsub->ai_continous)) { - // not continous, fixed number of samples + if (!udfs->ignore) { + if (!udfs->ai_continous) { + /* not continous, fixed number of samples */ n = urb->actual_length / sizeof(uint16_t); - if (unlikely(this_usbduxfastsub->ai_sample_count < n)) { - // we have send only a fraction of the bytes received + if (unlikely(udfs->ai_sample_count < n)) { + /* + * we have send only a fraction of the bytes + * received + */ cfc_write_array_to_buffer(s, urb->transfer_buffer, - this_usbduxfastsub->ai_sample_count * - sizeof(uint16_t)); - usbduxfast_ai_stop(this_usbduxfastsub, 0); - // say comedi that the acquistion is over + udfs->ai_sample_count + * sizeof(uint16_t)); + usbduxfast_ai_stop(udfs, 0); + /* say comedi that the acquistion is over */ s->async->events |= COMEDI_CB_EOA; - comedi_event(this_usbduxfastsub->comedidev, s); + comedi_event(udfs->comedidev, s); return; } - this_usbduxfastsub->ai_sample_count -= n; + udfs->ai_sample_count -= n; } - // write the full buffer to comedi - cfc_write_array_to_buffer(s, - urb->transfer_buffer, urb->actual_length); + /* write the full buffer to comedi */ + cfc_write_array_to_buffer(s, urb->transfer_buffer, + urb->actual_length); - // tell comedi that data is there - comedi_event(this_usbduxfastsub->comedidev, s); + /* tell comedi that data is there */ + comedi_event(udfs->comedidev, s); } else { - // ignore this packet - this_usbduxfastsub->ignore--; + /* ignore this packet */ + udfs->ignore--; } - // command is still running - // resubmit urb for BULK transfer - urb->dev = this_usbduxfastsub->usbdev; + /* + * command is still running + * resubmit urb for BULK transfer + */ + urb->dev = udfs->usbdev; urb->status = 0; err = usb_submit_urb(urb, GFP_ATOMIC); if (err < 0) { - printk("comedi%d: usbduxfast: urb resubm failed: %d", - this_usbduxfastsub->comedidev->minor, err); + printk(KERN_ERR "comedi%d: usbduxfast: urb resubm failed: %d", + udfs->comedidev->minor, err); s->async->events |= COMEDI_CB_EOA; s->async->events |= COMEDI_CB_ERROR; - comedi_event(this_usbduxfastsub->comedidev, s); - usbduxfast_ai_stop(this_usbduxfastsub, 0); + comedi_event(udfs->comedidev, s); + usbduxfast_ai_stop(udfs, 0); } } -static int usbduxfastsub_start(usbduxfastsub_t * usbduxfastsub) +static int usbduxfastsub_start(struct usbduxfastsub_s *udfs) { - int errcode = 0; + int ret; unsigned char local_transfer_buffer[16]; - if (usbduxfastsub->probed) { - // 7f92 to zero - local_transfer_buffer[0] = 0; - errcode = usb_control_msg(usbduxfastsub->usbdev, - // create a pipe for a control transfer - usb_sndctrlpipe(usbduxfastsub->usbdev, 0), - // bRequest, "Firmware" - USBDUXFASTSUB_FIRMWARE, - // bmRequestType - VENDOR_DIR_OUT, - // Value - USBDUXFASTSUB_CPUCS, - // Index - 0x0000, - // address of the transfer buffer - local_transfer_buffer, - // Length - 1, - // Timeout - EZTIMEOUT); - if (errcode < 0) { - printk("comedi_: usbduxfast_: control msg failed (start)\n"); - return errcode; - } + if (!udfs->probed) + return 0; + + /* 7f92 to zero */ + local_transfer_buffer[0] = 0; + ret = usb_control_msg(udfs->usbdev, + usb_sndctrlpipe(udfs->usbdev, 0), + USBDUXFASTSUB_FIRMWARE, /* bRequest, "Firmware" */ + VENDOR_DIR_OUT, /* bmRequestType */ + USBDUXFASTSUB_CPUCS, /* Value */ + 0x0000, /* Index */ + local_transfer_buffer, /* address of the transfer buffer */ + 1, /* Length */ + EZTIMEOUT); /* Timeout */ + if (ret < 0) { + printk("comedi_: usbduxfast_: control msg failed (start)\n"); + return ret; } + return 0; } -static int usbduxfastsub_stop(usbduxfastsub_t * usbduxfastsub) +static int usbduxfastsub_stop(struct usbduxfastsub_s *udfs) { - int errcode = 0; - + int ret; unsigned char local_transfer_buffer[16]; - if (usbduxfastsub->probed) { - // 7f92 to one - local_transfer_buffer[0] = 1; - errcode = usb_control_msg(usbduxfastsub->usbdev, - usb_sndctrlpipe(usbduxfastsub->usbdev, 0), - // bRequest, "Firmware" - USBDUXFASTSUB_FIRMWARE, - // bmRequestType - VENDOR_DIR_OUT, - // Value - USBDUXFASTSUB_CPUCS, - // Index - 0x0000, local_transfer_buffer, - // Length - 1, - // Timeout - EZTIMEOUT); - if (errcode < 0) { - printk("comedi_: usbduxfast: control msg failed (stop)\n"); - return errcode; - } + + if (!udfs->probed) + return 0; + + /* 7f92 to one */ + local_transfer_buffer[0] = 1; + ret = usb_control_msg(udfs->usbdev, + usb_sndctrlpipe(udfs->usbdev, 0), + USBDUXFASTSUB_FIRMWARE, /* bRequest, "Firmware" */ + VENDOR_DIR_OUT, /* bmRequestType */ + USBDUXFASTSUB_CPUCS, /* Value */ + 0x0000, /* Index */ + local_transfer_buffer, + 1, /* Length */ + EZTIMEOUT); /* Timeout */ + if (ret < 0) { + printk(KERN_ERR "comedi_: usbduxfast: control msg failed " + "(stop)\n"); + return ret; } + return 0; } -static int usbduxfastsub_upload(usbduxfastsub_t * usbduxfastsub, +static int usbduxfastsub_upload(struct usbduxfastsub_s *udfs, unsigned char *local_transfer_buffer, unsigned int startAddr, unsigned int len) { - int errcode; + int ret; + + if (!udfs->probed) + /* no device on the bus for this index */ + return -EFAULT; - if (usbduxfastsub->probed) { #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast: uploading %d bytes", - usbduxfastsub->comedidev->minor, len); - printk(" to addr %d, first byte=%d.\n", - startAddr, local_transfer_buffer[0]); + printk(KERN_DEBUG "comedi%d: usbduxfast: uploading %d bytes", + udfs->comedidev->minor, len); + printk(KERN_DEBUG " to addr %d, first byte=%d.\n", + startAddr, local_transfer_buffer[0]); #endif - errcode = usb_control_msg(usbduxfastsub->usbdev, - usb_sndctrlpipe(usbduxfastsub->usbdev, 0), - // brequest, firmware - USBDUXFASTSUB_FIRMWARE, - // bmRequestType - VENDOR_DIR_OUT, - // value - startAddr, - // index - 0x0000, - // our local safe buffer - local_transfer_buffer, - // length - len, - // timeout - EZTIMEOUT); + ret = usb_control_msg(udfs->usbdev, + usb_sndctrlpipe(udfs->usbdev, 0), + USBDUXFASTSUB_FIRMWARE, /* brequest, firmware */ + VENDOR_DIR_OUT, /* bmRequestType */ + startAddr, /* value */ + 0x0000, /* index */ + local_transfer_buffer, /* our local safe buffer */ + len, /* length */ + EZTIMEOUT); /* timeout */ + #ifdef CONFIG_COMEDI_DEBUG - printk("comedi_: usbduxfast: result=%d\n", errcode); + printk(KERN_DEBUG "comedi_: usbduxfast: result=%d\n", ret); #endif - if (errcode < 0) { - printk("comedi_: usbduxfast: uppload failed\n"); - return errcode; - } - } else { - // no device on the bus for this index - return -EFAULT; + + if (ret < 0) { + printk(KERN_ERR "comedi_: usbduxfast: uppload failed\n"); + return ret; } + return 0; } -int firmwareUpload(usbduxfastsub_t * usbduxfastsub, - unsigned char *firmwareBinary, int sizeFirmware) +int firmwareUpload(struct usbduxfastsub_s *udfs, unsigned char *firmwareBinary, + int sizeFirmware) { int ret; - if (!firmwareBinary) { + if (!firmwareBinary) return 0; - } - ret = usbduxfastsub_stop(usbduxfastsub); + + ret = usbduxfastsub_stop(udfs); if (ret < 0) { - printk("comedi_: usbduxfast: can not stop firmware\n"); + printk(KERN_ERR "comedi_: usbduxfast: can not stop firmware\n"); return ret; } - ret = usbduxfastsub_upload(usbduxfastsub, - firmwareBinary, 0, sizeFirmware); + ret = usbduxfastsub_upload(udfs, firmwareBinary, 0, sizeFirmware); if (ret < 0) { - printk("comedi_: usbduxfast: firmware upload failed\n"); + printk(KERN_ERR "comedi_: usbduxfast: firmware upload failed\n"); return ret; } - ret = usbduxfastsub_start(usbduxfastsub); + ret = usbduxfastsub_start(udfs); if (ret < 0) { - printk("comedi_: usbduxfast: can not start firmware\n"); + printk(KERN_ERR "comedi_: usbduxfast: can not start firmware\n"); return ret; } + return 0; } -int usbduxfastsub_submit_InURBs(usbduxfastsub_t * usbduxfastsub) +int usbduxfastsub_submit_InURBs(struct usbduxfastsub_s *udfs) { - int errFlag; + int ret; - if (!usbduxfastsub) { + if (!udfs) return -EFAULT; - } - usb_fill_bulk_urb(usbduxfastsub->urbIn, - usbduxfastsub->usbdev, - usb_rcvbulkpipe(usbduxfastsub->usbdev, BULKINEP), - usbduxfastsub->transfer_buffer, - SIZEINBUF, usbduxfastsub_ai_Irq, usbduxfastsub->comedidev); + + usb_fill_bulk_urb(udfs->urbIn, udfs->usbdev, + usb_rcvbulkpipe(udfs->usbdev, BULKINEP), + udfs->transfer_buffer, + SIZEINBUF, usbduxfastsub_ai_Irq, udfs->comedidev); #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast: submitting in-urb: 0x%p,0x%p\n", - usbduxfastsub->comedidev->minor, - usbduxfastsub->urbIn->context, - usbduxfastsub->urbIn->dev); + printk(KERN_DEBUG "comedi%d: usbduxfast: submitting in-urb: " + "0x%p,0x%p\n", udfs->comedidev->minor, udfs->urbIn->context, + udfs->urbIn->dev); #endif - errFlag = usb_submit_urb(usbduxfastsub->urbIn, GFP_ATOMIC); - if (errFlag) { - printk("comedi_: usbduxfast: ai: usb_submit_urb error %d\n", - errFlag); - return errFlag; + ret = usb_submit_urb(udfs->urbIn, GFP_ATOMIC); + if (ret) { + printk(KERN_ERR "comedi_: usbduxfast: ai: usb_submit_urb error" + " %d\n", ret); + return ret; } return 0; } -static int usbduxfast_ai_cmdtest(comedi_device * dev, - comedi_subdevice * s, comedi_cmd * cmd) +static int usbduxfast_ai_cmdtest(comedi_device *dev, + comedi_subdevice *s, comedi_cmd *cmd) { int err = 0, stop_mask = 0; - long int steps, tmp = 0; + long int steps, tmp; int minSamplPer; - usbduxfastsub_t *this_usbduxfastsub = dev->private; - if (!(this_usbduxfastsub->probed)) { + struct usbduxfastsub_s *udfs = dev->private; + + if (!udfs->probed) return -ENODEV; - } + #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast_ai_cmdtest\n", dev->minor); - printk("comedi%d: usbduxfast: convert_arg=%u scan_begin_arg=%u\n", - dev->minor, cmd->convert_arg, cmd->scan_begin_arg); + printk(KERN_DEBUG "comedi%d: usbduxfast_ai_cmdtest\n", dev->minor); + printk(KERN_DEBUG "comedi%d: usbduxfast: convert_arg=%u " + "scan_begin_arg=%u\n", + dev->minor, cmd->convert_arg, cmd->scan_begin_arg); #endif /* step 1: make sure trigger sources are trivially valid */ @@ -607,7 +633,9 @@ static int usbduxfast_ai_cmdtest(comedi_device * dev, if (err) return 1; - /* step 2: make sure trigger sources are unique and mutually compatible */ + /* + * step 2: make sure trigger sources are unique and mutually compatible + */ if (cmd->start_src != TRIG_NOW && cmd->start_src != TRIG_EXT && cmd->start_src != TRIG_INT) @@ -622,7 +650,7 @@ static int usbduxfast_ai_cmdtest(comedi_device * dev, cmd->stop_src != TRIG_EXT && cmd->stop_src != TRIG_NONE) err++; - // can't have external stop and start triggers at once + /* can't have external stop and start triggers at once */ if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT) err++; @@ -636,29 +664,28 @@ static int usbduxfast_ai_cmdtest(comedi_device * dev, err++; } - if (!cmd->chanlist_len) { + if (!cmd->chanlist_len) err++; - } + if (cmd->scan_end_arg != cmd->chanlist_len) { cmd->scan_end_arg = cmd->chanlist_len; err++; } - if (cmd->chanlist_len == 1) { + if (cmd->chanlist_len == 1) minSamplPer = 1; - } else { + else minSamplPer = MIN_SAMPLING_PERIOD; - } if (cmd->convert_src == TRIG_TIMER) { steps = cmd->convert_arg * 30; - if (steps < (minSamplPer * 1000)) { + if (steps < (minSamplPer * 1000)) steps = minSamplPer * 1000; - } - if (steps > (MAX_SAMPLING_PERIOD * 1000)) { + + if (steps > (MAX_SAMPLING_PERIOD * 1000)) steps = MAX_SAMPLING_PERIOD * 1000; - } - // calc arg again + + /* calc arg again */ tmp = steps / 30; if (cmd->convert_arg != tmp) { cmd->convert_arg = tmp; @@ -666,10 +693,10 @@ static int usbduxfast_ai_cmdtest(comedi_device * dev, } } - if (cmd->scan_begin_src == TRIG_TIMER) { + if (cmd->scan_begin_src == TRIG_TIMER) err++; - } - // stop source + + /* stop source */ switch (cmd->stop_src) { case TRIG_COUNT: if (!cmd->stop_arg) { @@ -683,7 +710,10 @@ static int usbduxfast_ai_cmdtest(comedi_device * dev, err++; } break; - // TRIG_EXT doesn't care since it doesn't trigger off a numbered channel + /* + * TRIG_EXT doesn't care since it doesn't trigger + * off a numbered channel + */ default: break; } @@ -697,588 +727,676 @@ static int usbduxfast_ai_cmdtest(comedi_device * dev, } -static int usbduxfast_ai_inttrig(comedi_device * dev, - comedi_subdevice * s, unsigned int trignum) +static int usbduxfast_ai_inttrig(comedi_device *dev, + comedi_subdevice *s, unsigned int trignum) { int ret; - usbduxfastsub_t *this_usbduxfastsub = dev->private; - if (!this_usbduxfastsub) { + struct usbduxfastsub_s *udfs = dev->private; + + if (!udfs) return -EFAULT; - } - down(&this_usbduxfastsub->sem); - if (!(this_usbduxfastsub->probed)) { - up(&this_usbduxfastsub->sem); + + down(&udfs->sem); + if (!udfs->probed) { + up(&udfs->sem); return -ENODEV; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast_ai_inttrig\n", dev->minor); + printk(KERN_DEBUG "comedi%d: usbduxfast_ai_inttrig\n", dev->minor); #endif if (trignum != 0) { - printk("comedi%d: usbduxfast_ai_inttrig: invalid trignum\n", - dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: usbduxfast_ai_inttrig: invalid" + " trignum\n", dev->minor); + up(&udfs->sem); return -EINVAL; } - if (!(this_usbduxfastsub->ai_cmd_running)) { - this_usbduxfastsub->ai_cmd_running = 1; - ret = usbduxfastsub_submit_InURBs(this_usbduxfastsub); + if (!udfs->ai_cmd_running) { + udfs->ai_cmd_running = 1; + ret = usbduxfastsub_submit_InURBs(udfs); if (ret < 0) { - printk("comedi%d: usbduxfast_ai_inttrig: urbSubmit: err=%d\n", dev->minor, ret); - this_usbduxfastsub->ai_cmd_running = 0; - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: usbduxfast_ai_inttrig: " + "urbSubmit: err=%d\n", dev->minor, ret); + udfs->ai_cmd_running = 0; + up(&udfs->sem); return ret; } s->async->inttrig = NULL; } else { - printk("comedi%d: ai_inttrig but acqu is already running\n", - dev->minor); + printk(KERN_ERR "comedi%d: ai_inttrig but acqu is already" + " running\n", dev->minor); } - up(&this_usbduxfastsub->sem); + up(&udfs->sem); return 1; } -// offsets for the GPIF bytes -// the first byte is the command byte -#define LENBASE 1+0x00 -#define OPBASE 1+0x08 -#define OUTBASE 1+0x10 -#define LOGBASE 1+0x18 +/* + * offsets for the GPIF bytes + * the first byte is the command byte + */ +#define LENBASE (1+0x00) +#define OPBASE (1+0x08) +#define OUTBASE (1+0x10) +#define LOGBASE (1+0x18) -static int usbduxfast_ai_cmd(comedi_device * dev, comedi_subdevice * s) +static int usbduxfast_ai_cmd(comedi_device *dev, comedi_subdevice *s) { comedi_cmd *cmd = &s->async->cmd; unsigned int chan, gain, rngmask = 0xff; int i, j, ret; - usbduxfastsub_t *this_usbduxfastsub = dev->private; + struct usbduxfastsub_s *udfs; int result; long steps, steps_tmp; #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast_ai_cmd\n", dev->minor); + printk(KERN_DEBUG "comedi%d: usbduxfast_ai_cmd\n", dev->minor); #endif - if (!this_usbduxfastsub) { + udfs = dev->private; + if (!udfs) return -EFAULT; - } - down(&this_usbduxfastsub->sem); - if (!(this_usbduxfastsub->probed)) { - up(&this_usbduxfastsub->sem); + + down(&udfs->sem); + if (!udfs->probed) { + up(&udfs->sem); return -ENODEV; } - if (this_usbduxfastsub->ai_cmd_running) { - printk("comedi%d: ai_cmd not possible. Another ai_cmd is running.\n", dev->minor); - up(&this_usbduxfastsub->sem); + if (udfs->ai_cmd_running) { + printk(KERN_ERR "comedi%d: ai_cmd not possible. Another ai_cmd" + " is running.\n", dev->minor); + up(&udfs->sem); return -EBUSY; } - // set current channel of the running aquisition to zero + /* set current channel of the running aquisition to zero */ s->async->cur_chan = 0; - // ignore the first buffers from the device if there is an error condition - this_usbduxfastsub->ignore = PACKETS_TO_IGNORE; + /* + * ignore the first buffers from the device if there + * is an error condition + */ + udfs->ignore = PACKETS_TO_IGNORE; if (cmd->chanlist_len > 0) { gain = CR_RANGE(cmd->chanlist[0]); for (i = 0; i < cmd->chanlist_len; ++i) { chan = CR_CHAN(cmd->chanlist[i]); if (chan != i) { - printk("comedi%d: cmd is accepting only consecutive channels.\n", dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: cmd is accepting " + "only consecutive channels.\n", + dev->minor); + up(&udfs->sem); return -EINVAL; } if ((gain != CR_RANGE(cmd->chanlist[i])) && (cmd->chanlist_len > 3)) { - printk("comedi%d: the gain must be the same for all channels.\n", dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: the gain must be" + " the same for all channels.\n", + dev->minor); + up(&udfs->sem); return -EINVAL; } if (i >= NUMCHANNELS) { - printk("comedi%d: channel list too long\n", - dev->minor); + printk(KERN_ERR "comedi%d: channel list too" + " long\n", dev->minor); break; } } } steps = 0; if (cmd->scan_begin_src == TRIG_TIMER) { - printk("comedi%d: usbduxfast: scan_begin_src==TRIG_TIMER not valid.\n", dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: usbduxfast: " + "scan_begin_src==TRIG_TIMER not valid.\n", dev->minor); + up(&udfs->sem); return -EINVAL; } - if (cmd->convert_src == TRIG_TIMER) { + if (cmd->convert_src == TRIG_TIMER) steps = (cmd->convert_arg * 30) / 1000; - } + if ((steps < MIN_SAMPLING_PERIOD) && (cmd->chanlist_len != 1)) { - printk("comedi%d: usbduxfast: ai_cmd: steps=%ld, scan_begin_arg=%d. Not properly tested by cmdtest?\n", dev->minor, steps, cmd->scan_begin_arg); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: usbduxfast: ai_cmd: steps=%ld, " + "scan_begin_arg=%d. Not properly tested by cmdtest?\n", + dev->minor, steps, cmd->scan_begin_arg); + up(&udfs->sem); return -EINVAL; } if (steps > MAX_SAMPLING_PERIOD) { - printk("comedi%d: usbduxfast: ai_cmd: sampling rate too low.\n", - dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: usbduxfast: ai_cmd: sampling rate " + "too low.\n", dev->minor); + up(&udfs->sem); return -EINVAL; } if ((cmd->start_src == TRIG_EXT) && (cmd->chanlist_len != 1) && (cmd->chanlist_len != 16)) { - printk("comedi%d: usbduxfast: ai_cmd: TRIG_EXT only with 1 or 16 channels possible.\n", dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: usbduxfast: ai_cmd: TRIG_EXT only" + " with 1 or 16 channels possible.\n", dev->minor); + up(&udfs->sem); return -EINVAL; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast: steps=%ld, convert_arg=%u\n", - dev->minor, steps, cmd->convert_arg); + printk(KERN_DEBUG "comedi%d: usbduxfast: steps=%ld, convert_arg=%u\n", + dev->minor, steps, cmd->convert_arg); #endif switch (cmd->chanlist_len) { - // one channel case 1: + /* + * one channel + */ + if (CR_RANGE(cmd->chanlist[0]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - // for external trigger: looping in this state until the RDY0 pin - // becomes zero - if (cmd->start_src == TRIG_EXT) { // we loop here until ready has been set - this_usbduxfastsub->dux_commands[LENBASE + 0] = 0x01; // branch back to state 0 - this_usbduxfastsub->dux_commands[OPBASE + 0] = 0x01; // deceision state w/o data - this_usbduxfastsub->dux_commands[OUTBASE + 0] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0x00; // RDY0 = 0 - } else { // we just proceed to state 1 - this_usbduxfastsub->dux_commands[LENBASE + 0] = 1; - this_usbduxfastsub->dux_commands[OPBASE + 0] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 0] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0; + /* + * for external trigger: looping in this state until + * the RDY0 pin becomes zero + */ + + /* we loop here until ready has been set */ + if (cmd->start_src == TRIG_EXT) { + /* branch back to state 0 */ + udfs->dux_commands[LENBASE+0] = 0x01; + /* deceision state w/o data */ + udfs->dux_commands[OPBASE+0] = 0x01; + udfs->dux_commands[OUTBASE+0] = 0xFF & rngmask; + /* RDY0 = 0 */ + udfs->dux_commands[LOGBASE+0] = 0x00; + } else { /* we just proceed to state 1 */ + udfs->dux_commands[LENBASE+0] = 1; + udfs->dux_commands[OPBASE+0] = 0; + udfs->dux_commands[OUTBASE+0] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+0] = 0; } if (steps < MIN_SAMPLING_PERIOD) { - // for fast single channel aqu without mux + /* for fast single channel aqu without mux */ if (steps <= 1) { - // we just stay here at state 1 and rexecute the same state - // this gives us 30MHz sampling rate - this_usbduxfastsub->dux_commands[LENBASE + 1] = 0x89; // branch back to state 1 - this_usbduxfastsub->dux_commands[OPBASE + 1] = 0x03; // deceision state with data - this_usbduxfastsub->dux_commands[OUTBASE + 1] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0xFF; // doesn't matter + /* + * we just stay here at state 1 and rexecute + * the same state this gives us 30MHz sampling + * rate + */ + + /* branch back to state 1 */ + udfs->dux_commands[LENBASE+1] = 0x89; + /* deceision state with data */ + udfs->dux_commands[OPBASE+1] = 0x03; + udfs->dux_commands[OUTBASE+1] = 0xFF & rngmask; + /* doesn't matter */ + udfs->dux_commands[LOGBASE+1] = 0xFF; } else { - // we loop through two states: data and delay: max rate is 15Mhz - this_usbduxfastsub->dux_commands[LENBASE + 1] = - steps - 1; - this_usbduxfastsub->dux_commands[OPBASE + 1] = 0x02; // data - this_usbduxfastsub->dux_commands[OUTBASE + 1] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0; // doesn't matter - - this_usbduxfastsub->dux_commands[LENBASE + 2] = 0x09; // branch back to state 1 - this_usbduxfastsub->dux_commands[OPBASE + 2] = 0x01; // deceision state w/o data - this_usbduxfastsub->dux_commands[OUTBASE + 2] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0xFF; // doesn't matter + /* + * we loop through two states: data and delay + * max rate is 15MHz + */ + udfs->dux_commands[LENBASE+1] = steps - 1; + /* data */ + udfs->dux_commands[OPBASE+1] = 0x02; + udfs->dux_commands[OUTBASE+1] = 0xFF & rngmask; + /* doesn't matter */ + udfs->dux_commands[LOGBASE+1] = 0; + /* branch back to state 1 */ + udfs->dux_commands[LENBASE+2] = 0x09; + /* deceision state w/o data */ + udfs->dux_commands[OPBASE+2] = 0x01; + udfs->dux_commands[OUTBASE+2] = 0xFF & rngmask; + /* doesn't matter */ + udfs->dux_commands[LOGBASE+2] = 0xFF; } } else { - // we loop through 3 states: 2x delay and 1x data. This gives a min - // sampling rate of 60kHz. + /* + * we loop through 3 states: 2x delay and 1x data + * this gives a min sampling rate of 60kHz + */ - // we have 1 state with duration 1 + /* we have 1 state with duration 1 */ steps = steps - 1; - // do the first part of the delay - this_usbduxfastsub->dux_commands[LENBASE + 1] = - steps / 2; - this_usbduxfastsub->dux_commands[OPBASE + 1] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 1] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0; - - // and the second part - this_usbduxfastsub->dux_commands[LENBASE + 2] = - steps - steps / 2; - this_usbduxfastsub->dux_commands[OPBASE + 2] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 2] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0; - - // get the data and branch back - this_usbduxfastsub->dux_commands[LENBASE + 3] = 0x09; // branch back to state 1 - this_usbduxfastsub->dux_commands[OPBASE + 3] = 0x03; // deceision state w data - this_usbduxfastsub->dux_commands[OUTBASE + 3] = - 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 3] = 0xFF; // doesn't matter + /* do the first part of the delay */ + udfs->dux_commands[LENBASE+1] = steps / 2; + udfs->dux_commands[OPBASE+1] = 0; + udfs->dux_commands[OUTBASE+1] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+1] = 0; + + /* and the second part */ + udfs->dux_commands[LENBASE+2] = steps - steps / 2; + udfs->dux_commands[OPBASE+2] = 0; + udfs->dux_commands[OUTBASE+2] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+2] = 0; + + /* get the data and branch back */ + + /* branch back to state 1 */ + udfs->dux_commands[LENBASE+3] = 0x09; + /* deceision state w data */ + udfs->dux_commands[OPBASE+3] = 0x03; + udfs->dux_commands[OUTBASE+3] = 0xFF & rngmask; + /* doesn't matter */ + udfs->dux_commands[LOGBASE+3] = 0xFF; } break; case 2: - // two channels - // commit data to the FIFO + /* + * two channels + * commit data to the FIFO + */ + if (CR_RANGE(cmd->chanlist[0]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - this_usbduxfastsub->dux_commands[LENBASE + 0] = 1; - this_usbduxfastsub->dux_commands[OPBASE + 0] = 0x02; // data - this_usbduxfastsub->dux_commands[OUTBASE + 0] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0; - // we have 1 state with duration 1: state 0 + udfs->dux_commands[LENBASE+0] = 1; + /* data */ + udfs->dux_commands[OPBASE+0] = 0x02; + udfs->dux_commands[OUTBASE+0] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+0] = 0; + + /* we have 1 state with duration 1: state 0 */ steps_tmp = steps - 1; if (CR_RANGE(cmd->chanlist[1]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - // do the first part of the delay - this_usbduxfastsub->dux_commands[LENBASE + 1] = steps_tmp / 2; - this_usbduxfastsub->dux_commands[OPBASE + 1] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 1] = 0xFE & rngmask; //count - this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0; - - // and the second part - this_usbduxfastsub->dux_commands[LENBASE + 2] = - steps_tmp - steps_tmp / 2; - this_usbduxfastsub->dux_commands[OPBASE + 2] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 2] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0; - - this_usbduxfastsub->dux_commands[LENBASE + 3] = 1; - this_usbduxfastsub->dux_commands[OPBASE + 3] = 0x02; // data - this_usbduxfastsub->dux_commands[OUTBASE + 3] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 3] = 0; - - // we have 2 states with duration 1: step 6 and the IDLE state + + /* do the first part of the delay */ + udfs->dux_commands[LENBASE+1] = steps_tmp / 2; + udfs->dux_commands[OPBASE+1] = 0; + /* count */ + udfs->dux_commands[OUTBASE+1] = 0xFE & rngmask; + udfs->dux_commands[LOGBASE+1] = 0; + + /* and the second part */ + udfs->dux_commands[LENBASE+2] = steps_tmp - steps_tmp / 2; + udfs->dux_commands[OPBASE+2] = 0; + udfs->dux_commands[OUTBASE+2] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+2] = 0; + + udfs->dux_commands[LENBASE+3] = 1; + /* data */ + udfs->dux_commands[OPBASE+3] = 0x02; + udfs->dux_commands[OUTBASE+3] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+3] = 0; + + /* + * we have 2 states with duration 1: step 6 and + * the IDLE state + */ steps_tmp = steps - 2; if (CR_RANGE(cmd->chanlist[0]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - // do the first part of the delay - this_usbduxfastsub->dux_commands[LENBASE + 4] = steps_tmp / 2; - this_usbduxfastsub->dux_commands[OPBASE + 4] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 4] = (0xFF - 0x02) & rngmask; //reset - this_usbduxfastsub->dux_commands[LOGBASE + 4] = 0; - - // and the second part - this_usbduxfastsub->dux_commands[LENBASE + 5] = - steps_tmp - steps_tmp / 2; - this_usbduxfastsub->dux_commands[OPBASE + 5] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 5] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 5] = 0; - - this_usbduxfastsub->dux_commands[LENBASE + 6] = 1; - this_usbduxfastsub->dux_commands[OPBASE + 6] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 6] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 6] = 0; + + /* do the first part of the delay */ + udfs->dux_commands[LENBASE+4] = steps_tmp / 2; + udfs->dux_commands[OPBASE+4] = 0; + /* reset */ + udfs->dux_commands[OUTBASE+4] = (0xFF - 0x02) & rngmask; + udfs->dux_commands[LOGBASE+4] = 0; + + /* and the second part */ + udfs->dux_commands[LENBASE+5] = steps_tmp - steps_tmp / 2; + udfs->dux_commands[OPBASE+5] = 0; + udfs->dux_commands[OUTBASE+5] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+5] = 0; + + udfs->dux_commands[LENBASE+6] = 1; + udfs->dux_commands[OPBASE+6] = 0; + udfs->dux_commands[OUTBASE+6] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+6] = 0; break; case 3: - // three channels + /* + * three channels + */ for (j = 0; j < 1; j++) { if (CR_RANGE(cmd->chanlist[j]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - // commit data to the FIFO and do the first part of the delay - this_usbduxfastsub->dux_commands[LENBASE + j * 2] = - steps / 2; - this_usbduxfastsub->dux_commands[OPBASE + j * 2] = 0x02; // data - this_usbduxfastsub->dux_commands[OUTBASE + j * 2] = 0xFF & rngmask; // no change - this_usbduxfastsub->dux_commands[LOGBASE + j * 2] = 0; + /* + * commit data to the FIFO and do the first part + * of the delay + */ + udfs->dux_commands[LENBASE+j*2] = steps / 2; + /* data */ + udfs->dux_commands[OPBASE+j*2] = 0x02; + /* no change */ + udfs->dux_commands[OUTBASE+j*2] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+j*2] = 0; if (CR_RANGE(cmd->chanlist[j + 1]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - // do the second part of the delay - this_usbduxfastsub->dux_commands[LENBASE + j * 2 + 1] = - steps - steps / 2; - this_usbduxfastsub->dux_commands[OPBASE + j * 2 + 1] = 0; // no data - this_usbduxfastsub->dux_commands[OUTBASE + j * 2 + 1] = 0xFE & rngmask; //count - this_usbduxfastsub->dux_commands[LOGBASE + j * 2 + 1] = - 0; + + /* do the second part of the delay */ + udfs->dux_commands[LENBASE+j*2+1] = steps - steps / 2; + /* no data */ + udfs->dux_commands[OPBASE+j*2+1] = 0; + /* count */ + udfs->dux_commands[OUTBASE+j*2+1] = 0xFE & rngmask; + udfs->dux_commands[LOGBASE+j*2+1] = 0; } - // 2 steps with duration 1: the idele step and step 6: + /* 2 steps with duration 1: the idele step and step 6: */ steps_tmp = steps - 2; - // commit data to the FIFO and do the first part of the delay - this_usbduxfastsub->dux_commands[LENBASE + 4] = steps_tmp / 2; - this_usbduxfastsub->dux_commands[OPBASE + 4] = 0x02; // data - this_usbduxfastsub->dux_commands[OUTBASE + 4] = 0xFF & rngmask; // no change - this_usbduxfastsub->dux_commands[LOGBASE + 4] = 0; + + /* commit data to the FIFO and do the first part of the delay */ + udfs->dux_commands[LENBASE+4] = steps_tmp / 2; + /* data */ + udfs->dux_commands[OPBASE+4] = 0x02; + udfs->dux_commands[OUTBASE+4] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+4] = 0; if (CR_RANGE(cmd->chanlist[0]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - // do the second part of the delay - this_usbduxfastsub->dux_commands[LENBASE + 5] = - steps_tmp - steps_tmp / 2; - this_usbduxfastsub->dux_commands[OPBASE + 5] = 0; // no data - this_usbduxfastsub->dux_commands[OUTBASE + 5] = (0xFF - 0x02) & rngmask; // reset - this_usbduxfastsub->dux_commands[LOGBASE + 5] = 0; - - this_usbduxfastsub->dux_commands[LENBASE + 6] = 1; - this_usbduxfastsub->dux_commands[OPBASE + 6] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 6] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 6] = 0; + + /* do the second part of the delay */ + udfs->dux_commands[LENBASE+5] = steps_tmp - steps_tmp / 2; + /* no data */ + udfs->dux_commands[OPBASE+5] = 0; + /* reset */ + udfs->dux_commands[OUTBASE+5] = (0xFF - 0x02) & rngmask; + udfs->dux_commands[LOGBASE+5] = 0; + + udfs->dux_commands[LENBASE+6] = 1; + udfs->dux_commands[OPBASE+6] = 0; + udfs->dux_commands[OUTBASE+6] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+6] = 0; case 16: if (CR_RANGE(cmd->chanlist[0]) > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - if (cmd->start_src == TRIG_EXT) { // we loop here until ready has been set - this_usbduxfastsub->dux_commands[LENBASE + 0] = 0x01; // branch back to state 0 - this_usbduxfastsub->dux_commands[OPBASE + 0] = 0x01; // deceision state w/o data - this_usbduxfastsub->dux_commands[OUTBASE + 0] = (0xFF - 0x02) & rngmask; // reset - this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0x00; // RDY0 = 0 - } else { // we just proceed to state 1 - this_usbduxfastsub->dux_commands[LENBASE + 0] = 255; // 30us reset pulse - this_usbduxfastsub->dux_commands[OPBASE + 0] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 0] = (0xFF - 0x02) & rngmask; // reset - this_usbduxfastsub->dux_commands[LOGBASE + 0] = 0; + + if (cmd->start_src == TRIG_EXT) { + /* + * we loop here until ready has been set + */ + + /* branch back to state 0 */ + udfs->dux_commands[LENBASE+0] = 0x01; + /* deceision state w/o data */ + udfs->dux_commands[OPBASE+0] = 0x01; + /* reset */ + udfs->dux_commands[OUTBASE+0] = (0xFF-0x02) & rngmask; + /* RDY0 = 0 */ + udfs->dux_commands[LOGBASE+0] = 0x00; + } else { + /* + * we just proceed to state 1 + */ + + /* 30us reset pulse */ + udfs->dux_commands[LENBASE+0] = 255; + udfs->dux_commands[OPBASE+0] = 0; + /* reset */ + udfs->dux_commands[OUTBASE+0] = (0xFF-0x02) & rngmask; + udfs->dux_commands[LOGBASE+0] = 0; } - // commit data to the FIFO - this_usbduxfastsub->dux_commands[LENBASE + 1] = 1; - this_usbduxfastsub->dux_commands[OPBASE + 1] = 0x02; // data - this_usbduxfastsub->dux_commands[OUTBASE + 1] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 1] = 0; + /* commit data to the FIFO */ + udfs->dux_commands[LENBASE+1] = 1; + /* data */ + udfs->dux_commands[OPBASE+1] = 0x02; + udfs->dux_commands[OUTBASE+1] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+1] = 0; - // we have 2 states with duration 1 + /* we have 2 states with duration 1 */ steps = steps - 2; - // do the first part of the delay - this_usbduxfastsub->dux_commands[LENBASE + 2] = steps / 2; - this_usbduxfastsub->dux_commands[OPBASE + 2] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 2] = 0xFE & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 2] = 0; - - // and the second part - this_usbduxfastsub->dux_commands[LENBASE + 3] = - steps - steps / 2; - this_usbduxfastsub->dux_commands[OPBASE + 3] = 0; - this_usbduxfastsub->dux_commands[OUTBASE + 3] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 3] = 0; - - this_usbduxfastsub->dux_commands[LENBASE + 4] = 0x09; // branch back to state 1 - this_usbduxfastsub->dux_commands[OPBASE + 4] = 0x01; // deceision state w/o data - this_usbduxfastsub->dux_commands[OUTBASE + 4] = 0xFF & rngmask; - this_usbduxfastsub->dux_commands[LOGBASE + 4] = 0xFF; // doesn't matter + /* do the first part of the delay */ + udfs->dux_commands[LENBASE+2] = steps / 2; + udfs->dux_commands[OPBASE+2] = 0; + udfs->dux_commands[OUTBASE+2] = 0xFE & rngmask; + udfs->dux_commands[LOGBASE+2] = 0; + + /* and the second part */ + udfs->dux_commands[LENBASE+3] = steps - steps / 2; + udfs->dux_commands[OPBASE+3] = 0; + udfs->dux_commands[OUTBASE+3] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+3] = 0; + + /* branch back to state 1 */ + udfs->dux_commands[LENBASE+4] = 0x09; + /* deceision state w/o data */ + udfs->dux_commands[OPBASE+4] = 0x01; + udfs->dux_commands[OUTBASE+4] = 0xFF & rngmask; + /* doesn't matter */ + udfs->dux_commands[LOGBASE+4] = 0xFF; break; default: - printk("comedi %d: unsupported combination of channels\n", - dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi %d: unsupported combination of " + "channels\n", dev->minor); + up(&udfs->sem); return -EFAULT; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi %d: sending commands to the usb device\n", dev->minor); + printk(KERN_DEBUG "comedi %d: sending commands to the usb device\n", + dev->minor); #endif - // 0 means that the AD commands are sent - result = send_dux_commands(this_usbduxfastsub, SENDADCOMMANDS); + /* 0 means that the AD commands are sent */ + result = send_dux_commands(udfs, SENDADCOMMANDS); if (result < 0) { - printk("comedi%d: adc command could not be submitted. Aborting...\n", dev->minor); - up(&this_usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: adc command could not be submitted." + "Aborting...\n", dev->minor); + up(&udfs->sem); return result; } if (cmd->stop_src == TRIG_COUNT) { - this_usbduxfastsub->ai_sample_count = - (cmd->stop_arg) * (cmd->scan_end_arg); - if (usbduxfastsub->ai_sample_count < 1) { - printk("comedi%d: (cmd->stop_arg)*(cmd->scan_end_arg)<1, aborting.\n", dev->minor); - up(&this_usbduxfastsub->sem); + udfs->ai_sample_count = cmd->stop_arg * cmd->scan_end_arg; + if (udfs->ai_sample_count < 1) { + printk(KERN_ERR "comedi%d: " + "(cmd->stop_arg)*(cmd->scan_end_arg)<1, " + "aborting.\n", dev->minor); + up(&udfs->sem); return -EFAULT; } - this_usbduxfastsub->ai_continous = 0; + udfs->ai_continous = 0; } else { - // continous aquisition - this_usbduxfastsub->ai_continous = 1; - this_usbduxfastsub->ai_sample_count = 0; + /* continous aquisition */ + udfs->ai_continous = 1; + udfs->ai_sample_count = 0; } if ((cmd->start_src == TRIG_NOW) || (cmd->start_src == TRIG_EXT)) { - // enable this acquisition operation - this_usbduxfastsub->ai_cmd_running = 1; - ret = usbduxfastsub_submit_InURBs(this_usbduxfastsub); + /* enable this acquisition operation */ + udfs->ai_cmd_running = 1; + ret = usbduxfastsub_submit_InURBs(udfs); if (ret < 0) { - this_usbduxfastsub->ai_cmd_running = 0; - // fixme: unlink here?? - up(&this_usbduxfastsub->sem); + udfs->ai_cmd_running = 0; + /* fixme: unlink here?? */ + up(&udfs->sem); return ret; } s->async->inttrig = NULL; } else { - /* TRIG_INT */ - // don't enable the acquision operation - // wait for an internal signal + /* + * TRIG_INT + * don't enable the acquision operation + * wait for an internal signal + */ s->async->inttrig = usbduxfast_ai_inttrig; } - up(&this_usbduxfastsub->sem); + up(&udfs->sem); return 0; } -/* Mode 0 is used to get a single conversion on demand */ -static int usbduxfast_ai_insn_read(comedi_device * dev, - comedi_subdevice * s, comedi_insn * insn, lsampl_t * data) +/* + * Mode 0 is used to get a single conversion on demand. + */ +static int usbduxfast_ai_insn_read(comedi_device *dev, + comedi_subdevice *s, comedi_insn *insn, lsampl_t *data) { int i, j, n, actual_length; int chan, range, rngmask; int err; - usbduxfastsub_t *usbduxfastsub = dev->private; + struct usbduxfastsub_s *udfs; - if (!usbduxfastsub) { - printk("comedi%d: ai_insn_read: no usb dev.\n", dev->minor); + udfs = dev->private; + if (!udfs) { + printk(KERN_ERR "comedi%d: ai_insn_read: no usb dev.\n", + dev->minor); return -ENODEV; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: ai_insn_read, insn->n=%d, insn->subdev=%d\n", - dev->minor, insn->n, insn->subdev); + printk(KERN_DEBUG "comedi%d: ai_insn_read, insn->n=%d, " + "insn->subdev=%d\n", dev->minor, insn->n, insn->subdev); #endif - down(&usbduxfastsub->sem); - if (!(usbduxfastsub->probed)) { - up(&usbduxfastsub->sem); + down(&udfs->sem); + if (!udfs->probed) { + up(&udfs->sem); return -ENODEV; } - if (usbduxfastsub->ai_cmd_running) { - printk("comedi%d: ai_insn_read not possible. Async Command is running.\n", dev->minor); - up(&usbduxfastsub->sem); + if (udfs->ai_cmd_running) { + printk(KERN_ERR "comedi%d: ai_insn_read not possible. Async " + "Command is running.\n", dev->minor); + up(&udfs->sem); return -EBUSY; } - // sample one channel + /* sample one channel */ chan = CR_CHAN(insn->chanspec); range = CR_RANGE(insn->chanspec); - // set command for the first channel + /* set command for the first channel */ if (range > 0) rngmask = 0xff - 0x04; else rngmask = 0xff; - // commit data to the FIFO - usbduxfastsub->dux_commands[LENBASE + 0] = 1; - usbduxfastsub->dux_commands[OPBASE + 0] = 0x02; // data - usbduxfastsub->dux_commands[OUTBASE + 0] = 0xFF & rngmask; - usbduxfastsub->dux_commands[LOGBASE + 0] = 0; - - // do the first part of the delay - usbduxfastsub->dux_commands[LENBASE + 1] = 12; - usbduxfastsub->dux_commands[OPBASE + 1] = 0; - usbduxfastsub->dux_commands[OUTBASE + 1] = 0xFE & rngmask; - usbduxfastsub->dux_commands[LOGBASE + 1] = 0; - - usbduxfastsub->dux_commands[LENBASE + 2] = 1; - usbduxfastsub->dux_commands[OPBASE + 2] = 0; - usbduxfastsub->dux_commands[OUTBASE + 2] = 0xFE & rngmask; - usbduxfastsub->dux_commands[LOGBASE + 2] = 0; - - usbduxfastsub->dux_commands[LENBASE + 3] = 1; - usbduxfastsub->dux_commands[OPBASE + 3] = 0; - usbduxfastsub->dux_commands[OUTBASE + 3] = 0xFE & rngmask; - usbduxfastsub->dux_commands[LOGBASE + 3] = 0; - - usbduxfastsub->dux_commands[LENBASE + 4] = 1; - usbduxfastsub->dux_commands[OPBASE + 4] = 0; - usbduxfastsub->dux_commands[OUTBASE + 4] = 0xFE & rngmask; - usbduxfastsub->dux_commands[LOGBASE + 4] = 0; - - // second part - usbduxfastsub->dux_commands[LENBASE + 5] = 12; - usbduxfastsub->dux_commands[OPBASE + 5] = 0; - usbduxfastsub->dux_commands[OUTBASE + 5] = 0xFF & rngmask; - usbduxfastsub->dux_commands[LOGBASE + 5] = 0; - - usbduxfastsub->dux_commands[LENBASE + 6] = 1; - usbduxfastsub->dux_commands[OPBASE + 6] = 0; - usbduxfastsub->dux_commands[OUTBASE + 6] = 0xFF & rngmask; - usbduxfastsub->dux_commands[LOGBASE + 0] = 0; + + /* commit data to the FIFO */ + udfs->dux_commands[LENBASE+0] = 1; + /* data */ + udfs->dux_commands[OPBASE+0] = 0x02; + udfs->dux_commands[OUTBASE+0] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+0] = 0; + + /* do the first part of the delay */ + udfs->dux_commands[LENBASE+1] = 12; + udfs->dux_commands[OPBASE+1] = 0; + udfs->dux_commands[OUTBASE+1] = 0xFE & rngmask; + udfs->dux_commands[LOGBASE+1] = 0; + + udfs->dux_commands[LENBASE+2] = 1; + udfs->dux_commands[OPBASE+2] = 0; + udfs->dux_commands[OUTBASE+2] = 0xFE & rngmask; + udfs->dux_commands[LOGBASE+2] = 0; + + udfs->dux_commands[LENBASE+3] = 1; + udfs->dux_commands[OPBASE+3] = 0; + udfs->dux_commands[OUTBASE+3] = 0xFE & rngmask; + udfs->dux_commands[LOGBASE+3] = 0; + + udfs->dux_commands[LENBASE+4] = 1; + udfs->dux_commands[OPBASE+4] = 0; + udfs->dux_commands[OUTBASE+4] = 0xFE & rngmask; + udfs->dux_commands[LOGBASE+4] = 0; + + /* second part */ + udfs->dux_commands[LENBASE+5] = 12; + udfs->dux_commands[OPBASE+5] = 0; + udfs->dux_commands[OUTBASE+5] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+5] = 0; + + udfs->dux_commands[LENBASE+6] = 1; + udfs->dux_commands[OPBASE+6] = 0; + udfs->dux_commands[OUTBASE+6] = 0xFF & rngmask; + udfs->dux_commands[LOGBASE+0] = 0; #ifdef CONFIG_COMEDI_DEBUG - printk("comedi %d: sending commands to the usb device\n", dev->minor); + printk(KERN_DEBUG "comedi %d: sending commands to the usb device\n", + dev->minor); #endif - // 0 means that the AD commands are sent - err = send_dux_commands(usbduxfastsub, SENDADCOMMANDS); + /* 0 means that the AD commands are sent */ + err = send_dux_commands(udfs, SENDADCOMMANDS); if (err < 0) { - printk("comedi%d: adc command could not be submitted. Aborting...\n", dev->minor); - up(&usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: adc command could not be submitted." + "Aborting...\n", dev->minor); + up(&udfs->sem); return err; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast: submitting in-urb: 0x%p,0x%p\n", - usbduxfastsub->comedidev->minor, - usbduxfastsub->urbIn->context, - usbduxfastsub->urbIn->dev); + printk(KERN_DEBUG "comedi%d: usbduxfast: submitting in-urb: " + "0x%p,0x%p\n", udfs->comedidev->minor, udfs->urbIn->context, + udfs->urbIn->dev); #endif for (i = 0; i < PACKETS_TO_IGNORE; i++) { - err = usb_bulk_msg(usbduxfastsub->usbdev, - usb_rcvbulkpipe(usbduxfastsub->usbdev, - BULKINEP), - usbduxfastsub->transfer_buffer, SIZEINBUF, + err = usb_bulk_msg(udfs->usbdev, + usb_rcvbulkpipe(udfs->usbdev, BULKINEP), + udfs->transfer_buffer, SIZEINBUF, &actual_length, 10000); if (err < 0) { - printk("comedi%d: insn timeout. No data.\n", + printk(KERN_ERR "comedi%d: insn timeout. No data.\n", dev->minor); - up(&usbduxfastsub->sem); + up(&udfs->sem); return err; } } - // data points + /* data points */ for (i = 0; i < insn->n;) { - err = usb_bulk_msg(usbduxfastsub->usbdev, - usb_rcvbulkpipe(usbduxfastsub->usbdev, - BULKINEP), - usbduxfastsub->transfer_buffer, SIZEINBUF, + err = usb_bulk_msg(udfs->usbdev, + usb_rcvbulkpipe(udfs->usbdev, BULKINEP), + udfs->transfer_buffer, SIZEINBUF, &actual_length, 10000); if (err < 0) { - printk("comedi%d: insn data error: %d\n", + printk(KERN_ERR "comedi%d: insn data error: %d\n", dev->minor, err); - up(&usbduxfastsub->sem); + up(&udfs->sem); return err; } n = actual_length / sizeof(uint16_t); if ((n % 16) != 0) { - printk("comedi%d: insn data packet corrupted.\n", - dev->minor); - up(&usbduxfastsub->sem); + printk(KERN_ERR "comedi%d: insn data packet " + "corrupted.\n", dev->minor); + up(&udfs->sem); return -EINVAL; } for (j = chan; (j < n) && (i < insn->n); j = j + 16) { - data[i] = - ((uint16_t *) (usbduxfastsub-> - transfer_buffer))[j]; + data[i] = ((uint16_t *) (udfs->transfer_buffer))[j]; i++; } } - up(&usbduxfastsub->sem); + up(&udfs->sem); return i; } static unsigned hex2unsigned(char *h) { unsigned hi, lo; - if (h[0] > '9') { + + if (h[0] > '9') hi = h[0] - 'A' + 0x0a; - } else { + else hi = h[0] - '0'; - } - if (h[1] > '9') { + + if (h[1] > '9') lo = h[1] - 'A' + 0x0a; - } else { + else lo = h[1] - '0'; - } + return hi * 0x10 + lo; } -// for FX2 +/* for FX2 */ #define FIRMWARE_MAX_LEN 0x2000 -// taken from David Brownell's fxload and adjusted for this driver -static int read_firmware(usbduxfastsub_t * usbduxfastsub, void *firmwarePtr, +/* + * taken from David Brownell's fxload and adjusted for this driver + */ +static int read_firmware(struct usbduxfastsub_s *udfs, void *firmwarePtr, long size) { int i = 0; @@ -1289,7 +1407,8 @@ static int read_firmware(usbduxfastsub_t * usbduxfastsub, void *firmwarePtr, firmwareBinary = kmalloc(FIRMWARE_MAX_LEN, GFP_KERNEL); if (!firmwareBinary) { - printk("comedi_: usbduxfast: mem alloc for firmware failed\n"); + printk(KERN_ERR "comedi_: usbduxfast: mem alloc for firmware " + " failed\n"); return -ENOMEM; } @@ -1300,32 +1419,36 @@ static int read_firmware(usbduxfastsub_t * usbduxfastsub, void *firmwarePtr, int idx, off; int j = 0; - // get one line + /* get one line */ while ((i < size) && (fp[i] != 13) && (fp[i] != 10)) { buf[j] = fp[i]; i++; j++; if (j >= sizeof(buf)) { - printk("comedi_: usbduxfast: bogus firmware file!\n"); + printk(KERN_ERR "comedi_: usbduxfast: bogus " + "firmware file!\n"); kfree(firmwareBinary); return -1; } } - // get rid of LF/CR/... + /* get rid of LF/CR/... */ while ((i < size) && ((fp[i] == 13) || (fp[i] == 10) - || (fp[i] == 0))) { + || (fp[i] == 0))) i++; - } buf[j] = 0; - //printk("comedi_: buf=%s\n",buf); + /* printk("comedi_: buf=%s\n",buf); */ - /* EXTENSION: "# comment-till-end-of-line", for copyrights etc */ + /* + * EXTENSION: "# comment-till-end-of-line", + * for copyrights etc + */ if (buf[0] == '#') continue; if (buf[0] != ':') { - printk("comedi_: usbduxfast: upload: not an ihex record: %s", buf); + printk(KERN_ERR "comedi_: usbduxfast: upload: not an " + "ihex record: %s", buf); kfree(firmwareBinary); return -EFAULT; } @@ -1336,86 +1459,88 @@ static int read_firmware(usbduxfastsub_t * usbduxfastsub, void *firmwarePtr, /* Read the target offset */ off = (hex2unsigned(buf + 3) * 0x0100) + hex2unsigned(buf + 5); - if ((off + len) > maxAddr) { + if ((off + len) > maxAddr) maxAddr = off + len; - } if (maxAddr >= FIRMWARE_MAX_LEN) { - printk("comedi_: usbduxfast: firmware upload goes beyond FX2 RAM boundaries."); + printk(KERN_ERR "comedi_: usbduxfast: firmware upload " + "goes beyond FX2 RAM boundaries."); kfree(firmwareBinary); return -EFAULT; } - //printk("comedi_: usbduxfast: off=%x, len=%x:",off,len); + /* printk("comedi_: usbduxfast: off=%x, len=%x:",off,len); */ /* Read the record type */ type = hex2unsigned(buf + 7); /* If this is an EOF record, then make it so. */ - if (type == 1) { + if (type == 1) break; - } if (type != 0) { - printk("comedi_: usbduxfast: unsupported record type: %u\n", type); + printk(KERN_ERR "comedi_: usbduxfast: unsupported " + "record type: %u\n", type); kfree(firmwareBinary); return -EFAULT; } for (idx = 0, cp = buf + 9; idx < len; idx += 1, cp += 2) { firmwareBinary[idx + off] = hex2unsigned(cp); - //printk("%02x ",firmwareBinary[idx+off]); + /* printk("%02x ",firmwareBinary[idx+off]); */ } - //printk("\n"); + + /* printk("\n"); */ if (i >= size) { - printk("comedi_: usbduxfast: unexpected end of hex file\n"); + printk(KERN_ERR "comedi_: usbduxfast: unexpected end " + "of hex file\n"); break; } } - res = firmwareUpload(usbduxfastsub, firmwareBinary, maxAddr + 1); + res = firmwareUpload(udfs, firmwareBinary, maxAddr + 1); kfree(firmwareBinary); return res; } -static void tidy_up(usbduxfastsub_t * usbduxfastsub_tmp) +static void tidy_up(struct usbduxfastsub_s *udfs) { #ifdef CONFIG_COMEDI_DEBUG - printk("comedi_: usbduxfast: tiding up\n"); + printk(KERN_DEBUG "comedi_: usbduxfast: tiding up\n"); #endif - if (!usbduxfastsub_tmp) { + + if (!udfs) return; - } - // shows the usb subsystem that the driver is down - if (usbduxfastsub_tmp->interface) { - usb_set_intfdata(usbduxfastsub_tmp->interface, NULL); - } + /* shows the usb subsystem that the driver is down */ + if (udfs->interface) + usb_set_intfdata(udfs->interface, NULL); - usbduxfastsub_tmp->probed = 0; + udfs->probed = 0; - if (usbduxfastsub_tmp->urbIn) { - // waits until a running transfer is over - usb_kill_urb(usbduxfastsub_tmp->urbIn); - if (usbduxfastsub_tmp->transfer_buffer) { - kfree(usbduxfastsub_tmp->transfer_buffer); - usbduxfastsub_tmp->transfer_buffer = NULL; - } - usb_free_urb(usbduxfastsub_tmp->urbIn); - usbduxfastsub_tmp->urbIn = NULL; - } - if (usbduxfastsub_tmp->insnBuffer) { - kfree(usbduxfastsub_tmp->insnBuffer); - usbduxfastsub_tmp->insnBuffer = NULL; - } - if (usbduxfastsub_tmp->dux_commands) { - kfree(usbduxfastsub_tmp->dux_commands); - usbduxfastsub_tmp->dux_commands = NULL; + if (udfs->urbIn) { + /* waits until a running transfer is over */ + usb_kill_urb(udfs->urbIn); + + kfree(udfs->transfer_buffer); + udfs->transfer_buffer = NULL; + + usb_free_urb(udfs->urbIn); + udfs->urbIn = NULL; } - usbduxfastsub_tmp->ai_cmd_running = 0; + + kfree(udfs->insnBuffer); + udfs->insnBuffer = NULL; + + kfree(udfs->dux_commands); + udfs->dux_commands = NULL; + + udfs->ai_cmd_running = 0; } -// allocate memory for the urbs and initialise them +/* + * allocate memory for the urbs and initialise them + */ static int usbduxfastsub_probe(struct usb_interface *uinterf, const struct usb_device_id *id) { @@ -1424,122 +1549,137 @@ static int usbduxfastsub_probe(struct usb_interface *uinterf, int index; if (udev->speed != USB_SPEED_HIGH) { - printk("comedi_: usbduxfast_: This driver needs USB 2.0 to operate. Aborting...\n"); + printk(KERN_ERR "comedi_: usbduxfast_: This driver needs" + "USB 2.0 to operate. Aborting...\n"); return -ENODEV; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi_: usbduxfast_: finding a free structure for the usb-device\n"); + printk(KERN_DEBUG "comedi_: usbduxfast_: finding a free structure for " + "the usb-device\n"); #endif down(&start_stop_sem); - // look for a free place in the usbduxfast array + /* look for a free place in the usbduxfast array */ index = -1; for (i = 0; i < NUMUSBDUXFAST; i++) { - if (!(usbduxfastsub[i].probed)) { + if (!usbduxfastsub[i].probed) { index = i; break; } } - // no more space + /* no more space */ if (index == -1) { - printk("Too many usbduxfast-devices connected.\n"); + printk(KERN_ERR "Too many usbduxfast-devices connected.\n"); up(&start_stop_sem); return -EMFILE; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi_: usbduxfast: usbduxfastsub[%d] is ready to connect to comedi.\n", index); + printk(KERN_DEBUG "comedi_: usbduxfast: usbduxfastsub[%d] is ready to " + "connect to comedi.\n", index); #endif init_MUTEX(&(usbduxfastsub[index].sem)); - // save a pointer to the usb device + /* save a pointer to the usb device */ usbduxfastsub[index].usbdev = udev; - // save the interface itself + /* save the interface itself */ usbduxfastsub[index].interface = uinterf; - // get the interface number from the interface + /* get the interface number from the interface */ usbduxfastsub[index].ifnum = uinterf->altsetting->desc.bInterfaceNumber; - // hand the private data over to the usb subsystem - // will be needed for disconnect + /* + * hand the private data over to the usb subsystem + * will be needed for disconnect + */ usb_set_intfdata(uinterf, &(usbduxfastsub[index])); #ifdef CONFIG_COMEDI_DEBUG - printk("comedi_: usbduxfast: ifnum=%d\n", usbduxfastsub[index].ifnum); + printk(KERN_DEBUG "comedi_: usbduxfast: ifnum=%d\n", + usbduxfastsub[index].ifnum); #endif - // create space for the commands going to the usb device + /* create space for the commands going to the usb device */ usbduxfastsub[index].dux_commands = kmalloc(SIZEOFDUXBUFFER, - GFP_KERNEL); + GFP_KERNEL); if (!usbduxfastsub[index].dux_commands) { - printk("comedi_: usbduxfast: error alloc space for dac commands\n"); + printk(KERN_ERR "comedi_: usbduxfast: error alloc space for " + "dac commands\n"); tidy_up(&(usbduxfastsub[index])); up(&start_stop_sem); return -ENOMEM; } - // create space of the instruction buffer + /* create space of the instruction buffer */ usbduxfastsub[index].insnBuffer = kmalloc(SIZEINSNBUF, GFP_KERNEL); - if (!(usbduxfastsub[index].insnBuffer)) { - printk("comedi_: usbduxfast: could not alloc space for insnBuffer\n"); + if (!usbduxfastsub[index].insnBuffer) { + printk(KERN_ERR "comedi_: usbduxfast: could not alloc space " + "for insnBuffer\n"); tidy_up(&(usbduxfastsub[index])); up(&start_stop_sem); return -ENOMEM; } - // setting to alternate setting 1: enabling bulk ep + /* setting to alternate setting 1: enabling bulk ep */ i = usb_set_interface(usbduxfastsub[index].usbdev, usbduxfastsub[index].ifnum, 1); if (i < 0) { - printk("comedi_: usbduxfast%d: could not switch to alternate setting 1.\n", index); + printk(KERN_ERR "comedi_: usbduxfast%d: could not switch to " + "alternate setting 1.\n", index); tidy_up(&(usbduxfastsub[index])); up(&start_stop_sem); return -ENODEV; } usbduxfastsub[index].urbIn = usb_alloc_urb(0, GFP_KERNEL); - if (usbduxfastsub[index].urbIn == NULL) { - printk("comedi_: usbduxfast%d: Could not alloc. urb\n", index); + if (!usbduxfastsub[index].urbIn) { + printk(KERN_ERR "comedi_: usbduxfast%d: Could not alloc." + "urb\n", index); tidy_up(&(usbduxfastsub[index])); up(&start_stop_sem); return -ENOMEM; } usbduxfastsub[index].transfer_buffer = kmalloc(SIZEINBUF, GFP_KERNEL); - if (!(usbduxfastsub[index].transfer_buffer)) { - printk("comedi_: usbduxfast%d: could not alloc. transb.\n", - index); + if (!usbduxfastsub[index].transfer_buffer) { + printk(KERN_ERR "comedi_: usbduxfast%d: could not alloc. " + "transb.\n", index); tidy_up(&(usbduxfastsub[index])); up(&start_stop_sem); return -ENOMEM; } - // we've reached the bottom of the function + /* we've reached the bottom of the function */ usbduxfastsub[index].probed = 1; up(&start_stop_sem); - printk("comedi_: usbduxfast%d has been successfully initialized.\n", - index); - // success + printk(KERN_INFO "comedi_: usbduxfast%d has been successfully " + "initialized.\n", index); + /* success */ return 0; } static void usbduxfastsub_disconnect(struct usb_interface *intf) { - usbduxfastsub_t *usbduxfastsub_tmp = usb_get_intfdata(intf); + struct usbduxfastsub_s *udfs = usb_get_intfdata(intf); struct usb_device *udev = interface_to_usbdev(intf); - if (!usbduxfastsub_tmp) { - printk("comedi_: usbduxfast: disconnect called with null pointer.\n"); + if (!udfs) { + printk(KERN_ERR "comedi_: usbduxfast: disconnect called with " + "null pointer.\n"); return; } - if (usbduxfastsub_tmp->usbdev != udev) { - printk("comedi_: usbduxfast: BUG! called with wrong ptr!!!\n"); + if (udfs->usbdev != udev) { + printk(KERN_ERR "comedi_: usbduxfast: BUG! called with wrong " + "ptr!!!\n"); return; } down(&start_stop_sem); - down(&usbduxfastsub_tmp->sem); - tidy_up(usbduxfastsub_tmp); - up(&usbduxfastsub_tmp->sem); + down(&udfs->sem); + tidy_up(udfs); + up(&udfs->sem); up(&start_stop_sem); + #ifdef CONFIG_COMEDI_DEBUG - printk("comedi_: usbduxfast: disconnected from the usb\n"); + printk(KERN_DEBUG "comedi_: usbduxfast: disconnected from the usb\n"); #endif } -// is called when comedi-config is called -static int usbduxfast_attach(comedi_device * dev, comedi_devconfig * it) +/* + * is called when comedi-config is called + */ +static int usbduxfast_attach(comedi_device *dev, comedi_devconfig *it) { int ret; int index; @@ -1548,26 +1688,31 @@ static int usbduxfast_attach(comedi_device * dev, comedi_devconfig * it) dev->private = NULL; down(&start_stop_sem); - // find a valid device which has been detected by the probe function of the usb + /* + * find a valid device which has been detected by the + * probe function of the usb + */ index = -1; for (i = 0; i < NUMUSBDUXFAST; i++) { - if ((usbduxfastsub[i].probed) && (!usbduxfastsub[i].attached)) { + if (usbduxfastsub[i].probed && !usbduxfastsub[i].attached) { index = i; break; } } if (index < 0) { - printk("comedi%d: usbduxfast: error: attach failed, no usbduxfast devs connected to the usb bus.\n", dev->minor); + printk(KERN_ERR "comedi%d: usbduxfast: error: attach failed, " + "no usbduxfast devs connected to the usb bus.\n", + dev->minor); up(&start_stop_sem); return -ENODEV; } down(&(usbduxfastsub[index].sem)); - // pointer back to the corresponding comedi device + /* pointer back to the corresponding comedi device */ usbduxfastsub[index].comedidev = dev; - // trying to upload the firmware into the chip + /* trying to upload the firmware into the chip */ if (comedi_aux_data(it->options, 0) && it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) { read_firmware(usbduxfastsub, @@ -1580,109 +1725,120 @@ static int usbduxfast_attach(comedi_device * dev, comedi_devconfig * it) /* set number of subdevices */ dev->n_subdevices = N_SUBDEVICES; - // allocate space for the subdevices - if ((ret = alloc_subdevices(dev, N_SUBDEVICES)) < 0) { - printk("comedi%d: usbduxfast: error alloc space for subdev\n", - dev->minor); + /* allocate space for the subdevices */ + ret = alloc_subdevices(dev, N_SUBDEVICES); + if (ret < 0) { + printk(KERN_ERR "comedi%d: usbduxfast: error alloc space for " + "subdev\n", dev->minor); up(&start_stop_sem); return ret; } - printk("comedi%d: usbduxfast: usb-device %d is attached to comedi.\n", - dev->minor, index); - // private structure is also simply the usb-structure + printk(KERN_INFO "comedi%d: usbduxfast: usb-device %d is attached to " + "comedi.\n", dev->minor, index); + /* private structure is also simply the usb-structure */ dev->private = usbduxfastsub + index; - // the first subdevice is the A/D converter + /* the first subdevice is the A/D converter */ s = dev->subdevices + SUBDEV_AD; - // the URBs get the comedi subdevice - // which is responsible for reading - // this is the subdevice which reads data + /* + * the URBs get the comedi subdevice which is responsible for reading + * this is the subdevice which reads data + */ dev->read_subdev = s; - // the subdevice receives as private structure the - // usb-structure + /* the subdevice receives as private structure the usb-structure */ s->private = NULL; - // analog input + /* analog input */ s->type = COMEDI_SUBD_AI; - // readable and ref is to ground + /* readable and ref is to ground */ s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ; - // 16 channels + /* 16 channels */ s->n_chan = 16; - // length of the channellist + /* length of the channellist */ s->len_chanlist = 16; - // callback functions + /* callback functions */ s->insn_read = usbduxfast_ai_insn_read; s->do_cmdtest = usbduxfast_ai_cmdtest; s->do_cmd = usbduxfast_ai_cmd; s->cancel = usbduxfast_ai_cancel; - // max value from the A/D converter (12bit+1 bit for overflow) + /* max value from the A/D converter (12bit+1 bit for overflow) */ s->maxdata = 0x1000; - // range table to convert to physical units + /* range table to convert to physical units */ s->range_table = &range_usbduxfast_ai_range; - // finally decide that it's attached + /* finally decide that it's attached */ usbduxfastsub[index].attached = 1; up(&(usbduxfastsub[index].sem)); - up(&start_stop_sem); - - printk("comedi%d: successfully attached to usbduxfast.\n", dev->minor); + printk(KERN_INFO "comedi%d: successfully attached to usbduxfast.\n", + dev->minor); return 0; } -static int usbduxfast_detach(comedi_device * dev) +static int usbduxfast_detach(comedi_device *dev) { - usbduxfastsub_t *usbduxfastsub_tmp; + struct usbduxfastsub_s *udfs; if (!dev) { - printk("comedi?: usbduxfast: detach without dev variable...\n"); + printk(KERN_ERR "comedi?: usbduxfast: detach without dev " + "variable...\n"); return -EFAULT; } #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast: detach usb device\n", dev->minor); + printk(KERN_DEBUG "comedi%d: usbduxfast: detach usb device\n", + dev->minor); #endif - usbduxfastsub_tmp = dev->private; - if (!usbduxfastsub_tmp) { - printk("comedi?: usbduxfast: detach without ptr to usbduxfastsub[]\n"); + udfs = dev->private; + if (!udfs) { + printk(KERN_ERR "comedi?: usbduxfast: detach without ptr to " + "usbduxfastsub[]\n"); return -EFAULT; } - down(&usbduxfastsub_tmp->sem); + down(&udfs->sem); down(&start_stop_sem); - // Don't allow detach to free the private structure - // It's one entry of of usbduxfastsub[] + /* + * Don't allow detach to free the private structure + * It's one entry of of usbduxfastsub[] + */ dev->private = NULL; - usbduxfastsub_tmp->attached = 0; - usbduxfastsub_tmp->comedidev = NULL; + udfs->attached = 0; + udfs->comedidev = NULL; #ifdef CONFIG_COMEDI_DEBUG - printk("comedi%d: usbduxfast: detach: successfully removed\n", - dev->minor); + printk(KERN_DEBUG "comedi%d: usbduxfast: detach: successfully " + "removed\n", dev->minor); #endif up(&start_stop_sem); - up(&usbduxfastsub_tmp->sem); + up(&udfs->sem); return 0; } -/* main driver struct */ +/* + * main driver struct + */ static comedi_driver driver_usbduxfast = { - driver_name:"usbduxfast", - module:THIS_MODULE, - attach:usbduxfast_attach, - detach:usbduxfast_detach, + .driver_name = "usbduxfast", + .module = THIS_MODULE, + .attach = usbduxfast_attach, + .detach = usbduxfast_detach }; static void init_usb_devices(void) { int index; + #ifdef CONFIG_COMEDI_DEBUG - printk("comedi_: usbduxfast: setting all possible devs to invalid\n"); + printk(KERN_DEBUG "comedi_: usbduxfast: setting all possible devs to " + "invalid\n"); #endif - // all devices entries are invalid to begin with - // they will become valid by the probe function - // and then finally by the attach-function + /* + * all devices entries are invalid to begin with + * they will become valid by the probe function + * and then finally by the attach-function + */ for (index = 0; index < NUMUSBDUXFAST; index++) { memset(&(usbduxfastsub[index]), 0x00, sizeof(usbduxfastsub[index])); @@ -1690,44 +1846,48 @@ static void init_usb_devices(void) } } -// Table with the USB-devices: just now only testing IDs +/* + * Table with the USB-devices: just now only testing IDs + */ static struct usb_device_id usbduxfastsub_table[] = { - // { USB_DEVICE(0x4b4, 0x8613), //testing - // }, - {USB_DEVICE(0x13d8, 0x0010) //real ID - }, - {USB_DEVICE(0x13d8, 0x0011) //real ID - }, - {} /* Terminating entry */ + /* { USB_DEVICE(0x4b4, 0x8613) }, testing */ + { USB_DEVICE(0x13d8, 0x0010) }, /* real ID */ + { USB_DEVICE(0x13d8, 0x0011) }, /* real ID */ + { } /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, usbduxfastsub_table); -// The usbduxfastsub-driver +/* + * The usbduxfastsub-driver + */ static struct usb_driver usbduxfastsub_driver = { #ifdef COMEDI_HAVE_USB_DRIVER_OWNER - owner:THIS_MODULE, + .owner = THIS_MODULE, #endif - name:BOARDNAME, - probe:usbduxfastsub_probe, - disconnect:usbduxfastsub_disconnect, - id_table:usbduxfastsub_table, + .name = BOARDNAME, + .probe = usbduxfastsub_probe, + .disconnect = usbduxfastsub_disconnect, + .id_table = usbduxfastsub_table }; -// Can't use the nice macro as I have also to initialise the USB -// subsystem: -// registering the usb-system _and_ the comedi-driver +/* + * Can't use the nice macro as I have also to initialise the USB subsystem: + * registering the usb-system _and_ the comedi-driver + */ static int init_usbduxfast(void) { - printk(KERN_INFO KBUILD_MODNAME ": " - DRIVER_VERSION ":" DRIVER_DESC "\n"); + printk(KERN_INFO + KBUILD_MODNAME ": " DRIVER_VERSION ":" DRIVER_DESC "\n"); init_usb_devices(); usb_register(&usbduxfastsub_driver); comedi_driver_register(&driver_usbduxfast); return 0; } -// deregistering the comedi driver and the usb-subsystem +/* + * deregistering the comedi driver and the usb-subsystem + */ static void exit_usbduxfast(void) { comedi_driver_unregister(&driver_usbduxfast);