drivers/staging/comedi/drivers/vmk80xx.c

   1 /*
   2     comedi/drivers/vmk80xx.c
   3     Velleman USB Board Low-Level Driver
   4
   5     Copyright (C) 2009 Manuel Gebele <forensixs@gmx.de>, Germany
   6
   7     COMEDI - Linux Control and Measurement Device Interface
   8     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18     GNU General Public License for more details.
  19
  20     You should have received a copy of the GNU General Public License
  21     along with this program; if not, write to the Free Software
  22     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23
  24 */
  25 /*
  26 Driver: vmk80xx
  27 Description: Velleman USB Board Low-Level Driver
  28 Devices: K8055/K8061 aka VM110/VM140
  29 Author: Manuel Gebele <forensixs@gmx.de>
  30 Updated: Sun, 10 May 2009 11:14:59 +0200
  31 Status: works
  32
  33 Supports:
  34  - analog input
  35  - analog output
  36  - digital input
  37  - digital output
  38  - counter
  39  - pwm
  40 */
  41 /*
  42 Changelog:
  43
  44 0.8.81  -3-  code completely rewritten (adjust driver logic)
  45 0.8.81  -2-  full support for K8061
  46 0.8.81  -1-  fix some mistaken among others the number of
  47              supported boards and I/O handling
  48
  49 0.7.76  -4-  renamed to vmk80xx
  50 0.7.76  -3-  detect K8061 (only theoretically supported)
  51 0.7.76  -2-  code completely rewritten (adjust driver logic)
  52 0.7.76  -1-  support for digital and counter subdevice
  53 */
  54
  55 #include <linux/kernel.h>
  56 #include <linux/module.h>
  57 #include <linux/mutex.h>
  58 #include <linux/errno.h>
  59 #include <linux/input.h>
  60 #include <linux/slab.h>
  61 #include <linux/poll.h>
  62 #include <linux/usb.h>
  63 #include <linux/uaccess.h>
  64
  65 #include "../comedidev.h"
  66
  67 enum {
  68         DEVICE_VMK8055,
  69         DEVICE_VMK8061
  70 };
  71
  72 #define VMK8055_DI_REG          0x00
  73 #define VMK8055_DO_REG          0x01
  74 #define VMK8055_AO1_REG         0x02
  75 #define VMK8055_AO2_REG         0x03
  76 #define VMK8055_AI1_REG         0x02
  77 #define VMK8055_AI2_REG         0x03
  78 #define VMK8055_CNT1_REG        0x04
  79 #define VMK8055_CNT2_REG        0x06
  80
  81 #define VMK8061_CH_REG          0x01
  82 #define VMK8061_DI_REG          0x01
  83 #define VMK8061_DO_REG          0x01
  84 #define VMK8061_PWM_REG1        0x01
  85 #define VMK8061_PWM_REG2        0x02
  86 #define VMK8061_CNT_REG         0x02
  87 #define VMK8061_AO_REG          0x02
  88 #define VMK8061_AI_REG1         0x02
  89 #define VMK8061_AI_REG2         0x03
  90
  91 #define VMK8055_CMD_RST         0x00
  92 #define VMK8055_CMD_DEB1_TIME   0x01
  93 #define VMK8055_CMD_DEB2_TIME   0x02
  94 #define VMK8055_CMD_RST_CNT1    0x03
  95 #define VMK8055_CMD_RST_CNT2    0x04
  96 #define VMK8055_CMD_WRT_AD      0x05
  97
  98 #define VMK8061_CMD_RD_AI       0x00
  99 #define VMK8061_CMR_RD_ALL_AI   0x01    /* !non-active! */
 100 #define VMK8061_CMD_SET_AO      0x02
 101 #define VMK8061_CMD_SET_ALL_AO  0x03    /* !non-active! */
 102 #define VMK8061_CMD_OUT_PWM     0x04
 103 #define VMK8061_CMD_RD_DI       0x05
 104 #define VMK8061_CMD_DO          0x06    /* !non-active! */
 105 #define VMK8061_CMD_CLR_DO      0x07
 106 #define VMK8061_CMD_SET_DO      0x08
 107 #define VMK8061_CMD_RD_CNT      0x09    /* TODO: completely pointless? */
 108 #define VMK8061_CMD_RST_CNT     0x0a    /* TODO: completely pointless? */
 109 #define VMK8061_CMD_RD_VERSION  0x0b    /* internal usage */
 110 #define VMK8061_CMD_RD_JMP_STAT 0x0c    /* TODO: not implemented yet */
 111 #define VMK8061_CMD_RD_PWR_STAT 0x0d    /* internal usage */
 112 #define VMK8061_CMD_RD_DO       0x0e
 113 #define VMK8061_CMD_RD_AO       0x0f
 114 #define VMK8061_CMD_RD_PWM      0x10
 115
 116 #define VMK80XX_MAX_BOARDS      COMEDI_NUM_BOARD_MINORS
 117
 118 #define TRANS_OUT_BUSY          1
 119 #define TRANS_IN_BUSY           2
 120 #define TRANS_IN_RUNNING        3
 121
 122 #define IC3_VERSION             (1 << 0)
 123 #define IC6_VERSION             (1 << 1)
 124
 125 #define URB_RCV_FLAG            (1 << 0)
 126 #define URB_SND_FLAG            (1 << 1)
 127
 128 #ifdef CONFIG_COMEDI_DEBUG
 129 static int dbgcm = 1;
 130 #else
 131 static int dbgcm;
 132 #endif
 133
 134 #define dbgcm(fmt, arg...)                     \
 135 do {                                           \
 136         if (dbgcm)                             \
 137                 printk(KERN_DEBUG fmt, ##arg); \
 138 } while (0)
 139
 140 enum vmk80xx_model {
 141         VMK8055_MODEL,
 142         VMK8061_MODEL
 143 };
 144
 145 struct firmware_version {
 146         unsigned char ic3_vers[32];     /* USB-Controller */
 147         unsigned char ic6_vers[32];     /* CPU */
 148 };
 149
 150 static const struct comedi_lrange vmk8055_range = {
 151         1, {UNI_RANGE(5)}
 152 };
 153
 154 static const struct comedi_lrange vmk8061_range = {
 155         2, {UNI_RANGE(5), UNI_RANGE(10)}
 156 };
 157
 158 struct vmk80xx_board {
 159         const char *name;
 160         enum vmk80xx_model model;
 161         const struct comedi_lrange *range;
 162         __u8 ai_chans;
 163         __le16 ai_bits;
 164         __u8 ao_chans;
 165         __le16 ao_bits;
 166         __u8 di_chans;
 167         __le16 di_bits;
 168         __u8 do_chans;
 169         __le16 do_bits;
 170         __u8 cnt_chans;
 171         __le16 cnt_bits;
 172         __u8 pwm_chans;
 173         __le16 pwm_bits;
 174 };
 175
 176 enum {
 177         VMK80XX_SUBD_AI,
 178         VMK80XX_SUBD_AO,
 179         VMK80XX_SUBD_DI,
 180         VMK80XX_SUBD_DO,
 181         VMK80XX_SUBD_CNT,
 182         VMK80XX_SUBD_PWM,
 183 };
 184
 185 struct vmk80xx_usb {
 186         struct usb_device *udev;
 187         struct usb_interface *intf;
 188         struct usb_endpoint_descriptor *ep_rx;
 189         struct usb_endpoint_descriptor *ep_tx;
 190         struct usb_anchor rx_anchor;
 191         struct usb_anchor tx_anchor;
 192         struct vmk80xx_board board;
 193         struct firmware_version fw;
 194         struct semaphore limit_sem;
 195         wait_queue_head_t read_wait;
 196         wait_queue_head_t write_wait;
 197         unsigned char *usb_rx_buf;
 198         unsigned char *usb_tx_buf;
 199         unsigned long flags;
 200         int probed;
 201         int attached;
 202         int count;
 203 };
 204
 205 static struct vmk80xx_usb vmb[VMK80XX_MAX_BOARDS];
 206
 207 static DEFINE_MUTEX(glb_mutex);
 208
 209 static void vmk80xx_tx_callback(struct urb *urb)
 210 {
 211         struct vmk80xx_usb *dev = urb->context;
 212         int stat = urb->status;
 213
 214         if (stat && !(stat == -ENOENT
 215                       || stat == -ECONNRESET || stat == -ESHUTDOWN))
 216                 dbgcm("comedi#: vmk80xx: %s - nonzero urb status (%d)\n",
 217                       __func__, stat);
 218
 219         if (!test_bit(TRANS_OUT_BUSY, &dev->flags))
 220                 return;
 221
 222         clear_bit(TRANS_OUT_BUSY, &dev->flags);
 223
 224         wake_up_interruptible(&dev->write_wait);
 225 }
 226
 227 static void vmk80xx_rx_callback(struct urb *urb)
 228 {
 229         struct vmk80xx_usb *dev = urb->context;
 230         int stat = urb->status;
 231
 232         switch (stat) {
 233         case 0:
 234                 break;
 235         case -ENOENT:
 236         case -ECONNRESET:
 237         case -ESHUTDOWN:
 238                 break;
 239         default:
 240                 dbgcm("comedi#: vmk80xx: %s - nonzero urb status (%d)\n",
 241                       __func__, stat);
 242                 goto resubmit;
 243         }
 244
 245         goto exit;
 246 resubmit:
 247         if (test_bit(TRANS_IN_RUNNING, &dev->flags) && dev->intf) {
 248                 usb_anchor_urb(urb, &dev->rx_anchor);
 249
 250                 if (!usb_submit_urb(urb, GFP_KERNEL))
 251                         goto exit;
 252
 253                 dev_err(&urb->dev->dev,
 254                         "comedi#: vmk80xx: %s - submit urb failed\n",
 255                         __func__);
 256
 257                 usb_unanchor_urb(urb);
 258         }
 259 exit:
 260         clear_bit(TRANS_IN_BUSY, &dev->flags);
 261
 262         wake_up_interruptible(&dev->read_wait);
 263 }
 264
 265 static int vmk80xx_check_data_link(struct vmk80xx_usb *dev)
 266 {
 267         unsigned int tx_pipe;
 268         unsigned int rx_pipe;
 269         unsigned char tx[1];
 270         unsigned char rx[2];
 271
 272         tx_pipe = usb_sndbulkpipe(dev->udev, 0x01);
 273         rx_pipe = usb_rcvbulkpipe(dev->udev, 0x81);
 274
 275         tx[0] = VMK8061_CMD_RD_PWR_STAT;
 276
 277         /*
 278          * Check that IC6 (PIC16F871) is powered and
 279          * running and the data link between IC3 and
 280          * IC6 is working properly
 281          */
 282         usb_bulk_msg(dev->udev, tx_pipe, tx, 1, NULL, dev->ep_tx->bInterval);
 283         usb_bulk_msg(dev->udev, rx_pipe, rx, 2, NULL, HZ * 10);
 284
 285         return (int)rx[1];
 286 }
 287
 288 static void vmk80xx_read_eeprom(struct vmk80xx_usb *dev, int flag)
 289 {
 290         unsigned int tx_pipe;
 291         unsigned int rx_pipe;
 292         unsigned char tx[1];
 293         unsigned char rx[64];
 294         int cnt;
 295
 296         tx_pipe = usb_sndbulkpipe(dev->udev, 0x01);
 297         rx_pipe = usb_rcvbulkpipe(dev->udev, 0x81);
 298
 299         tx[0] = VMK8061_CMD_RD_VERSION;
 300
 301         /*
 302          * Read the firmware version info of IC3 and
 303          * IC6 from the internal EEPROM of the IC
 304          */
 305         usb_bulk_msg(dev->udev, tx_pipe, tx, 1, NULL, dev->ep_tx->bInterval);
 306         usb_bulk_msg(dev->udev, rx_pipe, rx, 64, &cnt, HZ * 10);
 307
 308         rx[cnt] = '\0';
 309
 310         if (flag & IC3_VERSION)
 311                 strncpy(dev->fw.ic3_vers, rx + 1, 24);
 312         else                    /* IC6_VERSION */
 313                 strncpy(dev->fw.ic6_vers, rx + 25, 24);
 314 }
 315
 316 static int vmk80xx_reset_device(struct vmk80xx_usb *dev)
 317 {
 318         struct urb *urb;
 319         unsigned int tx_pipe;
 320         int ival;
 321         size_t size;
 322
 323         urb = usb_alloc_urb(0, GFP_KERNEL);
 324         if (!urb)
 325                 return -ENOMEM;
 326
 327         tx_pipe = usb_sndintpipe(dev->udev, 0x01);
 328
 329         ival = dev->ep_tx->bInterval;
 330         size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
 331
 332         dev->usb_tx_buf[0] = VMK8055_CMD_RST;
 333         dev->usb_tx_buf[1] = 0x00;
 334         dev->usb_tx_buf[2] = 0x00;
 335         dev->usb_tx_buf[3] = 0x00;
 336         dev->usb_tx_buf[4] = 0x00;
 337         dev->usb_tx_buf[5] = 0x00;
 338         dev->usb_tx_buf[6] = 0x00;
 339         dev->usb_tx_buf[7] = 0x00;
 340
 341         usb_fill_int_urb(urb, dev->udev, tx_pipe, dev->usb_tx_buf,
 342                          size, vmk80xx_tx_callback, dev, ival);
 343
 344         usb_anchor_urb(urb, &dev->tx_anchor);
 345
 346         return usb_submit_urb(urb, GFP_KERNEL);
 347 }
 348
 349 static void vmk80xx_build_int_urb(struct urb *urb, int flag)
 350 {
 351         struct vmk80xx_usb *dev = urb->context;
 352         __u8 rx_addr;
 353         __u8 tx_addr;
 354         unsigned int pipe;
 355         unsigned char *buf;
 356         size_t size;
 357         void (*callback) (struct urb *);
 358         int ival;
 359
 360         if (flag & URB_RCV_FLAG) {
 361                 rx_addr = dev->ep_rx->bEndpointAddress;
 362                 pipe = usb_rcvintpipe(dev->udev, rx_addr);
 363                 buf = dev->usb_rx_buf;
 364                 size = le16_to_cpu(dev->ep_rx->wMaxPacketSize);
 365                 callback = vmk80xx_rx_callback;
 366                 ival = dev->ep_rx->bInterval;
 367         } else {                /* URB_SND_FLAG */
 368                 tx_addr = dev->ep_tx->bEndpointAddress;
 369                 pipe = usb_sndintpipe(dev->udev, tx_addr);
 370                 buf = dev->usb_tx_buf;
 371                 size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
 372                 callback = vmk80xx_tx_callback;
 373                 ival = dev->ep_tx->bInterval;
 374         }
 375
 376         usb_fill_int_urb(urb, dev->udev, pipe, buf, size, callback, dev, ival);
 377 }
 378
 379 static void vmk80xx_do_bulk_msg(struct vmk80xx_usb *dev)
 380 {
 381         __u8 tx_addr;
 382         __u8 rx_addr;
 383         unsigned int tx_pipe;
 384         unsigned int rx_pipe;
 385         size_t size;
 386
 387         set_bit(TRANS_IN_BUSY, &dev->flags);
 388         set_bit(TRANS_OUT_BUSY, &dev->flags);
 389
 390         tx_addr = dev->ep_tx->bEndpointAddress;
 391         rx_addr = dev->ep_rx->bEndpointAddress;
 392         tx_pipe = usb_sndbulkpipe(dev->udev, tx_addr);
 393         rx_pipe = usb_rcvbulkpipe(dev->udev, rx_addr);
 394
 395         /*
 396          * The max packet size attributes of the K8061
 397          * input/output endpoints are identical
 398          */
 399         size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
 400
 401         usb_bulk_msg(dev->udev, tx_pipe, dev->usb_tx_buf,
 402                      size, NULL, dev->ep_tx->bInterval);
 403         usb_bulk_msg(dev->udev, rx_pipe, dev->usb_rx_buf, size, NULL, HZ * 10);
 404
 405         clear_bit(TRANS_OUT_BUSY, &dev->flags);
 406         clear_bit(TRANS_IN_BUSY, &dev->flags);
 407 }
 408
 409 static int vmk80xx_read_packet(struct vmk80xx_usb *dev)
 410 {
 411         struct urb *urb;
 412         int retval;
 413
 414         if (!dev->intf)
 415                 return -ENODEV;
 416
 417         /* Only useful for interrupt transfers */
 418         if (test_bit(TRANS_IN_BUSY, &dev->flags))
 419                 if (wait_event_interruptible(dev->read_wait,
 420                                              !test_bit(TRANS_IN_BUSY,
 421                                                        &dev->flags)))
 422                         return -ERESTART;
 423
 424         if (dev->board.model == VMK8061_MODEL) {
 425                 vmk80xx_do_bulk_msg(dev);
 426
 427                 return 0;
 428         }
 429
 430         urb = usb_alloc_urb(0, GFP_KERNEL);
 431         if (!urb)
 432                 return -ENOMEM;
 433
 434         urb->context = dev;
 435         vmk80xx_build_int_urb(urb, URB_RCV_FLAG);
 436
 437         set_bit(TRANS_IN_RUNNING, &dev->flags);
 438         set_bit(TRANS_IN_BUSY, &dev->flags);
 439
 440         usb_anchor_urb(urb, &dev->rx_anchor);
 441
 442         retval = usb_submit_urb(urb, GFP_KERNEL);
 443         if (!retval)
 444                 goto exit;
 445
 446         clear_bit(TRANS_IN_RUNNING, &dev->flags);
 447         usb_unanchor_urb(urb);
 448
 449 exit:
 450         usb_free_urb(urb);
 451
 452         return retval;
 453 }
 454
 455 static int vmk80xx_write_packet(struct vmk80xx_usb *dev, int cmd)
 456 {
 457         struct urb *urb;
 458         int retval;
 459
 460         if (!dev->intf)
 461                 return -ENODEV;
 462
 463         if (test_bit(TRANS_OUT_BUSY, &dev->flags))
 464                 if (wait_event_interruptible(dev->write_wait,
 465                                              !test_bit(TRANS_OUT_BUSY,
 466                                                        &dev->flags)))
 467                         return -ERESTART;
 468
 469         if (dev->board.model == VMK8061_MODEL) {
 470                 dev->usb_tx_buf[0] = cmd;
 471                 vmk80xx_do_bulk_msg(dev);
 472
 473                 return 0;
 474         }
 475
 476         urb = usb_alloc_urb(0, GFP_KERNEL);
 477         if (!urb)
 478                 return -ENOMEM;
 479
 480         urb->context = dev;
 481         vmk80xx_build_int_urb(urb, URB_SND_FLAG);
 482
 483         set_bit(TRANS_OUT_BUSY, &dev->flags);
 484
 485         usb_anchor_urb(urb, &dev->tx_anchor);
 486
 487         dev->usb_tx_buf[0] = cmd;
 488
 489         retval = usb_submit_urb(urb, GFP_KERNEL);
 490         if (!retval)
 491                 goto exit;
 492
 493         clear_bit(TRANS_OUT_BUSY, &dev->flags);
 494         usb_unanchor_urb(urb);
 495
 496 exit:
 497         usb_free_urb(urb);
 498
 499         return retval;
 500 }
 501
 502 #define DIR_IN  1
 503 #define DIR_OUT 2
 504
 505 static int rudimentary_check(struct vmk80xx_usb *dev, int dir)
 506 {
 507         if (!dev)
 508                 return -EFAULT;
 509         if (!dev->probed)
 510                 return -ENODEV;
 511         if (!dev->attached)
 512                 return -ENODEV;
 513         if (dir & DIR_IN) {
 514                 if (test_bit(TRANS_IN_BUSY, &dev->flags))
 515                         return -EBUSY;
 516         }
 517         if (dir & DIR_OUT) {
 518                 if (test_bit(TRANS_OUT_BUSY, &dev->flags))
 519                         return -EBUSY;
 520         }
 521
 522         return 0;
 523 }
 524
 525 static int vmk80xx_ai_rinsn(struct comedi_device *cdev,
 526                             struct comedi_subdevice *s,
 527                             struct comedi_insn *insn, unsigned int *data)
 528 {
 529         struct vmk80xx_usb *dev = cdev->private;
 530         int chan;
 531         int reg[2];
 532         int n;
 533
 534         n = rudimentary_check(dev, DIR_IN);
 535         if (n)
 536                 return n;
 537
 538         down(&dev->limit_sem);
 539         chan = CR_CHAN(insn->chanspec);
 540
 541         switch (dev->board.model) {
 542         case VMK8055_MODEL:
 543                 if (!chan)
 544                         reg[0] = VMK8055_AI1_REG;
 545                 else
 546                         reg[0] = VMK8055_AI2_REG;
 547                 break;
 548         case VMK8061_MODEL:
 549                 reg[0] = VMK8061_AI_REG1;
 550                 reg[1] = VMK8061_AI_REG2;
 551                 dev->usb_tx_buf[0] = VMK8061_CMD_RD_AI;
 552                 dev->usb_tx_buf[VMK8061_CH_REG] = chan;
 553                 break;
 554         }
 555
 556         for (n = 0; n < insn->n; n++) {
 557                 if (vmk80xx_read_packet(dev))
 558                         break;
 559
 560                 if (dev->board.model == VMK8055_MODEL) {
 561                         data[n] = dev->usb_rx_buf[reg[0]];
 562                         continue;
 563                 }
 564
 565                 /* VMK8061_MODEL */
 566                 data[n] = dev->usb_rx_buf[reg[0]] + 256 *
 567                     dev->usb_rx_buf[reg[1]];
 568         }
 569
 570         up(&dev->limit_sem);
 571
 572         return n;
 573 }
 574
 575 static int vmk80xx_ao_winsn(struct comedi_device *cdev,
 576                             struct comedi_subdevice *s,
 577                             struct comedi_insn *insn, unsigned int *data)
 578 {
 579         struct vmk80xx_usb *dev = cdev->private;
 580         int chan;
 581         int cmd;
 582         int reg;
 583         int n;
 584
 585         n = rudimentary_check(dev, DIR_OUT);
 586         if (n)
 587                 return n;
 588
 589         down(&dev->limit_sem);
 590         chan = CR_CHAN(insn->chanspec);
 591
 592         switch (dev->board.model) {
 593         case VMK8055_MODEL:
 594                 cmd = VMK8055_CMD_WRT_AD;
 595                 if (!chan)
 596                         reg = VMK8055_AO1_REG;
 597                 else
 598                         reg = VMK8055_AO2_REG;
 599                 break;
 600         default:                /* NOTE: avoid compiler warnings */
 601                 cmd = VMK8061_CMD_SET_AO;
 602                 reg = VMK8061_AO_REG;
 603                 dev->usb_tx_buf[VMK8061_CH_REG] = chan;
 604                 break;
 605         }
 606
 607         for (n = 0; n < insn->n; n++) {
 608                 dev->usb_tx_buf[reg] = data[n];
 609
 610                 if (vmk80xx_write_packet(dev, cmd))
 611                         break;
 612         }
 613
 614         up(&dev->limit_sem);
 615
 616         return n;
 617 }
 618
 619 static int vmk80xx_ao_rinsn(struct comedi_device *cdev,
 620                             struct comedi_subdevice *s,
 621                             struct comedi_insn *insn, unsigned int *data)
 622 {
 623         struct vmk80xx_usb *dev = cdev->private;
 624         int chan;
 625         int reg;
 626         int n;
 627
 628         n = rudimentary_check(dev, DIR_IN);
 629         if (n)
 630                 return n;
 631
 632         down(&dev->limit_sem);
 633         chan = CR_CHAN(insn->chanspec);
 634
 635         reg = VMK8061_AO_REG - 1;
 636
 637         dev->usb_tx_buf[0] = VMK8061_CMD_RD_AO;
 638
 639         for (n = 0; n < insn->n; n++) {
 640                 if (vmk80xx_read_packet(dev))
 641                         break;
 642
 643                 data[n] = dev->usb_rx_buf[reg + chan];
 644         }
 645
 646         up(&dev->limit_sem);
 647
 648         return n;
 649 }
 650
 651 static int vmk80xx_di_bits(struct comedi_device *cdev,
 652                            struct comedi_subdevice *s,
 653                            struct comedi_insn *insn, unsigned int *data)
 654 {
 655         struct vmk80xx_usb *dev = cdev->private;
 656         unsigned char *rx_buf;
 657         int reg;
 658         int retval;
 659
 660         retval = rudimentary_check(dev, DIR_IN);
 661         if (retval)
 662                 return retval;
 663
 664         down(&dev->limit_sem);
 665
 666         rx_buf = dev->usb_rx_buf;
 667
 668         if (dev->board.model == VMK8061_MODEL) {
 669                 reg = VMK8061_DI_REG;
 670                 dev->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
 671         } else {
 672                 reg = VMK8055_DI_REG;
 673         }
 674
 675         retval = vmk80xx_read_packet(dev);
 676
 677         if (!retval) {
 678                 if (dev->board.model == VMK8055_MODEL)
 679                         data[1] = (((rx_buf[reg] >> 4) & 0x03) |
 680                                   ((rx_buf[reg] << 2) & 0x04) |
 681                                   ((rx_buf[reg] >> 3) & 0x18));
 682                 else
 683                         data[1] = rx_buf[reg];
 684
 685                 retval = 2;
 686         }
 687
 688         up(&dev->limit_sem);
 689
 690         return retval;
 691 }
 692
 693 static int vmk80xx_di_rinsn(struct comedi_device *cdev,
 694                             struct comedi_subdevice *s,
 695                             struct comedi_insn *insn, unsigned int *data)
 696 {
 697         struct vmk80xx_usb *dev = cdev->private;
 698         int chan;
 699         unsigned char *rx_buf;
 700         int reg;
 701         int inp;
 702         int n;
 703
 704         n = rudimentary_check(dev, DIR_IN);
 705         if (n)
 706                 return n;
 707
 708         down(&dev->limit_sem);
 709         chan = CR_CHAN(insn->chanspec);
 710
 711         rx_buf = dev->usb_rx_buf;
 712
 713         if (dev->board.model == VMK8061_MODEL) {
 714                 reg = VMK8061_DI_REG;
 715                 dev->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
 716         } else {
 717                 reg = VMK8055_DI_REG;
 718         }
 719         for (n = 0; n < insn->n; n++) {
 720                 if (vmk80xx_read_packet(dev))
 721                         break;
 722
 723                 if (dev->board.model == VMK8055_MODEL)
 724                         inp = (((rx_buf[reg] >> 4) & 0x03) |
 725                                ((rx_buf[reg] << 2) & 0x04) |
 726                                ((rx_buf[reg] >> 3) & 0x18));
 727                 else
 728                         inp = rx_buf[reg];
 729
 730                 data[n] = (inp >> chan) & 1;
 731         }
 732
 733         up(&dev->limit_sem);
 734
 735         return n;
 736 }
 737
 738 static int vmk80xx_do_winsn(struct comedi_device *cdev,
 739                             struct comedi_subdevice *s,
 740                             struct comedi_insn *insn, unsigned int *data)
 741 {
 742         struct vmk80xx_usb *dev = cdev->private;
 743         int chan;
 744         unsigned char *tx_buf;
 745         int reg;
 746         int cmd;
 747         int n;
 748
 749         n = rudimentary_check(dev, DIR_OUT);
 750         if (n)
 751                 return n;
 752
 753         down(&dev->limit_sem);
 754         chan = CR_CHAN(insn->chanspec);
 755
 756         tx_buf = dev->usb_tx_buf;
 757
 758         for (n = 0; n < insn->n; n++) {
 759                 if (dev->board.model == VMK8055_MODEL) {
 760                         reg = VMK8055_DO_REG;
 761                         cmd = VMK8055_CMD_WRT_AD;
 762                         if (data[n] == 1)
 763                                 tx_buf[reg] |= (1 << chan);
 764                         else
 765                                 tx_buf[reg] ^= (1 << chan);
 766                 } else { /* VMK8061_MODEL */
 767                         reg = VMK8061_DO_REG;
 768                         if (data[n] == 1) {
 769                                 cmd = VMK8061_CMD_SET_DO;
 770                                 tx_buf[reg] = 1 << chan;
 771                         } else {
 772                                 cmd = VMK8061_CMD_CLR_DO;
 773                                 tx_buf[reg] = 0xff - (1 << chan);
 774                         }
 775                 }
 776
 777                 if (vmk80xx_write_packet(dev, cmd))
 778                         break;
 779         }
 780
 781         up(&dev->limit_sem);
 782
 783         return n;
 784 }
 785
 786 static int vmk80xx_do_rinsn(struct comedi_device *cdev,
 787                             struct comedi_subdevice *s,
 788                             struct comedi_insn *insn, unsigned int *data)
 789 {
 790         struct vmk80xx_usb *dev = cdev->private;
 791         int chan;
 792         int reg;
 793         int n;
 794
 795         n = rudimentary_check(dev, DIR_IN);
 796         if (n)
 797                 return n;
 798
 799         down(&dev->limit_sem);
 800         chan = CR_CHAN(insn->chanspec);
 801
 802         reg = VMK8061_DO_REG;
 803
 804         dev->usb_tx_buf[0] = VMK8061_CMD_RD_DO;
 805
 806         for (n = 0; n < insn->n; n++) {
 807                 if (vmk80xx_read_packet(dev))
 808                         break;
 809
 810                 data[n] = (dev->usb_rx_buf[reg] >> chan) & 1;
 811         }
 812
 813         up(&dev->limit_sem);
 814
 815         return n;
 816 }
 817
 818 static int vmk80xx_do_bits(struct comedi_device *cdev,
 819                            struct comedi_subdevice *s,
 820                            struct comedi_insn *insn, unsigned int *data)
 821 {
 822         struct vmk80xx_usb *dev = cdev->private;
 823         unsigned char *rx_buf, *tx_buf;
 824         int dir, reg, cmd;
 825         int retval;
 826
 827         dir = 0;
 828
 829         if (data[0])
 830                 dir |= DIR_OUT;
 831
 832         if (dev->board.model == VMK8061_MODEL)
 833                 dir |= DIR_IN;
 834
 835         retval = rudimentary_check(dev, dir);
 836         if (retval)
 837                 return retval;
 838
 839         down(&dev->limit_sem);
 840
 841         rx_buf = dev->usb_rx_buf;
 842         tx_buf = dev->usb_tx_buf;
 843
 844         if (data[0]) {
 845                 if (dev->board.model == VMK8055_MODEL) {
 846                         reg = VMK8055_DO_REG;
 847                         cmd = VMK8055_CMD_WRT_AD;
 848                 } else { /* VMK8061_MODEL */
 849                         reg = VMK8061_DO_REG;
 850                         cmd = VMK8061_CMD_DO;
 851                 }
 852
 853                 tx_buf[reg] &= ~data[0];
 854                 tx_buf[reg] |= (data[0] & data[1]);
 855
 856                 retval = vmk80xx_write_packet(dev, cmd);
 857
 858                 if (retval)
 859                         goto out;
 860         }
 861
 862         if (dev->board.model == VMK8061_MODEL) {
 863                 reg = VMK8061_DO_REG;
 864                 tx_buf[0] = VMK8061_CMD_RD_DO;
 865
 866                 retval = vmk80xx_read_packet(dev);
 867
 868                 if (!retval) {
 869                         data[1] = rx_buf[reg];
 870                         retval = 2;
 871                 }
 872         } else {
 873                 data[1] = tx_buf[reg];
 874                 retval = 2;
 875         }
 876
 877 out:
 878         up(&dev->limit_sem);
 879
 880         return retval;
 881 }
 882
 883 static int vmk80xx_cnt_rinsn(struct comedi_device *cdev,
 884                              struct comedi_subdevice *s,
 885                              struct comedi_insn *insn, unsigned int *data)
 886 {
 887         struct vmk80xx_usb *dev = cdev->private;
 888         int chan;
 889         int reg[2];
 890         int n;
 891
 892         n = rudimentary_check(dev, DIR_IN);
 893         if (n)
 894                 return n;
 895
 896         down(&dev->limit_sem);
 897         chan = CR_CHAN(insn->chanspec);
 898
 899         switch (dev->board.model) {
 900         case VMK8055_MODEL:
 901                 if (!chan)
 902                         reg[0] = VMK8055_CNT1_REG;
 903                 else
 904                         reg[0] = VMK8055_CNT2_REG;
 905                 break;
 906         case VMK8061_MODEL:
 907                 reg[0] = VMK8061_CNT_REG;
 908                 reg[1] = VMK8061_CNT_REG;
 909                 dev->usb_tx_buf[0] = VMK8061_CMD_RD_CNT;
 910                 break;
 911         }
 912
 913         for (n = 0; n < insn->n; n++) {
 914                 if (vmk80xx_read_packet(dev))
 915                         break;
 916
 917                 if (dev->board.model == VMK8055_MODEL)
 918                         data[n] = dev->usb_rx_buf[reg[0]];
 919                 else /* VMK8061_MODEL */
 920                         data[n] = dev->usb_rx_buf[reg[0] * (chan + 1) + 1]
 921                             + 256 * dev->usb_rx_buf[reg[1] * 2 + 2];
 922         }
 923
 924         up(&dev->limit_sem);
 925
 926         return n;
 927 }
 928
 929 static int vmk80xx_cnt_cinsn(struct comedi_device *cdev,
 930                              struct comedi_subdevice *s,
 931                              struct comedi_insn *insn, unsigned int *data)
 932 {
 933         struct vmk80xx_usb *dev = cdev->private;
 934         unsigned int insn_cmd;
 935         int chan;
 936         int cmd;
 937         int reg;
 938         int n;
 939
 940         n = rudimentary_check(dev, DIR_OUT);
 941         if (n)
 942                 return n;
 943
 944         insn_cmd = data[0];
 945         if (insn_cmd != INSN_CONFIG_RESET && insn_cmd != GPCT_RESET)
 946                 return -EINVAL;
 947
 948         down(&dev->limit_sem);
 949
 950         chan = CR_CHAN(insn->chanspec);
 951
 952         if (dev->board.model == VMK8055_MODEL) {
 953                 if (!chan) {
 954                         cmd = VMK8055_CMD_RST_CNT1;
 955                         reg = VMK8055_CNT1_REG;
 956                 } else {
 957                         cmd = VMK8055_CMD_RST_CNT2;
 958                         reg = VMK8055_CNT2_REG;
 959                 }
 960
 961                 dev->usb_tx_buf[reg] = 0x00;
 962         } else {
 963                 cmd = VMK8061_CMD_RST_CNT;
 964         }
 965
 966         for (n = 0; n < insn->n; n++)
 967                 if (vmk80xx_write_packet(dev, cmd))
 968                         break;
 969
 970         up(&dev->limit_sem);
 971
 972         return n;
 973 }
 974
 975 static int vmk80xx_cnt_winsn(struct comedi_device *cdev,
 976                              struct comedi_subdevice *s,
 977                              struct comedi_insn *insn, unsigned int *data)
 978 {
 979         struct vmk80xx_usb *dev = cdev->private;
 980         unsigned long debtime;
 981         unsigned long val;
 982         int chan;
 983         int cmd;
 984         int n;
 985
 986         n = rudimentary_check(dev, DIR_OUT);
 987         if (n)
 988                 return n;
 989
 990         down(&dev->limit_sem);
 991         chan = CR_CHAN(insn->chanspec);
 992
 993         if (!chan)
 994                 cmd = VMK8055_CMD_DEB1_TIME;
 995         else
 996                 cmd = VMK8055_CMD_DEB2_TIME;
 997
 998         for (n = 0; n < insn->n; n++) {
 999                 debtime = data[n];
1000                 if (debtime == 0)
1001                         debtime = 1;
1002
1003                 /* TODO: Prevent overflows */
1004                 if (debtime > 7450)
1005                         debtime = 7450;
1006
1007                 val = int_sqrt(debtime * 1000 / 115);
1008                 if (((val + 1) * val) < debtime * 1000 / 115)
1009                         val += 1;
1010
1011                 dev->usb_tx_buf[6 + chan] = val;
1012
1013                 if (vmk80xx_write_packet(dev, cmd))
1014                         break;
1015         }
1016
1017         up(&dev->limit_sem);
1018
1019         return n;
1020 }
1021
1022 static int vmk80xx_pwm_rinsn(struct comedi_device *cdev,
1023                              struct comedi_subdevice *s,
1024                              struct comedi_insn *insn, unsigned int *data)
1025 {
1026         struct vmk80xx_usb *dev = cdev->private;
1027         int reg[2];
1028         int n;
1029
1030         n = rudimentary_check(dev, DIR_IN);
1031         if (n)
1032                 return n;
1033
1034         down(&dev->limit_sem);
1035
1036         reg[0] = VMK8061_PWM_REG1;
1037         reg[1] = VMK8061_PWM_REG2;
1038
1039         dev->usb_tx_buf[0] = VMK8061_CMD_RD_PWM;
1040
1041         for (n = 0; n < insn->n; n++) {
1042                 if (vmk80xx_read_packet(dev))
1043                         break;
1044
1045                 data[n] = dev->usb_rx_buf[reg[0]] + 4 * dev->usb_rx_buf[reg[1]];
1046         }
1047
1048         up(&dev->limit_sem);
1049
1050         return n;
1051 }
1052
1053 static int vmk80xx_pwm_winsn(struct comedi_device *cdev,
1054                              struct comedi_subdevice *s,
1055                              struct comedi_insn *insn, unsigned int *data)
1056 {
1057         struct vmk80xx_usb *dev = cdev->private;
1058         unsigned char *tx_buf;
1059         int reg[2];
1060         int cmd;
1061         int n;
1062
1063         n = rudimentary_check(dev, DIR_OUT);
1064         if (n)
1065                 return n;
1066
1067         down(&dev->limit_sem);
1068
1069         tx_buf = dev->usb_tx_buf;
1070
1071         reg[0] = VMK8061_PWM_REG1;
1072         reg[1] = VMK8061_PWM_REG2;
1073
1074         cmd = VMK8061_CMD_OUT_PWM;
1075
1076         /*
1077          * The followin piece of code was translated from the inline
1078          * assembler code in the DLL source code.
1079          *
1080          * asm
1081          *   mov eax, k  ; k is the value (data[n])
1082          *   and al, 03h ; al are the lower 8 bits of eax
1083          *   mov lo, al  ; lo is the low part (tx_buf[reg[0]])
1084          *   mov eax, k
1085          *   shr eax, 2  ; right shift eax register by 2
1086          *   mov hi, al  ; hi is the high part (tx_buf[reg[1]])
1087          * end;
1088          */
1089         for (n = 0; n < insn->n; n++) {
1090                 tx_buf[reg[0]] = (unsigned char)(data[n] & 0x03);
1091                 tx_buf[reg[1]] = (unsigned char)(data[n] >> 2) & 0xff;
1092
1093                 if (vmk80xx_write_packet(dev, cmd))
1094                         break;
1095         }
1096
1097         up(&dev->limit_sem);
1098
1099         return n;
1100 }
1101
1102 static int vmk80xx_attach_common(struct comedi_device *cdev,
1103                                  struct vmk80xx_usb *dev)
1104 {
1105         int n_subd;
1106         struct comedi_subdevice *s;
1107         int ret;
1108
1109         down(&dev->limit_sem);
1110         cdev->board_name = dev->board.name;
1111         cdev->private = dev;
1112         if (dev->board.model == VMK8055_MODEL)
1113                 n_subd = 5;
1114         else
1115                 n_subd = 6;
1116         ret = comedi_alloc_subdevices(cdev, n_subd);
1117         if (ret) {
1118                 up(&dev->limit_sem);
1119                 return ret;
1120         }
1121         /* Analog input subdevice */
1122         s = cdev->subdevices + VMK80XX_SUBD_AI;
1123         s->type = COMEDI_SUBD_AI;
1124         s->subdev_flags = SDF_READABLE | SDF_GROUND;
1125         s->n_chan = dev->board.ai_chans;
1126         s->maxdata = (1 << dev->board.ai_bits) - 1;
1127         s->range_table = dev->board.range;
1128         s->insn_read = vmk80xx_ai_rinsn;
1129         /* Analog output subdevice */
1130         s = cdev->subdevices + VMK80XX_SUBD_AO;
1131         s->type = COMEDI_SUBD_AO;
1132         s->subdev_flags = SDF_WRITEABLE | SDF_GROUND;
1133         s->n_chan = dev->board.ao_chans;
1134         s->maxdata = (1 << dev->board.ao_bits) - 1;
1135         s->range_table = dev->board.range;
1136         s->insn_write = vmk80xx_ao_winsn;
1137         if (dev->board.model == VMK8061_MODEL) {
1138                 s->subdev_flags |= SDF_READABLE;
1139                 s->insn_read = vmk80xx_ao_rinsn;
1140         }
1141         /* Digital input subdevice */
1142         s = cdev->subdevices + VMK80XX_SUBD_DI;
1143         s->type = COMEDI_SUBD_DI;
1144         s->subdev_flags = SDF_READABLE | SDF_GROUND;
1145         s->n_chan = dev->board.di_chans;
1146         s->maxdata = 1;
1147         s->insn_read = vmk80xx_di_rinsn;
1148         s->insn_bits = vmk80xx_di_bits;
1149         /* Digital output subdevice */
1150         s = cdev->subdevices + VMK80XX_SUBD_DO;
1151         s->type = COMEDI_SUBD_DO;
1152         s->subdev_flags = SDF_WRITEABLE | SDF_GROUND;
1153         s->n_chan = dev->board.do_chans;
1154         s->maxdata = 1;
1155         s->insn_write = vmk80xx_do_winsn;
1156         s->insn_bits = vmk80xx_do_bits;
1157         if (dev->board.model == VMK8061_MODEL) {
1158                 s->subdev_flags |= SDF_READABLE;
1159                 s->insn_read = vmk80xx_do_rinsn;
1160         }
1161         /* Counter subdevice */
1162         s = cdev->subdevices + VMK80XX_SUBD_CNT;
1163         s->type = COMEDI_SUBD_COUNTER;
1164         s->subdev_flags = SDF_READABLE;
1165         s->n_chan = dev->board.cnt_chans;
1166         s->insn_read = vmk80xx_cnt_rinsn;
1167         s->insn_config = vmk80xx_cnt_cinsn;
1168         if (dev->board.model == VMK8055_MODEL) {
1169                 s->subdev_flags |= SDF_WRITEABLE;
1170                 s->maxdata = (1 << dev->board.cnt_bits) - 1;
1171                 s->insn_write = vmk80xx_cnt_winsn;
1172         }
1173         /* PWM subdevice */
1174         if (dev->board.model == VMK8061_MODEL) {
1175                 s = cdev->subdevices + VMK80XX_SUBD_PWM;
1176                 s->type = COMEDI_SUBD_PWM;
1177                 s->subdev_flags = SDF_READABLE | SDF_WRITEABLE;
1178                 s->n_chan = dev->board.pwm_chans;
1179                 s->maxdata = (1 << dev->board.pwm_bits) - 1;
1180                 s->insn_read = vmk80xx_pwm_rinsn;
1181                 s->insn_write = vmk80xx_pwm_winsn;
1182         }
1183         dev->attached = 1;
1184         dev_info(cdev->class_dev, "vmk80xx: board #%d [%s] attached\n",
1185                  dev->count, dev->board.name);
1186         up(&dev->limit_sem);
1187         return 0;
1188 }
1189
1190 /* called for COMEDI_DEVCONFIG ioctl for board_name "vmk80xx" */
1191 static int vmk80xx_attach(struct comedi_device *cdev,
1192                           struct comedi_devconfig *it)
1193 {
1194         int i;
1195         int ret;
1196
1197         mutex_lock(&glb_mutex);
1198         for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
1199                 if (vmb[i].probed && !vmb[i].attached)
1200                         break;
1201         if (i == VMK80XX_MAX_BOARDS)
1202                 ret = -ENODEV;
1203         else
1204                 ret = vmk80xx_attach_common(cdev, &vmb[i]);
1205         mutex_unlock(&glb_mutex);
1206         return ret;
1207 }
1208
1209 /* called via comedi_usb_auto_config() */
1210 static int vmk80xx_attach_usb(struct comedi_device *cdev,
1211                               struct usb_interface *intf)
1212 {
1213         int i;
1214         int ret;
1215
1216         mutex_lock(&glb_mutex);
1217         for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
1218                 if (vmb[i].probed && vmb[i].intf == intf)
1219                         break;
1220         if (i == VMK80XX_MAX_BOARDS)
1221                 ret = -ENODEV;
1222         else if (vmb[i].attached)
1223                 ret = -EBUSY;
1224         else
1225                 ret = vmk80xx_attach_common(cdev, &vmb[i]);
1226         mutex_unlock(&glb_mutex);
1227         return ret;
1228 }
1229
1230 static void vmk80xx_detach(struct comedi_device *dev)
1231 {
1232         struct vmk80xx_usb *usb = dev->private;
1233
1234         if (usb) {
1235                 down(&usb->limit_sem);
1236                 dev->private = NULL;
1237                 usb->attached = 0;
1238                 up(&usb->limit_sem);
1239         }
1240 }
1241
1242 static struct comedi_driver vmk80xx_driver = {
1243         .module         = THIS_MODULE,
1244         .driver_name    = "vmk80xx",
1245         .attach         = vmk80xx_attach,
1246         .detach         = vmk80xx_detach,
1247         .attach_usb     = vmk80xx_attach_usb,
1248 };
1249
1250 static int vmk80xx_usb_probe(struct usb_interface *intf,
1251                              const struct usb_device_id *id)
1252 {
1253         int i;
1254         struct vmk80xx_usb *dev;
1255         struct usb_host_interface *iface_desc;
1256         struct usb_endpoint_descriptor *ep_desc;
1257         size_t size;
1258
1259         mutex_lock(&glb_mutex);
1260
1261         for (i = 0; i < VMK80XX_MAX_BOARDS; i++)
1262                 if (!vmb[i].probed)
1263                         break;
1264
1265         if (i == VMK80XX_MAX_BOARDS) {
1266                 mutex_unlock(&glb_mutex);
1267                 return -EMFILE;
1268         }
1269
1270         dev = &vmb[i];
1271
1272         memset(dev, 0x00, sizeof(struct vmk80xx_usb));
1273         dev->count = i;
1274
1275         iface_desc = intf->cur_altsetting;
1276         if (iface_desc->desc.bNumEndpoints != 2)
1277                 goto error;
1278
1279         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
1280                 ep_desc = &iface_desc->endpoint[i].desc;
1281
1282                 if (usb_endpoint_is_int_in(ep_desc)) {
1283                         dev->ep_rx = ep_desc;
1284                         continue;
1285                 }
1286
1287                 if (usb_endpoint_is_int_out(ep_desc)) {
1288                         dev->ep_tx = ep_desc;
1289                         continue;
1290                 }
1291
1292                 if (usb_endpoint_is_bulk_in(ep_desc)) {
1293                         dev->ep_rx = ep_desc;
1294                         continue;
1295                 }
1296
1297                 if (usb_endpoint_is_bulk_out(ep_desc)) {
1298                         dev->ep_tx = ep_desc;
1299                         continue;
1300                 }
1301         }
1302
1303         if (!dev->ep_rx || !dev->ep_tx)
1304                 goto error;
1305
1306         size = le16_to_cpu(dev->ep_rx->wMaxPacketSize);
1307         dev->usb_rx_buf = kmalloc(size, GFP_KERNEL);
1308         if (!dev->usb_rx_buf) {
1309                 mutex_unlock(&glb_mutex);
1310                 return -ENOMEM;
1311         }
1312
1313         size = le16_to_cpu(dev->ep_tx->wMaxPacketSize);
1314         dev->usb_tx_buf = kmalloc(size, GFP_KERNEL);
1315         if (!dev->usb_tx_buf) {
1316                 kfree(dev->usb_rx_buf);
1317                 mutex_unlock(&glb_mutex);
1318                 return -ENOMEM;
1319         }
1320
1321         dev->udev = interface_to_usbdev(intf);
1322         dev->intf = intf;
1323
1324         sema_init(&dev->limit_sem, 8);
1325         init_waitqueue_head(&dev->read_wait);
1326         init_waitqueue_head(&dev->write_wait);
1327
1328         init_usb_anchor(&dev->rx_anchor);
1329         init_usb_anchor(&dev->tx_anchor);
1330
1331         usb_set_intfdata(intf, dev);
1332
1333         switch (id->driver_info) {
1334         case DEVICE_VMK8055:
1335                 dev->board.name = "K8055 (VM110)";
1336                 dev->board.model = VMK8055_MODEL;
1337                 dev->board.range = &vmk8055_range;
1338                 dev->board.ai_chans = 2;
1339                 dev->board.ai_bits = 8;
1340                 dev->board.ao_chans = 2;
1341                 dev->board.ao_bits = 8;
1342                 dev->board.di_chans = 5;
1343                 dev->board.di_bits = 1;
1344                 dev->board.do_chans = 8;
1345                 dev->board.do_bits = 1;
1346                 dev->board.cnt_chans = 2;
1347                 dev->board.cnt_bits = 16;
1348                 dev->board.pwm_chans = 0;
1349                 dev->board.pwm_bits = 0;
1350                 break;
1351         case DEVICE_VMK8061:
1352                 dev->board.name = "K8061 (VM140)";
1353                 dev->board.model = VMK8061_MODEL;
1354                 dev->board.range = &vmk8061_range;
1355                 dev->board.ai_chans = 8;
1356                 dev->board.ai_bits = 10;
1357                 dev->board.ao_chans = 8;
1358                 dev->board.ao_bits = 8;
1359                 dev->board.di_chans = 8;
1360                 dev->board.di_bits = 1;
1361                 dev->board.do_chans = 8;
1362                 dev->board.do_bits = 1;
1363                 dev->board.cnt_chans = 2;
1364                 dev->board.cnt_bits = 0;
1365                 dev->board.pwm_chans = 1;
1366                 dev->board.pwm_bits = 10;
1367                 break;
1368         }
1369
1370         if (dev->board.model == VMK8061_MODEL) {
1371                 vmk80xx_read_eeprom(dev, IC3_VERSION);
1372                 printk(KERN_INFO "comedi#: vmk80xx: %s\n", dev->fw.ic3_vers);
1373
1374                 if (vmk80xx_check_data_link(dev)) {
1375                         vmk80xx_read_eeprom(dev, IC6_VERSION);
1376                         printk(KERN_INFO "comedi#: vmk80xx: %s\n",
1377                                dev->fw.ic6_vers);
1378                 } else {
1379                         dbgcm("comedi#: vmk80xx: no conn. to CPU\n");
1380                 }
1381         }
1382
1383         if (dev->board.model == VMK8055_MODEL)
1384                 vmk80xx_reset_device(dev);
1385
1386         dev->probed = 1;
1387
1388         printk(KERN_INFO "comedi#: vmk80xx: board #%d [%s] now attached\n",
1389                dev->count, dev->board.name);
1390
1391         mutex_unlock(&glb_mutex);
1392
1393         comedi_usb_auto_config(intf, &vmk80xx_driver);
1394
1395         return 0;
1396 error:
1397         mutex_unlock(&glb_mutex);
1398
1399         return -ENODEV;
1400 }
1401
1402 static void vmk80xx_usb_disconnect(struct usb_interface *intf)
1403 {
1404         struct vmk80xx_usb *dev = usb_get_intfdata(intf);
1405
1406         if (!dev)
1407                 return;
1408
1409         comedi_usb_auto_unconfig(intf);
1410
1411         mutex_lock(&glb_mutex);
1412         down(&dev->limit_sem);
1413
1414         dev->probed = 0;
1415         usb_set_intfdata(dev->intf, NULL);
1416
1417         usb_kill_anchored_urbs(&dev->rx_anchor);
1418         usb_kill_anchored_urbs(&dev->tx_anchor);
1419
1420         kfree(dev->usb_rx_buf);
1421         kfree(dev->usb_tx_buf);
1422
1423         printk(KERN_INFO "comedi#: vmk80xx: board #%d [%s] now detached\n",
1424                dev->count, dev->board.name);
1425
1426         up(&dev->limit_sem);
1427         mutex_unlock(&glb_mutex);
1428 }
1429
1430 static const struct usb_device_id vmk80xx_usb_id_table[] = {
1431         { USB_DEVICE(0x10cf, 0x5500), .driver_info = DEVICE_VMK8055 },
1432         { USB_DEVICE(0x10cf, 0x5501), .driver_info = DEVICE_VMK8055 },
1433         { USB_DEVICE(0x10cf, 0x5502), .driver_info = DEVICE_VMK8055 },
1434         { USB_DEVICE(0x10cf, 0x5503), .driver_info = DEVICE_VMK8055 },
1435         { USB_DEVICE(0x10cf, 0x8061), .driver_info = DEVICE_VMK8061 },
1436         { USB_DEVICE(0x10cf, 0x8062), .driver_info = DEVICE_VMK8061 },
1437         { USB_DEVICE(0x10cf, 0x8063), .driver_info = DEVICE_VMK8061 },
1438         { USB_DEVICE(0x10cf, 0x8064), .driver_info = DEVICE_VMK8061 },
1439         { USB_DEVICE(0x10cf, 0x8065), .driver_info = DEVICE_VMK8061 },
1440         { USB_DEVICE(0x10cf, 0x8066), .driver_info = DEVICE_VMK8061 },
1441         { USB_DEVICE(0x10cf, 0x8067), .driver_info = DEVICE_VMK8061 },
1442         { USB_DEVICE(0x10cf, 0x8068), .driver_info = DEVICE_VMK8061 },
1443         { }
1444 };
1445 MODULE_DEVICE_TABLE(usb, vmk80xx_usb_id_table);
1446
1447 /* TODO: Add support for suspend, resume, pre_reset,
1448  * post_reset and flush */
1449 static struct usb_driver vmk80xx_usb_driver = {
1450         .name           = "vmk80xx",
1451         .probe          = vmk80xx_usb_probe,
1452         .disconnect     = vmk80xx_usb_disconnect,
1453         .id_table       = vmk80xx_usb_id_table,
1454 };
1455 module_comedi_usb_driver(vmk80xx_driver, vmk80xx_usb_driver);
1456
1457 MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
1458 MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
1459 MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
1460 MODULE_VERSION("0.8.01");
1461 MODULE_LICENSE("GPL");