drivers/staging/comedi/drivers/usbdux.c

   1 /*
   2    comedi/drivers/usbdux.c
   3    Copyright (C) 2003-2007 Bernd Porr, Bernd.Porr@f2s.com
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14  */
  15 /*
  16 Driver: usbdux
  17 Description: University of Stirling USB DAQ & INCITE Technology Limited
  18 Devices: [ITL] USB-DUX (usbdux.o)
  19 Author: Bernd Porr <BerndPorr@f2s.com>
  20 Updated: 8 Dec 2008
  21 Status: Stable
  22 Configuration options:
  23   You have to upload firmware with the -i option. The
  24   firmware is usually installed under /usr/share/usb or
  25   /usr/local/share/usb or /lib/firmware.
  26
  27 Connection scheme for the counter at the digital port:
  28   0=/CLK0, 1=UP/DOWN0, 2=RESET0, 4=/CLK1, 5=UP/DOWN1, 6=RESET1.
  29   The sampling rate of the counter is approximately 500Hz.
  30
  31 Please note that under USB2.0 the length of the channel list determines
  32 the max sampling rate. If you sample only one channel you get 8kHz
  33 sampling rate. If you sample two channels you get 4kHz and so on.
  34 */
  35 /*
  36  * I must give credit here to Chris Baugher who
  37  * wrote the driver for AT-MIO-16d. I used some parts of this
  38  * driver. I also must give credits to David Brownell
  39  * who supported me with the USB development.
  40  *
  41  * Bernd Porr
  42  *
  43  *
  44  * Revision history:
  45  * 0.94: D/A output should work now with any channel list combinations
  46  * 0.95: .owner commented out for kernel vers below 2.4.19
  47  *       sanity checks in ai/ao_cmd
  48  * 0.96: trying to get it working with 2.6, moved all memory alloc to comedi's
  49  *       attach final USB IDs
  50  *       moved memory allocation completely to the corresponding comedi
  51  *       functions firmware upload is by fxload and no longer by comedi (due to
  52  *       enumeration)
  53  * 0.97: USB IDs received, adjusted table
  54  * 0.98: SMP, locking, memory alloc: moved all usb memory alloc
  55  *       to the usb subsystem and moved all comedi related memory
  56  *       alloc to comedi.
  57  *       | kernel | registration | usbdux-usb | usbdux-comedi | comedi |
  58  * 0.99: USB 2.0: changed protocol to isochronous transfer
  59  *                IRQ transfer is too buggy and too risky in 2.0
  60  *                for the high speed ISO transfer is now a working version
  61  *                available
  62  * 0.99b: Increased the iso transfer buffer for high sp.to 10 buffers. Some VIA
  63  *        chipsets miss out IRQs. Deeper buffering is needed.
  64  * 1.00: full USB 2.0 support for the A/D converter. Now: max 8kHz sampling
  65  *       rate.
  66  *       Firmware vers 1.00 is needed for this.
  67  *       Two 16 bit up/down/reset counter with a sampling rate of 1kHz
  68  *       And loads of cleaning up, in particular streamlining the
  69  *       bulk transfers.
  70  * 1.1:  moved EP4 transfers to EP1 to make space for a PWM output on EP4
  71  * 1.2:  added PWM support via EP4
  72  * 2.0:  PWM seems to be stable and is not interfering with the other functions
  73  * 2.1:  changed PWM API
  74  * 2.2:  added firmware kernel request to fix an udev problem
  75  * 2.3:  corrected a bug in bulk timeouts which were far too short
  76  * 2.4:  fixed a bug which causes the driver to hang when it ran out of data.
  77  *       Thanks to Jan-Matthias Braun and Ian to spot the bug and fix it.
  78  *
  79  */
  80
  81 #include <linux/kernel.h>
  82 #include <linux/module.h>
  83 #include <linux/init.h>
  84 #include <linux/slab.h>
  85 #include <linux/input.h>
  86 #include <linux/usb.h>
  87 #include <linux/fcntl.h>
  88 #include <linux/compiler.h>
  89
  90 #include "../comedidev.h"
  91
  92 #include "comedi_fc.h"
  93
  94 /* timeout for the USB-transfer in ms*/
  95 #define BULK_TIMEOUT 1000
  96
  97 /* constants for "firmware" upload and download */
  98 #define FIRMWARE "usbdux_firmware.bin"
  99 #define USBDUXSUB_FIRMWARE 0xA0
 100 #define VENDOR_DIR_IN  0xC0
 101 #define VENDOR_DIR_OUT 0x40
 102
 103 /* internal addresses of the 8051 processor */
 104 #define USBDUXSUB_CPUCS 0xE600
 105
 106 /*
 107  * the minor device number, major is 180 only for debugging purposes and to
 108  * upload special firmware (programming the eeprom etc) which is not compatible
 109  * with the comedi framwork
 110  */
 111 #define USBDUXSUB_MINOR 32
 112
 113 /* max lenghth of the transfer-buffer for software upload */
 114 #define TB_LEN 0x2000
 115
 116 /* Input endpoint number: ISO/IRQ */
 117 #define ISOINEP           6
 118
 119 /* Output endpoint number: ISO/IRQ */
 120 #define ISOOUTEP          2
 121
 122 /* This EP sends DUX commands to USBDUX */
 123 #define COMMAND_OUT_EP     1
 124
 125 /* This EP receives the DUX commands from USBDUX */
 126 #define COMMAND_IN_EP        8
 127
 128 /* Output endpoint for PWM */
 129 #define PWM_EP         4
 130
 131 /* 300Hz max frequ under PWM */
 132 #define MIN_PWM_PERIOD  ((long)(1E9/300))
 133
 134 /* Default PWM frequency */
 135 #define PWM_DEFAULT_PERIOD ((long)(1E9/100))
 136
 137 /* Number of channels */
 138 #define NUMCHANNELS       8
 139
 140 /* Size of one A/D value */
 141 #define SIZEADIN          ((sizeof(int16_t)))
 142
 143 /*
 144  * Size of the input-buffer IN BYTES
 145  * Always multiple of 8 for 8 microframes which is needed in the highspeed mode
 146  */
 147 #define SIZEINBUF         ((8*SIZEADIN))
 148
 149 /* 16 bytes. */
 150 #define SIZEINSNBUF       16
 151
 152 /* Number of DA channels */
 153 #define NUMOUTCHANNELS    8
 154
 155 /* size of one value for the D/A converter: channel and value */
 156 #define SIZEDAOUT          ((sizeof(int8_t)+sizeof(int16_t)))
 157
 158 /*
 159  * Size of the output-buffer in bytes
 160  * Actually only the first 4 triplets are used but for the
 161  * high speed mode we need to pad it to 8 (microframes).
 162  */
 163 #define SIZEOUTBUF         ((8*SIZEDAOUT))
 164
 165 /*
 166  * Size of the buffer for the dux commands: just now max size is determined
 167  * by the analogue out + command byte + panic bytes...
 168  */
 169 #define SIZEOFDUXBUFFER    ((8*SIZEDAOUT+2))
 170
 171 /* Number of in-URBs which receive the data: min=2 */
 172 #define NUMOFINBUFFERSFULL     5
 173
 174 /* Number of out-URBs which send the data: min=2 */
 175 #define NUMOFOUTBUFFERSFULL    5
 176
 177 /* Number of in-URBs which receive the data: min=5 */
 178 /* must have more buffers due to buggy USB ctr */
 179 #define NUMOFINBUFFERSHIGH     10
 180
 181 /* Number of out-URBs which send the data: min=5 */
 182 /* must have more buffers due to buggy USB ctr */
 183 #define NUMOFOUTBUFFERSHIGH    10
 184
 185 /* number of retries to get the right dux command */
 186 #define RETRIES 10
 187
 188 static const struct comedi_lrange range_usbdux_ai_range = {
 189         4, {
 190                 BIP_RANGE(4.096),
 191                 BIP_RANGE(4.096 / 2),
 192                 UNI_RANGE(4.096),
 193                 UNI_RANGE(4.096 / 2)
 194         }
 195 };
 196
 197 static const struct comedi_lrange range_usbdux_ao_range = {
 198         2, {
 199                 BIP_RANGE(4.096),
 200                 UNI_RANGE(4.096)
 201         }
 202 };
 203
 204 struct usbdux_private {
 205         /* pointer to the usb-device */
 206         struct usb_device *usbdev;
 207         /* actual number of in-buffers */
 208         int num_in_buffers;
 209         /* actual number of out-buffers */
 210         int num_out_buffers;
 211         /* ISO-transfer handling: buffers */
 212         struct urb **urb_in;
 213         struct urb **urb_out;
 214         /* pwm-transfer handling */
 215         struct urb *urb_pwm;
 216         /* PWM period */
 217         unsigned int pwm_period;
 218         /* PWM internal delay for the GPIF in the FX2 */
 219         int8_t pwn_delay;
 220         /* size of the PWM buffer which holds the bit pattern */
 221         int size_pwm_buf;
 222         /* input buffer for the ISO-transfer */
 223         int16_t *in_buffer;
 224         /* input buffer for single insn */
 225         int16_t *insn_buffer;
 226         /* output buffer for single DA outputs */
 227         int16_t *out_buffer;
 228         /* interface number */
 229         int ifnum;
 230         /* is it USB_SPEED_HIGH or not? */
 231         short int high_speed;
 232         /* asynchronous command is running */
 233         short int ai_cmd_running;
 234         short int ao_cmd_running;
 235         /* pwm is running */
 236         short int pwm_cmd_running;
 237         /* continous acquisition */
 238         short int ai_continous;
 239         short int ao_continous;
 240         /* number of samples to acquire */
 241         int ai_sample_count;
 242         int ao_sample_count;
 243         /* time between samples in units of the timer */
 244         unsigned int ai_timer;
 245         unsigned int ao_timer;
 246         /* counter between aquisitions */
 247         unsigned int ai_counter;
 248         unsigned int ao_counter;
 249         /* interval in frames/uframes */
 250         unsigned int ai_interval;
 251         /* D/A commands */
 252         int8_t *dac_commands;
 253         /* commands */
 254         int8_t *dux_commands;
 255         struct semaphore sem;
 256 };
 257
 258 /*
 259  * Stops the data acquision
 260  * It should be safe to call this function from any context
 261  */
 262 static int usbduxsub_unlink_inurbs(struct usbdux_private *usbduxsub_tmp)
 263 {
 264         int i = 0;
 265         int err = 0;
 266
 267         if (usbduxsub_tmp && usbduxsub_tmp->urb_in) {
 268                 for (i = 0; i < usbduxsub_tmp->num_in_buffers; i++) {
 269                         if (usbduxsub_tmp->urb_in[i]) {
 270                                 /* We wait here until all transfers have been
 271                                  * cancelled. */
 272                                 usb_kill_urb(usbduxsub_tmp->urb_in[i]);
 273                         }
 274                 }
 275         }
 276         return err;
 277 }
 278
 279 /*
 280  * This will stop a running acquisition operation
 281  * Is called from within this driver from both the
 282  * interrupt context and from comedi
 283  */
 284 static int usbdux_ai_stop(struct usbdux_private *this_usbduxsub, int do_unlink)
 285 {
 286         int ret = 0;
 287
 288         if (!this_usbduxsub)
 289                 return -EFAULT;
 290
 291         if (do_unlink) {
 292                 /* stop aquistion */
 293                 ret = usbduxsub_unlink_inurbs(this_usbduxsub);
 294         }
 295
 296         this_usbduxsub->ai_cmd_running = 0;
 297
 298         return ret;
 299 }
 300
 301 /*
 302  * This will cancel a running acquisition operation.
 303  * This is called by comedi but never from inside the driver.
 304  */
 305 static int usbdux_ai_cancel(struct comedi_device *dev,
 306                             struct comedi_subdevice *s)
 307 {
 308         struct usbdux_private *this_usbduxsub;
 309         int res = 0;
 310
 311         /* force unlink of all urbs */
 312         this_usbduxsub = dev->private;
 313         if (!this_usbduxsub)
 314                 return -EFAULT;
 315
 316         /* prevent other CPUs from submitting new commands just now */
 317         down(&this_usbduxsub->sem);
 318         /* unlink only if the urb really has been submitted */
 319         res = usbdux_ai_stop(this_usbduxsub, this_usbduxsub->ai_cmd_running);
 320         up(&this_usbduxsub->sem);
 321         return res;
 322 }
 323
 324 /* analogue IN - interrupt service routine */
 325 static void usbduxsub_ai_isoc_irq(struct urb *urb)
 326 {
 327         struct comedi_device *dev = urb->context;
 328         struct comedi_subdevice *s = dev->read_subdev;
 329         struct usbdux_private *devpriv = dev->private;
 330         int i, err, n;
 331
 332         /* first we test if something unusual has just happened */
 333         switch (urb->status) {
 334         case 0:
 335                 /* copy the result in the transfer buffer */
 336                 memcpy(devpriv->in_buffer, urb->transfer_buffer, SIZEINBUF);
 337                 break;
 338         case -EILSEQ:
 339                 /* error in the ISOchronous data */
 340                 /* we don't copy the data into the transfer buffer */
 341                 /* and recycle the last data byte */
 342                 dev_dbg(dev->class_dev, "CRC error in ISO IN stream\n");
 343                 break;
 344
 345         case -ECONNRESET:
 346         case -ENOENT:
 347         case -ESHUTDOWN:
 348         case -ECONNABORTED:
 349                 /* happens after an unlink command */
 350                 if (devpriv->ai_cmd_running) {
 351                         s->async->events |= COMEDI_CB_EOA;
 352                         s->async->events |= COMEDI_CB_ERROR;
 353                         comedi_event(dev, s);
 354                         /* stop the transfer w/o unlink */
 355                         usbdux_ai_stop(devpriv, 0);
 356                 }
 357                 return;
 358
 359         default:
 360                 /* a real error on the bus */
 361                 /* pass error to comedi if we are really running a command */
 362                 if (devpriv->ai_cmd_running) {
 363                         dev_err(dev->class_dev,
 364                                 "Non-zero urb status received in ai intr context: %d\n",
 365                                 urb->status);
 366                         s->async->events |= COMEDI_CB_EOA;
 367                         s->async->events |= COMEDI_CB_ERROR;
 368                         comedi_event(dev, s);
 369                         /* don't do an unlink here */
 370                         usbdux_ai_stop(devpriv, 0);
 371                 }
 372                 return;
 373         }
 374
 375         /*
 376          * at this point we are reasonably sure that nothing dodgy has happened
 377          * are we running a command?
 378          */
 379         if (unlikely(!devpriv->ai_cmd_running)) {
 380                 /*
 381                  * not running a command, do not continue execution if no
 382                  * asynchronous command is running in particular not resubmit
 383                  */
 384                 return;
 385         }
 386
 387         urb->dev = devpriv->usbdev;
 388
 389         /* resubmit the urb */
 390         err = usb_submit_urb(urb, GFP_ATOMIC);
 391         if (unlikely(err < 0)) {
 392                 dev_err(dev->class_dev,
 393                         "urb resubmit failed in int-context! err=%d\n", err);
 394                 if (err == -EL2NSYNC)
 395                         dev_err(dev->class_dev,
 396                                 "buggy USB host controller or bug in IRQ handler!\n");
 397                 s->async->events |= COMEDI_CB_EOA;
 398                 s->async->events |= COMEDI_CB_ERROR;
 399                 comedi_event(dev, s);
 400                 /* don't do an unlink here */
 401                 usbdux_ai_stop(devpriv, 0);
 402                 return;
 403         }
 404
 405         devpriv->ai_counter--;
 406         if (likely(devpriv->ai_counter > 0))
 407                 return;
 408
 409         /* timer zero, transfer measurements to comedi */
 410         devpriv->ai_counter = devpriv->ai_timer;
 411
 412         /* test, if we transmit only a fixed number of samples */
 413         if (!devpriv->ai_continous) {
 414                 /* not continuous, fixed number of samples */
 415                 devpriv->ai_sample_count--;
 416                 /* all samples received? */
 417                 if (devpriv->ai_sample_count < 0) {
 418                         /* prevent a resubmit next time */
 419                         usbdux_ai_stop(devpriv, 0);
 420                         /* say comedi that the acquistion is over */
 421                         s->async->events |= COMEDI_CB_EOA;
 422                         comedi_event(dev, s);
 423                         return;
 424                 }
 425         }
 426         /* get the data from the USB bus and hand it over to comedi */
 427         n = s->async->cmd.chanlist_len;
 428         for (i = 0; i < n; i++) {
 429                 /* transfer data */
 430                 if (CR_RANGE(s->async->cmd.chanlist[i]) <= 1) {
 431                         err = comedi_buf_put(s->async,
 432                              le16_to_cpu(devpriv->in_buffer[i]) ^ 0x800);
 433                 } else {
 434                         err = comedi_buf_put(s->async,
 435                              le16_to_cpu(devpriv->in_buffer[i]));
 436                 }
 437                 if (unlikely(err == 0)) {
 438                         /* buffer overflow */
 439                         usbdux_ai_stop(devpriv, 0);
 440                         return;
 441                 }
 442         }
 443         /* tell comedi that data is there */
 444         s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
 445         comedi_event(dev, s);
 446 }
 447
 448 static int usbduxsub_unlink_outurbs(struct usbdux_private *usbduxsub_tmp)
 449 {
 450         int i = 0;
 451         int err = 0;
 452
 453         if (usbduxsub_tmp && usbduxsub_tmp->urb_out) {
 454                 for (i = 0; i < usbduxsub_tmp->num_out_buffers; i++) {
 455                         if (usbduxsub_tmp->urb_out[i])
 456                                 usb_kill_urb(usbduxsub_tmp->urb_out[i]);
 457                 }
 458         }
 459         return err;
 460 }
 461
 462 /* This will cancel a running acquisition operation
 463  * in any context.
 464  */
 465 static int usbdux_ao_stop(struct usbdux_private *this_usbduxsub, int do_unlink)
 466 {
 467         int ret = 0;
 468
 469         if (!this_usbduxsub)
 470                 return -EFAULT;
 471
 472         if (do_unlink)
 473                 ret = usbduxsub_unlink_outurbs(this_usbduxsub);
 474
 475         this_usbduxsub->ao_cmd_running = 0;
 476
 477         return ret;
 478 }
 479
 480 /* force unlink, is called by comedi */
 481 static int usbdux_ao_cancel(struct comedi_device *dev,
 482                             struct comedi_subdevice *s)
 483 {
 484         struct usbdux_private *this_usbduxsub = dev->private;
 485         int res = 0;
 486
 487         if (!this_usbduxsub)
 488                 return -EFAULT;
 489
 490         /* prevent other CPUs from submitting a command just now */
 491         down(&this_usbduxsub->sem);
 492         /* unlink only if it is really running */
 493         res = usbdux_ao_stop(this_usbduxsub, this_usbduxsub->ao_cmd_running);
 494         up(&this_usbduxsub->sem);
 495         return res;
 496 }
 497
 498 static void usbduxsub_ao_isoc_irq(struct urb *urb)
 499 {
 500         struct comedi_device *dev = urb->context;
 501         struct comedi_subdevice *s = dev->write_subdev;
 502         struct usbdux_private *devpriv = dev->private;
 503         int i, ret;
 504         int8_t *datap;
 505
 506         switch (urb->status) {
 507         case 0:
 508                 /* success */
 509                 break;
 510
 511         case -ECONNRESET:
 512         case -ENOENT:
 513         case -ESHUTDOWN:
 514         case -ECONNABORTED:
 515                 /* after an unlink command, unplug, ... etc */
 516                 /* no unlink needed here. Already shutting down. */
 517                 if (devpriv->ao_cmd_running) {
 518                         s->async->events |= COMEDI_CB_EOA;
 519                         comedi_event(dev, s);
 520                         usbdux_ao_stop(devpriv, 0);
 521                 }
 522                 return;
 523
 524         default:
 525                 /* a real error */
 526                 if (devpriv->ao_cmd_running) {
 527                         dev_err(dev->class_dev,
 528                                 "Non-zero urb status received in ao intr context: %d\n",
 529                                 urb->status);
 530                         s->async->events |= COMEDI_CB_ERROR;
 531                         s->async->events |= COMEDI_CB_EOA;
 532                         comedi_event(dev, s);
 533                         /* we do an unlink if we are in the high speed mode */
 534                         usbdux_ao_stop(devpriv, 0);
 535                 }
 536                 return;
 537         }
 538
 539         /* are we actually running? */
 540         if (!devpriv->ao_cmd_running)
 541                 return;
 542
 543         /* normal operation: executing a command in this subdevice */
 544         devpriv->ao_counter--;
 545         if ((int)devpriv->ao_counter <= 0) {
 546                 /* timer zero */
 547                 devpriv->ao_counter = devpriv->ao_timer;
 548
 549                 /* handle non continous acquisition */
 550                 if (!devpriv->ao_continous) {
 551                         /* fixed number of samples */
 552                         devpriv->ao_sample_count--;
 553                         if (devpriv->ao_sample_count < 0) {
 554                                 /* all samples transmitted */
 555                                 usbdux_ao_stop(devpriv, 0);
 556                                 s->async->events |= COMEDI_CB_EOA;
 557                                 comedi_event(dev, s);
 558                                 /* no resubmit of the urb */
 559                                 return;
 560                         }
 561                 }
 562                 /* transmit data to the USB bus */
 563                 ((uint8_t *) (urb->transfer_buffer))[0] =
 564                     s->async->cmd.chanlist_len;
 565                 for (i = 0; i < s->async->cmd.chanlist_len; i++) {
 566                         short temp;
 567                         if (i >= NUMOUTCHANNELS)
 568                                 break;
 569
 570                         /* pointer to the DA */
 571                         datap =
 572                             (&(((int8_t *) urb->transfer_buffer)[i * 3 + 1]));
 573                         /* get the data from comedi */
 574                         ret = comedi_buf_get(s->async, &temp);
 575                         datap[0] = temp;
 576                         datap[1] = temp >> 8;
 577                         datap[2] = devpriv->dac_commands[i];
 578                         if (ret < 0) {
 579                                 dev_err(&urb->dev->dev,
 580                                         "comedi: buffer underflow\n");
 581                                 s->async->events |= COMEDI_CB_EOA;
 582                                 s->async->events |= COMEDI_CB_OVERFLOW;
 583                         }
 584                         /* transmit data to comedi */
 585                         s->async->events |= COMEDI_CB_BLOCK;
 586                         comedi_event(dev, s);
 587                 }
 588         }
 589         urb->transfer_buffer_length = SIZEOUTBUF;
 590         urb->dev = devpriv->usbdev;
 591         urb->status = 0;
 592         if (devpriv->ao_cmd_running) {
 593                 if (devpriv->high_speed)
 594                         urb->interval = 8;      /* uframes */
 595                 else
 596                         urb->interval = 1;      /* frames */
 597                 urb->number_of_packets = 1;
 598                 urb->iso_frame_desc[0].offset = 0;
 599                 urb->iso_frame_desc[0].length = SIZEOUTBUF;
 600                 urb->iso_frame_desc[0].status = 0;
 601                 ret = usb_submit_urb(urb, GFP_ATOMIC);
 602                 if (ret < 0) {
 603                         dev_err(dev->class_dev,
 604                                 "ao urb resubm failed in int-cont. ret=%d",
 605                                 ret);
 606                         if (ret == EL2NSYNC)
 607                                 dev_err(dev->class_dev,
 608                                         "buggy USB host controller or bug in IRQ handling!\n");
 609
 610                         s->async->events |= COMEDI_CB_EOA;
 611                         s->async->events |= COMEDI_CB_ERROR;
 612                         comedi_event(dev, s);
 613                         /* don't do an unlink here */
 614                         usbdux_ao_stop(devpriv, 0);
 615                 }
 616         }
 617 }
 618
 619 #define FIRMWARE_MAX_LEN 0x2000
 620
 621 static int usbdux_firmware_upload(struct comedi_device *dev,
 622                                   const u8 *data, size_t size,
 623                                   unsigned long context)
 624 {
 625         struct usbdux_private *usbduxsub = dev->private;
 626         struct usb_device *usb = usbduxsub->usbdev;
 627         uint8_t *buf;
 628         uint8_t *tmp;
 629         int ret;
 630
 631         if (!data)
 632                 return 0;
 633
 634         if (size > FIRMWARE_MAX_LEN) {
 635                 dev_err(dev->class_dev,
 636                         "usbdux firmware binary it too large for FX2.\n");
 637                 return -ENOMEM;
 638         }
 639
 640         /* we generate a local buffer for the firmware */
 641         buf = kmemdup(data, size, GFP_KERNEL);
 642         if (!buf)
 643                 return -ENOMEM;
 644
 645         /* we need a malloc'ed buffer for usb_control_msg() */
 646         tmp = kmalloc(1, GFP_KERNEL);
 647         if (!tmp) {
 648                 kfree(buf);
 649                 return -ENOMEM;
 650         }
 651
 652         /* stop the current firmware on the device */
 653         *tmp = 1;       /* 7f92 to one */
 654         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
 655                               USBDUXSUB_FIRMWARE,
 656                               VENDOR_DIR_OUT,
 657                               USBDUXSUB_CPUCS, 0x0000,
 658                               tmp, 1,
 659                               BULK_TIMEOUT);
 660         if (ret < 0) {
 661                 dev_err(dev->class_dev, "can not stop firmware\n");
 662                 goto done;
 663         }
 664
 665         /* upload the new firmware to the device */
 666         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
 667                               USBDUXSUB_FIRMWARE,
 668                               VENDOR_DIR_OUT,
 669                               0, 0x0000,
 670                               buf, size,
 671                               BULK_TIMEOUT);
 672         if (ret < 0) {
 673                 dev_err(dev->class_dev, "firmware upload failed\n");
 674                 goto done;
 675         }
 676
 677         /* start the new firmware on the device */
 678         *tmp = 0;       /* 7f92 to zero */
 679         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
 680                               USBDUXSUB_FIRMWARE,
 681                               VENDOR_DIR_OUT,
 682                               USBDUXSUB_CPUCS, 0x0000,
 683                               tmp, 1,
 684                               BULK_TIMEOUT);
 685         if (ret < 0)
 686                 dev_err(dev->class_dev, "can not start firmware\n");
 687
 688 done:
 689         kfree(tmp);
 690         kfree(buf);
 691         return ret;
 692 }
 693
 694 static int usbduxsub_submit_inurbs(struct comedi_device *dev)
 695 {
 696         struct usbdux_private *devpriv = dev->private;
 697         struct urb *urb;
 698         int ret;
 699         int i;
 700
 701         /* Submit all URBs and start the transfer on the bus */
 702         for (i = 0; i < devpriv->num_in_buffers; i++) {
 703                 urb = devpriv->urb_in[i];
 704
 705                 /* in case of a resubmission after an unlink... */
 706                 urb->interval = devpriv->ai_interval;
 707                 urb->context = dev;
 708                 urb->dev = devpriv->usbdev;
 709                 urb->status = 0;
 710                 urb->transfer_flags = URB_ISO_ASAP;
 711
 712                 ret = usb_submit_urb(urb, GFP_ATOMIC);
 713                 if (ret)
 714                         return ret;
 715         }
 716         return 0;
 717 }
 718
 719 static int usbduxsub_submit_outurbs(struct comedi_device *dev)
 720 {
 721         struct usbdux_private *devpriv = dev->private;
 722         struct urb *urb;
 723         int ret;
 724         int i;
 725
 726         for (i = 0; i < devpriv->num_out_buffers; i++) {
 727                 urb = devpriv->urb_out[i];
 728
 729                 /* in case of a resubmission after an unlink... */
 730                 urb->context = dev;
 731                 urb->dev = devpriv->usbdev;
 732                 urb->status = 0;
 733                 urb->transfer_flags = URB_ISO_ASAP;
 734
 735                 ret = usb_submit_urb(urb, GFP_ATOMIC);
 736                 if (ret)
 737                         return ret;
 738         }
 739         return 0;
 740 }
 741
 742 static int usbdux_ai_cmdtest(struct comedi_device *dev,
 743                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
 744 {
 745         struct usbdux_private *this_usbduxsub = dev->private;
 746         int err = 0, i;
 747         unsigned int tmp_timer;
 748
 749         /* Step 1 : check if triggers are trivially valid */
 750
 751         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
 752         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
 753         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 754         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 755         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 756
 757         if (err)
 758                 return 1;
 759
 760         /* Step 2a : make sure trigger sources are unique */
 761
 762         err |= cfc_check_trigger_is_unique(cmd->start_src);
 763         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 764
 765         /* Step 2b : and mutually compatible */
 766
 767         if (err)
 768                 return 2;
 769
 770         /* Step 3: check if arguments are trivially valid */
 771
 772         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 773
 774         if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
 775                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 776
 777         if (cmd->scan_begin_src == TRIG_TIMER) {
 778                 if (this_usbduxsub->high_speed) {
 779                         /*
 780                          * In high speed mode microframes are possible.
 781                          * However, during one microframe we can roughly
 782                          * sample one channel. Thus, the more channels
 783                          * are in the channel list the more time we need.
 784                          */
 785                         i = 1;
 786                         /* find a power of 2 for the number of channels */
 787                         while (i < (cmd->chanlist_len))
 788                                 i = i * 2;
 789
 790                         err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
 791                                                          1000000 / 8 * i);
 792                         /* now calc the real sampling rate with all the
 793                          * rounding errors */
 794                         tmp_timer =
 795                             ((unsigned int)(cmd->scan_begin_arg / 125000)) *
 796                             125000;
 797                 } else {
 798                         /* full speed */
 799                         /* 1kHz scans every USB frame */
 800                         err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
 801                                                          1000000);
 802                         /*
 803                          * calc the real sampling rate with the rounding errors
 804                          */
 805                         tmp_timer = ((unsigned int)(cmd->scan_begin_arg /
 806                                                    1000000)) * 1000000;
 807                 }
 808                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg,
 809                                                 tmp_timer);
 810         }
 811
 812         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 813
 814         if (cmd->stop_src == TRIG_COUNT) {
 815                 /* any count is allowed */
 816         } else {
 817                 /* TRIG_NONE */
 818                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 819         }
 820
 821         if (err)
 822                 return 3;
 823
 824         return 0;
 825 }
 826
 827 /*
 828  * creates the ADC command for the MAX1271
 829  * range is the range value from comedi
 830  */
 831 static int8_t create_adc_command(unsigned int chan, int range)
 832 {
 833         int8_t p = (range <= 1);
 834         int8_t r = ((range % 2) == 0);
 835         return (chan << 4) | ((p == 1) << 2) | ((r == 1) << 3);
 836 }
 837
 838 /* bulk transfers to usbdux */
 839
 840 #define SENDADCOMMANDS            0
 841 #define SENDDACOMMANDS            1
 842 #define SENDDIOCONFIGCOMMAND      2
 843 #define SENDDIOBITSCOMMAND        3
 844 #define SENDSINGLEAD              4
 845 #define READCOUNTERCOMMAND        5
 846 #define WRITECOUNTERCOMMAND       6
 847 #define SENDPWMON                 7
 848 #define SENDPWMOFF                8
 849
 850 static int send_dux_commands(struct comedi_device *dev, int cmd_type)
 851 {
 852         struct usbdux_private *devpriv = dev->private;
 853         struct usb_device *usb = devpriv->usbdev;
 854         int nsent;
 855
 856         devpriv->dux_commands[0] = cmd_type;
 857
 858         return usb_bulk_msg(usb, usb_sndbulkpipe(usb, COMMAND_OUT_EP),
 859                             devpriv->dux_commands, SIZEOFDUXBUFFER,
 860                             &nsent, BULK_TIMEOUT);
 861 }
 862
 863 static int receive_dux_commands(struct usbdux_private *this_usbduxsub, int command)
 864 {
 865         int result = (-EFAULT);
 866         int nrec;
 867         int i;
 868
 869         for (i = 0; i < RETRIES; i++) {
 870                 result = usb_bulk_msg(this_usbduxsub->usbdev,
 871                                       usb_rcvbulkpipe(this_usbduxsub->usbdev,
 872                                                       COMMAND_IN_EP),
 873                                       this_usbduxsub->insn_buffer, SIZEINSNBUF,
 874                                       &nrec, BULK_TIMEOUT);
 875                 if (result < 0)
 876                         return result;
 877                 if (le16_to_cpu(this_usbduxsub->insn_buffer[0]) == command)
 878                         return result;
 879         }
 880         /* this is only reached if the data has been requested a couple of
 881          * times */
 882         return -EFAULT;
 883 }
 884
 885 static int usbdux_ai_inttrig(struct comedi_device *dev,
 886                              struct comedi_subdevice *s, unsigned int trignum)
 887 {
 888         int ret;
 889         struct usbdux_private *this_usbduxsub = dev->private;
 890         if (!this_usbduxsub)
 891                 return -EFAULT;
 892
 893         down(&this_usbduxsub->sem);
 894
 895         if (trignum != 0) {
 896                 up(&this_usbduxsub->sem);
 897                 return -EINVAL;
 898         }
 899         if (!(this_usbduxsub->ai_cmd_running)) {
 900                 this_usbduxsub->ai_cmd_running = 1;
 901                 ret = usbduxsub_submit_inurbs(dev);
 902                 if (ret < 0) {
 903                         this_usbduxsub->ai_cmd_running = 0;
 904                         up(&this_usbduxsub->sem);
 905                         return ret;
 906                 }
 907                 s->async->inttrig = NULL;
 908         }
 909         up(&this_usbduxsub->sem);
 910         return 1;
 911 }
 912
 913 static int usbdux_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 914 {
 915         struct comedi_cmd *cmd = &s->async->cmd;
 916         unsigned int chan, range;
 917         int i, ret;
 918         struct usbdux_private *this_usbduxsub = dev->private;
 919         int result;
 920
 921         if (!this_usbduxsub)
 922                 return -EFAULT;
 923
 924         /* block other CPUs from starting an ai_cmd */
 925         down(&this_usbduxsub->sem);
 926         if (this_usbduxsub->ai_cmd_running) {
 927                 up(&this_usbduxsub->sem);
 928                 return -EBUSY;
 929         }
 930         /* set current channel of the running acquisition to zero */
 931         s->async->cur_chan = 0;
 932
 933         this_usbduxsub->dux_commands[1] = cmd->chanlist_len;
 934         for (i = 0; i < cmd->chanlist_len; ++i) {
 935                 chan = CR_CHAN(cmd->chanlist[i]);
 936                 range = CR_RANGE(cmd->chanlist[i]);
 937                 if (i >= NUMCHANNELS)
 938                         break;
 939                 this_usbduxsub->dux_commands[i + 2] =
 940                     create_adc_command(chan, range);
 941         }
 942
 943         result = send_dux_commands(dev, SENDADCOMMANDS);
 944         if (result < 0) {
 945                 up(&this_usbduxsub->sem);
 946                 return result;
 947         }
 948
 949         if (this_usbduxsub->high_speed) {
 950                 /*
 951                  * every channel gets a time window of 125us. Thus, if we
 952                  * sample all 8 channels we need 1ms. If we sample only one
 953                  * channel we need only 125us
 954                  */
 955                 this_usbduxsub->ai_interval = 1;
 956                 /* find a power of 2 for the interval */
 957                 while ((this_usbduxsub->ai_interval) < (cmd->chanlist_len)) {
 958                         this_usbduxsub->ai_interval =
 959                             (this_usbduxsub->ai_interval) * 2;
 960                 }
 961                 this_usbduxsub->ai_timer = cmd->scan_begin_arg / (125000 *
 962                                                           (this_usbduxsub->
 963                                                            ai_interval));
 964         } else {
 965                 /* interval always 1ms */
 966                 this_usbduxsub->ai_interval = 1;
 967                 this_usbduxsub->ai_timer = cmd->scan_begin_arg / 1000000;
 968         }
 969         if (this_usbduxsub->ai_timer < 1) {
 970                 up(&this_usbduxsub->sem);
 971                 return -EINVAL;
 972         }
 973         this_usbduxsub->ai_counter = this_usbduxsub->ai_timer;
 974
 975         if (cmd->stop_src == TRIG_COUNT) {
 976                 /* data arrives as one packet */
 977                 this_usbduxsub->ai_sample_count = cmd->stop_arg;
 978                 this_usbduxsub->ai_continous = 0;
 979         } else {
 980                 /* continous acquisition */
 981                 this_usbduxsub->ai_continous = 1;
 982                 this_usbduxsub->ai_sample_count = 0;
 983         }
 984
 985         if (cmd->start_src == TRIG_NOW) {
 986                 /* enable this acquisition operation */
 987                 this_usbduxsub->ai_cmd_running = 1;
 988                 ret = usbduxsub_submit_inurbs(dev);
 989                 if (ret < 0) {
 990                         this_usbduxsub->ai_cmd_running = 0;
 991                         /* fixme: unlink here?? */
 992                         up(&this_usbduxsub->sem);
 993                         return ret;
 994                 }
 995                 s->async->inttrig = NULL;
 996         } else {
 997                 /* TRIG_INT */
 998                 /* don't enable the acquision operation */
 999                 /* wait for an internal signal */
1000                 s->async->inttrig = usbdux_ai_inttrig;
1001         }
1002         up(&this_usbduxsub->sem);
1003         return 0;
1004 }
1005
1006 /* Mode 0 is used to get a single conversion on demand */
1007 static int usbdux_ai_insn_read(struct comedi_device *dev,
1008                                struct comedi_subdevice *s,
1009                                struct comedi_insn *insn, unsigned int *data)
1010 {
1011         int i;
1012         unsigned int one = 0;
1013         int chan, range;
1014         int err;
1015         struct usbdux_private *this_usbduxsub = dev->private;
1016
1017         if (!this_usbduxsub)
1018                 return 0;
1019
1020         down(&this_usbduxsub->sem);
1021         if (this_usbduxsub->ai_cmd_running) {
1022                 up(&this_usbduxsub->sem);
1023                 return 0;
1024         }
1025
1026         /* sample one channel */
1027         chan = CR_CHAN(insn->chanspec);
1028         range = CR_RANGE(insn->chanspec);
1029         /* set command for the first channel */
1030         this_usbduxsub->dux_commands[1] = create_adc_command(chan, range);
1031
1032         /* adc commands */
1033         err = send_dux_commands(dev, SENDSINGLEAD);
1034         if (err < 0) {
1035                 up(&this_usbduxsub->sem);
1036                 return err;
1037         }
1038
1039         for (i = 0; i < insn->n; i++) {
1040                 err = receive_dux_commands(this_usbduxsub, SENDSINGLEAD);
1041                 if (err < 0) {
1042                         up(&this_usbduxsub->sem);
1043                         return 0;
1044                 }
1045                 one = le16_to_cpu(this_usbduxsub->insn_buffer[1]);
1046                 if (CR_RANGE(insn->chanspec) <= 1)
1047                         one = one ^ 0x800;
1048
1049                 data[i] = one;
1050         }
1051         up(&this_usbduxsub->sem);
1052         return i;
1053 }
1054
1055 /************************************/
1056 /* analog out */
1057
1058 static int usbdux_ao_insn_read(struct comedi_device *dev,
1059                                struct comedi_subdevice *s,
1060                                struct comedi_insn *insn, unsigned int *data)
1061 {
1062         int i;
1063         int chan = CR_CHAN(insn->chanspec);
1064         struct usbdux_private *this_usbduxsub = dev->private;
1065
1066         if (!this_usbduxsub)
1067                 return -EFAULT;
1068
1069         down(&this_usbduxsub->sem);
1070         for (i = 0; i < insn->n; i++)
1071                 data[i] = this_usbduxsub->out_buffer[chan];
1072
1073         up(&this_usbduxsub->sem);
1074         return i;
1075 }
1076
1077 static int usbdux_ao_insn_write(struct comedi_device *dev,
1078                                 struct comedi_subdevice *s,
1079                                 struct comedi_insn *insn, unsigned int *data)
1080 {
1081         int i, err;
1082         int chan = CR_CHAN(insn->chanspec);
1083         struct usbdux_private *this_usbduxsub = dev->private;
1084
1085         if (!this_usbduxsub)
1086                 return -EFAULT;
1087
1088         down(&this_usbduxsub->sem);
1089         if (this_usbduxsub->ao_cmd_running) {
1090                 up(&this_usbduxsub->sem);
1091                 return 0;
1092         }
1093
1094         for (i = 0; i < insn->n; i++) {
1095                 /* number of channels: 1 */
1096                 this_usbduxsub->dux_commands[1] = 1;
1097                 /* one 16 bit value */
1098                 *((int16_t *) (this_usbduxsub->dux_commands + 2)) =
1099                     cpu_to_le16(data[i]);
1100                 this_usbduxsub->out_buffer[chan] = data[i];
1101                 /* channel number */
1102                 this_usbduxsub->dux_commands[4] = (chan << 6);
1103                 err = send_dux_commands(dev, SENDDACOMMANDS);
1104                 if (err < 0) {
1105                         up(&this_usbduxsub->sem);
1106                         return err;
1107                 }
1108         }
1109         up(&this_usbduxsub->sem);
1110
1111         return i;
1112 }
1113
1114 static int usbdux_ao_inttrig(struct comedi_device *dev,
1115                              struct comedi_subdevice *s, unsigned int trignum)
1116 {
1117         int ret;
1118         struct usbdux_private *this_usbduxsub = dev->private;
1119
1120         if (!this_usbduxsub)
1121                 return -EFAULT;
1122
1123         down(&this_usbduxsub->sem);
1124         if (trignum != 0) {
1125                 up(&this_usbduxsub->sem);
1126                 return -EINVAL;
1127         }
1128         if (!(this_usbduxsub->ao_cmd_running)) {
1129                 this_usbduxsub->ao_cmd_running = 1;
1130                 ret = usbduxsub_submit_outurbs(dev);
1131                 if (ret < 0) {
1132                         this_usbduxsub->ao_cmd_running = 0;
1133                         up(&this_usbduxsub->sem);
1134                         return ret;
1135                 }
1136                 s->async->inttrig = NULL;
1137         }
1138         up(&this_usbduxsub->sem);
1139         return 1;
1140 }
1141
1142 static int usbdux_ao_cmdtest(struct comedi_device *dev,
1143                              struct comedi_subdevice *s, struct comedi_cmd *cmd)
1144 {
1145         struct usbdux_private *this_usbduxsub = dev->private;
1146         int err = 0;
1147         unsigned int flags;
1148
1149         if (!this_usbduxsub)
1150                 return -EFAULT;
1151
1152         /* Step 1 : check if triggers are trivially valid */
1153
1154         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
1155
1156         if (0) {                /* (this_usbduxsub->high_speed) */
1157                 /* the sampling rate is set by the coversion rate */
1158                 flags = TRIG_FOLLOW;
1159         } else {
1160                 /* start a new scan (output at once) with a timer */
1161                 flags = TRIG_TIMER;
1162         }
1163         err |= cfc_check_trigger_src(&cmd->scan_begin_src, flags);
1164
1165         if (0) {                /* (this_usbduxsub->high_speed) */
1166                 /*
1167                  * in usb-2.0 only one conversion it transmitted
1168                  * but with 8kHz/n
1169                  */
1170                 flags = TRIG_TIMER;
1171         } else {
1172                 /*
1173                  * all conversion events happen simultaneously with
1174                  * a rate of 1kHz/n
1175                  */
1176                 flags = TRIG_NOW;
1177         }
1178         err |= cfc_check_trigger_src(&cmd->convert_src, flags);
1179
1180         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1181         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1182
1183         if (err)
1184                 return 1;
1185
1186         /* Step 2a : make sure trigger sources are unique */
1187
1188         err |= cfc_check_trigger_is_unique(cmd->start_src);
1189         err |= cfc_check_trigger_is_unique(cmd->stop_src);
1190
1191         /* Step 2b : and mutually compatible */
1192
1193         if (err)
1194                 return 2;
1195
1196         /* Step 3: check if arguments are trivially valid */
1197
1198         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
1199
1200         if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
1201                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
1202
1203         if (cmd->scan_begin_src == TRIG_TIMER)
1204                 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
1205                                                  1000000);
1206
1207         /* not used now, is for later use */
1208         if (cmd->convert_src == TRIG_TIMER)
1209                 err |= cfc_check_trigger_arg_min(&cmd->convert_arg, 125000);
1210
1211         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
1212
1213         if (cmd->stop_src == TRIG_COUNT) {
1214                 /* any count is allowed */
1215         } else {
1216                 /* TRIG_NONE */
1217                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
1218         }
1219
1220         if (err)
1221                 return 3;
1222
1223         return 0;
1224 }
1225
1226 static int usbdux_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1227 {
1228         struct comedi_cmd *cmd = &s->async->cmd;
1229         unsigned int chan, gain;
1230         int i, ret;
1231         struct usbdux_private *this_usbduxsub = dev->private;
1232
1233         if (!this_usbduxsub)
1234                 return -EFAULT;
1235
1236         down(&this_usbduxsub->sem);
1237
1238         /* set current channel of the running acquisition to zero */
1239         s->async->cur_chan = 0;
1240         for (i = 0; i < cmd->chanlist_len; ++i) {
1241                 chan = CR_CHAN(cmd->chanlist[i]);
1242                 gain = CR_RANGE(cmd->chanlist[i]);
1243                 if (i >= NUMOUTCHANNELS)
1244                         break;
1245                 this_usbduxsub->dac_commands[i] = (chan << 6);
1246         }
1247
1248         /* we count in steps of 1ms (125us) */
1249         /* 125us mode not used yet */
1250         if (0) {                /* (this_usbduxsub->high_speed) */
1251                 /* 125us */
1252                 /* timing of the conversion itself: every 125 us */
1253                 this_usbduxsub->ao_timer = cmd->convert_arg / 125000;
1254         } else {
1255                 /* 1ms */
1256                 /* timing of the scan: we get all channels at once */
1257                 this_usbduxsub->ao_timer = cmd->scan_begin_arg / 1000000;
1258                 if (this_usbduxsub->ao_timer < 1) {
1259                         up(&this_usbduxsub->sem);
1260                         return -EINVAL;
1261                 }
1262         }
1263         this_usbduxsub->ao_counter = this_usbduxsub->ao_timer;
1264
1265         if (cmd->stop_src == TRIG_COUNT) {
1266                 /* not continuous */
1267                 /* counter */
1268                 /* high speed also scans everything at once */
1269                 if (0) {        /* (this_usbduxsub->high_speed) */
1270                         this_usbduxsub->ao_sample_count =
1271                             (cmd->stop_arg) * (cmd->scan_end_arg);
1272                 } else {
1273                         /* there's no scan as the scan has been */
1274                         /* perf inside the FX2 */
1275                         /* data arrives as one packet */
1276                         this_usbduxsub->ao_sample_count = cmd->stop_arg;
1277                 }
1278                 this_usbduxsub->ao_continous = 0;
1279         } else {
1280                 /* continous acquisition */
1281                 this_usbduxsub->ao_continous = 1;
1282                 this_usbduxsub->ao_sample_count = 0;
1283         }
1284
1285         if (cmd->start_src == TRIG_NOW) {
1286                 /* enable this acquisition operation */
1287                 this_usbduxsub->ao_cmd_running = 1;
1288                 ret = usbduxsub_submit_outurbs(dev);
1289                 if (ret < 0) {
1290                         this_usbduxsub->ao_cmd_running = 0;
1291                         /* fixme: unlink here?? */
1292                         up(&this_usbduxsub->sem);
1293                         return ret;
1294                 }
1295                 s->async->inttrig = NULL;
1296         } else {
1297                 /* TRIG_INT */
1298                 /* submit the urbs later */
1299                 /* wait for an internal signal */
1300                 s->async->inttrig = usbdux_ao_inttrig;
1301         }
1302
1303         up(&this_usbduxsub->sem);
1304         return 0;
1305 }
1306
1307 static int usbdux_dio_insn_config(struct comedi_device *dev,
1308                                   struct comedi_subdevice *s,
1309                                   struct comedi_insn *insn, unsigned int *data)
1310 {
1311         int chan = CR_CHAN(insn->chanspec);
1312
1313         /* The input or output configuration of each digital line is
1314          * configured by a special insn_config instruction.  chanspec
1315          * contains the channel to be changed, and data[0] contains the
1316          * value COMEDI_INPUT or COMEDI_OUTPUT. */
1317
1318         switch (data[0]) {
1319         case INSN_CONFIG_DIO_OUTPUT:
1320                 s->io_bits |= 1 << chan;        /* 1 means Out */
1321                 break;
1322         case INSN_CONFIG_DIO_INPUT:
1323                 s->io_bits &= ~(1 << chan);
1324                 break;
1325         case INSN_CONFIG_DIO_QUERY:
1326                 data[1] =
1327                     (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
1328                 break;
1329         default:
1330                 return -EINVAL;
1331                 break;
1332         }
1333         /* we don't tell the firmware here as it would take 8 frames */
1334         /* to submit the information. We do it in the insn_bits. */
1335         return insn->n;
1336 }
1337
1338 static int usbdux_dio_insn_bits(struct comedi_device *dev,
1339                                 struct comedi_subdevice *s,
1340                                 struct comedi_insn *insn, unsigned int *data)
1341 {
1342
1343         struct usbdux_private *this_usbduxsub = dev->private;
1344         int err;
1345
1346         if (!this_usbduxsub)
1347                 return -EFAULT;
1348
1349         down(&this_usbduxsub->sem);
1350
1351         /* The insn data is a mask in data[0] and the new data
1352          * in data[1], each channel cooresponding to a bit. */
1353         s->state &= ~data[0];
1354         s->state |= data[0] & data[1];
1355         this_usbduxsub->dux_commands[1] = s->io_bits;
1356         this_usbduxsub->dux_commands[2] = s->state;
1357
1358         /* This command also tells the firmware to return */
1359         /* the digital input lines */
1360         err = send_dux_commands(dev, SENDDIOBITSCOMMAND);
1361         if (err < 0) {
1362                 up(&this_usbduxsub->sem);
1363                 return err;
1364         }
1365         err = receive_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND);
1366         if (err < 0) {
1367                 up(&this_usbduxsub->sem);
1368                 return err;
1369         }
1370
1371         data[1] = le16_to_cpu(this_usbduxsub->insn_buffer[1]);
1372         up(&this_usbduxsub->sem);
1373         return insn->n;
1374 }
1375
1376 /* reads the 4 counters, only two are used just now */
1377 static int usbdux_counter_read(struct comedi_device *dev,
1378                                struct comedi_subdevice *s,
1379                                struct comedi_insn *insn, unsigned int *data)
1380 {
1381         struct usbdux_private *this_usbduxsub = dev->private;
1382         int chan = insn->chanspec;
1383         int err;
1384
1385         if (!this_usbduxsub)
1386                 return -EFAULT;
1387
1388         down(&this_usbduxsub->sem);
1389         err = send_dux_commands(dev, READCOUNTERCOMMAND);
1390         if (err < 0) {
1391                 up(&this_usbduxsub->sem);
1392                 return err;
1393         }
1394
1395         err = receive_dux_commands(this_usbduxsub, READCOUNTERCOMMAND);
1396         if (err < 0) {
1397                 up(&this_usbduxsub->sem);
1398                 return err;
1399         }
1400
1401         data[0] = le16_to_cpu(this_usbduxsub->insn_buffer[chan + 1]);
1402         up(&this_usbduxsub->sem);
1403         return 1;
1404 }
1405
1406 static int usbdux_counter_write(struct comedi_device *dev,
1407                                 struct comedi_subdevice *s,
1408                                 struct comedi_insn *insn, unsigned int *data)
1409 {
1410         struct usbdux_private *this_usbduxsub = dev->private;
1411         int err;
1412
1413         if (!this_usbduxsub)
1414                 return -EFAULT;
1415
1416         down(&this_usbduxsub->sem);
1417         this_usbduxsub->dux_commands[1] = insn->chanspec;
1418         *((int16_t *) (this_usbduxsub->dux_commands + 2)) = cpu_to_le16(*data);
1419
1420         err = send_dux_commands(dev, WRITECOUNTERCOMMAND);
1421         if (err < 0) {
1422                 up(&this_usbduxsub->sem);
1423                 return err;
1424         }
1425
1426         up(&this_usbduxsub->sem);
1427
1428         return 1;
1429 }
1430
1431 static int usbdux_counter_config(struct comedi_device *dev,
1432                                  struct comedi_subdevice *s,
1433                                  struct comedi_insn *insn, unsigned int *data)
1434 {
1435         /* nothing to do so far */
1436         return 2;
1437 }
1438
1439 /***********************************/
1440 /* PWM */
1441
1442 static int usbduxsub_unlink_pwm_urbs(struct usbdux_private *usbduxsub_tmp)
1443 {
1444         int err = 0;
1445
1446         if (usbduxsub_tmp && usbduxsub_tmp->urb_pwm) {
1447                 if (usbduxsub_tmp->urb_pwm)
1448                         usb_kill_urb(usbduxsub_tmp->urb_pwm);
1449         }
1450         return err;
1451 }
1452
1453 /* This cancels a running acquisition operation
1454  * in any context.
1455  */
1456 static int usbdux_pwm_stop(struct usbdux_private *this_usbduxsub, int do_unlink)
1457 {
1458         int ret = 0;
1459
1460         if (!this_usbduxsub)
1461                 return -EFAULT;
1462
1463         if (do_unlink)
1464                 ret = usbduxsub_unlink_pwm_urbs(this_usbduxsub);
1465
1466         this_usbduxsub->pwm_cmd_running = 0;
1467
1468         return ret;
1469 }
1470
1471 /* force unlink - is called by comedi */
1472 static int usbdux_pwm_cancel(struct comedi_device *dev,
1473                              struct comedi_subdevice *s)
1474 {
1475         struct usbdux_private *this_usbduxsub = dev->private;
1476         int res = 0;
1477
1478         /* unlink only if it is really running */
1479         res = usbdux_pwm_stop(this_usbduxsub, this_usbduxsub->pwm_cmd_running);
1480
1481         return send_dux_commands(dev, SENDPWMOFF);
1482 }
1483
1484 static void usbduxsub_pwm_irq(struct urb *urb)
1485 {
1486         struct comedi_device *dev = urb->context;
1487         struct usbdux_private *devpriv = dev->private;
1488         int ret;
1489
1490         switch (urb->status) {
1491         case 0:
1492                 /* success */
1493                 break;
1494
1495         case -ECONNRESET:
1496         case -ENOENT:
1497         case -ESHUTDOWN:
1498         case -ECONNABORTED:
1499                 /*
1500                  * after an unlink command, unplug, ... etc
1501                  * no unlink needed here. Already shutting down.
1502                  */
1503                 if (devpriv->pwm_cmd_running)
1504                         usbdux_pwm_stop(devpriv, 0);
1505
1506                 return;
1507
1508         default:
1509                 /* a real error */
1510                 if (devpriv->pwm_cmd_running) {
1511                         dev_err(dev->class_dev,
1512                                 "Non-zero urb status received in pwm intr context: %d\n",
1513                                 urb->status);
1514                         usbdux_pwm_stop(devpriv, 0);
1515                 }
1516                 return;
1517         }
1518
1519         /* are we actually running? */
1520         if (!devpriv->pwm_cmd_running)
1521                 return;
1522
1523         urb->transfer_buffer_length = devpriv->size_pwm_buf;
1524         urb->dev = devpriv->usbdev;
1525         urb->status = 0;
1526         if (devpriv->pwm_cmd_running) {
1527                 ret = usb_submit_urb(urb, GFP_ATOMIC);
1528                 if (ret < 0) {
1529                         dev_err(dev->class_dev,
1530                                 "pwm urb resubm failed in int-cont. ret=%d",
1531                                 ret);
1532                         if (ret == EL2NSYNC)
1533                                 dev_err(dev->class_dev,
1534                                         "buggy USB host controller or bug in IRQ handling!\n");
1535
1536                         /* don't do an unlink here */
1537                         usbdux_pwm_stop(devpriv, 0);
1538                 }
1539         }
1540 }
1541
1542 static int usbduxsub_submit_pwm_urbs(struct comedi_device *dev)
1543 {
1544         struct usbdux_private *devpriv = dev->private;
1545         struct urb *urb = devpriv->urb_pwm;
1546
1547         /* in case of a resubmission after an unlink... */
1548         usb_fill_bulk_urb(urb, devpriv->usbdev,
1549                           usb_sndbulkpipe(devpriv->usbdev, PWM_EP),
1550                           urb->transfer_buffer,
1551                           devpriv->size_pwm_buf,
1552                           usbduxsub_pwm_irq,
1553                           dev);
1554
1555         return usb_submit_urb(urb, GFP_ATOMIC);
1556 }
1557
1558 static int usbdux_pwm_period(struct comedi_device *dev,
1559                              struct comedi_subdevice *s, unsigned int period)
1560 {
1561         struct usbdux_private *this_usbduxsub = dev->private;
1562         int fx2delay = 255;
1563
1564         if (period < MIN_PWM_PERIOD) {
1565                 return -EAGAIN;
1566         } else {
1567                 fx2delay = period / ((int)(6 * 512 * (1.0 / 0.033))) - 6;
1568                 if (fx2delay > 255)
1569                         return -EAGAIN;
1570         }
1571         this_usbduxsub->pwn_delay = fx2delay;
1572         this_usbduxsub->pwm_period = period;
1573
1574         return 0;
1575 }
1576
1577 /* is called from insn so there's no need to do all the sanity checks */
1578 static int usbdux_pwm_start(struct comedi_device *dev,
1579                             struct comedi_subdevice *s)
1580 {
1581         int ret, i;
1582         struct usbdux_private *this_usbduxsub = dev->private;
1583
1584         if (this_usbduxsub->pwm_cmd_running) {
1585                 /* already running */
1586                 return 0;
1587         }
1588
1589         this_usbduxsub->dux_commands[1] = ((int8_t) this_usbduxsub->pwn_delay);
1590         ret = send_dux_commands(dev, SENDPWMON);
1591         if (ret < 0)
1592                 return ret;
1593
1594         /* initialise the buffer */
1595         for (i = 0; i < this_usbduxsub->size_pwm_buf; i++)
1596                 ((char *)(this_usbduxsub->urb_pwm->transfer_buffer))[i] = 0;
1597
1598         this_usbduxsub->pwm_cmd_running = 1;
1599         ret = usbduxsub_submit_pwm_urbs(dev);
1600         if (ret < 0) {
1601                 this_usbduxsub->pwm_cmd_running = 0;
1602                 return ret;
1603         }
1604         return 0;
1605 }
1606
1607 /* generates the bit pattern for PWM with the optional sign bit */
1608 static int usbdux_pwm_pattern(struct comedi_device *dev,
1609                               struct comedi_subdevice *s, int channel,
1610                               unsigned int value, unsigned int sign)
1611 {
1612         struct usbdux_private *this_usbduxsub = dev->private;
1613         int i, szbuf;
1614         char *p_buf;
1615         char pwm_mask;
1616         char sgn_mask;
1617         char c;
1618
1619         if (!this_usbduxsub)
1620                 return -EFAULT;
1621
1622         /* this is the DIO bit which carries the PWM data */
1623         pwm_mask = (1 << channel);
1624         /* this is the DIO bit which carries the optional direction bit */
1625         sgn_mask = (16 << channel);
1626         /* this is the buffer which will be filled with the with bit */
1627         /* pattern for one period */
1628         szbuf = this_usbduxsub->size_pwm_buf;
1629         p_buf = (char *)(this_usbduxsub->urb_pwm->transfer_buffer);
1630         for (i = 0; i < szbuf; i++) {
1631                 c = *p_buf;
1632                 /* reset bits */
1633                 c = c & (~pwm_mask);
1634                 /* set the bit as long as the index is lower than the value */
1635                 if (i < value)
1636                         c = c | pwm_mask;
1637                 /* set the optional sign bit for a relay */
1638                 if (!sign) {
1639                         /* positive value */
1640                         c = c & (~sgn_mask);
1641                 } else {
1642                         /* negative value */
1643                         c = c | sgn_mask;
1644                 }
1645                 *(p_buf++) = c;
1646         }
1647         return 1;
1648 }
1649
1650 static int usbdux_pwm_write(struct comedi_device *dev,
1651                             struct comedi_subdevice *s,
1652                             struct comedi_insn *insn, unsigned int *data)
1653 {
1654         struct usbdux_private *this_usbduxsub = dev->private;
1655
1656         if (!this_usbduxsub)
1657                 return -EFAULT;
1658
1659         if ((insn->n) != 1) {
1660                 /*
1661                  * doesn't make sense to have more than one value here because
1662                  * it would just overwrite the PWM buffer a couple of times
1663                  */
1664                 return -EINVAL;
1665         }
1666
1667         /*
1668          * the sign is set via a special INSN only, this gives us 8 bits for
1669          * normal operation
1670          * relay sign 0 by default
1671          */
1672         return usbdux_pwm_pattern(dev, s, CR_CHAN(insn->chanspec), data[0], 0);
1673 }
1674
1675 static int usbdux_pwm_read(struct comedi_device *x1,
1676                            struct comedi_subdevice *x2, struct comedi_insn *x3,
1677                            unsigned int *x4)
1678 {
1679         /* not needed */
1680         return -EINVAL;
1681 };
1682
1683 /* switches on/off PWM */
1684 static int usbdux_pwm_config(struct comedi_device *dev,
1685                              struct comedi_subdevice *s,
1686                              struct comedi_insn *insn, unsigned int *data)
1687 {
1688         struct usbdux_private *this_usbduxsub = dev->private;
1689         switch (data[0]) {
1690         case INSN_CONFIG_ARM:
1691                 /* switch it on */
1692                 /*
1693                  * if not zero the PWM is limited to a certain time which is
1694                  * not supported here
1695                  */
1696                 if (data[1] != 0)
1697                         return -EINVAL;
1698                 return usbdux_pwm_start(dev, s);
1699         case INSN_CONFIG_DISARM:
1700                 return usbdux_pwm_cancel(dev, s);
1701         case INSN_CONFIG_GET_PWM_STATUS:
1702                 /*
1703                  * to check if the USB transmission has failed or in case PWM
1704                  * was limited to n cycles to check if it has terminated
1705                  */
1706                 data[1] = this_usbduxsub->pwm_cmd_running;
1707                 return 0;
1708         case INSN_CONFIG_PWM_SET_PERIOD:
1709                 return usbdux_pwm_period(dev, s, data[1]);
1710         case INSN_CONFIG_PWM_GET_PERIOD:
1711                 data[1] = this_usbduxsub->pwm_period;
1712                 return 0;
1713         case INSN_CONFIG_PWM_SET_H_BRIDGE:
1714                 /* value in the first byte and the sign in the second for a
1715                    relay */
1716                 return usbdux_pwm_pattern(dev, s,
1717                                           /* the channel number */
1718                                           CR_CHAN(insn->chanspec),
1719                                           /* actual PWM data */
1720                                           data[1],
1721                                           /* just a sign */
1722                                           (data[2] != 0));
1723         case INSN_CONFIG_PWM_GET_H_BRIDGE:
1724                 /* values are not kept in this driver, nothing to return here */
1725                 return -EINVAL;
1726         }
1727         return -EINVAL;
1728 }
1729
1730 /* end of PWM */
1731 /*****************************************************************/
1732
1733 static int usbdux_alloc_usb_buffers(struct usbdux_private *devpriv)
1734 {
1735         struct urb *urb;
1736         int i;
1737
1738         /* create space for the commands of the DA converter */
1739         devpriv->dac_commands = kzalloc(NUMOUTCHANNELS, GFP_KERNEL);
1740         if (!devpriv->dac_commands)
1741                 return -ENOMEM;
1742
1743         /* create space for the commands going to the usb device */
1744         devpriv->dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL);
1745         if (!devpriv->dux_commands)
1746                 return -ENOMEM;
1747
1748         /* create space for the in buffer and set it to zero */
1749         devpriv->in_buffer = kzalloc(SIZEINBUF, GFP_KERNEL);
1750         if (!devpriv->in_buffer)
1751                 return -ENOMEM;
1752
1753         /* create space of the instruction buffer */
1754         devpriv->insn_buffer = kzalloc(SIZEINSNBUF, GFP_KERNEL);
1755         if (!devpriv->insn_buffer)
1756                 return -ENOMEM;
1757
1758         /* create space for the outbuffer */
1759         devpriv->out_buffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
1760         if (!devpriv->out_buffer)
1761                 return -ENOMEM;
1762
1763         /* in urbs */
1764         devpriv->urb_in = kcalloc(devpriv->num_in_buffers, sizeof(*urb),
1765                                   GFP_KERNEL);
1766         if (!devpriv->urb_in)
1767                 return -ENOMEM;
1768
1769         for (i = 0; i < devpriv->num_in_buffers; i++) {
1770                 /* one frame: 1ms */
1771                 urb = usb_alloc_urb(1, GFP_KERNEL);
1772                 if (!urb)
1773                         return -ENOMEM;
1774                 devpriv->urb_in[i] = urb;
1775
1776                 urb->dev = devpriv->usbdev;
1777                 /* will be filled later with a pointer to the comedi-device */
1778                 /* and ONLY then the urb should be submitted */
1779                 urb->context = NULL;
1780                 urb->pipe = usb_rcvisocpipe(devpriv->usbdev, ISOINEP);
1781                 urb->transfer_flags = URB_ISO_ASAP;
1782                 urb->transfer_buffer = kzalloc(SIZEINBUF, GFP_KERNEL);
1783                 if (!urb->transfer_buffer)
1784                         return -ENOMEM;
1785
1786                 urb->complete = usbduxsub_ai_isoc_irq;
1787                 urb->number_of_packets = 1;
1788                 urb->transfer_buffer_length = SIZEINBUF;
1789                 urb->iso_frame_desc[0].offset = 0;
1790                 urb->iso_frame_desc[0].length = SIZEINBUF;
1791         }
1792
1793         /* out urbs */
1794         devpriv->urb_out = kcalloc(devpriv->num_out_buffers, sizeof(*urb),
1795                                    GFP_KERNEL);
1796         if (!devpriv->urb_out)
1797                 return -ENOMEM;
1798
1799         for (i = 0; i < devpriv->num_out_buffers; i++) {
1800                 /* one frame: 1ms */
1801                 urb = usb_alloc_urb(1, GFP_KERNEL);
1802                 if (!urb)
1803                         return -ENOMEM;
1804                 devpriv->urb_out[i] = urb;
1805
1806                 urb->dev = devpriv->usbdev;
1807                 /* will be filled later with a pointer to the comedi-device */
1808                 /* and ONLY then the urb should be submitted */
1809                 urb->context = NULL;
1810                 urb->pipe = usb_sndisocpipe(devpriv->usbdev, ISOOUTEP);
1811                 urb->transfer_flags = URB_ISO_ASAP;
1812                 urb->transfer_buffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
1813                 if (!urb->transfer_buffer)
1814                         return -ENOMEM;
1815
1816                 urb->complete = usbduxsub_ao_isoc_irq;
1817                 urb->number_of_packets = 1;
1818                 urb->transfer_buffer_length = SIZEOUTBUF;
1819                 urb->iso_frame_desc[0].offset = 0;
1820                 urb->iso_frame_desc[0].length = SIZEOUTBUF;
1821                 if (devpriv->high_speed)
1822                         urb->interval = 8;      /* uframes */
1823                 else
1824                         urb->interval = 1;      /* frames */
1825         }
1826
1827         /* pwm */
1828         if (devpriv->size_pwm_buf) {
1829                 urb = usb_alloc_urb(0, GFP_KERNEL);
1830                 if (!urb)
1831                         return -ENOMEM;
1832                 devpriv->urb_pwm = urb;
1833
1834                 /* max bulk ep size in high speed */
1835                 urb->transfer_buffer = kzalloc(devpriv->size_pwm_buf,
1836                                                GFP_KERNEL);
1837                 if (!urb->transfer_buffer)
1838                         return -ENOMEM;
1839         }
1840
1841         return 0;
1842 }
1843
1844 static void usbdux_free_usb_buffers(struct usbdux_private *devpriv)
1845 {
1846         struct urb *urb;
1847         int i;
1848
1849         urb = devpriv->urb_pwm;
1850         if (urb) {
1851                 kfree(urb->transfer_buffer);
1852                 usb_kill_urb(urb);
1853                 usb_free_urb(urb);
1854         }
1855         if (devpriv->urb_out) {
1856                 for (i = 0; i < devpriv->num_out_buffers; i++) {
1857                         urb = devpriv->urb_out[i];
1858                         if (urb) {
1859                                 kfree(urb->transfer_buffer);
1860                                 usb_kill_urb(urb);
1861                                 usb_free_urb(urb);
1862                         }
1863                 }
1864                 kfree(devpriv->urb_out);
1865         }
1866         if (devpriv->urb_in) {
1867                 for (i = 0; i < devpriv->num_in_buffers; i++) {
1868                         urb = devpriv->urb_in[i];
1869                         if (urb) {
1870                                 kfree(urb->transfer_buffer);
1871                                 usb_kill_urb(urb);
1872                                 usb_free_urb(urb);
1873                         }
1874                 }
1875                 kfree(devpriv->urb_in);
1876         }
1877         kfree(devpriv->out_buffer);
1878         kfree(devpriv->insn_buffer);
1879         kfree(devpriv->in_buffer);
1880         kfree(devpriv->dux_commands);
1881         kfree(devpriv->dac_commands);
1882 }
1883
1884 static int usbdux_auto_attach(struct comedi_device *dev,
1885                               unsigned long context_unused)
1886 {
1887         struct usb_interface *intf = comedi_to_usb_interface(dev);
1888         struct usb_device *usb = comedi_to_usb_dev(dev);
1889         struct usbdux_private *devpriv;
1890         struct comedi_subdevice *s;
1891         int ret;
1892
1893         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1894         if (!devpriv)
1895                 return -ENOMEM;
1896
1897         sema_init(&devpriv->sem, 1);
1898
1899         devpriv->usbdev = usb;
1900         devpriv->ifnum = intf->altsetting->desc.bInterfaceNumber;
1901         usb_set_intfdata(intf, devpriv);
1902
1903         devpriv->high_speed = (devpriv->usbdev->speed == USB_SPEED_HIGH);
1904         if (devpriv->high_speed) {
1905                 devpriv->num_in_buffers = NUMOFINBUFFERSHIGH;
1906                 devpriv->num_out_buffers = NUMOFOUTBUFFERSHIGH;
1907                 devpriv->size_pwm_buf = 512;
1908         } else {
1909                 devpriv->num_in_buffers = NUMOFINBUFFERSFULL;
1910                 devpriv->num_out_buffers = NUMOFOUTBUFFERSFULL;
1911         }
1912
1913         ret = usbdux_alloc_usb_buffers(devpriv);
1914         if (ret)
1915                 return ret;
1916
1917         /* setting to alternate setting 3: enabling iso ep and bulk ep. */
1918         ret = usb_set_interface(devpriv->usbdev, devpriv->ifnum, 3);
1919         if (ret < 0) {
1920                 dev_err(dev->class_dev,
1921                         "could not set alternate setting 3 in high speed\n");
1922                 return ret;
1923         }
1924
1925         ret = comedi_load_firmware(dev, &usb->dev, FIRMWARE,
1926                                    usbdux_firmware_upload, 0);
1927         if (ret < 0)
1928                 return ret;
1929
1930         ret = comedi_alloc_subdevices(dev, (devpriv->high_speed) ? 5 : 4);
1931         if (ret)
1932                 return ret;
1933
1934         /* Analog Input subdevice */
1935         s = &dev->subdevices[0];
1936         dev->read_subdev = s;
1937         s->type         = COMEDI_SUBD_AI;
1938         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
1939         s->n_chan       = 8;
1940         s->maxdata      = 0x0fff;
1941         s->len_chanlist = 8;
1942         s->range_table  = &range_usbdux_ai_range;
1943         s->insn_read    = usbdux_ai_insn_read;
1944         s->do_cmdtest   = usbdux_ai_cmdtest;
1945         s->do_cmd       = usbdux_ai_cmd;
1946         s->cancel       = usbdux_ai_cancel;
1947
1948         /* Analog Output subdevice */
1949         s = &dev->subdevices[1];
1950         dev->write_subdev = s;
1951         s->type         = COMEDI_SUBD_AO;
1952         s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
1953         s->n_chan       = 4;
1954         s->maxdata      = 0x0fff;
1955         s->len_chanlist = 4;
1956         s->range_table  = &range_usbdux_ao_range;
1957         s->do_cmdtest   = usbdux_ao_cmdtest;
1958         s->do_cmd       = usbdux_ao_cmd;
1959         s->cancel       = usbdux_ao_cancel;
1960         s->insn_read    = usbdux_ao_insn_read;
1961         s->insn_write   = usbdux_ao_insn_write;
1962
1963         /* Digital I/O subdevice */
1964         s = &dev->subdevices[2];
1965         s->type         = COMEDI_SUBD_DIO;
1966         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
1967         s->n_chan       = 8;
1968         s->maxdata      = 1;
1969         s->range_table  = &range_digital;
1970         s->insn_bits    = usbdux_dio_insn_bits;
1971         s->insn_config  = usbdux_dio_insn_config;
1972
1973         /* Counter subdevice */
1974         s = &dev->subdevices[3];
1975         s->type         = COMEDI_SUBD_COUNTER;
1976         s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
1977         s->n_chan       = 4;
1978         s->maxdata      = 0xffff;
1979         s->insn_read    = usbdux_counter_read;
1980         s->insn_write   = usbdux_counter_write;
1981         s->insn_config  = usbdux_counter_config;
1982
1983         if (devpriv->high_speed) {
1984                 /* PWM subdevice */
1985                 s = &dev->subdevices[4];
1986                 s->type         = COMEDI_SUBD_PWM;
1987                 s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
1988                 s->n_chan       = 8;
1989                 s->maxdata      = devpriv->size_pwm_buf;
1990                 s->insn_write   = usbdux_pwm_write;
1991                 s->insn_read    = usbdux_pwm_read;
1992                 s->insn_config  = usbdux_pwm_config;
1993
1994                 usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
1995         }
1996
1997         return 0;
1998 }
1999
2000 static void usbdux_detach(struct comedi_device *dev)
2001 {
2002         struct usb_interface *intf = comedi_to_usb_interface(dev);
2003         struct usbdux_private *devpriv = dev->private;
2004
2005         if (devpriv) {
2006                 down(&devpriv->sem);
2007
2008                 usb_set_intfdata(intf, NULL);
2009
2010                 if (devpriv->pwm_cmd_running)
2011                         usbduxsub_unlink_pwm_urbs(devpriv);
2012                 if (devpriv->ao_cmd_running)
2013                         usbduxsub_unlink_outurbs(devpriv);
2014                 if (devpriv->ai_cmd_running)
2015                         usbduxsub_unlink_inurbs(devpriv);
2016
2017                 usbdux_free_usb_buffers(devpriv);
2018
2019                 up(&devpriv->sem);
2020         }
2021 }
2022
2023 static struct comedi_driver usbdux_driver = {
2024         .driver_name    = "usbdux",
2025         .module         = THIS_MODULE,
2026         .auto_attach    = usbdux_auto_attach,
2027         .detach         = usbdux_detach,
2028 };
2029
2030 static int usbdux_usb_probe(struct usb_interface *intf,
2031                             const struct usb_device_id *id)
2032 {
2033         return comedi_usb_auto_config(intf, &usbdux_driver, 0);
2034 }
2035
2036 static const struct usb_device_id usbdux_usb_table[] = {
2037         { USB_DEVICE(0x13d8, 0x0001) },
2038         { USB_DEVICE(0x13d8, 0x0002) },
2039         { }
2040 };
2041 MODULE_DEVICE_TABLE(usb, usbdux_usb_table);
2042
2043 static struct usb_driver usbdux_usb_driver = {
2044         .name           = "usbdux",
2045         .probe          = usbdux_usb_probe,
2046         .disconnect     = comedi_usb_auto_unconfig,
2047         .id_table       = usbdux_usb_table,
2048 };
2049 module_comedi_usb_driver(usbdux_driver, usbdux_usb_driver);
2050
2051 MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
2052 MODULE_DESCRIPTION("Stirling/ITL USB-DUX -- Bernd.Porr@f2s.com");
2053 MODULE_LICENSE("GPL");
2054 MODULE_FIRMWARE(FIRMWARE);