3 * Velleman USB Board Low-Level Driver
5 * Copyright (C) 2009 Manuel Gebele <forensixs@gmx.de>, Germany
7 * COMEDI - Linux Control and Measurement Device Interface
8 * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
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.
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.
23 * Description: Velleman USB Board Low-Level Driver
24 * Devices: [Velleman] K8055 (K8055/VM110), K8061 (K8061/VM140),
25 * VM110 (K8055/VM110), VM140 (K8061/VM140)
26 * Author: Manuel Gebele <forensixs@gmx.de>
27 * Updated: Sun, 10 May 2009 11:14:59 +0200
39 #include <linux/kernel.h>
40 #include <linux/module.h>
41 #include <linux/mutex.h>
42 #include <linux/errno.h>
43 #include <linux/input.h>
44 #include <linux/slab.h>
45 #include <linux/poll.h>
46 #include <linux/uaccess.h>
48 #include "../comedi_usb.h"
55 #define VMK8055_DI_REG 0x00
56 #define VMK8055_DO_REG 0x01
57 #define VMK8055_AO1_REG 0x02
58 #define VMK8055_AO2_REG 0x03
59 #define VMK8055_AI1_REG 0x02
60 #define VMK8055_AI2_REG 0x03
61 #define VMK8055_CNT1_REG 0x04
62 #define VMK8055_CNT2_REG 0x06
64 #define VMK8061_CH_REG 0x01
65 #define VMK8061_DI_REG 0x01
66 #define VMK8061_DO_REG 0x01
67 #define VMK8061_PWM_REG1 0x01
68 #define VMK8061_PWM_REG2 0x02
69 #define VMK8061_CNT_REG 0x02
70 #define VMK8061_AO_REG 0x02
71 #define VMK8061_AI_REG1 0x02
72 #define VMK8061_AI_REG2 0x03
74 #define VMK8055_CMD_RST 0x00
75 #define VMK8055_CMD_DEB1_TIME 0x01
76 #define VMK8055_CMD_DEB2_TIME 0x02
77 #define VMK8055_CMD_RST_CNT1 0x03
78 #define VMK8055_CMD_RST_CNT2 0x04
79 #define VMK8055_CMD_WRT_AD 0x05
81 #define VMK8061_CMD_RD_AI 0x00
82 #define VMK8061_CMR_RD_ALL_AI 0x01 /* !non-active! */
83 #define VMK8061_CMD_SET_AO 0x02
84 #define VMK8061_CMD_SET_ALL_AO 0x03 /* !non-active! */
85 #define VMK8061_CMD_OUT_PWM 0x04
86 #define VMK8061_CMD_RD_DI 0x05
87 #define VMK8061_CMD_DO 0x06 /* !non-active! */
88 #define VMK8061_CMD_CLR_DO 0x07
89 #define VMK8061_CMD_SET_DO 0x08
90 #define VMK8061_CMD_RD_CNT 0x09 /* TODO: completely pointless? */
91 #define VMK8061_CMD_RST_CNT 0x0a /* TODO: completely pointless? */
92 #define VMK8061_CMD_RD_VERSION 0x0b /* internal usage */
93 #define VMK8061_CMD_RD_JMP_STAT 0x0c /* TODO: not implemented yet */
94 #define VMK8061_CMD_RD_PWR_STAT 0x0d /* internal usage */
95 #define VMK8061_CMD_RD_DO 0x0e
96 #define VMK8061_CMD_RD_AO 0x0f
97 #define VMK8061_CMD_RD_PWM 0x10
99 #define IC3_VERSION BIT(0)
100 #define IC6_VERSION BIT(1)
102 #define MIN_BUF_SIZE 64
103 #define PACKET_TIMEOUT 10000 /* ms */
110 static const struct comedi_lrange vmk8061_range = {
117 struct vmk80xx_board {
119 enum vmk80xx_model model;
120 const struct comedi_lrange *range;
122 unsigned int ai_maxdata;
125 unsigned int cnt_maxdata;
127 unsigned int pwm_maxdata;
130 static const struct vmk80xx_board vmk80xx_boardinfo[] = {
132 .name = "K8055 (VM110)",
133 .model = VMK8055_MODEL,
134 .range = &range_unipolar5,
136 .ai_maxdata = 0x00ff,
139 .cnt_maxdata = 0xffff,
142 .name = "K8061 (VM140)",
143 .model = VMK8061_MODEL,
144 .range = &vmk8061_range,
146 .ai_maxdata = 0x03ff,
149 .cnt_maxdata = 0, /* unknown, device is not writeable */
151 .pwm_maxdata = 0x03ff,
155 struct vmk80xx_private {
156 struct usb_endpoint_descriptor *ep_rx;
157 struct usb_endpoint_descriptor *ep_tx;
158 struct semaphore limit_sem;
159 unsigned char *usb_rx_buf;
160 unsigned char *usb_tx_buf;
161 enum vmk80xx_model model;
164 static void vmk80xx_do_bulk_msg(struct comedi_device *dev)
166 struct vmk80xx_private *devpriv = dev->private;
167 struct usb_device *usb = comedi_to_usb_dev(dev);
170 unsigned int tx_pipe;
171 unsigned int rx_pipe;
175 tx_addr = devpriv->ep_tx->bEndpointAddress;
176 rx_addr = devpriv->ep_rx->bEndpointAddress;
177 tx_pipe = usb_sndbulkpipe(usb, tx_addr);
178 rx_pipe = usb_rcvbulkpipe(usb, rx_addr);
179 tx_size = usb_endpoint_maxp(devpriv->ep_tx);
180 rx_size = usb_endpoint_maxp(devpriv->ep_rx);
182 usb_bulk_msg(usb, tx_pipe, devpriv->usb_tx_buf, tx_size, NULL,
185 usb_bulk_msg(usb, rx_pipe, devpriv->usb_rx_buf, rx_size, NULL,
189 static int vmk80xx_read_packet(struct comedi_device *dev)
191 struct vmk80xx_private *devpriv = dev->private;
192 struct usb_device *usb = comedi_to_usb_dev(dev);
193 struct usb_endpoint_descriptor *ep;
196 if (devpriv->model == VMK8061_MODEL) {
197 vmk80xx_do_bulk_msg(dev);
202 pipe = usb_rcvintpipe(usb, ep->bEndpointAddress);
203 return usb_interrupt_msg(usb, pipe, devpriv->usb_rx_buf,
204 usb_endpoint_maxp(ep), NULL,
208 static int vmk80xx_write_packet(struct comedi_device *dev, int cmd)
210 struct vmk80xx_private *devpriv = dev->private;
211 struct usb_device *usb = comedi_to_usb_dev(dev);
212 struct usb_endpoint_descriptor *ep;
215 devpriv->usb_tx_buf[0] = cmd;
217 if (devpriv->model == VMK8061_MODEL) {
218 vmk80xx_do_bulk_msg(dev);
223 pipe = usb_sndintpipe(usb, ep->bEndpointAddress);
224 return usb_interrupt_msg(usb, pipe, devpriv->usb_tx_buf,
225 usb_endpoint_maxp(ep), NULL,
229 static int vmk80xx_reset_device(struct comedi_device *dev)
231 struct vmk80xx_private *devpriv = dev->private;
235 size = usb_endpoint_maxp(devpriv->ep_tx);
236 memset(devpriv->usb_tx_buf, 0, size);
237 retval = vmk80xx_write_packet(dev, VMK8055_CMD_RST);
240 /* set outputs to known state as we cannot read them */
241 return vmk80xx_write_packet(dev, VMK8055_CMD_WRT_AD);
244 static int vmk80xx_ai_insn_read(struct comedi_device *dev,
245 struct comedi_subdevice *s,
246 struct comedi_insn *insn,
249 struct vmk80xx_private *devpriv = dev->private;
254 down(&devpriv->limit_sem);
255 chan = CR_CHAN(insn->chanspec);
257 switch (devpriv->model) {
260 reg[0] = VMK8055_AI1_REG;
262 reg[0] = VMK8055_AI2_REG;
266 reg[0] = VMK8061_AI_REG1;
267 reg[1] = VMK8061_AI_REG2;
268 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_AI;
269 devpriv->usb_tx_buf[VMK8061_CH_REG] = chan;
273 for (n = 0; n < insn->n; n++) {
274 if (vmk80xx_read_packet(dev))
277 if (devpriv->model == VMK8055_MODEL) {
278 data[n] = devpriv->usb_rx_buf[reg[0]];
283 data[n] = devpriv->usb_rx_buf[reg[0]] + 256 *
284 devpriv->usb_rx_buf[reg[1]];
287 up(&devpriv->limit_sem);
292 static int vmk80xx_ao_insn_write(struct comedi_device *dev,
293 struct comedi_subdevice *s,
294 struct comedi_insn *insn,
297 struct vmk80xx_private *devpriv = dev->private;
303 down(&devpriv->limit_sem);
304 chan = CR_CHAN(insn->chanspec);
306 switch (devpriv->model) {
308 cmd = VMK8055_CMD_WRT_AD;
310 reg = VMK8055_AO1_REG;
312 reg = VMK8055_AO2_REG;
314 default: /* NOTE: avoid compiler warnings */
315 cmd = VMK8061_CMD_SET_AO;
316 reg = VMK8061_AO_REG;
317 devpriv->usb_tx_buf[VMK8061_CH_REG] = chan;
321 for (n = 0; n < insn->n; n++) {
322 devpriv->usb_tx_buf[reg] = data[n];
324 if (vmk80xx_write_packet(dev, cmd))
328 up(&devpriv->limit_sem);
333 static int vmk80xx_ao_insn_read(struct comedi_device *dev,
334 struct comedi_subdevice *s,
335 struct comedi_insn *insn,
338 struct vmk80xx_private *devpriv = dev->private;
343 down(&devpriv->limit_sem);
344 chan = CR_CHAN(insn->chanspec);
346 reg = VMK8061_AO_REG - 1;
348 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_AO;
350 for (n = 0; n < insn->n; n++) {
351 if (vmk80xx_read_packet(dev))
354 data[n] = devpriv->usb_rx_buf[reg + chan];
357 up(&devpriv->limit_sem);
362 static int vmk80xx_di_insn_bits(struct comedi_device *dev,
363 struct comedi_subdevice *s,
364 struct comedi_insn *insn,
367 struct vmk80xx_private *devpriv = dev->private;
368 unsigned char *rx_buf;
372 down(&devpriv->limit_sem);
374 rx_buf = devpriv->usb_rx_buf;
376 if (devpriv->model == VMK8061_MODEL) {
377 reg = VMK8061_DI_REG;
378 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
380 reg = VMK8055_DI_REG;
383 retval = vmk80xx_read_packet(dev);
386 if (devpriv->model == VMK8055_MODEL)
387 data[1] = (((rx_buf[reg] >> 4) & 0x03) |
388 ((rx_buf[reg] << 2) & 0x04) |
389 ((rx_buf[reg] >> 3) & 0x18));
391 data[1] = rx_buf[reg];
396 up(&devpriv->limit_sem);
401 static int vmk80xx_do_insn_bits(struct comedi_device *dev,
402 struct comedi_subdevice *s,
403 struct comedi_insn *insn,
406 struct vmk80xx_private *devpriv = dev->private;
407 unsigned char *rx_buf = devpriv->usb_rx_buf;
408 unsigned char *tx_buf = devpriv->usb_tx_buf;
412 if (devpriv->model == VMK8061_MODEL) {
413 reg = VMK8061_DO_REG;
414 cmd = VMK8061_CMD_DO;
415 } else { /* VMK8055_MODEL */
416 reg = VMK8055_DO_REG;
417 cmd = VMK8055_CMD_WRT_AD;
420 down(&devpriv->limit_sem);
422 if (comedi_dio_update_state(s, data)) {
423 tx_buf[reg] = s->state;
424 ret = vmk80xx_write_packet(dev, cmd);
429 if (devpriv->model == VMK8061_MODEL) {
430 tx_buf[0] = VMK8061_CMD_RD_DO;
431 ret = vmk80xx_read_packet(dev);
434 data[1] = rx_buf[reg];
440 up(&devpriv->limit_sem);
442 return ret ? ret : insn->n;
445 static int vmk80xx_cnt_insn_read(struct comedi_device *dev,
446 struct comedi_subdevice *s,
447 struct comedi_insn *insn,
450 struct vmk80xx_private *devpriv = dev->private;
455 down(&devpriv->limit_sem);
456 chan = CR_CHAN(insn->chanspec);
458 switch (devpriv->model) {
461 reg[0] = VMK8055_CNT1_REG;
463 reg[0] = VMK8055_CNT2_REG;
467 reg[0] = VMK8061_CNT_REG;
468 reg[1] = VMK8061_CNT_REG;
469 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_CNT;
473 for (n = 0; n < insn->n; n++) {
474 if (vmk80xx_read_packet(dev))
477 if (devpriv->model == VMK8055_MODEL)
478 data[n] = devpriv->usb_rx_buf[reg[0]];
479 else /* VMK8061_MODEL */
480 data[n] = devpriv->usb_rx_buf[reg[0] * (chan + 1) + 1]
481 + 256 * devpriv->usb_rx_buf[reg[1] * 2 + 2];
484 up(&devpriv->limit_sem);
489 static int vmk80xx_cnt_insn_config(struct comedi_device *dev,
490 struct comedi_subdevice *s,
491 struct comedi_insn *insn,
494 struct vmk80xx_private *devpriv = dev->private;
495 unsigned int chan = CR_CHAN(insn->chanspec);
500 down(&devpriv->limit_sem);
502 case INSN_CONFIG_RESET:
503 if (devpriv->model == VMK8055_MODEL) {
505 cmd = VMK8055_CMD_RST_CNT1;
506 reg = VMK8055_CNT1_REG;
508 cmd = VMK8055_CMD_RST_CNT2;
509 reg = VMK8055_CNT2_REG;
511 devpriv->usb_tx_buf[reg] = 0x00;
513 cmd = VMK8061_CMD_RST_CNT;
515 ret = vmk80xx_write_packet(dev, cmd);
521 up(&devpriv->limit_sem);
523 return ret ? ret : insn->n;
526 static int vmk80xx_cnt_insn_write(struct comedi_device *dev,
527 struct comedi_subdevice *s,
528 struct comedi_insn *insn,
531 struct vmk80xx_private *devpriv = dev->private;
532 unsigned long debtime;
538 down(&devpriv->limit_sem);
539 chan = CR_CHAN(insn->chanspec);
542 cmd = VMK8055_CMD_DEB1_TIME;
544 cmd = VMK8055_CMD_DEB2_TIME;
546 for (n = 0; n < insn->n; n++) {
551 /* TODO: Prevent overflows */
555 val = int_sqrt(debtime * 1000 / 115);
556 if (((val + 1) * val) < debtime * 1000 / 115)
559 devpriv->usb_tx_buf[6 + chan] = val;
561 if (vmk80xx_write_packet(dev, cmd))
565 up(&devpriv->limit_sem);
570 static int vmk80xx_pwm_insn_read(struct comedi_device *dev,
571 struct comedi_subdevice *s,
572 struct comedi_insn *insn,
575 struct vmk80xx_private *devpriv = dev->private;
576 unsigned char *tx_buf;
577 unsigned char *rx_buf;
581 down(&devpriv->limit_sem);
583 tx_buf = devpriv->usb_tx_buf;
584 rx_buf = devpriv->usb_rx_buf;
586 reg[0] = VMK8061_PWM_REG1;
587 reg[1] = VMK8061_PWM_REG2;
589 tx_buf[0] = VMK8061_CMD_RD_PWM;
591 for (n = 0; n < insn->n; n++) {
592 if (vmk80xx_read_packet(dev))
595 data[n] = rx_buf[reg[0]] + 4 * rx_buf[reg[1]];
598 up(&devpriv->limit_sem);
603 static int vmk80xx_pwm_insn_write(struct comedi_device *dev,
604 struct comedi_subdevice *s,
605 struct comedi_insn *insn,
608 struct vmk80xx_private *devpriv = dev->private;
609 unsigned char *tx_buf;
614 down(&devpriv->limit_sem);
616 tx_buf = devpriv->usb_tx_buf;
618 reg[0] = VMK8061_PWM_REG1;
619 reg[1] = VMK8061_PWM_REG2;
621 cmd = VMK8061_CMD_OUT_PWM;
624 * The followin piece of code was translated from the inline
625 * assembler code in the DLL source code.
628 * mov eax, k ; k is the value (data[n])
629 * and al, 03h ; al are the lower 8 bits of eax
630 * mov lo, al ; lo is the low part (tx_buf[reg[0]])
632 * shr eax, 2 ; right shift eax register by 2
633 * mov hi, al ; hi is the high part (tx_buf[reg[1]])
636 for (n = 0; n < insn->n; n++) {
637 tx_buf[reg[0]] = (unsigned char)(data[n] & 0x03);
638 tx_buf[reg[1]] = (unsigned char)(data[n] >> 2) & 0xff;
640 if (vmk80xx_write_packet(dev, cmd))
644 up(&devpriv->limit_sem);
649 static int vmk80xx_find_usb_endpoints(struct comedi_device *dev)
651 struct vmk80xx_private *devpriv = dev->private;
652 struct usb_interface *intf = comedi_to_usb_interface(dev);
653 struct usb_host_interface *iface_desc = intf->cur_altsetting;
654 struct usb_endpoint_descriptor *ep_desc;
657 if (iface_desc->desc.bNumEndpoints != 2)
660 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
661 ep_desc = &iface_desc->endpoint[i].desc;
663 if (usb_endpoint_is_int_in(ep_desc) ||
664 usb_endpoint_is_bulk_in(ep_desc)) {
666 devpriv->ep_rx = ep_desc;
670 if (usb_endpoint_is_int_out(ep_desc) ||
671 usb_endpoint_is_bulk_out(ep_desc)) {
673 devpriv->ep_tx = ep_desc;
678 if (!devpriv->ep_rx || !devpriv->ep_tx)
681 if (!usb_endpoint_maxp(devpriv->ep_rx) || !usb_endpoint_maxp(devpriv->ep_tx))
687 static int vmk80xx_alloc_usb_buffers(struct comedi_device *dev)
689 struct vmk80xx_private *devpriv = dev->private;
692 size = max(usb_endpoint_maxp(devpriv->ep_rx), MIN_BUF_SIZE);
693 devpriv->usb_rx_buf = kzalloc(size, GFP_KERNEL);
694 if (!devpriv->usb_rx_buf)
697 size = max(usb_endpoint_maxp(devpriv->ep_rx), MIN_BUF_SIZE);
698 devpriv->usb_tx_buf = kzalloc(size, GFP_KERNEL);
699 if (!devpriv->usb_tx_buf)
705 static int vmk80xx_init_subdevices(struct comedi_device *dev)
707 const struct vmk80xx_board *board = dev->board_ptr;
708 struct vmk80xx_private *devpriv = dev->private;
709 struct comedi_subdevice *s;
713 down(&devpriv->limit_sem);
715 if (devpriv->model == VMK8055_MODEL)
719 ret = comedi_alloc_subdevices(dev, n_subd);
721 up(&devpriv->limit_sem);
725 /* Analog input subdevice */
726 s = &dev->subdevices[0];
727 s->type = COMEDI_SUBD_AI;
728 s->subdev_flags = SDF_READABLE | SDF_GROUND;
729 s->n_chan = board->ai_nchans;
730 s->maxdata = board->ai_maxdata;
731 s->range_table = board->range;
732 s->insn_read = vmk80xx_ai_insn_read;
734 /* Analog output subdevice */
735 s = &dev->subdevices[1];
736 s->type = COMEDI_SUBD_AO;
737 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
738 s->n_chan = board->ao_nchans;
740 s->range_table = board->range;
741 s->insn_write = vmk80xx_ao_insn_write;
742 if (devpriv->model == VMK8061_MODEL) {
743 s->subdev_flags |= SDF_READABLE;
744 s->insn_read = vmk80xx_ao_insn_read;
747 /* Digital input subdevice */
748 s = &dev->subdevices[2];
749 s->type = COMEDI_SUBD_DI;
750 s->subdev_flags = SDF_READABLE;
751 s->n_chan = board->di_nchans;
753 s->range_table = &range_digital;
754 s->insn_bits = vmk80xx_di_insn_bits;
756 /* Digital output subdevice */
757 s = &dev->subdevices[3];
758 s->type = COMEDI_SUBD_DO;
759 s->subdev_flags = SDF_WRITABLE;
762 s->range_table = &range_digital;
763 s->insn_bits = vmk80xx_do_insn_bits;
765 /* Counter subdevice */
766 s = &dev->subdevices[4];
767 s->type = COMEDI_SUBD_COUNTER;
768 s->subdev_flags = SDF_READABLE;
770 s->maxdata = board->cnt_maxdata;
771 s->insn_read = vmk80xx_cnt_insn_read;
772 s->insn_config = vmk80xx_cnt_insn_config;
773 if (devpriv->model == VMK8055_MODEL) {
774 s->subdev_flags |= SDF_WRITABLE;
775 s->insn_write = vmk80xx_cnt_insn_write;
779 if (devpriv->model == VMK8061_MODEL) {
780 s = &dev->subdevices[5];
781 s->type = COMEDI_SUBD_PWM;
782 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
783 s->n_chan = board->pwm_nchans;
784 s->maxdata = board->pwm_maxdata;
785 s->insn_read = vmk80xx_pwm_insn_read;
786 s->insn_write = vmk80xx_pwm_insn_write;
789 up(&devpriv->limit_sem);
794 static int vmk80xx_auto_attach(struct comedi_device *dev,
795 unsigned long context)
797 struct usb_interface *intf = comedi_to_usb_interface(dev);
798 const struct vmk80xx_board *board = NULL;
799 struct vmk80xx_private *devpriv;
802 if (context < ARRAY_SIZE(vmk80xx_boardinfo))
803 board = &vmk80xx_boardinfo[context];
806 dev->board_ptr = board;
807 dev->board_name = board->name;
809 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
813 devpriv->model = board->model;
815 sema_init(&devpriv->limit_sem, 8);
817 ret = vmk80xx_find_usb_endpoints(dev);
821 ret = vmk80xx_alloc_usb_buffers(dev);
825 usb_set_intfdata(intf, devpriv);
827 if (devpriv->model == VMK8055_MODEL)
828 vmk80xx_reset_device(dev);
830 return vmk80xx_init_subdevices(dev);
833 static void vmk80xx_detach(struct comedi_device *dev)
835 struct usb_interface *intf = comedi_to_usb_interface(dev);
836 struct vmk80xx_private *devpriv = dev->private;
841 down(&devpriv->limit_sem);
843 usb_set_intfdata(intf, NULL);
845 kfree(devpriv->usb_rx_buf);
846 kfree(devpriv->usb_tx_buf);
848 up(&devpriv->limit_sem);
851 static struct comedi_driver vmk80xx_driver = {
852 .module = THIS_MODULE,
853 .driver_name = "vmk80xx",
854 .auto_attach = vmk80xx_auto_attach,
855 .detach = vmk80xx_detach,
858 static int vmk80xx_usb_probe(struct usb_interface *intf,
859 const struct usb_device_id *id)
861 return comedi_usb_auto_config(intf, &vmk80xx_driver, id->driver_info);
864 static const struct usb_device_id vmk80xx_usb_id_table[] = {
865 { USB_DEVICE(0x10cf, 0x5500), .driver_info = DEVICE_VMK8055 },
866 { USB_DEVICE(0x10cf, 0x5501), .driver_info = DEVICE_VMK8055 },
867 { USB_DEVICE(0x10cf, 0x5502), .driver_info = DEVICE_VMK8055 },
868 { USB_DEVICE(0x10cf, 0x5503), .driver_info = DEVICE_VMK8055 },
869 { USB_DEVICE(0x10cf, 0x8061), .driver_info = DEVICE_VMK8061 },
870 { USB_DEVICE(0x10cf, 0x8062), .driver_info = DEVICE_VMK8061 },
871 { USB_DEVICE(0x10cf, 0x8063), .driver_info = DEVICE_VMK8061 },
872 { USB_DEVICE(0x10cf, 0x8064), .driver_info = DEVICE_VMK8061 },
873 { USB_DEVICE(0x10cf, 0x8065), .driver_info = DEVICE_VMK8061 },
874 { USB_DEVICE(0x10cf, 0x8066), .driver_info = DEVICE_VMK8061 },
875 { USB_DEVICE(0x10cf, 0x8067), .driver_info = DEVICE_VMK8061 },
876 { USB_DEVICE(0x10cf, 0x8068), .driver_info = DEVICE_VMK8061 },
879 MODULE_DEVICE_TABLE(usb, vmk80xx_usb_id_table);
881 static struct usb_driver vmk80xx_usb_driver = {
883 .id_table = vmk80xx_usb_id_table,
884 .probe = vmk80xx_usb_probe,
885 .disconnect = comedi_usb_auto_unconfig,
887 module_comedi_usb_driver(vmk80xx_driver, vmk80xx_usb_driver);
889 MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
890 MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
891 MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
892 MODULE_LICENSE("GPL");