Staging: comedi: add usb usbdux driver
authorBernd Porr <BerndPorr@f2s.com>
Fri, 14 Nov 2008 22:46:04 +0000 (14:46 -0800)
committerGreg Kroah-Hartman <gregkh@suse.de>
Tue, 6 Jan 2009 21:52:19 +0000 (13:52 -0800)
University of Stirling USB DAQ & INCITE Technology Limited driver.

From: Bernd Porr <BerndPorr@f2s.com>
Cc: David Schleef <ds@schleef.org>
Cc: Frank Mori Hess <fmhess@users.sourceforge.net>
Cc: Ian Abbott <abbotti@mev.co.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
drivers/staging/comedi/drivers/Makefile
drivers/staging/comedi/drivers/usbdux.c [new file with mode: 0644]

index 9a4fb1de5e8cb2af2718d75d5486baf45d624259..6b38d836095003321589e27c5f679dbd801d1019 100644 (file)
@@ -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 (file)
index 0000000..3320553
--- /dev/null
@@ -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");