diff options
| -rw-r--r-- | drivers/staging/comedi/drivers/Makefile | 3 | ||||
| -rw-r--r-- | drivers/staging/comedi/drivers/usbdux.c | 2981 |
2 files changed, 2984 insertions, 0 deletions
diff --git a/drivers/staging/comedi/drivers/Makefile b/drivers/staging/comedi/drivers/Makefile index 9a4fb1de5e8..6b38d836095 100644 --- a/drivers/staging/comedi/drivers/Makefile +++ b/drivers/staging/comedi/drivers/Makefile @@ -6,3 +6,6 @@ obj-$(CONFIG_COMEDI) += comedi_fc.o # Comedi PCI drivers obj-$(CONFIG_COMEDI_PCI_DRIVERS) += mite.o + +# Comedi USB drivers +obj-$(CONFIG_COMEDI_USB_DRIVERS) += usbdux.o diff --git a/drivers/staging/comedi/drivers/usbdux.c b/drivers/staging/comedi/drivers/usbdux.c new file mode 100644 index 00000000000..33205530b0d --- /dev/null +++ b/drivers/staging/comedi/drivers/usbdux.c @@ -0,0 +1,2981 @@ +#define DRIVER_VERSION "v2.1" +#define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com" +#define DRIVER_DESC "Stirling/ITL USB-DUX -- Bernd.Porr@f2s.com" +/* + comedi/drivers/usbdux.c + Copyright (C) 2003-2007 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: usbdux +Description: University of Stirling USB DAQ & INCITE Technology Limited +Devices: [ITL] USB-DUX (usbdux.o) +Author: Bernd Porr <BerndPorr@f2s.com> +Updated: 25 Nov 2007 +Status: Testing +Configuration options: + You have to upload firmware with the -i option. The + firmware is usually installed under /usr/share/usb or + /usr/local/share/usb or /lib/firmware. + +Connection scheme for the counter at the digital port: + 0=/CLK0, 1=UP/DOWN0, 2=RESET0, 4=/CLK1, 5=UP/DOWN1, 6=RESET1. + The sampling rate of the counter is approximately 500Hz. + +Please note that under USB2.0 the length of the channel list determines +the max sampling rate. If you sample only one channel you get 8kHz +sampling rate. If you sample two channels you get 4kHz and so on. +*/ +/* + * I must give credit here to Chris Baugher who + * wrote the driver for AT-MIO-16d. I used some parts of this + * driver. I also must give credits to David Brownell + * who supported me with the USB development. + * + * Bernd Porr + * + * + * Revision history: + * 0.94: D/A output should work now with any channel list combinations + * 0.95: .owner commented out for kernel vers below 2.4.19 + * sanity checks in ai/ao_cmd + * 0.96: trying to get it working with 2.6, moved all memory alloc to comedi's attach final USB IDs + * moved memory allocation completely to the corresponding comedi functions + * firmware upload is by fxload and no longer by comedi (due to enumeration) + * 0.97: USB IDs received, adjusted table + * 0.98: SMP, locking, memroy alloc: moved all usb memory alloc + * to the usb subsystem and moved all comedi related memory + * alloc to comedi. + * | kernel | registration | usbdux-usb | usbdux-comedi | comedi | + * 0.99: USB 2.0: changed protocol to isochronous transfer + * IRQ transfer is too buggy and too risky in 2.0 + * for the high speed ISO transfer is now a working version available + * 0.99b: Increased the iso transfer buffer for high sp.to 10 buffers. Some VIA + * chipsets miss out IRQs. Deeper buffering is needed. + * 1.00: full USB 2.0 support for the A/D converter. Now: max 8kHz sampling rate. + * Firmware vers 1.00 is needed for this. + * Two 16 bit up/down/reset counter with a sampling rate of 1kHz + * And loads of cleaning up, in particular streamlining the + * bulk transfers. + * 1.1: moved EP4 transfers to EP1 to make space for a PWM output on EP4 + * 1.2: added PWM suport via EP4 + * 2.0: PWM seems to be stable and is not interfering with the other functions + * 2.1: changed PWM API + * + */ + +// generates loads of debug info +// #define NOISY_DUX_DEBUGBUG + +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/init.h> +#include <linux/slab.h> +#include <linux/input.h> +#include <linux/usb.h> +#include <linux/smp_lock.h> +#include <linux/fcntl.h> +#include <linux/compiler.h> + +#include "../comedidev.h" +#include "../usb.h" + +#define BOARDNAME "usbdux" + +// timeout for the USB-transfer +#define EZTIMEOUT 30 + +// constants for "firmware" upload and download +#define USBDUXSUB_FIRMWARE 0xA0 +#define VENDOR_DIR_IN 0xC0 +#define VENDOR_DIR_OUT 0x40 + +// internal adresses of the 8051 processor +#define USBDUXSUB_CPUCS 0xE600 + +// the minor device number, major is 180 +// only for debugging purposes and to +// upload special firmware (programming the +// eeprom etc) which is not compatible with +// the comedi framwork +#define USBDUXSUB_MINOR 32 + +// max lenghth of the transfer-buffer for software upload +#define TB_LEN 0x2000 + +// Input endpoint number: ISO/IRQ +#define ISOINEP 6 + +// Output endpoint number: ISO/IRQ +#define ISOOUTEP 2 + +// This EP sends DUX commands to USBDUX +#define COMMAND_OUT_EP 1 + +// This EP receives the DUX commands from USBDUX +#define COMMAND_IN_EP 8 + +// Output endpoint for PWM +#define PWM_EP 4 + +// 300Hz max frequ under PWM +#define MIN_PWM_PERIOD ((long)(1E9/300)) + +// Default PWM frequency +#define PWM_DEFAULT_PERIOD ((long)(1E9/100)) + +// Number of channels +#define NUMCHANNELS 8 + +// Size of one A/D value +#define SIZEADIN ((sizeof(int16_t))) + +// Size of the input-buffer IN BYTES +// Always multiple of 8 for 8 microframes which is needed in the highspeed mode +#define SIZEINBUF ((8*SIZEADIN)) + +// 16 bytes. +#define SIZEINSNBUF 16 + +// Number of DA channels +#define NUMOUTCHANNELS 8 + +// size of one value for the D/A converter: channel and value +#define SIZEDAOUT ((sizeof(int8_t)+sizeof(int16_t))) + +// Size of the output-buffer in bytes +// Actually only the first 4 triplets are used but for the +// high speed mode we need to pad it to 8 (microframes). +#define SIZEOUTBUF ((8*SIZEDAOUT)) + +// Size of the buffer for the dux commands: just now max size is determined +// by the analogue out + command byte + panic bytes... +#define SIZEOFDUXBUFFER ((8*SIZEDAOUT+2)) + +// Number of in-URBs which receive the data: min=2 +#define NUMOFINBUFFERSFULL 5 + +// Number of out-URBs which send the data: min=2 +#define NUMOFOUTBUFFERSFULL 5 + +// Number of in-URBs which receive the data: min=5 +#define NUMOFINBUFFERSHIGH 10 // must have more buffers due to buggy USB ctr + +// Number of out-URBs which send the data: min=5 +#define NUMOFOUTBUFFERSHIGH 10 // must have more buffers due to buggy USB ctr + +// Total number of usbdux devices +#define NUMUSBDUX 16 + +// Analogue in subdevice +#define SUBDEV_AD 0 + +// Analogue out subdevice +#define SUBDEV_DA 1 + +// Digital I/O +#define SUBDEV_DIO 2 + +// counter +#define SUBDEV_COUNTER 3 + +// timer aka pwm output +#define SUBDEV_PWM 4 + +// number of retries to get the right dux command +#define RETRIES 10 + +///////////////////////////////////////////// +// comedi constants +static const comedi_lrange range_usbdux_ai_range = { 4, { + BIP_RANGE(4.096), + BIP_RANGE(4.096 / 2), + UNI_RANGE(4.096), + UNI_RANGE(4.096 / 2) + } +}; + +static const comedi_lrange range_usbdux_ao_range = { 2, { + BIP_RANGE(4.096), + UNI_RANGE(4.096), + } +}; + +/* + * private structure of one subdevice + */ + +// 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; + // actual number of in-buffers + int numOfInBuffers; + // actual number of out-buffers + int numOfOutBuffers; + // ISO-transfer handling: buffers + struct urb **urbIn; + struct urb **urbOut; + // pwm-transfer handling + struct urb *urbPwm; + // PWM period + lsampl_t pwmPeriod; + // PWM internal delay for the GPIF in the FX2 + int8_t pwmDelay; + // size of the PWM buffer which holds the bit pattern + int sizePwmBuf; + // input buffer for the ISO-transfer + int16_t *inBuffer; + // input buffer for single insn + int16_t *insnBuffer; + // output buffer for single DA outputs + int16_t *outBuffer; + // interface number + int ifnum; +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) + // interface structure in 2.6 + struct usb_interface *interface; +#endif + // comedi device for the interrupt context + comedi_device *comedidev; + // is it USB_SPEED_HIGH or not? + short int high_speed; + // asynchronous command is running + short int ai_cmd_running; + short int ao_cmd_running; + // pwm is running + short int pwm_cmd_running; + // continous aquisition + short int ai_continous; + short int ao_continous; + // number of samples to aquire + int ai_sample_count; + int ao_sample_count; + // time between samples in units of the timer + unsigned int ai_timer; + unsigned int ao_timer; + // counter between aquisitions + unsigned int ai_counter; + unsigned int ao_counter; + // interval in frames/uframes + unsigned int ai_interval; + // D/A commands + int8_t *dac_commands; + // commands + int8_t *dux_commands; + struct semaphore sem; +} usbduxsub_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 usbduxsub_t usbduxsub[NUMUSBDUX]; + +static DECLARE_MUTEX(start_stop_sem); + +// Stops the data acquision +// It should be safe to call this function from any context +static int usbduxsub_unlink_InURBs(usbduxsub_t * usbduxsub_tmp) +{ + int i = 0; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) + int j = 0; +#endif + int err = 0; + + if (usbduxsub_tmp && usbduxsub_tmp->urbIn) { + for (i = 0; i < usbduxsub_tmp->numOfInBuffers; i++) { + if (usbduxsub_tmp->urbIn[i]) { +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) + j = usb_unlink_urb(usbduxsub_tmp->urbIn[i]); + if (j < 0) { + err = j; + } +#else + // We wait here until all transfers + // have been cancelled. + usb_kill_urb(usbduxsub_tmp->urbIn[i]); +#endif + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi: usbdux: unlinked InURB %d, err=%d\n", + i, err); +#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 usbdux_ai_stop(usbduxsub_t * this_usbduxsub, int do_unlink) +{ + int ret = 0; + + if (!this_usbduxsub) { + printk("comedi?: usbdux_ai_stop: this_usbduxsub=NULL!\n"); + return -EFAULT; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi: usbdux_ai_stop\n"); +#endif + + if (do_unlink) { + // stop aquistion + ret = usbduxsub_unlink_InURBs(this_usbduxsub); + } + + this_usbduxsub->ai_cmd_running = 0; + + return ret; +} + +// This will cancel a running acquisition operation. +// This is called by comedi but never from inside the +// driver. +static int usbdux_ai_cancel(comedi_device * dev, comedi_subdevice * s) +{ + usbduxsub_t *this_usbduxsub; + int res = 0; + + // force unlink of all urbs +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi: usbdux_ai_cancel\n"); +#endif + this_usbduxsub = dev->private; + if (!this_usbduxsub) { + printk("comedi: usbdux_ai_cancel: this_usbduxsub=NULL\n"); + return -EFAULT; + } + // prevent other CPUs from submitting new commands just now + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + // unlink only if the urb really has been submitted + res = usbdux_ai_stop(this_usbduxsub, this_usbduxsub->ai_cmd_running); + up(&this_usbduxsub->sem); + return res; +} + +// analogue IN +// interrupt service routine +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) +static void usbduxsub_ai_IsocIrq(struct urb *urb) +#else +static void usbduxsub_ai_IsocIrq(struct urb *urb PT_REGS_ARG) +#endif +{ + int i, err, n; + usbduxsub_t *this_usbduxsub; + comedi_device *this_comedidev; + comedi_subdevice *s; + + // sanity checks + // is the urb there? + if (!urb) { + printk("comedi_: usbdux_: ao int-handler called with urb=NULL!\n"); + return; + } + // the context variable points to the subdevice + this_comedidev = urb->context; + if (unlikely(!this_comedidev)) { + printk("comedi_: usbdux_: BUG! urb context is a NULL pointer!\n"); + return; + } + // the private structure of the subdevice is usbduxsub_t + this_usbduxsub = this_comedidev->private; + if (unlikely(!this_usbduxsub)) { + printk("comedi_: usbdux_: BUG! private of comedi subdev is a NULL pointer!\n"); + return; + } + // subdevice which is the AD converter + s = this_comedidev->subdevices + SUBDEV_AD; + + // first we test if something unusual has just happened + switch (urb->status) { + case 0: + // copy the result in the transfer buffer + memcpy(this_usbduxsub->inBuffer, + urb->transfer_buffer, SIZEINBUF); + break; + case -EILSEQ: + // error in the ISOchronous data + // we don't copy the data into the transfer buffer + // and recycle the last data byte +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi%d: usbdux: CRC error in ISO IN stream.\n", + this_usbduxsub->comedidev->minor); +#endif + + break; + + // happens after an unlink command + case -ECONNRESET: + case -ENOENT: + case -ESHUTDOWN: + case -ECONNABORTED: + if (this_usbduxsub->ai_cmd_running) { + // we are still running a command + // tell this comedi + s->async->events |= COMEDI_CB_EOA; + s->async->events |= COMEDI_CB_ERROR; + comedi_event(this_usbduxsub->comedidev, s); + // stop the transfer w/o unlink + usbdux_ai_stop(this_usbduxsub, 0); + } + return; + + // a real error on the bus + default: + // pass error to comedi if we are really running a command + if (this_usbduxsub->ai_cmd_running) { + printk("Non-zero urb status received in ai intr context: %d\n", urb->status); + s->async->events |= COMEDI_CB_EOA; + s->async->events |= COMEDI_CB_ERROR; + comedi_event(this_usbduxsub->comedidev, s); + // don't do an unlink here + usbdux_ai_stop(this_usbduxsub, 0); + } + return; + } + + // at this point we are reasonably sure that nothing dodgy has happened + // are we running a command? + if (unlikely((!(this_usbduxsub->ai_cmd_running)))) { + // not running a command + // do not continue execution if no asynchronous command is running + // in particular not resubmit + return; + } + + urb->dev = this_usbduxsub->usbdev; + + // resubmit the urb + err = USB_SUBMIT_URB(urb); + if (unlikely(err < 0)) { + printk("comedi_: usbdux_: urb resubmit failed in int-context! err=%d ", err); + if (err == -EL2NSYNC) { + printk("--> buggy USB host controller or bug in IRQ handler!\n"); + } else { + printk("\n"); + } + s->async->events |= COMEDI_CB_EOA; + s->async->events |= COMEDI_CB_ERROR; + comedi_event(this_usbduxsub->comedidev, s); + // don't do an unlink here + usbdux_ai_stop(this_usbduxsub, 0); + return; + } + + this_usbduxsub->ai_counter--; + if (likely(this_usbduxsub->ai_counter > 0)) { + return; + } + // timer zero, transfer measurements to comedi + this_usbduxsub->ai_counter = this_usbduxsub->ai_timer; + + // test, if we transmit only a fixed number of samples + if (!(this_usbduxsub->ai_continous)) { + // not continous, fixed number of samples + this_usbduxsub->ai_sample_count--; + // all samples received? + if (this_usbduxsub->ai_sample_count < 0) { + // prevent a resubmit next time + usbdux_ai_stop(this_usbduxsub, 0); + // say comedi that the acquistion is over + s->async->events |= COMEDI_CB_EOA; + comedi_event(this_usbduxsub->comedidev, s); + return; + } + } + // get the data from the USB bus and hand it over + // to comedi + n = s->async->cmd.chanlist_len; + for (i = 0; i < n; i++) { + // transfer data + if (CR_RANGE(s->async->cmd.chanlist[i]) <= 1) { + comedi_buf_put + (s->async, + le16_to_cpu(this_usbduxsub-> + inBuffer[i]) ^ 0x800); + } else { + comedi_buf_put + (s->async, + le16_to_cpu(this_usbduxsub->inBuffer[i])); + } + } + // tell comedi that data is there + comedi_event(this_usbduxsub->comedidev, s); +} + +static int usbduxsub_unlink_OutURBs(usbduxsub_t * usbduxsub_tmp) +{ + int i = 0; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) + int j = 0; +#endif + + int err = 0; + + if (usbduxsub_tmp && usbduxsub_tmp->urbOut) { + for (i = 0; i < usbduxsub_tmp->numOfOutBuffers; i++) { + if (usbduxsub_tmp->urbOut[i]) { +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) + j = usb_unlink_urb(usbduxsub_tmp->urbOut[i]); + if (j < err) { + err = j; + } +#else + usb_kill_urb(usbduxsub_tmp->urbOut[i]); +#endif + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi: usbdux: unlinked OutURB %d: res=%d\n", + i, err); +#endif + } + } + return err; +} + +/* This will cancel a running acquisition operation + * in any context. + */ +static int usbdux_ao_stop(usbduxsub_t * this_usbduxsub, int do_unlink) +{ + int ret = 0; + + if (!this_usbduxsub) { +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi?: usbdux_ao_stop: this_usbduxsub=NULL!\n"); +#endif + return -EFAULT; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi: usbdux_ao_cancel\n"); +#endif + if (do_unlink) { + ret = usbduxsub_unlink_OutURBs(this_usbduxsub); + } + + this_usbduxsub->ao_cmd_running = 0; + + return ret; +} + +// force unlink +// is called by comedi +static int usbdux_ao_cancel(comedi_device * dev, comedi_subdevice * s) +{ + usbduxsub_t *this_usbduxsub = dev->private; + int res = 0; + + if (!this_usbduxsub) { + printk("comedi: usbdux_ao_cancel: this_usbduxsub=NULL\n"); + return -EFAULT; + } + // prevent other CPUs from submitting a command just now + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + // unlink only if it is really running + res = usbdux_ao_stop(this_usbduxsub, this_usbduxsub->ao_cmd_running); + up(&this_usbduxsub->sem); + return res; +} + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) +static void usbduxsub_ao_IsocIrq(struct urb *urb) +{ +#else +static void usbduxsub_ao_IsocIrq(struct urb *urb PT_REGS_ARG) +{ +#endif + int i, ret; + int8_t *datap; + usbduxsub_t *this_usbduxsub; + comedi_device *this_comedidev; + comedi_subdevice *s; + + if (!urb) { + printk("comedi_: usbdux_: ao urb handler called with NULL ptr.\n"); + return; + } + // the context variable points to the subdevice + this_comedidev = urb->context; + if (!this_comedidev) { + printk("comedi_: usbdux_: ao urb int-context is a NULL pointer.\n"); + return; + } + // the private structure of the subdevice is usbduxsub_t + this_usbduxsub = this_comedidev->private; + if (!this_usbduxsub) { + printk("comedi_: usbdux_: private data structure of ao subdev is NULL p.\n"); + return; + } + + s = this_comedidev->subdevices + SUBDEV_DA; + + switch (urb->status) { + case 0: + /* success */ + break; + + // after an unlink command, unplug, ... etc + // no unlink needed here. Already shutting down. + case -ECONNRESET: + case -ENOENT: + case -ESHUTDOWN: + case -ECONNABORTED: + if (this_usbduxsub->ao_cmd_running) { + s->async->events |= COMEDI_CB_EOA; + comedi_event(this_usbduxsub->comedidev, s); + usbdux_ao_stop(this_usbduxsub, 0); + } + return; + + // a real error + default: + if (this_usbduxsub->ao_cmd_running) { + printk("comedi_: usbdux_: Non-zero urb status received in ao intr context: %d\n", urb->status); + s->async->events |= COMEDI_CB_ERROR; + s->async->events |= COMEDI_CB_EOA; + comedi_event(this_usbduxsub->comedidev, s); + // we do an unlink if we are in the high speed mode + usbdux_ao_stop(this_usbduxsub, 0); + } + return; + } + + // are we actually running? + if (!(this_usbduxsub->ao_cmd_running)) { + return; + } + // normal operation: executing a command in this subdevice + this_usbduxsub->ao_counter--; + if (this_usbduxsub->ao_counter <= 0) { + // timer zero + this_usbduxsub->ao_counter = this_usbduxsub->ao_timer; + + // handle non continous aquisition + if (!(this_usbduxsub->ao_continous)) { + // fixed number of samples + this_usbduxsub->ao_sample_count--; + if (this_usbduxsub->ao_sample_count < 0) { + // all samples transmitted + usbdux_ao_stop(this_usbduxsub, 0); + s->async->events |= COMEDI_CB_EOA; + comedi_event(this_usbduxsub->comedidev, s); + // no resubmit of the urb + return; + } + } + // transmit data to the USB bus + ((uint8_t *) (urb->transfer_buffer))[0] = + s->async->cmd.chanlist_len; + for (i = 0; i < s->async->cmd.chanlist_len; i++) { + sampl_t temp; + if (i >= NUMOUTCHANNELS) { + break; + } + // pointer to the DA + datap = (&(((int8_t *) urb->transfer_buffer)[i * 3 + 1])); + // get the data from comedi + ret = comedi_buf_get(s->async, &temp); + datap[0] = temp; + datap[1] = temp >> 8; + datap[2] = this_usbduxsub->dac_commands[i]; + // printk("data[0]=%x, data[1]=%x, data[2]=%x\n", + // datap[0],datap[1],datap[2]); + if (ret < 0) { + printk("comedi: usbdux: buffer underflow\n"); + s->async->events |= COMEDI_CB_EOA; + s->async->events |= COMEDI_CB_OVERFLOW; + } + // transmit data to comedi + s->async->events |= COMEDI_CB_BLOCK; + comedi_event(this_usbduxsub->comedidev, s); + } + } + urb->transfer_buffer_length = SIZEOUTBUF; + urb->dev = this_usbduxsub->usbdev; + urb->status = 0; + if (this_usbduxsub->ao_cmd_running) { + if (this_usbduxsub->high_speed) { + // uframes + urb->interval = 8; + } else { + // frames + urb->interval = 1; + } + urb->number_of_packets = 1; + urb->iso_frame_desc[0].offset = 0; + urb->iso_frame_desc[0].length = SIZEOUTBUF; + urb->iso_frame_desc[0].status = 0; + if ((ret = USB_SUBMIT_URB(urb)) < 0) { + printk("comedi_: usbdux_: ao urb resubm failed in int-cont."); + printk("ret=%d", ret); + if (ret == EL2NSYNC) { + printk("--> buggy USB host controller or bug in IRQ handling!\n"); + } else { + printk("\n"); + } + s->async->events |= COMEDI_CB_EOA; + s->async->events |= COMEDI_CB_ERROR; + comedi_event(this_usbduxsub->comedidev, s); + // don't do an unlink here + usbdux_ao_stop(this_usbduxsub, 0); + } + } +} + +static int usbduxsub_start(usbduxsub_t * usbduxsub) +{ + int errcode = 0; + uint8_t local_transfer_buffer[16]; + + if (usbduxsub->probed) { + // 7f92 to zero + local_transfer_buffer[0] = 0; + errcode = USB_CONTROL_MSG(usbduxsub->usbdev, + // create a pipe for a control transfer + usb_sndctrlpipe(usbduxsub->usbdev, 0), + // bRequest, "Firmware" + USBDUXSUB_FIRMWARE, + // bmRequestType + VENDOR_DIR_OUT, + // Value + USBDUXSUB_CPUCS, + // Index + 0x0000, + // address of the transfer buffer + local_transfer_buffer, + // Length + 1, + // Timeout + EZTIMEOUT); + if (errcode < 0) { + printk("comedi_: usbdux_: control msg failed (start)\n"); + return errcode; + } + } + return 0; +} + +static int usbduxsub_stop(usbduxsub_t * usbduxsub) +{ + int errcode = 0; + + uint8_t local_transfer_buffer[16]; + if (usbduxsub->probed) { + // 7f92 to one + local_transfer_buffer[0] = 1; + errcode = USB_CONTROL_MSG + (usbduxsub->usbdev, + usb_sndctrlpipe(usbduxsub->usbdev, 0), + // bRequest, "Firmware" + USBDUXSUB_FIRMWARE, + // bmRequestType + VENDOR_DIR_OUT, + // Value + USBDUXSUB_CPUCS, + // Index + 0x0000, local_transfer_buffer, + // Length + 1, + // Timeout + EZTIMEOUT); + if (errcode < 0) { + printk("comedi_: usbdux: control msg failed (stop)\n"); + return errcode; + } + } + return 0; +} + +static int usbduxsub_upload(usbduxsub_t * usbduxsub, + uint8_t * local_transfer_buffer, + unsigned int startAddr, unsigned int len) +{ + int errcode; + + if (usbduxsub->probed) { +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi%d: usbdux: uploading %d bytes", + usbduxsub->comedidev->minor, len); + printk(" to addr %d, first byte=%d.\n", + startAddr, local_transfer_buffer[0]); +#endif + errcode = USB_CONTROL_MSG + (usbduxsub->usbdev, + usb_sndctrlpipe(usbduxsub->usbdev, 0), + // brequest, firmware + USBDUXSUB_FIRMWARE, + // bmRequestType + VENDOR_DIR_OUT, + // value + startAddr, + // index + 0x0000, + // our local safe buffer + local_transfer_buffer, + // length + len, + // timeout + EZTIMEOUT); +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi_: usbdux: result=%d\n", errcode); +#endif + if (errcode < 0) { + printk("comedi_: usbdux: uppload failed\n"); + return errcode; + } + } else { + // no device on the bus for this index + return -EFAULT; + } + return 0; +} + +int firmwareUpload(usbduxsub_t * usbduxsub, + uint8_t * firmwareBinary, int sizeFirmware) +{ + int ret; + + if (!firmwareBinary) { + return 0; + } + ret = usbduxsub_stop(usbduxsub); + if (ret < 0) { + printk("comedi_: usbdux: can not stop firmware\n"); + return ret; + } + ret = usbduxsub_upload(usbduxsub, firmwareBinary, 0, sizeFirmware); + if (ret < 0) { + printk("comedi_: usbdux: firmware upload failed\n"); + return ret; + } + ret = usbduxsub_start(usbduxsub); + if (ret < 0) { + printk("comedi_: usbdux: can not start firmware\n"); + return ret; + } + return 0; +} + +int usbduxsub_submit_InURBs(usbduxsub_t * usbduxsub) +{ + int i, errFlag; + + if (!usbduxsub) { + return -EFAULT; + } + /* Submit all URBs and start the transfer on the bus */ + for (i = 0; i < usbduxsub->numOfInBuffers; i++) { + // in case of a resubmission after an unlink... + usbduxsub->urbIn[i]->interval = usbduxsub->ai_interval; + usbduxsub->urbIn[i]->context = usbduxsub->comedidev; + usbduxsub->urbIn[i]->dev = usbduxsub->usbdev; + usbduxsub->urbIn[i]->status = 0; + usbduxsub->urbIn[i]->transfer_flags = URB_ISO_ASAP; +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux: submitting in-urb[%d]: %p,%p intv=%d\n", usbduxsub->comedidev->minor, i, (usbduxsub->urbIn[i]->context), (usbduxsub->urbIn[i]->dev), (usbduxsub->urbIn[i]->interval)); +#endif + errFlag = USB_SUBMIT_URB(usbduxsub->urbIn[i]); + if (errFlag) { + printk("comedi_: usbdux: ai: "); + printk("USB_SUBMIT_URB(%d)", i); + printk(" error %d\n", errFlag); + return errFlag; + } + } + return 0; +} + +int usbduxsub_submit_OutURBs(usbduxsub_t * usbduxsub) +{ + int i, errFlag; + + if (!usbduxsub) { + return -EFAULT; + } + for (i = 0; i < usbduxsub->numOfOutBuffers; i++) { +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi_: usbdux: submitting out-urb[%d]\n", i); +#endif + // in case of a resubmission after an unlink... + usbduxsub->urbOut[i]->context = usbduxsub->comedidev; + usbduxsub->urbOut[i]->dev = usbduxsub->usbdev; + usbduxsub->urbOut[i]->status = 0; + usbduxsub->urbOut[i]->transfer_flags = URB_ISO_ASAP; + errFlag = USB_SUBMIT_URB(usbduxsub->urbOut[i]); + if (errFlag) { + printk("comedi_: usbdux: ao: "); + printk("USB_SUBMIT_URB(%d)", i); + printk(" error %d\n", errFlag); + return errFlag; + } + } + return 0; +} + +static int usbdux_ai_cmdtest(comedi_device * dev, + comedi_subdevice * s, comedi_cmd * cmd) +{ + int err = 0, tmp, i; + unsigned int tmpTimer; + usbduxsub_t *this_usbduxsub = dev->private; + if (!(this_usbduxsub->probed)) { + return -ENODEV; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux_ai_cmdtest\n", dev->minor); +#endif + /* make sure triggers are valid */ + // Only immediate triggers are allowed + tmp = cmd->start_src; + cmd->start_src &= TRIG_NOW | TRIG_INT; + if (!cmd->start_src || tmp != cmd->start_src) + err++; + + // trigger should happen timed + tmp = cmd->scan_begin_src; + // start a new _scan_ with a timer + cmd->scan_begin_src &= TRIG_TIMER; + if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) + err++; + + // scanning is continous + tmp = cmd->convert_src; + cmd->convert_src &= TRIG_NOW; + if (!cmd->convert_src || tmp != cmd->convert_src) + err++; + + // issue a trigger when scan is finished and start a new scan + tmp = cmd->scan_end_src; + cmd->scan_end_src &= TRIG_COUNT; + if (!cmd->scan_end_src || tmp != cmd->scan_end_src) + err++; + + // trigger at the end of count events or not, stop condition or not + tmp = cmd->stop_src; + cmd->stop_src &= TRIG_COUNT | TRIG_NONE; + if (!cmd->stop_src || tmp != cmd->stop_src) + err++; + + if (err) + return 1; + + /* step 2: make sure trigger sources are unique and mutually compatible */ + /* note that mutual compatiblity is not an issue here */ + if (cmd->scan_begin_src != TRIG_FOLLOW && + cmd->scan_begin_src != TRIG_EXT && + cmd->scan_begin_src != TRIG_TIMER) + err++; + if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) + err++; + + if (err) + return 2; + + /* step 3: make sure arguments are trivially compatible */ + + if (cmd->start_arg != 0) { + cmd->start_arg = 0; + err++; + } + + if (cmd->scan_begin_src == TRIG_FOLLOW) { + /* internal trigger */ + if (cmd->scan_begin_arg != 0) { + cmd->scan_begin_arg = 0; + err++; + } + } + + if (cmd->scan_begin_src == TRIG_TIMER) { + if (this_usbduxsub->high_speed) { + // In high speed mode microframes are possible. + // However, during one microframe we can roughly + // sample one channel. Thus, the more channels + // are in the channel list the more time we need. + i = 1; + // find a power of 2 for the number of channels + while (i < (cmd->chanlist_len)) { + i = i * 2; + } + if (cmd->scan_begin_arg < (1000000 / 8 * i)) { + cmd->scan_begin_arg = 1000000 / 8 * i; + err++; + } + // now calc the real sampling rate with all the rounding errors + tmpTimer = + ((unsigned int)(cmd->scan_begin_arg / 125000)) * + 125000; + if (cmd->scan_begin_arg != tmpTimer) { + cmd->scan_begin_arg = tmpTimer; + err++; + } + } else { // full speed + // 1kHz scans every USB frame + if (cmd->scan_begin_arg < 1000000) { + cmd->scan_begin_arg = 1000000; + err++; + } + // calc the real sampling rate with the rounding errors + tmpTimer = + ((unsigned int)(cmd->scan_begin_arg / + 1000000)) * 1000000; + if (cmd->scan_begin_arg != tmpTimer) { + cmd->scan_begin_arg = tmpTimer; + err++; + } + } + } + // the same argument + if (cmd->scan_end_arg != cmd->chanlist_len) { + cmd->scan_end_arg = cmd->chanlist_len; + err++; + } + + if (cmd->stop_src == TRIG_COUNT) { + /* any count is allowed */ + } else { + /* TRIG_NONE */ + if (cmd->stop_arg != 0) { + cmd->stop_arg = 0; + err++; + } + } + + if (err) + return 3; + + return 0; +} + +// creates the ADC command for the MAX1271 +// range is the range value from comedi +static int8_t create_adc_command(unsigned int chan, int range) +{ + int8_t p = (range <= 1); + int8_t r = ((range % 2) == 0); + return (chan << 4) | ((p == 1) << 2) | ((r == 1) << 3); +} + +// bulk transfers to usbdux + +#define SENDADCOMMANDS 0 +#define SENDDACOMMANDS 1 +#define SENDDIOCONFIGCOMMAND 2 +#define SENDDIOBITSCOMMAND 3 +#define SENDSINGLEAD 4 +#define READCOUNTERCOMMAND 5 +#define WRITECOUNTERCOMMAND 6 +#define SENDPWMON 7 +#define SENDPWMOFF 8 + +static int send_dux_commands(usbduxsub_t * this_usbduxsub, int cmd_type) +{ + int result, nsent; + + this_usbduxsub->dux_commands[0] = cmd_type; +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux: dux_commands: ", + this_usbduxsub->comedidev->minor); + for (result = 0; result < SIZEOFDUXBUFFER; result++) { + printk(" %02x", this_usbduxsub->dux_commands[result]); + } + printk("\n"); +#endif + result = USB_BULK_MSG(this_usbduxsub->usbdev, + usb_sndbulkpipe(this_usbduxsub->usbdev, + COMMAND_OUT_EP), + this_usbduxsub->dux_commands, SIZEOFDUXBUFFER, &nsent, 10 * HZ); + if (result < 0) { + printk("comedi%d: could not transmit dux_command to the usb-device, err=%d\n", this_usbduxsub->comedidev->minor, result); + } + return result; +} + +static int receive_dux_commands(usbduxsub_t * this_usbduxsub, int command) +{ + int result = (-EFAULT); + int nrec; + int i; + + for (i = 0; i < RETRIES; i++) { + result = USB_BULK_MSG(this_usbduxsub->usbdev, + usb_rcvbulkpipe(this_usbduxsub->usbdev, + COMMAND_IN_EP), + this_usbduxsub->insnBuffer, SIZEINSNBUF, &nrec, 1 * HZ); + if (result < 0) { + printk("comedi%d: insn: USB error %d while receiving DUX command\n", this_usbduxsub->comedidev->minor, result); + return result; + } + if (le16_to_cpu(this_usbduxsub->insnBuffer[0]) == command) { + return result; + } + } + // this is only reached if the data has been requested a couple of times + printk("comedi%d: insn: wrong data returned from firmware: want cmd %d, got cmd %d.\n", this_usbduxsub->comedidev->minor, command, le16_to_cpu(this_usbduxsub->insnBuffer[0])); + return -EFAULT; +} + +static int usbdux_ai_inttrig(comedi_device * dev, + comedi_subdevice * s, unsigned int trignum) +{ + int ret; + usbduxsub_t *this_usbduxsub = dev->private; + if (!this_usbduxsub) { + return -EFAULT; + } + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux_ai_inttrig\n", dev->minor); +#endif + + if (trignum != 0) { + printk("comedi%d: usbdux_ai_inttrig: invalid trignum\n", + dev->minor); + up(&this_usbduxsub->sem); + return -EINVAL; + } + if (!(this_usbduxsub->ai_cmd_running)) { + this_usbduxsub->ai_cmd_running = 1; + ret = usbduxsub_submit_InURBs(this_usbduxsub); + if (ret < 0) { + printk("comedi%d: usbdux_ai_inttrig: urbSubmit: err=%d\n", dev->minor, ret); + this_usbduxsub->ai_cmd_running = 0; + up(&this_usbduxsub->sem); + return ret; + } + s->async->inttrig = NULL; + } else { + printk("comedi%d: ai_inttrig but acqu is already running\n", + dev->minor); + } + up(&this_usbduxsub->sem); + return 1; +} + +static int usbdux_ai_cmd(comedi_device * dev, comedi_subdevice * s) +{ + comedi_cmd *cmd = &s->async->cmd; + unsigned int chan, range; + int i, ret; + usbduxsub_t *this_usbduxsub = dev->private; + int result; + +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux_ai_cmd\n", dev->minor); +#endif + if (!this_usbduxsub) { + return -EFAULT; + } + // block other CPUs from starting an ai_cmd + down(&this_usbduxsub->sem); + + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + if (this_usbduxsub->ai_cmd_running) { + printk("comedi%d: ai_cmd not possible. Another ai_cmd is running.\n", dev->minor); + up(&this_usbduxsub->sem); + return -EBUSY; + } + // set current channel of the running aquisition to zero + s->async->cur_chan = 0; + + this_usbduxsub->dux_commands[1] = cmd->chanlist_len; + for (i = 0; i < cmd->chanlist_len; ++i) { + chan = CR_CHAN(cmd->chanlist[i]); + range = CR_RANGE(cmd->chanlist[i]); + if (i >= NUMCHANNELS) { + printk("comedi%d: channel list too long\n", dev->minor); + break; + } + this_usbduxsub->dux_commands[i + 2] = + create_adc_command(chan, range); + } + +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi %d: sending commands to the usb device: ", dev->minor); + printk("size=%u\n", NUMCHANNELS); +#endif + if ((result = send_dux_commands(this_usbduxsub, SENDADCOMMANDS)) < 0) { + up(&this_usbduxsub->sem); + return result; + } + + if (this_usbduxsub->high_speed) { + // every channel gets a time window of 125us. Thus, if we + // sample all 8 channels we need 1ms. If we sample only + // one channel we need only 125us + this_usbduxsub->ai_interval = 1; + // find a power of 2 for the interval + while ((this_usbduxsub->ai_interval) < (cmd->chanlist_len)) { + this_usbduxsub->ai_interval = + (this_usbduxsub->ai_interval) * 2; + } + this_usbduxsub->ai_timer = + cmd->scan_begin_arg / (125000 * + (this_usbduxsub->ai_interval)); + } else { + // interval always 1ms + this_usbduxsub->ai_interval = 1; + this_usbduxsub->ai_timer = cmd->scan_begin_arg / 1000000; + } + if (this_usbduxsub->ai_timer < 1) { + printk("comedi%d: usbdux: ai_cmd: timer=%d, scan_begin_arg=%d. Not properly tested by cmdtest?\n", dev->minor, this_usbduxsub->ai_timer, cmd->scan_begin_arg); + up(&this_usbduxsub->sem); + return -EINVAL; + } + this_usbduxsub->ai_counter = this_usbduxsub->ai_timer; + + if (cmd->stop_src == TRIG_COUNT) { + // data arrives as one packet + this_usbduxsub->ai_sample_count = cmd->stop_arg; + this_usbduxsub->ai_continous = 0; + } else { + // continous aquisition + this_usbduxsub->ai_continous = 1; + this_usbduxsub->ai_sample_count = 0; + } + + if (cmd->start_src == TRIG_NOW) { + // enable this acquisition operation + this_usbduxsub->ai_cmd_running = 1; + ret = usbduxsub_submit_InURBs(this_usbduxsub); + if (ret < 0) { + this_usbduxsub->ai_cmd_running = 0; + // fixme: unlink here?? + up(&this_usbduxsub->sem); + return ret; + } + s->async->inttrig = NULL; + } else { + /* TRIG_INT */ + // don't enable the acquision operation + // wait for an internal signal + s->async->inttrig = usbdux_ai_inttrig; + } + up(&this_usbduxsub->sem); + return 0; +} + +/* Mode 0 is used to get a single conversion on demand */ +static int usbdux_ai_insn_read(comedi_device * dev, + comedi_subdevice * s, comedi_insn * insn, lsampl_t * data) +{ + int i; + lsampl_t one = 0; + int chan, range; + int err; + usbduxsub_t *this_usbduxsub = dev->private; + + if (!this_usbduxsub) { + printk("comedi%d: ai_insn_read: no usb dev.\n", dev->minor); + return 0; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: ai_insn_read, insn->n=%d, insn->subdev=%d\n", + dev->minor, insn->n, insn->subdev); +#endif + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + if (this_usbduxsub->ai_cmd_running) { + printk("comedi%d: ai_insn_read not possible. Async Command is running.\n", dev->minor); + up(&this_usbduxsub->sem); + return 0; + } + + // sample one channel + chan = CR_CHAN(insn->chanspec); + range = CR_RANGE(insn->chanspec); + // set command for the first channel + this_usbduxsub->dux_commands[1] = create_adc_command(chan, range); + + // adc commands + if ((err = send_dux_commands(this_usbduxsub, SENDSINGLEAD)) < 0) { + up(&this_usbduxsub->sem); + return err; + } + + for (i = 0; i < insn->n; i++) { + if ((err = receive_dux_commands(this_usbduxsub, + SENDSINGLEAD)) < 0) { + up(&this_usbduxsub->sem); + return 0; + } + one = le16_to_cpu(this_usbduxsub->insnBuffer[1]); + if (CR_RANGE(insn->chanspec) <= 1) { + one = one ^ 0x800; + } + data[i] = one; + } + up(&this_usbduxsub->sem); + return i; +} + +////////////////// +// analog out + +static int usbdux_ao_insn_read(comedi_device * dev, comedi_subdevice * s, + comedi_insn * insn, lsampl_t * data) +{ + int i; + int chan = CR_CHAN(insn->chanspec); + usbduxsub_t *this_usbduxsub = dev->private; + + if (!this_usbduxsub) { + return -EFAULT; + } + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + for (i = 0; i < insn->n; i++) { + data[i] = this_usbduxsub->outBuffer[chan]; + } + up(&this_usbduxsub->sem); + return i; +} + +static int usbdux_ao_insn_write(comedi_device * dev, comedi_subdevice * s, + comedi_insn * insn, lsampl_t * data) +{ + int i, err; + int chan = CR_CHAN(insn->chanspec); + usbduxsub_t *this_usbduxsub = dev->private; + +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: ao_insn_write\n", dev->minor); +#endif + if (!this_usbduxsub) { + return -EFAULT; + } + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + if (this_usbduxsub->ao_cmd_running) { + printk("comedi%d: ao_insn_write: ERROR: asynchronous ao_cmd is running\n", dev->minor); + up(&this_usbduxsub->sem); + return 0; + } + + for (i = 0; i < insn->n; i++) { +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: ao_insn_write: data[chan=%d,i=%d]=%d\n", + dev->minor, chan, i, data[i]); +#endif + // number of channels: 1 + this_usbduxsub->dux_commands[1] = 1; + // one 16 bit value + *((int16_t *) (this_usbduxsub->dux_commands + 2)) = + cpu_to_le16(data[i]); + this_usbduxsub->outBuffer[chan] = data[i]; + // channel number + this_usbduxsub->dux_commands[4] = (chan << 6); + if ((err = send_dux_commands(this_usbduxsub, + SENDDACOMMANDS)) < 0) { + up(&this_usbduxsub->sem); + return err; + } + } + up(&this_usbduxsub->sem); + + return i; +} + +static int usbdux_ao_inttrig(comedi_device * dev, comedi_subdevice * s, + unsigned int trignum) +{ + int ret; + usbduxsub_t *this_usbduxsub = dev->private; + + if (!this_usbduxsub) { + return -EFAULT; + } + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + if (trignum != 0) { + printk("comedi%d: usbdux_ao_inttrig: invalid trignum\n", + dev->minor); + return -EINVAL; + } + if (!(this_usbduxsub->ao_cmd_running)) { + this_usbduxsub->ao_cmd_running = 1; + ret = usbduxsub_submit_OutURBs(this_usbduxsub); + if (ret < 0) { + printk("comedi%d: usbdux_ao_inttrig: submitURB: err=%d\n", dev->minor, ret); + this_usbduxsub->ao_cmd_running = 0; + up(&this_usbduxsub->sem); + return ret; + } + s->async->inttrig = NULL; + } else { + printk("comedi%d: ao_inttrig but acqu is already running.\n", + dev->minor); + } + up(&this_usbduxsub->sem); + return 1; +} + +static int usbdux_ao_cmdtest(comedi_device * dev, + comedi_subdevice * s, comedi_cmd * cmd) +{ + int err = 0, tmp; + usbduxsub_t *this_usbduxsub = dev->private; + + if (!this_usbduxsub) { + return -EFAULT; + } + if (!(this_usbduxsub->probed)) { + return -ENODEV; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux_ao_cmdtest\n", dev->minor); +#endif + /* make sure triggers are valid */ + // Only immediate triggers are allowed + tmp = cmd->start_src; + cmd->start_src &= TRIG_NOW | TRIG_INT; + if (!cmd->start_src || tmp != cmd->start_src) + err++; + + // trigger should happen timed + tmp = cmd->scan_begin_src; + // just now we scan also in the high speed mode every frame + // this is due to ehci driver limitations + if (0) { /* (this_usbduxsub->high_speed) */ + // start immidiately a new scan + // the sampling rate is set by the coversion rate + cmd->scan_begin_src &= TRIG_FOLLOW; + } else { + // start a new scan (output at once) with a timer + cmd->scan_begin_src &= TRIG_TIMER; + } + if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src) + err++; + + // scanning is continous + tmp = cmd->convert_src; + // we always output at 1kHz just now all channels at once + if (0) { /* (this_usbduxsub->high_speed) */ + // in usb-2.0 only one conversion it tranmitted but with 8kHz/n + cmd->convert_src &= TRIG_TIMER; + } else { + // all conversion events happen simultaneously with a rate of 1kHz/n + cmd->convert_src &= TRIG_NOW; + } + if (!cmd->convert_src || tmp != cmd->convert_src) + err++; + + // issue a trigger when scan is finished and start a new scan + tmp = cmd->scan_end_src; + cmd->scan_end_src &= TRIG_COUNT; + if (!cmd->scan_end_src || tmp != cmd->scan_end_src) + err++; + + // trigger at the end of count events or not, stop condition or not + tmp = cmd->stop_src; + cmd->stop_src &= TRIG_COUNT | TRIG_NONE; + if (!cmd->stop_src || tmp != cmd->stop_src) + err++; + + if (err) + return 1; + + /* step 2: make sure trigger sources are unique and mutually compatible */ + /* note that mutual compatiblity is not an issue here */ + if (cmd->scan_begin_src != TRIG_FOLLOW && + cmd->scan_begin_src != TRIG_EXT && + cmd->scan_begin_src != TRIG_TIMER) + err++; + if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE) + err++; + + if (err) + return 2; + + /* step 3: make sure arguments are trivially compatible */ + + if (cmd->start_arg != 0) { + cmd->start_arg = 0; + err++; + } + + if (cmd->scan_begin_src == TRIG_FOLLOW) { + /* internal trigger */ + if (cmd->scan_begin_arg != 0) { + cmd->scan_begin_arg = 0; + err++; + } + } + + if (cmd->scan_begin_src == TRIG_TIMER) { + /* timer */ + if (cmd->scan_begin_arg < 1000000) { + cmd->scan_begin_arg = 1000000; + err++; + } + } + // not used now, is for later use + if (cmd->convert_src == TRIG_TIMER) { + if (cmd->convert_arg < 125000) { + cmd->convert_arg = 125000; + err++; + } + } + + // the same argument + if (cmd->scan_end_arg != cmd->chanlist_len) { + cmd->scan_end_arg = cmd->chanlist_len; + err++; + } + + if (cmd->stop_src == TRIG_COUNT) { + /* any count is allowed */ + } else { + /* TRIG_NONE */ + if (cmd->stop_arg != 0) { + cmd->stop_arg = 0; + err++; + } + } + +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: err=%d, scan_begin_src=%d, scan_begin_arg=%d, convert_src=%d, convert_arg=%d\n", dev->minor, err, cmd->scan_begin_src, cmd->scan_begin_arg, cmd->convert_src, cmd->convert_arg); +#endif + + if (err) + return 3; + + return 0; +} + +static int usbdux_ao_cmd(comedi_device * dev, comedi_subdevice * s) +{ + comedi_cmd *cmd = &s->async->cmd; + unsigned int chan, gain; + int i, ret; + usbduxsub_t *this_usbduxsub = dev->private; + + if (!this_usbduxsub) { + return -EFAULT; + } + down(&this_usbduxsub->sem); + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux_ao_cmd\n", dev->minor); +#endif + + // set current channel of the running aquisition to zero + s->async->cur_chan = 0; + for (i = 0; i < cmd->chanlist_len; ++i) { + chan = CR_CHAN(cmd->chanlist[i]); + gain = CR_RANGE(cmd->chanlist[i]); + if (i >= NUMOUTCHANNELS) { + printk("comedi%d: usbdux_ao_cmd: channel list too long\n", dev->minor); + break; + } + this_usbduxsub->dac_commands[i] = (chan << 6); +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: dac command for ch %d is %x\n", + dev->minor, i, this_usbduxsub->dac_commands[i]); +#endif + } + + // we count in steps of 1ms (125us) + // 125us mode not used yet + if (0) { /* (this_usbduxsub->high_speed) */ + // 125us + // timing of the conversion itself: every 125 us + this_usbduxsub->ao_timer = cmd->convert_arg / 125000; + } else { + // 1ms + // timing of the scan: we get all channels at once + this_usbduxsub->ao_timer = cmd->scan_begin_arg / 1000000; +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux: scan_begin_src=%d, scan_begin_arg=%d, convert_src=%d, convert_arg=%d\n", dev->minor, cmd->scan_begin_src, cmd->scan_begin_arg, cmd->convert_src, cmd->convert_arg); + printk("comedi%d: usbdux: ao_timer=%d (ms)\n", + dev->minor, this_usbduxsub->ao_timer); +#endif + if (this_usbduxsub->ao_timer < 1) { + printk("comedi%d: usbdux: ao_timer=%d, scan_begin_arg=%d. Not properly tested by cmdtest?\n", dev->minor, this_usbduxsub->ao_timer, cmd->scan_begin_arg); + up(&this_usbduxsub->sem); + return -EINVAL; + } + } + this_usbduxsub->ao_counter = this_usbduxsub->ao_timer; + + if (cmd->stop_src == TRIG_COUNT) { + // not continous + // counter + // high speed also scans everything at once + if (0) { /* (this_usbduxsub->high_speed) */ + this_usbduxsub->ao_sample_count = + (cmd->stop_arg) * (cmd->scan_end_arg); + } else { + // there's no scan as the scan has been + // perf inside the FX2 + // data arrives as one packet + this_usbduxsub->ao_sample_count = cmd->stop_arg; + } + this_usbduxsub->ao_continous = 0; + } else { + // continous aquisition + this_usbduxsub->ao_continous = 1; + this_usbduxsub->ao_sample_count = 0; + } + + if (cmd->start_src == TRIG_NOW) { + // enable this acquisition operation + this_usbduxsub->ao_cmd_running = 1; + ret = usbduxsub_submit_OutURBs(this_usbduxsub); + if (ret < 0) { + this_usbduxsub->ao_cmd_running = 0; + // fixme: unlink here?? + up(&this_usbduxsub->sem); + return ret; + } + s->async->inttrig = NULL; + } else { + /* TRIG_INT */ + // submit the urbs later + // wait for an internal signal + s->async->inttrig = usbdux_ao_inttrig; + } + + up(&this_usbduxsub->sem); + return 0; +} + +static int usbdux_dio_insn_config(comedi_device * dev, + comedi_subdevice * s, comedi_insn * insn, lsampl_t * data) +{ + int chan = CR_CHAN(insn->chanspec); + + /* The input or output configuration of each digital line is + * configured by a special insn_config instruction. chanspec + * contains the channel to be changed, and data[0] contains the + * value COMEDI_INPUT or COMEDI_OUTPUT. */ + + switch (data[0]) { + case INSN_CONFIG_DIO_OUTPUT: + s->io_bits |= 1 << chan; /* 1 means Out */ + break; + case INSN_CONFIG_DIO_INPUT: + s->io_bits &= ~(1 << chan); + break; + case INSN_CONFIG_DIO_QUERY: + data[1] = + (s-> + io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT; + break; + default: + return -EINVAL; + break; + } + // we don't tell the firmware here as it would take 8 frames + // to submit the information. We do it in the insn_bits. + return insn->n; +} + +static int usbdux_dio_insn_bits(comedi_device * dev, + comedi_subdevice * s, comedi_insn * insn, lsampl_t * data) +{ + + usbduxsub_t *this_usbduxsub = dev->private; + int err; + + if (!this_usbduxsub) { + return -EFAULT; + } + + if (insn->n != 2) + return -EINVAL; + + down(&this_usbduxsub->sem); + + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + + /* The insn data is a mask in data[0] and the new data + * in data[1], each channel cooresponding to a bit. */ + s->state &= ~data[0]; + s->state |= data[0] & data[1]; + this_usbduxsub->dux_commands[1] = s->io_bits; + this_usbduxsub->dux_commands[2] = s->state; + + // This command also tells the firmware to return + // the digital input lines + if ((err = send_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND)) < 0) { + up(&this_usbduxsub->sem); + return err; + } + if ((err = receive_dux_commands(this_usbduxsub, + SENDDIOBITSCOMMAND)) < 0) { + up(&this_usbduxsub->sem); + return err; + } + + data[1] = le16_to_cpu(this_usbduxsub->insnBuffer[1]); + up(&this_usbduxsub->sem); + return 2; +} + +// reads the 4 counters +// only two are used just now +static int usbdux_counter_read(comedi_device * dev, comedi_subdevice * s, + comedi_insn * insn, lsampl_t * data) +{ + usbduxsub_t *this_usbduxsub = dev->private; + int chan = insn->chanspec; + int err; + + if (!this_usbduxsub) { + return -EFAULT; + } + + down(&this_usbduxsub->sem); + + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + + if ((err = send_dux_commands(this_usbduxsub, READCOUNTERCOMMAND)) < 0) { + up(&this_usbduxsub->sem); + return err; + } + + if ((err = receive_dux_commands(this_usbduxsub, + READCOUNTERCOMMAND)) < 0) { + up(&this_usbduxsub->sem); + return err; + } + + data[0] = le16_to_cpu(this_usbduxsub->insnBuffer[chan + 1]); + up(&this_usbduxsub->sem); + return 1; +} + +static int usbdux_counter_write(comedi_device * dev, comedi_subdevice * s, + comedi_insn * insn, lsampl_t * data) +{ + usbduxsub_t *this_usbduxsub = dev->private; + int err; + + if (!this_usbduxsub) { + return -EFAULT; + } + + down(&this_usbduxsub->sem); + + if (!(this_usbduxsub->probed)) { + up(&this_usbduxsub->sem); + return -ENODEV; + } + + this_usbduxsub->dux_commands[1] = insn->chanspec; + *((int16_t *) (this_usbduxsub->dux_commands + 2)) = cpu_to_le16(*data); + + if ((err = send_dux_commands(this_usbduxsub, WRITECOUNTERCOMMAND)) < 0) { + up(&this_usbduxsub->sem); + return err; + } + + up(&this_usbduxsub->sem); + + return 1; +} + +static int usbdux_counter_config(comedi_device * dev, comedi_subdevice * s, + comedi_insn * insn, lsampl_t * data) +{ + // nothing to do so far + return 2; +} + +///////////////////////////// +// PWM + +static int usbduxsub_unlink_PwmURBs(usbduxsub_t * usbduxsub_tmp) +{ +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) + int j = 0; +#endif + + int err = 0; + + if (usbduxsub_tmp && usbduxsub_tmp->urbPwm) { + if (usbduxsub_tmp->urbPwm) { +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,8) + j = usb_unlink_urb(usbduxsub_tmp->urbPwm); + if (j < err) { + err = j; + } +#else + usb_kill_urb(usbduxsub_tmp->urbPwm); +#endif + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi: usbdux: unlinked PwmURB: res=%d\n", err); +#endif + } + return err; +} + +/* This cancels a running acquisition operation + * in any context. + */ +static int usbdux_pwm_stop(usbduxsub_t * this_usbduxsub, int do_unlink) +{ + int ret = 0; + + if (!this_usbduxsub) { +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi?: usbdux_pwm_stop: this_usbduxsub=NULL!\n"); +#endif + return -EFAULT; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi: usbdux_pwm_cancel\n"); +#endif + if (do_unlink) { + ret = usbduxsub_unlink_PwmURBs(this_usbduxsub); + } + + this_usbduxsub->pwm_cmd_running = 0; + + return ret; +} + +// force unlink +// is called by comedi +static int usbdux_pwm_cancel(comedi_device * dev, comedi_subdevice * s) +{ + usbduxsub_t *this_usbduxsub = dev->private; + int res = 0; + + // unlink only if it is really running + res = usbdux_pwm_stop(this_usbduxsub, this_usbduxsub->pwm_cmd_running); + +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi %d: sending pwm off command to the usb device.\n", + dev->minor); +#endif + if ((res = send_dux_commands(this_usbduxsub, SENDPWMOFF)) < 0) { + return res; + } + + return res; +} + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) || LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,19) +static void usbduxsub_pwm_irq(struct urb *urb) +{ +#else +static void usbduxsub_pwm_irq(struct urb *urb, struct pt_regs *regs) +{ +#endif + int ret; + usbduxsub_t *this_usbduxsub; + comedi_device *this_comedidev; + comedi_subdevice *s; + + // printk("PWM: IRQ\n"); + + if (!urb) { + printk("comedi_: usbdux_: pwm urb handler called with NULL ptr.\n"); + return; + } + // the context variable points to the subdevice + this_comedidev = urb->context; + if (!this_comedidev) { + printk("comedi_: usbdux_: pwm urb int-context is a NULL pointer.\n"); + return; + } + // the private structure of the subdevice is usbduxsub_t + this_usbduxsub = this_comedidev->private; + if (!this_usbduxsub) { + printk("comedi_: usbdux_: private data structure of pwm subdev is NULL p.\n"); + return; + } + + s = this_comedidev->subdevices + SUBDEV_DA; + + switch (urb->status) { + case 0: + /* success */ + break; + + // after an unlink command, unplug, ... etc + // no unlink needed here. Already shutting down. + case -ECONNRESET: + case -ENOENT: + case -ESHUTDOWN: + case -ECONNABORTED: + if (this_usbduxsub->pwm_cmd_running) { + usbdux_pwm_stop(this_usbduxsub, 0); + } + return; + + // a real error + default: + if (this_usbduxsub->pwm_cmd_running) { + printk("comedi_: usbdux_: Non-zero urb status received in pwm intr context: %d\n", urb->status); + usbdux_pwm_stop(this_usbduxsub, 0); + } + return; + } + + // are we actually running? + if (!(this_usbduxsub->pwm_cmd_running)) { + return; + } + + urb->transfer_buffer_length = this_usbduxsub->sizePwmBuf; + urb->dev = this_usbduxsub->usbdev; + urb->status = 0; + if (this_usbduxsub->pwm_cmd_running) { + if ((ret = USB_SUBMIT_URB(urb)) < 0) { + printk("comedi_: usbdux_: pwm urb resubm failed in int-cont."); + printk("ret=%d", ret); + if (ret == EL2NSYNC) { + printk("--> buggy USB host controller or bug in IRQ handling!\n"); + } else { + printk("\n"); + } + // don't do an unlink here + usbdux_pwm_stop(this_usbduxsub, 0); + } + } +} + +int usbduxsub_submit_PwmURBs(usbduxsub_t * usbduxsub) +{ + int errFlag; + + if (!usbduxsub) { + return -EFAULT; + } +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi_: usbdux: submitting pwm-urb\n"); +#endif + // in case of a resubmission after an unlink... + + usb_fill_bulk_urb(usbduxsub->urbPwm, + usbduxsub->usbdev, + usb_sndbulkpipe(usbduxsub->usbdev, PWM_EP), + usbduxsub->urbPwm->transfer_buffer, + usbduxsub->sizePwmBuf, usbduxsub_pwm_irq, usbduxsub->comedidev); + + errFlag = USB_SUBMIT_URB(usbduxsub->urbPwm); + if (errFlag) { + printk("comedi_: usbdux: pwm: "); + printk("USB_SUBMIT_URB"); + printk(" error %d\n", errFlag); + return errFlag; + } + return 0; +} + +static int usbdux_pwm_period(comedi_device * dev, comedi_subdevice * s, + lsampl_t period) +{ + usbduxsub_t *this_usbduxsub = dev->private; + int fx2delay=255; + if (period < MIN_PWM_PERIOD) + { + printk("comedi%d: illegal period setting for pwm.\n", dev->minor); + return -EAGAIN; + } else { + fx2delay = period / ((int)(6*512*(1.0/0.033))) - 6; + if (fx2delay > 255) { + printk("comedi%d: period %d for pwm is too low.\n", + dev->minor, period); + return -EAGAIN; + } + } + this_usbduxsub->pwmDelay=fx2delay; + this_usbduxsub->pwmPeriod=period; +#ifdef NOISY_DUX_DEBUGBUG + printk("usbdux_pwm_period: frequ=%d, period=%d\n",period,fx2delay); +#endif + return 0; +} + + +// is called from insn so there's no need to do all the sanity checks +static int usbdux_pwm_start(comedi_device * dev, comedi_subdevice * s) +{ + int ret, i; + usbduxsub_t *this_usbduxsub = dev->private; + +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: usbdux_pwm_start\n", dev->minor); +#endif + if (this_usbduxsub->pwm_cmd_running) { + // already running + return 0; + } + + this_usbduxsub->dux_commands[1] = ((int8_t) this_usbduxsub->pwmDelay); + if ((ret = send_dux_commands(this_usbduxsub, SENDPWMON)) < 0) { + return ret; + } + // initalise the buffer + for (i = 0; i < this_usbduxsub->sizePwmBuf; i++) { + ((char *)(this_usbduxsub->urbPwm->transfer_buffer))[i] = 0; + } + + this_usbduxsub->pwm_cmd_running = 1; + ret = usbduxsub_submit_PwmURBs(this_usbduxsub); + if (ret < 0) { + this_usbduxsub->pwm_cmd_running = 0; + return ret; + } + return 0; +} + + +// generates the bit pattern for PWM with the optional sign bit +static int usbdux_pwm_pattern(comedi_device * dev, comedi_subdevice * s, + int channel, lsampl_t value, lsampl_t sign) +{ + usbduxsub_t *this_usbduxsub = dev->private; + int i, szbuf; + char *pBuf; + char pwm_mask,sgn_mask,c; + + if (!this_usbduxsub) { + return -EFAULT; + } + // this is the DIO bit which carries the PWM data + pwm_mask = (1 << channel); + // this is the DIO bit which carries the optional direction bit + sgn_mask = (16 << channel); + // this is the buffer which will be filled with the with bit + // pattern for one period + szbuf = this_usbduxsub->sizePwmBuf; + pBuf = (char *)(this_usbduxsub->urbPwm->transfer_buffer); + for (i = 0; i < szbuf; i++) { + c = *pBuf; + // reset bits + c = c & (~pwm_mask); + // set the bit as long as the index is lower than the value + if (i < value) + c = c | pwm_mask; + // set the optional sign bit for a relay + if (!sign) { + // positive value + c = c & (~sgn_mask); + } else { + // negative value + c = c | sgn_mask; + } + *(pBuf++) = c; + } + return 1; +} + +static int usbdux_pwm_write(comedi_device * dev, comedi_subdevice * s, + comedi_insn * insn, lsampl_t * data) +{ + usbduxsub_t *this_usbduxsub = dev->private; + + if (!this_usbduxsub) { + return -EFAULT; + } + + if ((insn->n)!=1) { + // doesn't make sense to have more than one value here + // because it would just overwrite the PWM buffer a couple of times + return -EINVAL; + } + + // the sign is set via a special INSN only, this gives us 8 bits for + // normal operation + return usbdux_pwm_pattern(dev,s, + CR_CHAN(insn->chanspec), + data[0], + 0); // relay sign 0 by default +} + + +static int usbdux_pwm_read(comedi_device * x1, comedi_subdevice * x2, + comedi_insn * x3, lsampl_t * x4) +{ + // not needed + return -EINVAL; +}; + +// switches on/off PWM +static int usbdux_pwm_config(comedi_device * dev, comedi_subdevice * s, + comedi_insn * insn, lsampl_t * data) +{ + usbduxsub_t *this_usbduxsub = dev->private; + switch (data[0]) { + case INSN_CONFIG_ARM: +#ifdef NOISY_DUX_DEBUGBUG + // switch it on + printk("comedi%d: pwm_insn_config: pwm on\n", + dev->minor); +#endif + // if not zero the PWM is limited to a certain time which is + // not supported here + if (data[1]!=0) { + return -EINVAL; + } + return usbdux_pwm_start(dev, s); + case INSN_CONFIG_DISARM: +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: pwm_insn_config: pwm off\n", + dev->minor); +#endif + return usbdux_pwm_cancel(dev, s); + case INSN_CONFIG_GET_PWM_STATUS: + // to check if the USB transmission has failed or in case + // PWM was limited to n cycles to check if it has terminated + data[1] = this_usbduxsub->pwm_cmd_running; + return 0; + case INSN_CONFIG_PWM_SET_PERIOD: +#ifdef NOISY_DUX_DEBUGBUG + printk("comedi%d: pwm_insn_config: setting period\n", + dev->minor); +#endif + return usbdux_pwm_period(dev,s,data[1]); + case INSN_CONFIG_PWM_GET_PERIOD: + data[1] = this_usbduxsub->pwmPeriod; + return 0; + case INSN_CONFIG_PWM_SET_H_BRIDGE: + // value in the first byte and the sign in the second for a relay + return usbdux_pwm_pattern(dev, s, + CR_CHAN(insn->chanspec), // the channel number + data[1], // actual PWM data + (data[2]!=0)); // just a sign + case INSN_CONFIG_PWM_GET_H_BRIDGE: + // values are not kept in this driver, nothing to return here + return -EINVAL; + } + return -EINVAL; +} + +// end of PWM +/////////////////////////////////////////////////////////////////// + +static void tidy_up(usbduxsub_t * usbduxsub_tmp) +{ + int i; + +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi_: usbdux: tiding up\n"); +#endif + if (!usbduxsub_tmp) { + return; + } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) + // shows the usb subsystem that the driver is down + if (usbduxsub_tmp->interface) { + usb_set_intfdata(usbduxsub_tmp->interface, NULL); + } +#endif + + usbduxsub_tmp->probed = 0; + + if (usbduxsub_tmp->urbIn) { + if (usbduxsub_tmp->ai_cmd_running) { + usbduxsub_tmp->ai_cmd_running = 0; + usbduxsub_unlink_InURBs(usbduxsub_tmp); + } + for (i = 0; i < usbduxsub_tmp->numOfInBuffers; i++) { + if (usbduxsub_tmp->urbIn[i]->transfer_buffer) { + kfree(usbduxsub_tmp->urbIn[i]->transfer_buffer); + usbduxsub_tmp->urbIn[i]->transfer_buffer = NULL; + } + if (usbduxsub_tmp->urbIn[i]) { +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8) + usb_kill_urb(usbduxsub_tmp->urbIn[i]); +#endif + usb_free_urb(usbduxsub_tmp->urbIn[i]); + usbduxsub_tmp->urbIn[i] = NULL; + } + } + kfree(usbduxsub_tmp->urbIn); + usbduxsub_tmp->urbIn = NULL; + } + if (usbduxsub_tmp->urbOut) { + if (usbduxsub_tmp->ao_cmd_running) { + usbduxsub_tmp->ao_cmd_running = 0; + usbduxsub_unlink_OutURBs(usbduxsub_tmp); + } + for (i = 0; i < usbduxsub_tmp->numOfOutBuffers; i++) { + if (usbduxsub_tmp->urbOut[i]->transfer_buffer) { + kfree(usbduxsub_tmp->urbOut[i]-> + transfer_buffer); + usbduxsub_tmp->urbOut[i]->transfer_buffer = + NULL; + } + if (usbduxsub_tmp->urbOut[i]) { +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8) + usb_kill_urb(usbduxsub_tmp->urbOut[i]); +#endif + usb_free_urb(usbduxsub_tmp->urbOut[i]); + usbduxsub_tmp->urbOut[i] = NULL; + } + } + kfree(usbduxsub_tmp->urbOut); + usbduxsub_tmp->urbOut = NULL; + } + if (usbduxsub_tmp->urbPwm) { + if (usbduxsub_tmp->pwm_cmd_running) { + usbduxsub_tmp->pwm_cmd_running = 0; + usbduxsub_unlink_PwmURBs(usbduxsub_tmp); + } + if (usbduxsub_tmp->urbPwm->transfer_buffer) { + kfree(usbduxsub_tmp->urbPwm->transfer_buffer); + usbduxsub_tmp->urbPwm->transfer_buffer = NULL; + } +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8) + usb_kill_urb(usbduxsub_tmp->urbPwm); +#endif + usb_free_urb(usbduxsub_tmp->urbPwm); + usbduxsub_tmp->urbPwm = NULL; + } + if (usbduxsub_tmp->inBuffer) { + kfree(usbduxsub_tmp->inBuffer); + usbduxsub_tmp->inBuffer = NULL; + } + if (usbduxsub_tmp->insnBuffer) { + kfree(usbduxsub_tmp->insnBuffer); + usbduxsub_tmp->insnBuffer = NULL; + } + if (usbduxsub_tmp->inBuffer) { + kfree(usbduxsub_tmp->inBuffer); + usbduxsub_tmp->inBuffer = NULL; + } + if (usbduxsub_tmp->dac_commands) { + kfree(usbduxsub_tmp->dac_commands); + usbduxsub_tmp->dac_commands = NULL; + } + if (usbduxsub_tmp->dux_commands) { + kfree(usbduxsub_tmp->dux_commands); + usbduxsub_tmp->dux_commands = NULL; + } + usbduxsub_tmp->ai_cmd_running = 0; + usbduxsub_tmp->ao_cmd_running = 0; + usbduxsub_tmp->pwm_cmd_running = 0; +} + +static unsigned hex2unsigned(char *h) +{ + unsigned hi, lo; + if (h[0] > '9') { + hi = h[0] - 'A' + 0x0a; + } else { + hi = h[0] - '0'; + } + if (h[1] > '9') { + lo = h[1] - 'A' + 0x0a; + } else { + lo = h[1] - '0'; + } + return hi * 0x10 + lo; +} + +// for FX2 +#define FIRMWARE_MAX_LEN 0x2000 + +// taken from David Brownell's fxload and adjusted for this driver +static int read_firmware(usbduxsub_t * usbduxsub, void *firmwarePtr, long size) +{ + int i = 0; + unsigned char *fp = (char *)firmwarePtr; + unsigned char *firmwareBinary = NULL; + int res = 0; + int maxAddr = 0; + + firmwareBinary = kzalloc(FIRMWARE_MAX_LEN, GFP_KERNEL); + if (!firmwareBinary) { + printk("comedi_: usbdux: mem alloc for firmware failed\n"); + return -ENOMEM; + } + + for (;;) { + char buf[256], *cp; + char type; + int len; + int idx, off; + int j = 0; + + // get one line + while ((i < size) && (fp[i] != 13) && (fp[i] != 10)) { + buf[j] = fp[i]; + i++; + j++; + if (j >= sizeof(buf)) { + printk("comedi_: usbdux: bogus firmware file!\n"); + return -1; + } + } + // get rid of LF/CR/... + while ((i < size) && ((fp[i] == 13) || (fp[i] == 10) + || (fp[i] == 0))) { + i++; + } + + buf[j] = 0; + //printk("comedi_: buf=%s\n",buf); + + /* EXTENSION: "# comment-till-end-of-line", for copyrights etc */ + if (buf[0] == '#') + continue; + + if (buf[0] != ':') { + printk("comedi_: usbdux: upload: not an ihex record: %s", buf); + return -EFAULT; + } + + /* Read the length field (up to 16 bytes) */ + len = hex2unsigned(buf + 1); + + /* Read the target offset */ + off = (hex2unsigned(buf + 3) * 0x0100) + hex2unsigned(buf + 5); + + if ((off + len) > maxAddr) { + maxAddr = off + len; + } + + if (maxAddr >= FIRMWARE_MAX_LEN) { + printk("comedi_: usbdux: firmware upload goes beyond FX2 RAM boundaries."); + return -EFAULT; + } + //printk("comedi_: usbdux: 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) { + break; + } + + if (type != 0) { + printk("comedi_: usbdux: unsupported record type: %u\n", + type); + 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("\n"); + + if (i >= size) { + printk("comedi_: usbdux: unexpected end of hex file\n"); + break; + } + + } + res = firmwareUpload(usbduxsub, firmwareBinary, maxAddr + 1); + kfree(firmwareBinary); + return res; +} + +// allocate memory for the urbs and initialise them +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) +static void *usbduxsub_probe(struct usb_device *udev, + unsigned int interfnum, const struct usb_device_id *id) +{ +#else +static int usbduxsub_probe(struct usb_interface *uinterf, + const struct usb_device_id *id) +{ + struct usb_device *udev = interface_to_usbdev(uinterf); +#endif + int i; + int index; + +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi_: usbdux_: finding a free structure for the usb-device\n"); +#endif + down(&start_stop_sem); + // look for a free place in the usbdux array + index = -1; + for (i = 0; i < NUMUSBDUX; i++) { + if (!(usbduxsub[i].probed)) { + index = i; + break; + } + } + + // no more space + if (index == -1) { + printk("Too many usbdux-devices connected.\n"); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-EMFILE); + } +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi_: usbdux: usbduxsub[%d] is ready to connect to comedi.\n", index); +#endif + + init_MUTEX(&(usbduxsub[index].sem)); + // save a pointer to the usb device + usbduxsub[index].usbdev = udev; + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) + // save the interface number + usbduxsub[index].ifnum = interfnum; +#else + // 2.6: save the interface itself + usbduxsub[index].interface = uinterf; + // get the interface number from the interface + usbduxsub[index].ifnum = uinterf->altsetting->desc.bInterfaceNumber; + // hand the private data over to the usb subsystem + // will be needed for disconnect + usb_set_intfdata(uinterf, &(usbduxsub[index])); +#endif + +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi_: usbdux: ifnum=%d\n", usbduxsub[index].ifnum); +#endif + // test if it is high speed (USB 2.0) + usbduxsub[index].high_speed = + (usbduxsub[index].usbdev->speed == USB_SPEED_HIGH); + + // create space for the commands of the DA converter + usbduxsub[index].dac_commands = kzalloc(NUMOUTCHANNELS, GFP_KERNEL); + if (!usbduxsub[index].dac_commands) { + printk("comedi_: usbdux: error alloc space for dac commands\n"); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + // create space for the commands going to the usb device + usbduxsub[index].dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL); + if (!usbduxsub[index].dux_commands) { + printk("comedi_: usbdux: error alloc space for dac commands\n"); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + // create space for the in buffer and set it to zero + usbduxsub[index].inBuffer = kzalloc(SIZEINBUF, GFP_KERNEL); + if (!(usbduxsub[index].inBuffer)) { + printk("comedi_: usbdux: could not alloc space for inBuffer\n"); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + // create space of the instruction buffer + usbduxsub[index].insnBuffer = kzalloc(SIZEINSNBUF, GFP_KERNEL); + if (!(usbduxsub[index].insnBuffer)) { + printk("comedi_: usbdux: could not alloc space for insnBuffer\n"); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + // create space for the outbuffer + usbduxsub[index].outBuffer = kzalloc(SIZEOUTBUF, GFP_KERNEL); + if (!(usbduxsub[index].outBuffer)) { + printk("comedi_: usbdux: could not alloc space for outBuffer\n"); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + // setting to alternate setting 3: enabling iso ep and bulk ep. + i = usb_set_interface(usbduxsub[index].usbdev, + usbduxsub[index].ifnum, 3); + if (i < 0) { + printk("comedi_: usbdux%d: could not set alternate setting 3 in high speed.\n", index); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENODEV); + } + if (usbduxsub[index].high_speed) { + usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSHIGH; + } else { + usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSFULL; + } + usbduxsub[index].urbIn = + kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfInBuffers, + GFP_KERNEL); + if (!(usbduxsub[index].urbIn)) { + printk("comedi_: usbdux: Could not alloc. urbIn array\n"); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + for (i = 0; i < usbduxsub[index].numOfInBuffers; i++) { + // one frame: 1ms + usbduxsub[index].urbIn[i] = USB_ALLOC_URB(1); + if (usbduxsub[index].urbIn[i] == NULL) { + printk("comedi_: usbdux%d: Could not alloc. urb(%d)\n", + index, i); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + usbduxsub[index].urbIn[i]->dev = usbduxsub[index].usbdev; + // will be filled later with a pointer to the comedi-device + // and ONLY then the urb should be submitted + usbduxsub[index].urbIn[i]->context = NULL; + usbduxsub[index].urbIn[i]->pipe = + usb_rcvisocpipe(usbduxsub[index].usbdev, ISOINEP); + usbduxsub[index].urbIn[i]->transfer_flags = URB_ISO_ASAP; + usbduxsub[index].urbIn[i]->transfer_buffer = + kzalloc(SIZEINBUF, GFP_KERNEL); + if (!(usbduxsub[index].urbIn[i]->transfer_buffer)) { + printk("comedi_: usbdux%d: could not alloc. transb.\n", + index); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + usbduxsub[index].urbIn[i]->complete = usbduxsub_ai_IsocIrq; + usbduxsub[index].urbIn[i]->number_of_packets = 1; + usbduxsub[index].urbIn[i]->transfer_buffer_length = SIZEINBUF; + usbduxsub[index].urbIn[i]->iso_frame_desc[0].offset = 0; + usbduxsub[index].urbIn[i]->iso_frame_desc[0].length = SIZEINBUF; + } + + // out + if (usbduxsub[index].high_speed) { + usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSHIGH; + } else { + usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSFULL; + } + usbduxsub[index].urbOut = + kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfOutBuffers, + GFP_KERNEL); + if (!(usbduxsub[index].urbOut)) { + printk("comedi_: usbdux: Could not alloc. urbOut array\n"); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + for (i = 0; i < usbduxsub[index].numOfOutBuffers; i++) { + // one frame: 1ms + usbduxsub[index].urbOut[i] = USB_ALLOC_URB(1); + if (usbduxsub[index].urbOut[i] == NULL) { + printk("comedi_: usbdux%d: Could not alloc. urb(%d)\n", + index, i); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + usbduxsub[index].urbOut[i]->dev = usbduxsub[index].usbdev; + // will be filled later with a pointer to the comedi-device + // and ONLY then the urb should be submitted + usbduxsub[index].urbOut[i]->context = NULL; + usbduxsub[index].urbOut[i]->pipe = + usb_sndisocpipe(usbduxsub[index].usbdev, ISOOUTEP); + usbduxsub[index].urbOut[i]->transfer_flags = URB_ISO_ASAP; + usbduxsub[index].urbOut[i]->transfer_buffer = + kzalloc(SIZEOUTBUF, GFP_KERNEL); + if (!(usbduxsub[index].urbOut[i]->transfer_buffer)) { + printk("comedi_: usbdux%d: could not alloc. transb.\n", + index); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + usbduxsub[index].urbOut[i]->complete = usbduxsub_ao_IsocIrq; + usbduxsub[index].urbOut[i]->number_of_packets = 1; + usbduxsub[index].urbOut[i]->transfer_buffer_length = SIZEOUTBUF; + usbduxsub[index].urbOut[i]->iso_frame_desc[0].offset = 0; + usbduxsub[index].urbOut[i]->iso_frame_desc[0].length = + SIZEOUTBUF; + if (usbduxsub[index].high_speed) { + // uframes + usbduxsub[index].urbOut[i]->interval = 8; + } else { + // frames + usbduxsub[index].urbOut[i]->interval = 1; + } + } + + // pwm + if (usbduxsub[index].high_speed) { + usbduxsub[index].sizePwmBuf = 512; // max bulk ep size in high speed + usbduxsub[index].urbPwm = USB_ALLOC_URB(0); + if (usbduxsub[index].urbPwm == NULL) { + printk("comedi_: usbdux%d: Could not alloc. pwm urb\n", + index); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + usbduxsub[index].urbPwm->transfer_buffer = + kzalloc(usbduxsub[index].sizePwmBuf, GFP_KERNEL); + if (!(usbduxsub[index].urbPwm->transfer_buffer)) { + printk("comedi_: usbdux%d: could not alloc. transb. for pwm\n", index); + tidy_up(&(usbduxsub[index])); + up(&start_stop_sem); + return PROBE_ERR_RETURN(-ENOMEM); + } + } else { + usbduxsub[index].urbPwm = NULL; + usbduxsub[index].sizePwmBuf = 0; + } + + usbduxsub[index].ai_cmd_running = 0; + usbduxsub[index].ao_cmd_running = 0; + usbduxsub[index].pwm_cmd_running = 0; + + // we've reached the bottom of the function + usbduxsub[index].probed = 1; + up(&start_stop_sem); + printk("comedi_: usbdux%d has been successfully initialised.\n", index); +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) + return (void *)(&usbduxsub[index]); +#else + // success + return 0; +#endif +} + +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) +static void usbduxsub_disconnect(struct usb_device *udev, void *ptr) +{ + usbduxsub_t *usbduxsub_tmp = (usbduxsub_t *) ptr; +#else +static void usbduxsub_disconnect(struct usb_interface *intf) +{ + usbduxsub_t *usbduxsub_tmp = usb_get_intfdata(intf); + struct usb_device *udev = interface_to_usbdev(intf); +#endif + if (!usbduxsub_tmp) { + printk("comedi_: usbdux: disconnect called with null pointer.\n"); + return; + } + if (usbduxsub_tmp->usbdev != udev) { + printk("comedi_: usbdux: BUG! called with wrong ptr!!!\n"); + return; + } + down(&start_stop_sem); + down(&usbduxsub_tmp->sem); + tidy_up(usbduxsub_tmp); + up(&usbduxsub_tmp->sem); + up(&start_stop_sem); +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi_: usbdux: disconnected from the usb\n"); +#endif +} + +// is called when comedi-config is called +static int usbdux_attach(comedi_device * dev, comedi_devconfig * it) +{ + int ret; + int index; + int i; + comedi_subdevice *s = NULL; + dev->private = NULL; + + down(&start_stop_sem); + // find a valid device which has been detected by the probe function of the usb + index = -1; + for (i = 0; i < NUMUSBDUX; i++) { + if ((usbduxsub[i].probed) && (!usbduxsub[i].attached)) { + index = i; + break; + } + } + + if (index < 0) { + printk("comedi%d: usbdux: error: attach failed, no usbdux devs connected to the usb bus.\n", dev->minor); + up(&start_stop_sem); + return -ENODEV; + } + + down(&(usbduxsub[index].sem)); + // pointer back to the corresponding comedi device + usbduxsub[index].comedidev = dev; + + // trying to upload the firmware into the chip + if (comedi_aux_data(it->options, 0) && + it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) { + read_firmware(usbduxsub + index, + comedi_aux_data(it->options, 0), + it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]); + } + + dev->board_name = BOARDNAME; + + /* set number of subdevices */ + if (usbduxsub[index].high_speed) { + // with pwm + dev->n_subdevices = 5; + } else { + // without pwm + dev->n_subdevices = 4; + } + + // allocate space for the subdevices + if ((ret = alloc_subdevices(dev, dev->n_subdevices)) < 0) { + printk("comedi%d: usbdux: error alloc space for subdev\n", + dev->minor); + up(&start_stop_sem); + return ret; + } + + printk("comedi%d: usbdux: usb-device %d is attached to comedi.\n", + dev->minor, index); + // private structure is also simply the usb-structure + dev->private = usbduxsub + index; + + // 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 + dev->read_subdev = s; + // the subdevice receives as private structure the + // usb-structure + s->private = NULL; + // analog input + s->type = COMEDI_SUBD_AI; + // readable and ref is to ground + s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ; + // 8 channels + s->n_chan = 8; + // length of the channellist + s->len_chanlist = 8; + // callback functions + s->insn_read = usbdux_ai_insn_read; + s->do_cmdtest = usbdux_ai_cmdtest; + s->do_cmd = usbdux_ai_cmd; + s->cancel = usbdux_ai_cancel; + // max value from the A/D converter (12bit) + s->maxdata = 0xfff; + // range table to convert to physical units + s->range_table = (&range_usbdux_ai_range); + // + + // analog out + s = dev->subdevices + SUBDEV_DA; + // analog out + s->type = COMEDI_SUBD_AO; + // backward pointer + dev->write_subdev = s; + // the subdevice receives as private structure the + // usb-structure + s->private = NULL; + // are writable + s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE; + // 4 channels + s->n_chan = 4; + // length of the channellist + s->len_chanlist = 4; + // 12 bit resolution + s->maxdata = 0x0fff; + // bipolar range + s->range_table = (&range_usbdux_ao_range); + // callback + s->do_cmdtest = usbdux_ao_cmdtest; + s->do_cmd = usbdux_ao_cmd; + s->cancel = usbdux_ao_cancel; + s->insn_read = usbdux_ao_insn_read; + s->insn_write = usbdux_ao_insn_write; + + // digital I/O + s = dev->subdevices + SUBDEV_DIO; + s->type = COMEDI_SUBD_DIO; + s->subdev_flags = SDF_READABLE | SDF_WRITABLE; + s->n_chan = 8; + s->maxdata = 1; + s->range_table = (&range_digital); + s->insn_bits = usbdux_dio_insn_bits; + s->insn_config = usbdux_dio_insn_config; + // we don't use it + s->private = NULL; + + //counter + s = dev->subdevices + SUBDEV_COUNTER; + s->type = COMEDI_SUBD_COUNTER; + s->subdev_flags = SDF_WRITABLE | SDF_READABLE; + s->n_chan = 4; + s->maxdata = 0xFFFF; + s->insn_read = usbdux_counter_read; + s->insn_write = usbdux_counter_write; + s->insn_config = usbdux_counter_config; + + if (usbduxsub[index].high_speed) { + //timer / pwm + s = dev->subdevices + SUBDEV_PWM; + s->type = COMEDI_SUBD_PWM; + s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE; + s->n_chan = 8; + // this defines the max duty cycle resolution + s->maxdata = usbduxsub[index].sizePwmBuf; + s->insn_write = usbdux_pwm_write; + s->insn_read = usbdux_pwm_read; + s->insn_config = usbdux_pwm_config; + usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD); + } + // finally decide that it's attached + usbduxsub[index].attached = 1; + + up(&(usbduxsub[index].sem)); + + up(&start_stop_sem); + + printk("comedi%d: attached to usbdux.\n", dev->minor); + + return 0; +} + +static int usbdux_detach(comedi_device * dev) +{ + usbduxsub_t *usbduxsub_tmp; + +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi%d: usbdux: detach usb device\n", dev->minor); +#endif + + if (!dev) { + printk("comedi?: usbdux: detach without dev variable...\n"); + return -EFAULT; + } + + usbduxsub_tmp = dev->private; + if (!usbduxsub_tmp) { + printk("comedi?: usbdux: detach without ptr to usbduxsub[]\n"); + return -EFAULT; + } + + down(&usbduxsub_tmp->sem); + // Don't allow detach to free the private structure + // It's one entry of of usbduxsub[] + dev->private = NULL; + usbduxsub_tmp->attached = 0; + usbduxsub_tmp->comedidev = NULL; +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi%d: usbdux: detach: successfully removed\n", dev->minor); +#endif + up(&usbduxsub_tmp->sem); + return 0; +} + +/* main driver struct */ +static comedi_driver driver_usbdux = { + driver_name:"usbdux", + module:THIS_MODULE, + attach:usbdux_attach, + detach:usbdux_detach, +}; + +static void init_usb_devices(void) +{ + int index; +#ifdef CONFIG_COMEDI_DEBUG + printk("comedi_: usbdux: 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 + for (index = 0; index < NUMUSBDUX; index++) { + memset(&(usbduxsub[index]), 0x00, sizeof(usbduxsub[index])); + init_MUTEX(&(usbduxsub[index].sem)); + } +} + +// Table with the USB-devices: just now only testing IDs +static struct usb_device_id usbduxsub_table[] = { + {USB_DEVICE(0x13d8, 0x0001), + }, + {USB_DEVICE(0x13d8, 0x0002) + }, + {} /* Terminating entry */ +}; + +MODULE_DEVICE_TABLE(usb, usbduxsub_table); + +// The usbduxsub-driver +static struct usb_driver usbduxsub_driver = { +#ifdef COMEDI_HAVE_USB_DRIVER_OWNER + owner:THIS_MODULE, +#endif + name:BOARDNAME, + probe:usbduxsub_probe, + disconnect:usbduxsub_disconnect, + id_table:usbduxsub_table, +}; + +// 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_usbdux(void) +{ + printk(KERN_INFO KBUILD_MODNAME ": " + DRIVER_VERSION ":" DRIVER_DESC "\n"); + init_usb_devices(); + usb_register(&usbduxsub_driver); + comedi_driver_register(&driver_usbdux); + return 0; +} + +// deregistering the comedi driver and the usb-subsystem +static void exit_usbdux(void) +{ + comedi_driver_unregister(&driver_usbdux); + usb_deregister(&usbduxsub_driver); +} + +module_init(init_usbdux); +module_exit(exit_usbdux); + +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC); +MODULE_LICENSE("GPL"); |