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