drivers/staging/comedi/drivers/usbduxsigma.c

   1 /*
   2  * usbduxsigma.c
   3  * Copyright (C) 2011 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 /*
  17  * Driver: usbduxsigma
  18  * Description: University of Stirling USB DAQ & INCITE Technology Limited
  19  * Devices: (ITL) USB-DUX [usbduxsigma]
  20  * Author: Bernd Porr <BerndPorr@f2s.com>
  21  * Updated: 8 Nov 2011
  22  * Status: testing
  23  */
  24
  25 /*
  26  * I must give credit here to Chris Baugher who
  27  * wrote the driver for AT-MIO-16d. I used some parts of this
  28  * driver. I also must give credits to David Brownell
  29  * who supported me with the USB development.
  30  *
  31  * Note: the raw data from the A/D converter is 24 bit big endian
  32  * anything else is little endian to/from the dux board
  33  *
  34  *
  35  * Revision history:
  36  *   0.1: initial version
  37  *   0.2: all basic functions implemented, digital I/O only for one port
  38  *   0.3: proper vendor ID and driver name
  39  *   0.4: fixed D/A voltage range
  40  *   0.5: various bug fixes, health check at startup
  41  *   0.6: corrected wrong input range
  42  */
  43
  44 #include <linux/kernel.h>
  45 #include <linux/module.h>
  46 #include <linux/slab.h>
  47 #include <linux/input.h>
  48 #include <linux/usb.h>
  49 #include <linux/fcntl.h>
  50 #include <linux/compiler.h>
  51
  52 #include "comedi_fc.h"
  53 #include "../comedidev.h"
  54
  55 /* timeout for the USB-transfer in ms*/
  56 #define BULK_TIMEOUT 1000
  57
  58 /* constants for "firmware" upload and download */
  59 #define FIRMWARE                "usbduxsigma_firmware.bin"
  60 #define FIRMWARE_MAX_LEN        0x4000
  61 #define USBDUXSUB_FIRMWARE      0xa0
  62 #define VENDOR_DIR_IN           0xc0
  63 #define VENDOR_DIR_OUT          0x40
  64
  65 /* internal addresses of the 8051 processor */
  66 #define USBDUXSUB_CPUCS 0xE600
  67
  68 /* 300Hz max frequ under PWM */
  69 #define MIN_PWM_PERIOD  ((long)(1E9/300))
  70
  71 /* Default PWM frequency */
  72 #define PWM_DEFAULT_PERIOD ((long)(1E9/100))
  73
  74 /* Number of channels (16 AD and offset)*/
  75 #define NUMCHANNELS 16
  76
  77 #define USBDUXSIGMA_NUM_AO_CHAN         4
  78
  79 /* Size of one A/D value */
  80 #define SIZEADIN          ((sizeof(uint32_t)))
  81
  82 /*
  83  * Size of the async input-buffer IN BYTES, the DIO state is transmitted
  84  * as the first byte.
  85  */
  86 #define SIZEINBUF         (((NUMCHANNELS+1)*SIZEADIN))
  87
  88 /* 16 bytes. */
  89 #define SIZEINSNBUF       16
  90
  91 /* Number of DA channels */
  92 #define NUMOUTCHANNELS    8
  93
  94 /* size of one value for the D/A converter: channel and value */
  95 #define SIZEDAOUT          ((sizeof(uint8_t)+sizeof(uint16_t)))
  96
  97 /*
  98  * Size of the output-buffer in bytes
  99  * Actually only the first 4 triplets are used but for the
 100  * high speed mode we need to pad it to 8 (microframes).
 101  */
 102 #define SIZEOUTBUF         ((8*SIZEDAOUT))
 103
 104 /*
 105  * Size of the buffer for the dux commands: just now max size is determined
 106  * by the analogue out + command byte + panic bytes...
 107  */
 108 #define SIZEOFDUXBUFFER    ((8*SIZEDAOUT+2))
 109
 110 /* Number of in-URBs which receive the data: min=2 */
 111 #define NUMOFINBUFFERSFULL     5
 112
 113 /* Number of out-URBs which send the data: min=2 */
 114 #define NUMOFOUTBUFFERSFULL    5
 115
 116 /* Number of in-URBs which receive the data: min=5 */
 117 /* must have more buffers due to buggy USB ctr */
 118 #define NUMOFINBUFFERSHIGH     10
 119
 120 /* Number of out-URBs which send the data: min=5 */
 121 /* must have more buffers due to buggy USB ctr */
 122 #define NUMOFOUTBUFFERSHIGH    10
 123
 124 /* number of retries to get the right dux command */
 125 #define RETRIES 10
 126
 127 /* bulk transfer commands to usbduxsigma */
 128 #define USBBUXSIGMA_AD_CMD              0
 129 #define USBDUXSIGMA_DA_CMD              1
 130 #define USBDUXSIGMA_DIO_CFG_CMD         2
 131 #define USBDUXSIGMA_DIO_BITS_CMD        3
 132 #define USBDUXSIGMA_SINGLE_AD_CMD       4
 133 #define USBDUXSIGMA_PWM_ON_CMD          7
 134 #define USBDUXSIGMA_PWM_OFF_CMD         8
 135
 136 static const struct comedi_lrange usbduxsigma_ai_range = {
 137         1, {
 138                 BIP_RANGE(2.65 / 2.0)
 139         }
 140 };
 141
 142 struct usbduxsigma_private {
 143         /* actual number of in-buffers */
 144         int n_ai_urbs;
 145         /* actual number of out-buffers */
 146         int n_ao_urbs;
 147         /* ISO-transfer handling: buffers */
 148         struct urb **ai_urbs;
 149         struct urb **ao_urbs;
 150         /* pwm-transfer handling */
 151         struct urb *pwm_urb;
 152         /* PWM period */
 153         unsigned int pwm_period;
 154         /* PWM internal delay for the GPIF in the FX2 */
 155         uint8_t pwm_delay;
 156         /* size of the PWM buffer which holds the bit pattern */
 157         int pwm_buf_sz;
 158         /* input buffer for the ISO-transfer */
 159         uint32_t *in_buf;
 160         /* input buffer for single insn */
 161         uint8_t *insn_buf;
 162
 163         uint8_t ao_chanlist[USBDUXSIGMA_NUM_AO_CHAN];
 164         unsigned int ao_readback[USBDUXSIGMA_NUM_AO_CHAN];
 165
 166         unsigned high_speed:1;
 167         unsigned ai_cmd_running:1;
 168         unsigned ai_continuous:1;
 169         unsigned ao_cmd_running:1;
 170         unsigned ao_continuous:1;
 171         unsigned pwm_cmd_running:1;
 172
 173         /* number of samples to acquire */
 174         int ai_sample_count;
 175         int ao_sample_count;
 176         /* time between samples in units of the timer */
 177         unsigned int ai_timer;
 178         unsigned int ao_timer;
 179         /* counter between acquisitions */
 180         unsigned int ai_counter;
 181         unsigned int ao_counter;
 182         /* interval in frames/uframes */
 183         unsigned int ai_interval;
 184         /* commands */
 185         uint8_t *dux_commands;
 186         struct semaphore sem;
 187 };
 188
 189 static void usbduxsigma_unlink_urbs(struct urb **urbs, int num_urbs)
 190 {
 191         int i;
 192
 193         for (i = 0; i < num_urbs; i++)
 194                 usb_kill_urb(urbs[i]);
 195 }
 196
 197 static void usbduxsigma_ai_stop(struct comedi_device *dev, int do_unlink)
 198 {
 199         struct usbduxsigma_private *devpriv = dev->private;
 200
 201         if (do_unlink && devpriv->ai_urbs)
 202                 usbduxsigma_unlink_urbs(devpriv->ai_urbs, devpriv->n_ai_urbs);
 203
 204         devpriv->ai_cmd_running = 0;
 205 }
 206
 207 static int usbduxsigma_ai_cancel(struct comedi_device *dev,
 208                                  struct comedi_subdevice *s)
 209 {
 210         struct usbduxsigma_private *devpriv = dev->private;
 211
 212         down(&devpriv->sem);
 213         /* unlink only if it is really running */
 214         usbduxsigma_ai_stop(dev, devpriv->ai_cmd_running);
 215         up(&devpriv->sem);
 216
 217         return 0;
 218 }
 219
 220 static void usbduxsigma_ai_urb_complete(struct urb *urb)
 221 {
 222         struct comedi_device *dev = urb->context;
 223         struct usbduxsigma_private *devpriv = dev->private;
 224         struct comedi_subdevice *s = dev->read_subdev;
 225         unsigned int dio_state;
 226         uint32_t val;
 227         int ret;
 228         int i;
 229
 230         /* first we test if something unusual has just happened */
 231         switch (urb->status) {
 232         case 0:
 233                 /* copy the result in the transfer buffer */
 234                 memcpy(devpriv->in_buf, urb->transfer_buffer, SIZEINBUF);
 235                 break;
 236         case -EILSEQ:
 237                 /*
 238                  * error in the ISOchronous data
 239                  * we don't copy the data into the transfer buffer
 240                  * and recycle the last data byte
 241                  */
 242                 dev_dbg(dev->class_dev, "CRC error in ISO IN stream\n");
 243
 244                 break;
 245
 246         case -ECONNRESET:
 247         case -ENOENT:
 248         case -ESHUTDOWN:
 249         case -ECONNABORTED:
 250                 /* happens after an unlink command */
 251                 if (devpriv->ai_cmd_running) {
 252                         usbduxsigma_ai_stop(dev, 0);    /* w/o unlink */
 253                         /* we are still running a command, tell comedi */
 254                         s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR);
 255                         comedi_event(dev, s);
 256                 }
 257                 return;
 258
 259         default:
 260                 /*
 261                  * a real error on the bus
 262                  * pass error to comedi if we are really running a command
 263                  */
 264                 if (devpriv->ai_cmd_running) {
 265                         dev_err(dev->class_dev,
 266                                 "%s: non-zero urb status (%d)\n",
 267                                 __func__, urb->status);
 268                         usbduxsigma_ai_stop(dev, 0);    /* w/o unlink */
 269                         s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR);
 270                         comedi_event(dev, s);
 271                 }
 272                 return;
 273         }
 274
 275         if (unlikely(!devpriv->ai_cmd_running))
 276                 return;
 277
 278         urb->dev = comedi_to_usb_dev(dev);
 279
 280         ret = usb_submit_urb(urb, GFP_ATOMIC);
 281         if (unlikely(ret < 0)) {
 282                 dev_err(dev->class_dev, "%s: urb resubmit failed (%d)\n",
 283                         __func__, ret);
 284                 if (ret == -EL2NSYNC)
 285                         dev_err(dev->class_dev,
 286                                 "buggy USB host controller or bug in IRQ handler\n");
 287                 usbduxsigma_ai_stop(dev, 0);    /* w/o unlink */
 288                 s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR);
 289                 comedi_event(dev, s);
 290                 return;
 291         }
 292
 293         /* get the state of the dio pins to allow external trigger */
 294         dio_state = be32_to_cpu(devpriv->in_buf[0]);
 295
 296         devpriv->ai_counter--;
 297         if (likely(devpriv->ai_counter > 0))
 298                 return;
 299
 300         /* timer zero, transfer measurements to comedi */
 301         devpriv->ai_counter = devpriv->ai_timer;
 302
 303         if (!devpriv->ai_continuous) {
 304                 /* not continuous, fixed number of samples */
 305                 devpriv->ai_sample_count--;
 306                 if (devpriv->ai_sample_count < 0) {
 307                         usbduxsigma_ai_stop(dev, 0);    /* w/o unlink */
 308                         /* acquistion is over, tell comedi */
 309                         s->async->events |= COMEDI_CB_EOA;
 310                         comedi_event(dev, s);
 311                         return;
 312                 }
 313         }
 314
 315         /* get the data from the USB bus and hand it over to comedi */
 316         for (i = 0; i < s->async->cmd.chanlist_len; i++) {
 317                 /* transfer data, note first byte is the DIO state */
 318                 val = be32_to_cpu(devpriv->in_buf[i+1]);
 319                 val &= 0x00ffffff;      /* strip status byte */
 320                 val ^= 0x00800000;      /* convert to unsigned */
 321
 322                 ret = cfc_write_array_to_buffer(s, &val, sizeof(uint32_t));
 323                 if (unlikely(ret == 0)) {
 324                         /* buffer overflow */
 325                         usbduxsigma_ai_stop(dev, 0);    /* w/o unlink */
 326                         return;
 327                 }
 328         }
 329         /* tell comedi that data is there */
 330         s->async->events |= (COMEDI_CB_BLOCK | COMEDI_CB_EOS);
 331         comedi_event(dev, s);
 332 }
 333
 334 static void usbduxsigma_ao_stop(struct comedi_device *dev, int do_unlink)
 335 {
 336         struct usbduxsigma_private *devpriv = dev->private;
 337
 338         if (do_unlink && devpriv->ao_urbs)
 339                 usbduxsigma_unlink_urbs(devpriv->ao_urbs, devpriv->n_ao_urbs);
 340
 341         devpriv->ao_cmd_running = 0;
 342 }
 343
 344 static int usbduxsigma_ao_cancel(struct comedi_device *dev,
 345                                  struct comedi_subdevice *s)
 346 {
 347         struct usbduxsigma_private *devpriv = dev->private;
 348
 349         down(&devpriv->sem);
 350         /* unlink only if it is really running */
 351         usbduxsigma_ao_stop(dev, devpriv->ao_cmd_running);
 352         up(&devpriv->sem);
 353
 354         return 0;
 355 }
 356
 357 static void usbduxsigma_ao_urb_complete(struct urb *urb)
 358 {
 359         struct comedi_device *dev = urb->context;
 360         struct usbduxsigma_private *devpriv = dev->private;
 361         struct comedi_subdevice *s = dev->write_subdev;
 362         uint8_t *datap;
 363         int len;
 364         int ret;
 365         int i;
 366
 367         switch (urb->status) {
 368         case 0:
 369                 /* success */
 370                 break;
 371
 372         case -ECONNRESET:
 373         case -ENOENT:
 374         case -ESHUTDOWN:
 375         case -ECONNABORTED:
 376                 /* happens after an unlink command */
 377                 if (devpriv->ao_cmd_running) {
 378                         usbduxsigma_ao_stop(dev, 0);    /* w/o unlink */
 379                         s->async->events |= COMEDI_CB_EOA;
 380                         comedi_event(dev, s);
 381                 }
 382                 return;
 383
 384         default:
 385                 /* a real error */
 386                 if (devpriv->ao_cmd_running) {
 387                         dev_err(dev->class_dev,
 388                                 "%s: non-zero urb status (%d)\n",
 389                                 __func__, urb->status);
 390                         usbduxsigma_ao_stop(dev, 0);    /* w/o unlink */
 391                         s->async->events |= (COMEDI_CB_ERROR | COMEDI_CB_EOA);
 392                         comedi_event(dev, s);
 393                 }
 394                 return;
 395         }
 396
 397         if (!devpriv->ao_cmd_running)
 398                 return;
 399
 400         devpriv->ao_counter--;
 401         if ((int)devpriv->ao_counter <= 0) {
 402                 /* timer zero, transfer from comedi */
 403                 devpriv->ao_counter = devpriv->ao_timer;
 404
 405                 if (!devpriv->ao_continuous) {
 406                         /* not continuous, fixed number of samples */
 407                         devpriv->ao_sample_count--;
 408                         if (devpriv->ao_sample_count < 0) {
 409                                 usbduxsigma_ao_stop(dev, 0);    /* w/o unlink */
 410                                 /* acquistion is over, tell comedi */
 411                                 s->async->events |= COMEDI_CB_EOA;
 412                                 comedi_event(dev, s);
 413                                 return;
 414                         }
 415                 }
 416
 417                 /* transmit data to the USB bus */
 418                 datap = urb->transfer_buffer;
 419                 len = s->async->cmd.chanlist_len;
 420                 *datap++ = len;
 421                 for (i = 0; i < len; i++) {
 422                         unsigned int chan = devpriv->ao_chanlist[i];
 423                         unsigned short val;
 424
 425                         ret = comedi_buf_get(s->async, &val);
 426                         if (ret < 0) {
 427                                 dev_err(dev->class_dev, "buffer underflow\n");
 428                                 s->async->events |= (COMEDI_CB_EOA |
 429                                                      COMEDI_CB_OVERFLOW);
 430                         }
 431                         *datap++ = val;
 432                         *datap++ = chan;
 433                         devpriv->ao_readback[chan] = val;
 434
 435                         s->async->events |= COMEDI_CB_BLOCK;
 436                         comedi_event(dev, s);
 437                 }
 438         }
 439
 440         urb->transfer_buffer_length = SIZEOUTBUF;
 441         urb->dev = comedi_to_usb_dev(dev);
 442         urb->status = 0;
 443         if (devpriv->high_speed)
 444                 urb->interval = 8;      /* uframes */
 445         else
 446                 urb->interval = 1;      /* frames */
 447         urb->number_of_packets = 1;
 448         urb->iso_frame_desc[0].offset = 0;
 449         urb->iso_frame_desc[0].length = SIZEOUTBUF;
 450         urb->iso_frame_desc[0].status = 0;
 451         ret = usb_submit_urb(urb, GFP_ATOMIC);
 452         if (ret < 0) {
 453                 dev_err(dev->class_dev,
 454                         "%s: urb resubmit failed (%d)\n",
 455                         __func__, ret);
 456                 if (ret == EL2NSYNC)
 457                         dev_err(dev->class_dev,
 458                                 "buggy USB host controller or bug in IRQ handler\n");
 459                 usbduxsigma_ao_stop(dev, 0);    /* w/o unlink */
 460                 s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR);
 461                 comedi_event(dev, s);
 462         }
 463 }
 464
 465 static int usbduxsigma_submit_urbs(struct comedi_device *dev,
 466                                    struct urb **urbs, int num_urbs,
 467                                    int input_urb)
 468 {
 469         struct usb_device *usb = comedi_to_usb_dev(dev);
 470         struct usbduxsigma_private *devpriv = dev->private;
 471         struct urb *urb;
 472         int ret;
 473         int i;
 474
 475         /* Submit all URBs and start the transfer on the bus */
 476         for (i = 0; i < num_urbs; i++) {
 477                 urb = urbs[i];
 478
 479                 /* in case of a resubmission after an unlink... */
 480                 if (input_urb)
 481                         urb->interval = devpriv->ai_interval;
 482                 urb->context = dev;
 483                 urb->dev = usb;
 484                 urb->status = 0;
 485                 urb->transfer_flags = URB_ISO_ASAP;
 486
 487                 ret = usb_submit_urb(urb, GFP_ATOMIC);
 488                 if (ret)
 489                         return ret;
 490         }
 491         return 0;
 492 }
 493
 494 static int usbduxsigma_chans_to_interval(int num_chan)
 495 {
 496         if (num_chan <= 2)
 497                 return 2;       /* 4kHz */
 498         if (num_chan <= 8)
 499                 return 4;       /* 2kHz */
 500         return 8;               /* 1kHz */
 501 }
 502
 503 static int usbduxsigma_ai_cmdtest(struct comedi_device *dev,
 504                                   struct comedi_subdevice *s,
 505                                   struct comedi_cmd *cmd)
 506 {
 507         struct usbduxsigma_private *devpriv = dev->private;
 508         int high_speed = devpriv->high_speed;
 509         int interval = usbduxsigma_chans_to_interval(cmd->chanlist_len);
 510         int err = 0;
 511
 512         /* Step 1 : check if triggers are trivially valid */
 513
 514         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
 515         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
 516         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 517         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 518         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 519
 520         if (err)
 521                 return 1;
 522
 523         /* Step 2a : make sure trigger sources are unique */
 524
 525         err |= cfc_check_trigger_is_unique(cmd->start_src);
 526         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 527
 528         /* Step 2b : and mutually compatible */
 529
 530         if (err)
 531                 return 2;
 532
 533         /* Step 3: check if arguments are trivially valid */
 534
 535         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 536
 537         if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
 538                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 539
 540         if (cmd->scan_begin_src == TRIG_TIMER) {
 541                 unsigned int tmp;
 542
 543                 if (high_speed) {
 544                         /*
 545                          * In high speed mode microframes are possible.
 546                          * However, during one microframe we can roughly
 547                          * sample two channels. Thus, the more channels
 548                          * are in the channel list the more time we need.
 549                          */
 550                         err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
 551                                                 (1000000 / 8 * interval));
 552
 553                         tmp = (cmd->scan_begin_arg / 125000) * 125000;
 554                 } else {
 555                         /* full speed */
 556                         /* 1kHz scans every USB frame */
 557                         err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
 558                                                          1000000);
 559
 560                         tmp = (cmd->scan_begin_arg / 1000000) * 1000000;
 561                 }
 562                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, tmp);
 563         }
 564
 565         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 566
 567         if (cmd->stop_src == TRIG_COUNT) {
 568                 /* any count is allowed */
 569         } else {
 570                 /* TRIG_NONE */
 571                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 572         }
 573
 574         if (err)
 575                 return 3;
 576
 577         /* Step 4: fix up any arguments */
 578
 579         if (high_speed) {
 580                 /*
 581                  * every 2 channels get a time window of 125us. Thus, if we
 582                  * sample all 16 channels we need 1ms. If we sample only one
 583                  * channel we need only 125us
 584                  */
 585                 devpriv->ai_interval = interval;
 586                 devpriv->ai_timer = cmd->scan_begin_arg / (125000 * interval);
 587         } else {
 588                 /* interval always 1ms */
 589                 devpriv->ai_interval = 1;
 590                 devpriv->ai_timer = cmd->scan_begin_arg / 1000000;
 591         }
 592         if (devpriv->ai_timer < 1)
 593                 err |= -EINVAL;
 594
 595         if (cmd->stop_src == TRIG_COUNT) {
 596                 /* data arrives as one packet */
 597                 devpriv->ai_sample_count = cmd->stop_arg;
 598                 devpriv->ai_continuous = 0;
 599         } else {
 600                 /* continuous acquisition */
 601                 devpriv->ai_continuous = 1;
 602                 devpriv->ai_sample_count = 0;
 603         }
 604
 605         if (err)
 606                 return 4;
 607
 608         return 0;
 609 }
 610
 611 /*
 612  * creates the ADC command for the MAX1271
 613  * range is the range value from comedi
 614  */
 615 static void create_adc_command(unsigned int chan,
 616                                uint8_t *muxsg0,
 617                                uint8_t *muxsg1)
 618 {
 619         if (chan < 8)
 620                 (*muxsg0) = (*muxsg0) | (1 << chan);
 621         else if (chan < 16)
 622                 (*muxsg1) = (*muxsg1) | (1 << (chan-8));
 623 }
 624
 625 static int usbbuxsigma_send_cmd(struct comedi_device *dev, int cmd_type)
 626 {
 627         struct usb_device *usb = comedi_to_usb_dev(dev);
 628         struct usbduxsigma_private *devpriv = dev->private;
 629         int nsent;
 630
 631         devpriv->dux_commands[0] = cmd_type;
 632
 633         return usb_bulk_msg(usb, usb_sndbulkpipe(usb, 1),
 634                             devpriv->dux_commands, SIZEOFDUXBUFFER,
 635                             &nsent, BULK_TIMEOUT);
 636 }
 637
 638 static int usbduxsigma_receive_cmd(struct comedi_device *dev, int command)
 639 {
 640         struct usb_device *usb = comedi_to_usb_dev(dev);
 641         struct usbduxsigma_private *devpriv = dev->private;
 642         int nrec;
 643         int ret;
 644         int i;
 645
 646         for (i = 0; i < RETRIES; i++) {
 647                 ret = usb_bulk_msg(usb, usb_rcvbulkpipe(usb, 8),
 648                                    devpriv->insn_buf, SIZEINSNBUF,
 649                                    &nrec, BULK_TIMEOUT);
 650                 if (ret < 0)
 651                         return ret;
 652
 653                 if (devpriv->insn_buf[0] == command)
 654                         return 0;
 655         }
 656         /*
 657          * This is only reached if the data has been requested a
 658          * couple of times and the command was not received.
 659          */
 660         return -EFAULT;
 661 }
 662
 663 static int usbduxsigma_ai_inttrig(struct comedi_device *dev,
 664                                   struct comedi_subdevice *s,
 665                                   unsigned int trignum)
 666 {
 667         struct usbduxsigma_private *devpriv = dev->private;
 668         int ret;
 669
 670         if (trignum != 0)
 671                 return -EINVAL;
 672
 673         down(&devpriv->sem);
 674         if (!devpriv->ai_cmd_running) {
 675                 devpriv->ai_cmd_running = 1;
 676                 ret = usbduxsigma_submit_urbs(dev, devpriv->ai_urbs,
 677                                               devpriv->n_ai_urbs, 1);
 678                 if (ret < 0) {
 679                         devpriv->ai_cmd_running = 0;
 680                         up(&devpriv->sem);
 681                         return ret;
 682                 }
 683                 s->async->inttrig = NULL;
 684         }
 685         up(&devpriv->sem);
 686
 687         return 1;
 688 }
 689
 690 static int usbduxsigma_ai_cmd(struct comedi_device *dev,
 691                               struct comedi_subdevice *s)
 692 {
 693         struct usbduxsigma_private *devpriv = dev->private;
 694         struct comedi_cmd *cmd = &s->async->cmd;
 695         unsigned int len = cmd->chanlist_len;
 696         uint8_t muxsg0 = 0;
 697         uint8_t muxsg1 = 0;
 698         uint8_t sysred = 0;
 699         int ret;
 700         int i;
 701
 702         down(&devpriv->sem);
 703
 704         /* set current channel of the running acquisition to zero */
 705         s->async->cur_chan = 0;
 706         for (i = 0; i < len; i++) {
 707                 unsigned int chan  = CR_CHAN(cmd->chanlist[i]);
 708
 709                 create_adc_command(chan, &muxsg0, &muxsg1);
 710         }
 711
 712         devpriv->dux_commands[1] = len;  /* num channels per time step */
 713         devpriv->dux_commands[2] = 0x12; /* CONFIG0 */
 714         devpriv->dux_commands[3] = 0x03; /* CONFIG1: 23kHz sample, delay 0us */
 715         devpriv->dux_commands[4] = 0x00; /* CONFIG3: diff. channels off */
 716         devpriv->dux_commands[5] = muxsg0;
 717         devpriv->dux_commands[6] = muxsg1;
 718         devpriv->dux_commands[7] = sysred;
 719
 720         ret = usbbuxsigma_send_cmd(dev, USBBUXSIGMA_AD_CMD);
 721         if (ret < 0) {
 722                 up(&devpriv->sem);
 723                 return ret;
 724         }
 725
 726         devpriv->ai_counter = devpriv->ai_timer;
 727
 728         if (cmd->start_src == TRIG_NOW) {
 729                 /* enable this acquisition operation */
 730                 devpriv->ai_cmd_running = 1;
 731                 ret = usbduxsigma_submit_urbs(dev, devpriv->ai_urbs,
 732                                               devpriv->n_ai_urbs, 1);
 733                 if (ret < 0) {
 734                         devpriv->ai_cmd_running = 0;
 735                         up(&devpriv->sem);
 736                         return ret;
 737                 }
 738                 s->async->inttrig = NULL;
 739         } else {        /* TRIG_INT */
 740                 /* wait for an internal signal and submit the urbs later */
 741                 s->async->inttrig = usbduxsigma_ai_inttrig;
 742         }
 743
 744         up(&devpriv->sem);
 745
 746         return 0;
 747 }
 748
 749 static int usbduxsigma_ai_insn_read(struct comedi_device *dev,
 750                                     struct comedi_subdevice *s,
 751                                     struct comedi_insn *insn,
 752                                     unsigned int *data)
 753 {
 754         struct usbduxsigma_private *devpriv = dev->private;
 755         unsigned int chan = CR_CHAN(insn->chanspec);
 756         uint8_t muxsg0 = 0;
 757         uint8_t muxsg1 = 0;
 758         uint8_t sysred = 0;
 759         int ret;
 760         int i;
 761
 762         down(&devpriv->sem);
 763         if (devpriv->ai_cmd_running) {
 764                 up(&devpriv->sem);
 765                 return -EBUSY;
 766         }
 767
 768         create_adc_command(chan, &muxsg0, &muxsg1);
 769
 770         /* Mode 0 is used to get a single conversion on demand */
 771         devpriv->dux_commands[1] = 0x16; /* CONFIG0: chopper on */
 772         devpriv->dux_commands[2] = 0x80; /* CONFIG1: 2kHz sampling rate */
 773         devpriv->dux_commands[3] = 0x00; /* CONFIG3: diff. channels off */
 774         devpriv->dux_commands[4] = muxsg0;
 775         devpriv->dux_commands[5] = muxsg1;
 776         devpriv->dux_commands[6] = sysred;
 777
 778         /* adc commands */
 779         ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD);
 780         if (ret < 0) {
 781                 up(&devpriv->sem);
 782                 return ret;
 783         }
 784
 785         for (i = 0; i < insn->n; i++) {
 786                 uint32_t val;
 787
 788                 ret = usbduxsigma_receive_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD);
 789                 if (ret < 0) {
 790                         up(&devpriv->sem);
 791                         return ret;
 792                 }
 793
 794                 /* 32 bits big endian from the A/D converter */
 795                 val = be32_to_cpu(*((uint32_t *)((devpriv->insn_buf) + 1)));
 796                 val &= 0x00ffffff;      /* strip status byte */
 797                 val ^= 0x00800000;      /* convert to unsigned */
 798
 799                 data[i] = val;
 800         }
 801         up(&devpriv->sem);
 802
 803         return insn->n;
 804 }
 805
 806 static int usbduxsigma_ao_insn_read(struct comedi_device *dev,
 807                                     struct comedi_subdevice *s,
 808                                     struct comedi_insn *insn,
 809                                     unsigned int *data)
 810 {
 811         struct usbduxsigma_private *devpriv = dev->private;
 812         unsigned int chan = CR_CHAN(insn->chanspec);
 813         int i;
 814
 815         down(&devpriv->sem);
 816         for (i = 0; i < insn->n; i++)
 817                 data[i] = devpriv->ao_readback[chan];
 818         up(&devpriv->sem);
 819
 820         return insn->n;
 821 }
 822
 823 static int usbduxsigma_ao_insn_write(struct comedi_device *dev,
 824                                      struct comedi_subdevice *s,
 825                                      struct comedi_insn *insn,
 826                                      unsigned int *data)
 827 {
 828         struct usbduxsigma_private *devpriv = dev->private;
 829         unsigned int chan = CR_CHAN(insn->chanspec);
 830         int ret;
 831         int i;
 832
 833         down(&devpriv->sem);
 834         if (devpriv->ao_cmd_running) {
 835                 up(&devpriv->sem);
 836                 return -EBUSY;
 837         }
 838
 839         for (i = 0; i < insn->n; i++) {
 840                 devpriv->dux_commands[1] = 1;           /* num channels */
 841                 devpriv->dux_commands[2] = data[i];     /* value */
 842                 devpriv->dux_commands[3] = chan;        /* channel number */
 843                 ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_DA_CMD);
 844                 if (ret < 0) {
 845                         up(&devpriv->sem);
 846                         return ret;
 847                 }
 848                 devpriv->ao_readback[chan] = data[i];
 849         }
 850         up(&devpriv->sem);
 851
 852         return insn->n;
 853 }
 854
 855 static int usbduxsigma_ao_inttrig(struct comedi_device *dev,
 856                                   struct comedi_subdevice *s,
 857                                   unsigned int trignum)
 858 {
 859         struct usbduxsigma_private *devpriv = dev->private;
 860         int ret;
 861
 862         if (trignum != 0)
 863                 return -EINVAL;
 864
 865         down(&devpriv->sem);
 866         if (!devpriv->ao_cmd_running) {
 867                 devpriv->ao_cmd_running = 1;
 868                 ret = usbduxsigma_submit_urbs(dev, devpriv->ao_urbs,
 869                                               devpriv->n_ao_urbs, 0);
 870                 if (ret < 0) {
 871                         devpriv->ao_cmd_running = 0;
 872                         up(&devpriv->sem);
 873                         return ret;
 874                 }
 875                 s->async->inttrig = NULL;
 876         }
 877         up(&devpriv->sem);
 878
 879         return 1;
 880 }
 881
 882 static int usbduxsigma_ao_cmdtest(struct comedi_device *dev,
 883                                   struct comedi_subdevice *s,
 884                                   struct comedi_cmd *cmd)
 885 {
 886         struct usbduxsigma_private *devpriv = dev->private;
 887         int err = 0;
 888         int high_speed;
 889         unsigned int flags;
 890
 891         /* high speed conversions are not used yet */
 892         high_speed = 0;         /* (devpriv->high_speed) */
 893
 894         /* Step 1 : check if triggers are trivially valid */
 895
 896         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
 897
 898         if (high_speed) {
 899                 /*
 900                  * start immediately a new scan
 901                  * the sampling rate is set by the coversion rate
 902                  */
 903                 flags = TRIG_FOLLOW;
 904         } else {
 905                 /* start a new scan (output at once) with a timer */
 906                 flags = TRIG_TIMER;
 907         }
 908         err |= cfc_check_trigger_src(&cmd->scan_begin_src, flags);
 909
 910         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
 911         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 912         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
 913
 914         if (err) {
 915                 up(&devpriv->sem);
 916                 return 1;
 917         }
 918
 919         /* Step 2a : make sure trigger sources are unique */
 920
 921         err |= cfc_check_trigger_is_unique(cmd->start_src);
 922         err |= cfc_check_trigger_is_unique(cmd->stop_src);
 923
 924         /* Step 2b : and mutually compatible */
 925
 926         if (err)
 927                 return 2;
 928
 929         /* Step 3: check if arguments are trivially valid */
 930
 931         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 932
 933         if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
 934                 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 935
 936         if (cmd->scan_begin_src == TRIG_TIMER)
 937                 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
 938                                                  1000000);
 939
 940         /* not used now, is for later use */
 941         if (cmd->convert_src == TRIG_TIMER)
 942                 err |= cfc_check_trigger_arg_min(&cmd->convert_arg, 125000);
 943
 944         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
 945
 946         if (cmd->stop_src == TRIG_COUNT) {
 947                 /* any count is allowed */
 948         } else {
 949                 /* TRIG_NONE */
 950                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 951         }
 952
 953         if (err)
 954                 return 3;
 955
 956         /* Step 4: fix up any arguments */
 957
 958         /* we count in timer steps */
 959         if (high_speed) {
 960                 /* timing of the conversion itself: every 125 us */
 961                 devpriv->ao_timer = cmd->convert_arg / 125000;
 962         } else {
 963                 /*
 964                  * timing of the scan: every 1ms
 965                  * we get all channels at once
 966                  */
 967                 devpriv->ao_timer = cmd->scan_begin_arg / 1000000;
 968         }
 969         if (devpriv->ao_timer < 1)
 970                 err |= -EINVAL;
 971
 972         if (cmd->stop_src == TRIG_COUNT) {
 973                 /* not continuous, use counter */
 974                 if (high_speed) {
 975                         /* high speed also scans everything at once */
 976                         devpriv->ao_sample_count = cmd->stop_arg *
 977                                                    cmd->scan_end_arg;
 978                 } else {
 979                         /*
 980                          * There's no scan as the scan has been
 981                          * handled inside the FX2. Data arrives as
 982                          * one packet.
 983                          */
 984                         devpriv->ao_sample_count = cmd->stop_arg;
 985                 }
 986                 devpriv->ao_continuous = 0;
 987         } else {
 988                 /* continuous acquisition */
 989                 devpriv->ao_continuous = 1;
 990                 devpriv->ao_sample_count = 0;
 991         }
 992
 993         if (err)
 994                 return 4;
 995
 996         return 0;
 997 }
 998
 999 static int usbduxsigma_ao_cmd(struct comedi_device *dev,
1000                               struct comedi_subdevice *s)
1001 {
1002         struct usbduxsigma_private *devpriv = dev->private;
1003         struct comedi_cmd *cmd = &s->async->cmd;
1004         int ret;
1005         int i;
1006
1007         down(&devpriv->sem);
1008
1009         /* set current channel of the running acquisition to zero */
1010         s->async->cur_chan = 0;
1011         for (i = 0; i < cmd->chanlist_len; ++i)
1012                 devpriv->ao_chanlist[i] = CR_CHAN(cmd->chanlist[i]);
1013
1014         devpriv->ao_counter = devpriv->ao_timer;
1015
1016         if (cmd->start_src == TRIG_NOW) {
1017                 /* enable this acquisition operation */
1018                 devpriv->ao_cmd_running = 1;
1019                 ret = usbduxsigma_submit_urbs(dev, devpriv->ao_urbs,
1020                                               devpriv->n_ao_urbs, 0);
1021                 if (ret < 0) {
1022                         devpriv->ao_cmd_running = 0;
1023                         up(&devpriv->sem);
1024                         return ret;
1025                 }
1026                 s->async->inttrig = NULL;
1027         } else {        /* TRIG_INT */
1028                 /* wait for an internal signal and submit the urbs later */
1029                 s->async->inttrig = usbduxsigma_ao_inttrig;
1030         }
1031
1032         up(&devpriv->sem);
1033
1034         return 0;
1035 }
1036
1037 static int usbduxsigma_dio_insn_config(struct comedi_device *dev,
1038                                        struct comedi_subdevice *s,
1039                                        struct comedi_insn *insn,
1040                                        unsigned int *data)
1041 {
1042         int ret;
1043
1044         ret = comedi_dio_insn_config(dev, s, insn, data, 0);
1045         if (ret)
1046                 return ret;
1047
1048         /*
1049          * We don't tell the firmware here as it would take 8 frames
1050          * to submit the information. We do it in the (*insn_bits).
1051          */
1052         return insn->n;
1053 }
1054
1055 static int usbduxsigma_dio_insn_bits(struct comedi_device *dev,
1056                                      struct comedi_subdevice *s,
1057                                      struct comedi_insn *insn,
1058                                      unsigned int *data)
1059 {
1060         struct usbduxsigma_private *devpriv = dev->private;
1061         int ret;
1062
1063         down(&devpriv->sem);
1064
1065         comedi_dio_update_state(s, data);
1066
1067         /* Always update the hardware. See the (*insn_config). */
1068         devpriv->dux_commands[1] = s->io_bits & 0xff;
1069         devpriv->dux_commands[4] = s->state & 0xff;
1070         devpriv->dux_commands[2] = (s->io_bits >> 8) & 0xff;
1071         devpriv->dux_commands[5] = (s->state >> 8) & 0xff;
1072         devpriv->dux_commands[3] = (s->io_bits >> 16) & 0xff;
1073         devpriv->dux_commands[6] = (s->state >> 16) & 0xff;
1074
1075         ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_DIO_BITS_CMD);
1076         if (ret < 0)
1077                 goto done;
1078         ret = usbduxsigma_receive_cmd(dev, USBDUXSIGMA_DIO_BITS_CMD);
1079         if (ret < 0)
1080                 goto done;
1081
1082         s->state = devpriv->insn_buf[1] |
1083                    (devpriv->insn_buf[2] << 8) |
1084                    (devpriv->insn_buf[3] << 16);
1085
1086         data[1] = s->state;
1087         ret = insn->n;
1088
1089 done:
1090         up(&devpriv->sem);
1091
1092         return ret;
1093 }
1094
1095 static void usbduxsigma_pwm_stop(struct comedi_device *dev, int do_unlink)
1096 {
1097         struct usbduxsigma_private *devpriv = dev->private;
1098
1099         if (do_unlink) {
1100                 if (devpriv->pwm_urb)
1101                         usb_kill_urb(devpriv->pwm_urb);
1102         }
1103
1104         devpriv->pwm_cmd_running = 0;
1105 }
1106
1107 static int usbduxsigma_pwm_cancel(struct comedi_device *dev,
1108                                   struct comedi_subdevice *s)
1109 {
1110         struct usbduxsigma_private *devpriv = dev->private;
1111
1112         /* unlink only if it is really running */
1113         usbduxsigma_pwm_stop(dev, devpriv->pwm_cmd_running);
1114
1115         return usbbuxsigma_send_cmd(dev, USBDUXSIGMA_PWM_OFF_CMD);
1116 }
1117
1118 static void usbduxsigma_pwm_urb_complete(struct urb *urb)
1119 {
1120         struct comedi_device *dev = urb->context;
1121         struct usbduxsigma_private *devpriv = dev->private;
1122         int ret;
1123
1124         switch (urb->status) {
1125         case 0:
1126                 /* success */
1127                 break;
1128
1129         case -ECONNRESET:
1130         case -ENOENT:
1131         case -ESHUTDOWN:
1132         case -ECONNABORTED:
1133                 /* happens after an unlink command */
1134                 if (devpriv->pwm_cmd_running)
1135                         usbduxsigma_pwm_stop(dev, 0);   /* w/o unlink */
1136                 return;
1137
1138         default:
1139                 /* a real error */
1140                 if (devpriv->pwm_cmd_running) {
1141                         dev_err(dev->class_dev,
1142                                 "%s: non-zero urb status (%d)\n",
1143                                 __func__, urb->status);
1144                         usbduxsigma_pwm_stop(dev, 0);   /* w/o unlink */
1145                 }
1146                 return;
1147         }
1148
1149         if (!devpriv->pwm_cmd_running)
1150                 return;
1151
1152         urb->transfer_buffer_length = devpriv->pwm_buf_sz;
1153         urb->dev = comedi_to_usb_dev(dev);
1154         urb->status = 0;
1155         ret = usb_submit_urb(urb, GFP_ATOMIC);
1156         if (ret < 0) {
1157                 dev_err(dev->class_dev, "%s: urb resubmit failed (%d)\n",
1158                         __func__, ret);
1159                 if (ret == EL2NSYNC)
1160                         dev_err(dev->class_dev,
1161                                 "buggy USB host controller or bug in IRQ handler\n");
1162                 usbduxsigma_pwm_stop(dev, 0);   /* w/o unlink */
1163         }
1164 }
1165
1166 static int usbduxsigma_submit_pwm_urb(struct comedi_device *dev)
1167 {
1168         struct usb_device *usb = comedi_to_usb_dev(dev);
1169         struct usbduxsigma_private *devpriv = dev->private;
1170         struct urb *urb = devpriv->pwm_urb;
1171
1172         /* in case of a resubmission after an unlink... */
1173         usb_fill_bulk_urb(urb, usb, usb_sndbulkpipe(usb, 4),
1174                           urb->transfer_buffer, devpriv->pwm_buf_sz,
1175                           usbduxsigma_pwm_urb_complete, dev);
1176
1177         return usb_submit_urb(urb, GFP_ATOMIC);
1178 }
1179
1180 static int usbduxsigma_pwm_period(struct comedi_device *dev,
1181                                   struct comedi_subdevice *s,
1182                                   unsigned int period)
1183 {
1184         struct usbduxsigma_private *devpriv = dev->private;
1185         int fx2delay = 255;
1186
1187         if (period < MIN_PWM_PERIOD) {
1188                 return -EAGAIN;
1189         } else {
1190                 fx2delay = (period / (6 * 512 * 1000 / 33)) - 6;
1191                 if (fx2delay > 255)
1192                         return -EAGAIN;
1193         }
1194         devpriv->pwm_delay = fx2delay;
1195         devpriv->pwm_period = period;
1196         return 0;
1197 }
1198
1199 static int usbduxsigma_pwm_start(struct comedi_device *dev,
1200                                  struct comedi_subdevice *s)
1201 {
1202         struct usbduxsigma_private *devpriv = dev->private;
1203         int ret;
1204
1205         if (devpriv->pwm_cmd_running)
1206                 return 0;
1207
1208         devpriv->dux_commands[1] = devpriv->pwm_delay;
1209         ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_PWM_ON_CMD);
1210         if (ret < 0)
1211                 return ret;
1212
1213         memset(devpriv->pwm_urb->transfer_buffer, 0, devpriv->pwm_buf_sz);
1214
1215         devpriv->pwm_cmd_running = 1;
1216         ret = usbduxsigma_submit_pwm_urb(dev);
1217         if (ret < 0) {
1218                 devpriv->pwm_cmd_running = 0;
1219                 return ret;
1220         }
1221
1222         return 0;
1223 }
1224
1225 static void usbduxsigma_pwm_pattern(struct comedi_device *dev,
1226                                     struct comedi_subdevice *s,
1227                                     unsigned int chan,
1228                                     unsigned int value,
1229                                     unsigned int sign)
1230 {
1231         struct usbduxsigma_private *devpriv = dev->private;
1232         char pwm_mask = (1 << chan);    /* DIO bit for the PWM data */
1233         char sgn_mask = (16 << chan);   /* DIO bit for the sign */
1234         char *buf = (char *)(devpriv->pwm_urb->transfer_buffer);
1235         int szbuf = devpriv->pwm_buf_sz;
1236         int i;
1237
1238         for (i = 0; i < szbuf; i++) {
1239                 char c = *buf;
1240
1241                 c &= ~pwm_mask;
1242                 if (i < value)
1243                         c |= pwm_mask;
1244                 if (!sign)
1245                         c &= ~sgn_mask;
1246                 else
1247                         c |= sgn_mask;
1248                 *buf++ = c;
1249         }
1250 }
1251
1252 static int usbduxsigma_pwm_write(struct comedi_device *dev,
1253                                  struct comedi_subdevice *s,
1254                                  struct comedi_insn *insn,
1255                                  unsigned int *data)
1256 {
1257         unsigned int chan = CR_CHAN(insn->chanspec);
1258
1259         /*
1260          * It doesn't make sense to support more than one value here
1261          * because it would just overwrite the PWM buffer.
1262          */
1263         if (insn->n != 1)
1264                 return -EINVAL;
1265
1266         /*
1267          * The sign is set via a special INSN only, this gives us 8 bits
1268          * for normal operation, sign is 0 by default.
1269          */
1270         usbduxsigma_pwm_pattern(dev, s, chan, data[0], 0);
1271
1272         return insn->n;
1273 }
1274
1275 static int usbduxsigma_pwm_config(struct comedi_device *dev,
1276                                   struct comedi_subdevice *s,
1277                                   struct comedi_insn *insn,
1278                                   unsigned int *data)
1279 {
1280         struct usbduxsigma_private *devpriv = dev->private;
1281         unsigned int chan = CR_CHAN(insn->chanspec);
1282
1283         switch (data[0]) {
1284         case INSN_CONFIG_ARM:
1285                 /*
1286                  * if not zero the PWM is limited to a certain time which is
1287                  * not supported here
1288                  */
1289                 if (data[1] != 0)
1290                         return -EINVAL;
1291                 return usbduxsigma_pwm_start(dev, s);
1292         case INSN_CONFIG_DISARM:
1293                 return usbduxsigma_pwm_cancel(dev, s);
1294         case INSN_CONFIG_GET_PWM_STATUS:
1295                 data[1] = devpriv->pwm_cmd_running;
1296                 return 0;
1297         case INSN_CONFIG_PWM_SET_PERIOD:
1298                 return usbduxsigma_pwm_period(dev, s, data[1]);
1299         case INSN_CONFIG_PWM_GET_PERIOD:
1300                 data[1] = devpriv->pwm_period;
1301                 return 0;
1302         case INSN_CONFIG_PWM_SET_H_BRIDGE:
1303                 /*
1304                  * data[1] = value
1305                  * data[2] = sign (for a relay)
1306                  */
1307                 usbduxsigma_pwm_pattern(dev, s, chan, data[1], (data[2] != 0));
1308                 return 0;
1309         case INSN_CONFIG_PWM_GET_H_BRIDGE:
1310                 /* values are not kept in this driver, nothing to return */
1311                 return -EINVAL;
1312         }
1313         return -EINVAL;
1314 }
1315
1316 static int usbduxsigma_getstatusinfo(struct comedi_device *dev, int chan)
1317 {
1318         struct usbduxsigma_private *devpriv = dev->private;
1319         uint8_t sysred;
1320         uint32_t val;
1321         int ret;
1322
1323         switch (chan) {
1324         default:
1325         case 0:
1326                 sysred = 0;             /* ADC zero */
1327                 break;
1328         case 1:
1329                 sysred = 1;             /* ADC offset */
1330                 break;
1331         case 2:
1332                 sysred = 4;             /* VCC */
1333                 break;
1334         case 3:
1335                 sysred = 8;             /* temperature */
1336                 break;
1337         case 4:
1338                 sysred = 16;            /* gain */
1339                 break;
1340         case 5:
1341                 sysred =  32;           /* ref */
1342                 break;
1343         }
1344
1345         devpriv->dux_commands[1] = 0x12; /* CONFIG0 */
1346         devpriv->dux_commands[2] = 0x80; /* CONFIG1: 2kHz sampling rate */
1347         devpriv->dux_commands[3] = 0x00; /* CONFIG3: diff. channels off */
1348         devpriv->dux_commands[4] = 0;
1349         devpriv->dux_commands[5] = 0;
1350         devpriv->dux_commands[6] = sysred;
1351         ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD);
1352         if (ret < 0)
1353                 return ret;
1354
1355         ret = usbduxsigma_receive_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD);
1356         if (ret < 0)
1357                 return ret;
1358
1359         /* 32 bits big endian from the A/D converter */
1360         val = be32_to_cpu(*((uint32_t *)((devpriv->insn_buf)+1)));
1361         val &= 0x00ffffff;      /* strip status byte */
1362         val ^= 0x00800000;      /* convert to unsigned */
1363
1364         return (int)val;
1365 }
1366
1367 static int usbduxsigma_firmware_upload(struct comedi_device *dev,
1368                                        const u8 *data, size_t size,
1369                                        unsigned long context)
1370 {
1371         struct usb_device *usb = comedi_to_usb_dev(dev);
1372         uint8_t *buf;
1373         uint8_t *tmp;
1374         int ret;
1375
1376         if (!data)
1377                 return 0;
1378
1379         if (size > FIRMWARE_MAX_LEN) {
1380                 dev_err(dev->class_dev, "firmware binary too large for FX2\n");
1381                 return -ENOMEM;
1382         }
1383
1384         /* we generate a local buffer for the firmware */
1385         buf = kmemdup(data, size, GFP_KERNEL);
1386         if (!buf)
1387                 return -ENOMEM;
1388
1389         /* we need a malloc'ed buffer for usb_control_msg() */
1390         tmp = kmalloc(1, GFP_KERNEL);
1391         if (!tmp) {
1392                 kfree(buf);
1393                 return -ENOMEM;
1394         }
1395
1396         /* stop the current firmware on the device */
1397         *tmp = 1;       /* 7f92 to one */
1398         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
1399                               USBDUXSUB_FIRMWARE,
1400                               VENDOR_DIR_OUT,
1401                               USBDUXSUB_CPUCS, 0x0000,
1402                               tmp, 1,
1403                               BULK_TIMEOUT);
1404         if (ret < 0) {
1405                 dev_err(dev->class_dev, "can not stop firmware\n");
1406                 goto done;
1407         }
1408
1409         /* upload the new firmware to the device */
1410         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
1411                               USBDUXSUB_FIRMWARE,
1412                               VENDOR_DIR_OUT,
1413                               0, 0x0000,
1414                               buf, size,
1415                               BULK_TIMEOUT);
1416         if (ret < 0) {
1417                 dev_err(dev->class_dev, "firmware upload failed\n");
1418                 goto done;
1419         }
1420
1421         /* start the new firmware on the device */
1422         *tmp = 0;       /* 7f92 to zero */
1423         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
1424                               USBDUXSUB_FIRMWARE,
1425                               VENDOR_DIR_OUT,
1426                               USBDUXSUB_CPUCS, 0x0000,
1427                               tmp, 1,
1428                               BULK_TIMEOUT);
1429         if (ret < 0)
1430                 dev_err(dev->class_dev, "can not start firmware\n");
1431
1432 done:
1433         kfree(tmp);
1434         kfree(buf);
1435         return ret;
1436 }
1437
1438 static int usbduxsigma_alloc_usb_buffers(struct comedi_device *dev)
1439 {
1440         struct usb_device *usb = comedi_to_usb_dev(dev);
1441         struct usbduxsigma_private *devpriv = dev->private;
1442         struct urb *urb;
1443         int i;
1444
1445         devpriv->dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL);
1446         devpriv->in_buf = kzalloc(SIZEINBUF, GFP_KERNEL);
1447         devpriv->insn_buf = kzalloc(SIZEINSNBUF, GFP_KERNEL);
1448         devpriv->ai_urbs = kcalloc(devpriv->n_ai_urbs, sizeof(*urb),
1449                                    GFP_KERNEL);
1450         devpriv->ao_urbs = kcalloc(devpriv->n_ao_urbs, sizeof(*urb),
1451                                    GFP_KERNEL);
1452         if (!devpriv->dux_commands || !devpriv->in_buf || !devpriv->insn_buf ||
1453             !devpriv->ai_urbs || !devpriv->ao_urbs)
1454                 return -ENOMEM;
1455
1456         for (i = 0; i < devpriv->n_ai_urbs; i++) {
1457                 /* one frame: 1ms */
1458                 urb = usb_alloc_urb(1, GFP_KERNEL);
1459                 if (!urb)
1460                         return -ENOMEM;
1461                 devpriv->ai_urbs[i] = urb;
1462                 urb->dev = usb;
1463                 /* will be filled later with a pointer to the comedi-device */
1464                 /* and ONLY then the urb should be submitted */
1465                 urb->context = NULL;
1466                 urb->pipe = usb_rcvisocpipe(usb, 6);
1467                 urb->transfer_flags = URB_ISO_ASAP;
1468                 urb->transfer_buffer = kzalloc(SIZEINBUF, GFP_KERNEL);
1469                 if (!urb->transfer_buffer)
1470                         return -ENOMEM;
1471                 urb->complete = usbduxsigma_ai_urb_complete;
1472                 urb->number_of_packets = 1;
1473                 urb->transfer_buffer_length = SIZEINBUF;
1474                 urb->iso_frame_desc[0].offset = 0;
1475                 urb->iso_frame_desc[0].length = SIZEINBUF;
1476         }
1477
1478         for (i = 0; i < devpriv->n_ao_urbs; i++) {
1479                 /* one frame: 1ms */
1480                 urb = usb_alloc_urb(1, GFP_KERNEL);
1481                 if (!urb)
1482                         return -ENOMEM;
1483                 devpriv->ao_urbs[i] = urb;
1484                 urb->dev = usb;
1485                 /* will be filled later with a pointer to the comedi-device */
1486                 /* and ONLY then the urb should be submitted */
1487                 urb->context = NULL;
1488                 urb->pipe = usb_sndisocpipe(usb, 2);
1489                 urb->transfer_flags = URB_ISO_ASAP;
1490                 urb->transfer_buffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
1491                 if (!urb->transfer_buffer)
1492                         return -ENOMEM;
1493                 urb->complete = usbduxsigma_ao_urb_complete;
1494                 urb->number_of_packets = 1;
1495                 urb->transfer_buffer_length = SIZEOUTBUF;
1496                 urb->iso_frame_desc[0].offset = 0;
1497                 urb->iso_frame_desc[0].length = SIZEOUTBUF;
1498                 if (devpriv->high_speed)
1499                         urb->interval = 8;      /* uframes */
1500                 else
1501                         urb->interval = 1;      /* frames */
1502         }
1503
1504         if (devpriv->pwm_buf_sz) {
1505                 urb = usb_alloc_urb(0, GFP_KERNEL);
1506                 if (!urb)
1507                         return -ENOMEM;
1508                 devpriv->pwm_urb = urb;
1509
1510                 urb->transfer_buffer = kzalloc(devpriv->pwm_buf_sz,
1511                                                GFP_KERNEL);
1512                 if (!urb->transfer_buffer)
1513                         return -ENOMEM;
1514         }
1515
1516         return 0;
1517 }
1518
1519 static void usbduxsigma_free_usb_buffers(struct comedi_device *dev)
1520 {
1521         struct usbduxsigma_private *devpriv = dev->private;
1522         struct urb *urb;
1523         int i;
1524
1525         urb = devpriv->pwm_urb;
1526         if (urb) {
1527                 kfree(urb->transfer_buffer);
1528                 usb_free_urb(urb);
1529         }
1530         if (devpriv->ao_urbs) {
1531                 for (i = 0; i < devpriv->n_ao_urbs; i++) {
1532                         urb = devpriv->ao_urbs[i];
1533                         if (urb) {
1534                                 kfree(urb->transfer_buffer);
1535                                 usb_free_urb(urb);
1536                         }
1537                 }
1538                 kfree(devpriv->ao_urbs);
1539         }
1540         if (devpriv->ai_urbs) {
1541                 for (i = 0; i < devpriv->n_ai_urbs; i++) {
1542                         urb = devpriv->ai_urbs[i];
1543                         if (urb) {
1544                                 kfree(urb->transfer_buffer);
1545                                 usb_free_urb(urb);
1546                         }
1547                 }
1548                 kfree(devpriv->ai_urbs);
1549         }
1550         kfree(devpriv->insn_buf);
1551         kfree(devpriv->in_buf);
1552         kfree(devpriv->dux_commands);
1553 }
1554
1555 static int usbduxsigma_auto_attach(struct comedi_device *dev,
1556                                    unsigned long context_unused)
1557 {
1558         struct usb_interface *intf = comedi_to_usb_interface(dev);
1559         struct usb_device *usb = comedi_to_usb_dev(dev);
1560         struct usbduxsigma_private *devpriv;
1561         struct comedi_subdevice *s;
1562         int offset;
1563         int ret;
1564
1565         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1566         if (!devpriv)
1567                 return -ENOMEM;
1568
1569         sema_init(&devpriv->sem, 1);
1570
1571         usb_set_intfdata(intf, devpriv);
1572
1573         devpriv->high_speed = (usb->speed == USB_SPEED_HIGH);
1574         if (devpriv->high_speed) {
1575                 devpriv->n_ai_urbs = NUMOFINBUFFERSHIGH;
1576                 devpriv->n_ao_urbs = NUMOFOUTBUFFERSHIGH;
1577                 devpriv->pwm_buf_sz = 512;
1578         } else {
1579                 devpriv->n_ai_urbs = NUMOFINBUFFERSFULL;
1580                 devpriv->n_ao_urbs = NUMOFOUTBUFFERSFULL;
1581         }
1582
1583         ret = usbduxsigma_alloc_usb_buffers(dev);
1584         if (ret)
1585                 return ret;
1586
1587         /* setting to alternate setting 3: enabling iso ep and bulk ep. */
1588         ret = usb_set_interface(usb, intf->altsetting->desc.bInterfaceNumber,
1589                                 3);
1590         if (ret < 0) {
1591                 dev_err(dev->class_dev,
1592                         "could not set alternate setting 3 in high speed\n");
1593                 return ret;
1594         }
1595
1596         ret = comedi_load_firmware(dev, &usb->dev, FIRMWARE,
1597                                    usbduxsigma_firmware_upload, 0);
1598         if (ret)
1599                 return ret;
1600
1601         ret = comedi_alloc_subdevices(dev, (devpriv->high_speed) ? 4 : 3);
1602         if (ret)
1603                 return ret;
1604
1605         /* Analog Input subdevice */
1606         s = &dev->subdevices[0];
1607         dev->read_subdev = s;
1608         s->type         = COMEDI_SUBD_AI;
1609         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ | SDF_LSAMPL;
1610         s->n_chan       = NUMCHANNELS;
1611         s->len_chanlist = NUMCHANNELS;
1612         s->maxdata      = 0x00ffffff;
1613         s->range_table  = &usbduxsigma_ai_range;
1614         s->insn_read    = usbduxsigma_ai_insn_read;
1615         s->do_cmdtest   = usbduxsigma_ai_cmdtest;
1616         s->do_cmd       = usbduxsigma_ai_cmd;
1617         s->cancel       = usbduxsigma_ai_cancel;
1618
1619         /* Analog Output subdevice */
1620         s = &dev->subdevices[1];
1621         dev->write_subdev = s;
1622         s->type         = COMEDI_SUBD_AO;
1623         s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
1624         s->n_chan       = USBDUXSIGMA_NUM_AO_CHAN;
1625         s->len_chanlist = s->n_chan;
1626         s->maxdata      = 0x00ff;
1627         s->range_table  = &range_unipolar2_5;
1628         s->insn_write   = usbduxsigma_ao_insn_write;
1629         s->insn_read    = usbduxsigma_ao_insn_read;
1630         s->do_cmdtest   = usbduxsigma_ao_cmdtest;
1631         s->do_cmd       = usbduxsigma_ao_cmd;
1632         s->cancel       = usbduxsigma_ao_cancel;
1633
1634         /* Digital I/O subdevice */
1635         s = &dev->subdevices[2];
1636         s->type         = COMEDI_SUBD_DIO;
1637         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
1638         s->n_chan       = 24;
1639         s->maxdata      = 1;
1640         s->range_table  = &range_digital;
1641         s->insn_bits    = usbduxsigma_dio_insn_bits;
1642         s->insn_config  = usbduxsigma_dio_insn_config;
1643
1644         if (devpriv->high_speed) {
1645                 /* Timer / pwm subdevice */
1646                 s = &dev->subdevices[3];
1647                 s->type         = COMEDI_SUBD_PWM;
1648                 s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
1649                 s->n_chan       = 8;
1650                 s->maxdata      = devpriv->pwm_buf_sz;
1651                 s->insn_write   = usbduxsigma_pwm_write;
1652                 s->insn_config  = usbduxsigma_pwm_config;
1653
1654                 usbduxsigma_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
1655         }
1656
1657         offset = usbduxsigma_getstatusinfo(dev, 0);
1658         if (offset < 0) {
1659                 dev_err(dev->class_dev,
1660                         "Communication to USBDUXSIGMA failed! Check firmware and cabling.\n");
1661                 return offset;
1662         }
1663
1664         dev_info(dev->class_dev, "ADC_zero = %x\n", offset);
1665
1666         return 0;
1667 }
1668
1669 static void usbduxsigma_detach(struct comedi_device *dev)
1670 {
1671         struct usb_interface *intf = comedi_to_usb_interface(dev);
1672         struct usbduxsigma_private *devpriv = dev->private;
1673
1674         usb_set_intfdata(intf, NULL);
1675
1676         if (!devpriv)
1677                 return;
1678
1679         down(&devpriv->sem);
1680
1681         /* force unlink all urbs */
1682         usbduxsigma_ai_stop(dev, 1);
1683         usbduxsigma_ao_stop(dev, 1);
1684         usbduxsigma_pwm_stop(dev, 1);
1685
1686         usbduxsigma_free_usb_buffers(dev);
1687
1688         up(&devpriv->sem);
1689 }
1690
1691 static struct comedi_driver usbduxsigma_driver = {
1692         .driver_name    = "usbduxsigma",
1693         .module         = THIS_MODULE,
1694         .auto_attach    = usbduxsigma_auto_attach,
1695         .detach         = usbduxsigma_detach,
1696 };
1697
1698 static int usbduxsigma_usb_probe(struct usb_interface *intf,
1699                                  const struct usb_device_id *id)
1700 {
1701         return comedi_usb_auto_config(intf, &usbduxsigma_driver, 0);
1702 }
1703
1704 static const struct usb_device_id usbduxsigma_usb_table[] = {
1705         { USB_DEVICE(0x13d8, 0x0020) },
1706         { USB_DEVICE(0x13d8, 0x0021) },
1707         { USB_DEVICE(0x13d8, 0x0022) },
1708         { }
1709 };
1710 MODULE_DEVICE_TABLE(usb, usbduxsigma_usb_table);
1711
1712 static struct usb_driver usbduxsigma_usb_driver = {
1713         .name           = "usbduxsigma",
1714         .probe          = usbduxsigma_usb_probe,
1715         .disconnect     = comedi_usb_auto_unconfig,
1716         .id_table       = usbduxsigma_usb_table,
1717 };
1718 module_comedi_usb_driver(usbduxsigma_driver, usbduxsigma_usb_driver);
1719
1720 MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
1721 MODULE_DESCRIPTION("Stirling/ITL USB-DUX SIGMA -- Bernd.Porr@f2s.com");
1722 MODULE_LICENSE("GPL");
1723 MODULE_FIRMWARE(FIRMWARE);