projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'for-4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/kishon/linux...
[deliverable/linux.git] / 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 /*
21 * Driver: vmk80xx
22 * Description: Velleman USB Board Low-Level Driver
23 * Devices: [Velleman] K8055 (K8055/VM110), K8061 (K8061/VM140),
24 * VM110 (K8055/VM110), VM140 (K8061/VM140)
25 * Author: Manuel Gebele <forensixs@gmx.de>
26 * Updated: Sun, 10 May 2009 11:14:59 +0200
27 * Status: works
28 *
29 * Supports:
30 * - analog input
31 * - analog output
32 * - digital input
33 * - digital output
34 * - counter
35 * - pwm
36 */
37
38 #include <linux/kernel.h>
39 #include <linux/module.h>
40 #include <linux/mutex.h>
41 #include <linux/errno.h>
42 #include <linux/input.h>
43 #include <linux/slab.h>
44 #include <linux/poll.h>
45 #include <linux/uaccess.h>
46
47 #include "../comedi_usb.h"
48
49 enum {
50 DEVICE_VMK8055,
51 DEVICE_VMK8061
52 };
53
54 #define VMK8055_DI_REG 0x00
55 #define VMK8055_DO_REG 0x01
56 #define VMK8055_AO1_REG 0x02
57 #define VMK8055_AO2_REG 0x03
58 #define VMK8055_AI1_REG 0x02
59 #define VMK8055_AI2_REG 0x03
60 #define VMK8055_CNT1_REG 0x04
61 #define VMK8055_CNT2_REG 0x06
62
63 #define VMK8061_CH_REG 0x01
64 #define VMK8061_DI_REG 0x01
65 #define VMK8061_DO_REG 0x01
66 #define VMK8061_PWM_REG1 0x01
67 #define VMK8061_PWM_REG2 0x02
68 #define VMK8061_CNT_REG 0x02
69 #define VMK8061_AO_REG 0x02
70 #define VMK8061_AI_REG1 0x02
71 #define VMK8061_AI_REG2 0x03
72
73 #define VMK8055_CMD_RST 0x00
74 #define VMK8055_CMD_DEB1_TIME 0x01
75 #define VMK8055_CMD_DEB2_TIME 0x02
76 #define VMK8055_CMD_RST_CNT1 0x03
77 #define VMK8055_CMD_RST_CNT2 0x04
78 #define VMK8055_CMD_WRT_AD 0x05
79
80 #define VMK8061_CMD_RD_AI 0x00
81 #define VMK8061_CMR_RD_ALL_AI 0x01 /* !non-active! */
82 #define VMK8061_CMD_SET_AO 0x02
83 #define VMK8061_CMD_SET_ALL_AO 0x03 /* !non-active! */
84 #define VMK8061_CMD_OUT_PWM 0x04
85 #define VMK8061_CMD_RD_DI 0x05
86 #define VMK8061_CMD_DO 0x06 /* !non-active! */
87 #define VMK8061_CMD_CLR_DO 0x07
88 #define VMK8061_CMD_SET_DO 0x08
89 #define VMK8061_CMD_RD_CNT 0x09 /* TODO: completely pointless? */
90 #define VMK8061_CMD_RST_CNT 0x0a /* TODO: completely pointless? */
91 #define VMK8061_CMD_RD_VERSION 0x0b /* internal usage */
92 #define VMK8061_CMD_RD_JMP_STAT 0x0c /* TODO: not implemented yet */
93 #define VMK8061_CMD_RD_PWR_STAT 0x0d /* internal usage */
94 #define VMK8061_CMD_RD_DO 0x0e
95 #define VMK8061_CMD_RD_AO 0x0f
96 #define VMK8061_CMD_RD_PWM 0x10
97
98 #define IC3_VERSION (1 << 0)
99 #define IC6_VERSION (1 << 1)
100
101 enum vmk80xx_model {
102 VMK8055_MODEL,
103 VMK8061_MODEL
104 };
105
106 static const struct comedi_lrange vmk8061_range = {
107 2, {
108 UNI_RANGE(5),
109 UNI_RANGE(10)
110 }
111 };
112
113 struct vmk80xx_board {
114 const char *name;
115 enum vmk80xx_model model;
116 const struct comedi_lrange *range;
117 int ai_nchans;
118 unsigned int ai_maxdata;
119 int ao_nchans;
120 int di_nchans;
121 unsigned int cnt_maxdata;
122 int pwm_nchans;
123 unsigned int pwm_maxdata;
124 };
125
126 static const struct vmk80xx_board vmk80xx_boardinfo[] = {
127 [DEVICE_VMK8055] = {
128 .name = "K8055 (VM110)",
129 .model = VMK8055_MODEL,
130 .range = &range_unipolar5,
131 .ai_nchans = 2,
132 .ai_maxdata = 0x00ff,
133 .ao_nchans = 2,
134 .di_nchans = 6,
135 .cnt_maxdata = 0xffff,
136 },
137 [DEVICE_VMK8061] = {
138 .name = "K8061 (VM140)",
139 .model = VMK8061_MODEL,
140 .range = &vmk8061_range,
141 .ai_nchans = 8,
142 .ai_maxdata = 0x03ff,
143 .ao_nchans = 8,
144 .di_nchans = 8,
145 .cnt_maxdata = 0, /* unknown, device is not writeable */
146 .pwm_nchans = 1,
147 .pwm_maxdata = 0x03ff,
148 },
149 };
150
151 struct vmk80xx_private {
152 struct usb_endpoint_descriptor *ep_rx;
153 struct usb_endpoint_descriptor *ep_tx;
154 struct semaphore limit_sem;
155 unsigned char *usb_rx_buf;
156 unsigned char *usb_tx_buf;
157 enum vmk80xx_model model;
158 };
159
160 static void vmk80xx_do_bulk_msg(struct comedi_device *dev)
161 {
162 struct vmk80xx_private *devpriv = dev->private;
163 struct usb_device *usb = comedi_to_usb_dev(dev);
164 __u8 tx_addr;
165 __u8 rx_addr;
166 unsigned int tx_pipe;
167 unsigned int rx_pipe;
168 size_t size;
169
170 tx_addr = devpriv->ep_tx->bEndpointAddress;
171 rx_addr = devpriv->ep_rx->bEndpointAddress;
172 tx_pipe = usb_sndbulkpipe(usb, tx_addr);
173 rx_pipe = usb_rcvbulkpipe(usb, rx_addr);
174
175 /*
176 * The max packet size attributes of the K8061
177 * input/output endpoints are identical
178 */
179 size = le16_to_cpu(devpriv->ep_tx->wMaxPacketSize);
180
181 usb_bulk_msg(usb, tx_pipe, devpriv->usb_tx_buf,
182 size, NULL, devpriv->ep_tx->bInterval);
183 usb_bulk_msg(usb, rx_pipe, devpriv->usb_rx_buf, size, NULL, HZ * 10);
184 }
185
186 static int vmk80xx_read_packet(struct comedi_device *dev)
187 {
188 struct vmk80xx_private *devpriv = dev->private;
189 struct usb_device *usb = comedi_to_usb_dev(dev);
190 struct usb_endpoint_descriptor *ep;
191 unsigned int pipe;
192
193 if (devpriv->model == VMK8061_MODEL) {
194 vmk80xx_do_bulk_msg(dev);
195 return 0;
196 }
197
198 ep = devpriv->ep_rx;
199 pipe = usb_rcvintpipe(usb, ep->bEndpointAddress);
200 return usb_interrupt_msg(usb, pipe, devpriv->usb_rx_buf,
201 le16_to_cpu(ep->wMaxPacketSize), NULL,
202 HZ * 10);
203 }
204
205 static int vmk80xx_write_packet(struct comedi_device *dev, int cmd)
206 {
207 struct vmk80xx_private *devpriv = dev->private;
208 struct usb_device *usb = comedi_to_usb_dev(dev);
209 struct usb_endpoint_descriptor *ep;
210 unsigned int pipe;
211
212 devpriv->usb_tx_buf[0] = cmd;
213
214 if (devpriv->model == VMK8061_MODEL) {
215 vmk80xx_do_bulk_msg(dev);
216 return 0;
217 }
218
219 ep = devpriv->ep_tx;
220 pipe = usb_sndintpipe(usb, ep->bEndpointAddress);
221 return usb_interrupt_msg(usb, pipe, devpriv->usb_tx_buf,
222 le16_to_cpu(ep->wMaxPacketSize), NULL,
223 HZ * 10);
224 }
225
226 static int vmk80xx_reset_device(struct comedi_device *dev)
227 {
228 struct vmk80xx_private *devpriv = dev->private;
229 size_t size;
230 int retval;
231
232 size = le16_to_cpu(devpriv->ep_tx->wMaxPacketSize);
233 memset(devpriv->usb_tx_buf, 0, size);
234 retval = vmk80xx_write_packet(dev, VMK8055_CMD_RST);
235 if (retval)
236 return retval;
237 /* set outputs to known state as we cannot read them */
238 return vmk80xx_write_packet(dev, VMK8055_CMD_WRT_AD);
239 }
240
241 static int vmk80xx_ai_insn_read(struct comedi_device *dev,
242 struct comedi_subdevice *s,
243 struct comedi_insn *insn,
244 unsigned int *data)
245 {
246 struct vmk80xx_private *devpriv = dev->private;
247 int chan;
248 int reg[2];
249 int n;
250
251 down(&devpriv->limit_sem);
252 chan = CR_CHAN(insn->chanspec);
253
254 switch (devpriv->model) {
255 case VMK8055_MODEL:
256 if (!chan)
257 reg[0] = VMK8055_AI1_REG;
258 else
259 reg[0] = VMK8055_AI2_REG;
260 break;
261 case VMK8061_MODEL:
262 default:
263 reg[0] = VMK8061_AI_REG1;
264 reg[1] = VMK8061_AI_REG2;
265 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_AI;
266 devpriv->usb_tx_buf[VMK8061_CH_REG] = chan;
267 break;
268 }
269
270 for (n = 0; n < insn->n; n++) {
271 if (vmk80xx_read_packet(dev))
272 break;
273
274 if (devpriv->model == VMK8055_MODEL) {
275 data[n] = devpriv->usb_rx_buf[reg[0]];
276 continue;
277 }
278
279 /* VMK8061_MODEL */
280 data[n] = devpriv->usb_rx_buf[reg[0]] + 256 *
281 devpriv->usb_rx_buf[reg[1]];
282 }
283
284 up(&devpriv->limit_sem);
285
286 return n;
287 }
288
289 static int vmk80xx_ao_insn_write(struct comedi_device *dev,
290 struct comedi_subdevice *s,
291 struct comedi_insn *insn,
292 unsigned int *data)
293 {
294 struct vmk80xx_private *devpriv = dev->private;
295 int chan;
296 int cmd;
297 int reg;
298 int n;
299
300 down(&devpriv->limit_sem);
301 chan = CR_CHAN(insn->chanspec);
302
303 switch (devpriv->model) {
304 case VMK8055_MODEL:
305 cmd = VMK8055_CMD_WRT_AD;
306 if (!chan)
307 reg = VMK8055_AO1_REG;
308 else
309 reg = VMK8055_AO2_REG;
310 break;
311 default: /* NOTE: avoid compiler warnings */
312 cmd = VMK8061_CMD_SET_AO;
313 reg = VMK8061_AO_REG;
314 devpriv->usb_tx_buf[VMK8061_CH_REG] = chan;
315 break;
316 }
317
318 for (n = 0; n < insn->n; n++) {
319 devpriv->usb_tx_buf[reg] = data[n];
320
321 if (vmk80xx_write_packet(dev, cmd))
322 break;
323 }
324
325 up(&devpriv->limit_sem);
326
327 return n;
328 }
329
330 static int vmk80xx_ao_insn_read(struct comedi_device *dev,
331 struct comedi_subdevice *s,
332 struct comedi_insn *insn,
333 unsigned int *data)
334 {
335 struct vmk80xx_private *devpriv = dev->private;
336 int chan;
337 int reg;
338 int n;
339
340 down(&devpriv->limit_sem);
341 chan = CR_CHAN(insn->chanspec);
342
343 reg = VMK8061_AO_REG - 1;
344
345 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_AO;
346
347 for (n = 0; n < insn->n; n++) {
348 if (vmk80xx_read_packet(dev))
349 break;
350
351 data[n] = devpriv->usb_rx_buf[reg + chan];
352 }
353
354 up(&devpriv->limit_sem);
355
356 return n;
357 }
358
359 static int vmk80xx_di_insn_bits(struct comedi_device *dev,
360 struct comedi_subdevice *s,
361 struct comedi_insn *insn,
362 unsigned int *data)
363 {
364 struct vmk80xx_private *devpriv = dev->private;
365 unsigned char *rx_buf;
366 int reg;
367 int retval;
368
369 down(&devpriv->limit_sem);
370
371 rx_buf = devpriv->usb_rx_buf;
372
373 if (devpriv->model == VMK8061_MODEL) {
374 reg = VMK8061_DI_REG;
375 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_DI;
376 } else {
377 reg = VMK8055_DI_REG;
378 }
379
380 retval = vmk80xx_read_packet(dev);
381
382 if (!retval) {
383 if (devpriv->model == VMK8055_MODEL)
384 data[1] = (((rx_buf[reg] >> 4) & 0x03) |
385 ((rx_buf[reg] << 2) & 0x04) |
386 ((rx_buf[reg] >> 3) & 0x18));
387 else
388 data[1] = rx_buf[reg];
389
390 retval = 2;
391 }
392
393 up(&devpriv->limit_sem);
394
395 return retval;
396 }
397
398 static int vmk80xx_do_insn_bits(struct comedi_device *dev,
399 struct comedi_subdevice *s,
400 struct comedi_insn *insn,
401 unsigned int *data)
402 {
403 struct vmk80xx_private *devpriv = dev->private;
404 unsigned char *rx_buf = devpriv->usb_rx_buf;
405 unsigned char *tx_buf = devpriv->usb_tx_buf;
406 int reg, cmd;
407 int ret = 0;
408
409 if (devpriv->model == VMK8061_MODEL) {
410 reg = VMK8061_DO_REG;
411 cmd = VMK8061_CMD_DO;
412 } else { /* VMK8055_MODEL */
413 reg = VMK8055_DO_REG;
414 cmd = VMK8055_CMD_WRT_AD;
415 }
416
417 down(&devpriv->limit_sem);
418
419 if (comedi_dio_update_state(s, data)) {
420 tx_buf[reg] = s->state;
421 ret = vmk80xx_write_packet(dev, cmd);
422 if (ret)
423 goto out;
424 }
425
426 if (devpriv->model == VMK8061_MODEL) {
427 tx_buf[0] = VMK8061_CMD_RD_DO;
428 ret = vmk80xx_read_packet(dev);
429 if (ret)
430 goto out;
431 data[1] = rx_buf[reg];
432 } else {
433 data[1] = s->state;
434 }
435
436 out:
437 up(&devpriv->limit_sem);
438
439 return ret ? ret : insn->n;
440 }
441
442 static int vmk80xx_cnt_insn_read(struct comedi_device *dev,
443 struct comedi_subdevice *s,
444 struct comedi_insn *insn,
445 unsigned int *data)
446 {
447 struct vmk80xx_private *devpriv = dev->private;
448 int chan;
449 int reg[2];
450 int n;
451
452 down(&devpriv->limit_sem);
453 chan = CR_CHAN(insn->chanspec);
454
455 switch (devpriv->model) {
456 case VMK8055_MODEL:
457 if (!chan)
458 reg[0] = VMK8055_CNT1_REG;
459 else
460 reg[0] = VMK8055_CNT2_REG;
461 break;
462 case VMK8061_MODEL:
463 default:
464 reg[0] = VMK8061_CNT_REG;
465 reg[1] = VMK8061_CNT_REG;
466 devpriv->usb_tx_buf[0] = VMK8061_CMD_RD_CNT;
467 break;
468 }
469
470 for (n = 0; n < insn->n; n++) {
471 if (vmk80xx_read_packet(dev))
472 break;
473
474 if (devpriv->model == VMK8055_MODEL)
475 data[n] = devpriv->usb_rx_buf[reg[0]];
476 else /* VMK8061_MODEL */
477 data[n] = devpriv->usb_rx_buf[reg[0] * (chan + 1) + 1]
478 + 256 * devpriv->usb_rx_buf[reg[1] * 2 + 2];
479 }
480
481 up(&devpriv->limit_sem);
482
483 return n;
484 }
485
486 static int vmk80xx_cnt_insn_config(struct comedi_device *dev,
487 struct comedi_subdevice *s,
488 struct comedi_insn *insn,
489 unsigned int *data)
490 {
491 struct vmk80xx_private *devpriv = dev->private;
492 unsigned int chan = CR_CHAN(insn->chanspec);
493 int cmd;
494 int reg;
495 int ret;
496
497 down(&devpriv->limit_sem);
498 switch (data[0]) {
499 case INSN_CONFIG_RESET:
500 if (devpriv->model == VMK8055_MODEL) {
501 if (!chan) {
502 cmd = VMK8055_CMD_RST_CNT1;
503 reg = VMK8055_CNT1_REG;
504 } else {
505 cmd = VMK8055_CMD_RST_CNT2;
506 reg = VMK8055_CNT2_REG;
507 }
508 devpriv->usb_tx_buf[reg] = 0x00;
509 } else {
510 cmd = VMK8061_CMD_RST_CNT;
511 }
512 ret = vmk80xx_write_packet(dev, cmd);
513 break;
514 default:
515 ret = -EINVAL;
516 break;
517 }
518 up(&devpriv->limit_sem);
519
520 return ret ? ret : insn->n;
521 }
522
523 static int vmk80xx_cnt_insn_write(struct comedi_device *dev,
524 struct comedi_subdevice *s,
525 struct comedi_insn *insn,
526 unsigned int *data)
527 {
528 struct vmk80xx_private *devpriv = dev->private;
529 unsigned long debtime;
530 unsigned long val;
531 int chan;
532 int cmd;
533 int n;
534
535 down(&devpriv->limit_sem);
536 chan = CR_CHAN(insn->chanspec);
537
538 if (!chan)
539 cmd = VMK8055_CMD_DEB1_TIME;
540 else
541 cmd = VMK8055_CMD_DEB2_TIME;
542
543 for (n = 0; n < insn->n; n++) {
544 debtime = data[n];
545 if (debtime == 0)
546 debtime = 1;
547
548 /* TODO: Prevent overflows */
549 if (debtime > 7450)
550 debtime = 7450;
551
552 val = int_sqrt(debtime * 1000 / 115);
553 if (((val + 1) * val) < debtime * 1000 / 115)
554 val += 1;
555
556 devpriv->usb_tx_buf[6 + chan] = val;
557
558 if (vmk80xx_write_packet(dev, cmd))
559 break;
560 }
561
562 up(&devpriv->limit_sem);
563
564 return n;
565 }
566
567 static int vmk80xx_pwm_insn_read(struct comedi_device *dev,
568 struct comedi_subdevice *s,
569 struct comedi_insn *insn,
570 unsigned int *data)
571 {
572 struct vmk80xx_private *devpriv = dev->private;
573 unsigned char *tx_buf;
574 unsigned char *rx_buf;
575 int reg[2];
576 int n;
577
578 down(&devpriv->limit_sem);
579
580 tx_buf = devpriv->usb_tx_buf;
581 rx_buf = devpriv->usb_rx_buf;
582
583 reg[0] = VMK8061_PWM_REG1;
584 reg[1] = VMK8061_PWM_REG2;
585
586 tx_buf[0] = VMK8061_CMD_RD_PWM;
587
588 for (n = 0; n < insn->n; n++) {
589 if (vmk80xx_read_packet(dev))
590 break;
591
592 data[n] = rx_buf[reg[0]] + 4 * rx_buf[reg[1]];
593 }
594
595 up(&devpriv->limit_sem);
596
597 return n;
598 }
599
600 static int vmk80xx_pwm_insn_write(struct comedi_device *dev,
601 struct comedi_subdevice *s,
602 struct comedi_insn *insn,
603 unsigned int *data)
604 {
605 struct vmk80xx_private *devpriv = dev->private;
606 unsigned char *tx_buf;
607 int reg[2];
608 int cmd;
609 int n;
610
611 down(&devpriv->limit_sem);
612
613 tx_buf = devpriv->usb_tx_buf;
614
615 reg[0] = VMK8061_PWM_REG1;
616 reg[1] = VMK8061_PWM_REG2;
617
618 cmd = VMK8061_CMD_OUT_PWM;
619
620 /*
621 * The followin piece of code was translated from the inline
622 * assembler code in the DLL source code.
623 *
624 * asm
625 * mov eax, k ; k is the value (data[n])
626 * and al, 03h ; al are the lower 8 bits of eax
627 * mov lo, al ; lo is the low part (tx_buf[reg[0]])
628 * mov eax, k
629 * shr eax, 2 ; right shift eax register by 2
630 * mov hi, al ; hi is the high part (tx_buf[reg[1]])
631 * end;
632 */
633 for (n = 0; n < insn->n; n++) {
634 tx_buf[reg[0]] = (unsigned char)(data[n] & 0x03);
635 tx_buf[reg[1]] = (unsigned char)(data[n] >> 2) & 0xff;
636
637 if (vmk80xx_write_packet(dev, cmd))
638 break;
639 }
640
641 up(&devpriv->limit_sem);
642
643 return n;
644 }
645
646 static int vmk80xx_find_usb_endpoints(struct comedi_device *dev)
647 {
648 struct vmk80xx_private *devpriv = dev->private;
649 struct usb_interface *intf = comedi_to_usb_interface(dev);
650 struct usb_host_interface *iface_desc = intf->cur_altsetting;
651 struct usb_endpoint_descriptor *ep_desc;
652 int i;
653
654 if (iface_desc->desc.bNumEndpoints != 2)
655 return -ENODEV;
656
657 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
658 ep_desc = &iface_desc->endpoint[i].desc;
659
660 if (usb_endpoint_is_int_in(ep_desc) ||
661 usb_endpoint_is_bulk_in(ep_desc)) {
662 if (!devpriv->ep_rx)
663 devpriv->ep_rx = ep_desc;
664 continue;
665 }
666
667 if (usb_endpoint_is_int_out(ep_desc) ||
668 usb_endpoint_is_bulk_out(ep_desc)) {
669 if (!devpriv->ep_tx)
670 devpriv->ep_tx = ep_desc;
671 continue;
672 }
673 }
674
675 if (!devpriv->ep_rx || !devpriv->ep_tx)
676 return -ENODEV;
677
678 return 0;
679 }
680
681 static int vmk80xx_alloc_usb_buffers(struct comedi_device *dev)
682 {
683 struct vmk80xx_private *devpriv = dev->private;
684 size_t size;
685
686 size = le16_to_cpu(devpriv->ep_rx->wMaxPacketSize);
687 devpriv->usb_rx_buf = kzalloc(size, GFP_KERNEL);
688 if (!devpriv->usb_rx_buf)
689 return -ENOMEM;
690
691 size = le16_to_cpu(devpriv->ep_tx->wMaxPacketSize);
692 devpriv->usb_tx_buf = kzalloc(size, GFP_KERNEL);
693 if (!devpriv->usb_tx_buf) {
694 kfree(devpriv->usb_rx_buf);
695 return -ENOMEM;
696 }
697
698 return 0;
699 }
700
701 static int vmk80xx_init_subdevices(struct comedi_device *dev)
702 {
703 const struct vmk80xx_board *boardinfo = dev->board_ptr;
704 struct vmk80xx_private *devpriv = dev->private;
705 struct comedi_subdevice *s;
706 int n_subd;
707 int ret;
708
709 down(&devpriv->limit_sem);
710
711 if (devpriv->model == VMK8055_MODEL)
712 n_subd = 5;
713 else
714 n_subd = 6;
715 ret = comedi_alloc_subdevices(dev, n_subd);
716 if (ret) {
717 up(&devpriv->limit_sem);
718 return ret;
719 }
720
721 /* Analog input subdevice */
722 s = &dev->subdevices[0];
723 s->type = COMEDI_SUBD_AI;
724 s->subdev_flags = SDF_READABLE | SDF_GROUND;
725 s->n_chan = boardinfo->ai_nchans;
726 s->maxdata = boardinfo->ai_maxdata;
727 s->range_table = boardinfo->range;
728 s->insn_read = vmk80xx_ai_insn_read;
729
730 /* Analog output subdevice */
731 s = &dev->subdevices[1];
732 s->type = COMEDI_SUBD_AO;
733 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
734 s->n_chan = boardinfo->ao_nchans;
735 s->maxdata = 0x00ff;
736 s->range_table = boardinfo->range;
737 s->insn_write = vmk80xx_ao_insn_write;
738 if (devpriv->model == VMK8061_MODEL) {
739 s->subdev_flags |= SDF_READABLE;
740 s->insn_read = vmk80xx_ao_insn_read;
741 }
742
743 /* Digital input subdevice */
744 s = &dev->subdevices[2];
745 s->type = COMEDI_SUBD_DI;
746 s->subdev_flags = SDF_READABLE;
747 s->n_chan = boardinfo->di_nchans;
748 s->maxdata = 1;
749 s->range_table = &range_digital;
750 s->insn_bits = vmk80xx_di_insn_bits;
751
752 /* Digital output subdevice */
753 s = &dev->subdevices[3];
754 s->type = COMEDI_SUBD_DO;
755 s->subdev_flags = SDF_WRITABLE;
756 s->n_chan = 8;
757 s->maxdata = 1;
758 s->range_table = &range_digital;
759 s->insn_bits = vmk80xx_do_insn_bits;
760
761 /* Counter subdevice */
762 s = &dev->subdevices[4];
763 s->type = COMEDI_SUBD_COUNTER;
764 s->subdev_flags = SDF_READABLE;
765 s->n_chan = 2;
766 s->maxdata = boardinfo->cnt_maxdata;
767 s->insn_read = vmk80xx_cnt_insn_read;
768 s->insn_config = vmk80xx_cnt_insn_config;
769 if (devpriv->model == VMK8055_MODEL) {
770 s->subdev_flags |= SDF_WRITABLE;
771 s->insn_write = vmk80xx_cnt_insn_write;
772 }
773
774 /* PWM subdevice */
775 if (devpriv->model == VMK8061_MODEL) {
776 s = &dev->subdevices[5];
777 s->type = COMEDI_SUBD_PWM;
778 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
779 s->n_chan = boardinfo->pwm_nchans;
780 s->maxdata = boardinfo->pwm_maxdata;
781 s->insn_read = vmk80xx_pwm_insn_read;
782 s->insn_write = vmk80xx_pwm_insn_write;
783 }
784
785 up(&devpriv->limit_sem);
786
787 return 0;
788 }
789
790 static int vmk80xx_auto_attach(struct comedi_device *dev,
791 unsigned long context)
792 {
793 struct usb_interface *intf = comedi_to_usb_interface(dev);
794 const struct vmk80xx_board *boardinfo;
795 struct vmk80xx_private *devpriv;
796 int ret;
797
798 boardinfo = &vmk80xx_boardinfo[context];
799 dev->board_ptr = boardinfo;
800 dev->board_name = boardinfo->name;
801
802 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
803 if (!devpriv)
804 return -ENOMEM;
805
806 devpriv->model = boardinfo->model;
807
808 ret = vmk80xx_find_usb_endpoints(dev);
809 if (ret)
810 return ret;
811
812 ret = vmk80xx_alloc_usb_buffers(dev);
813 if (ret)
814 return ret;
815
816 sema_init(&devpriv->limit_sem, 8);
817
818 usb_set_intfdata(intf, devpriv);
819
820 if (devpriv->model == VMK8055_MODEL)
821 vmk80xx_reset_device(dev);
822
823 return vmk80xx_init_subdevices(dev);
824 }
825
826 static void vmk80xx_detach(struct comedi_device *dev)
827 {
828 struct usb_interface *intf = comedi_to_usb_interface(dev);
829 struct vmk80xx_private *devpriv = dev->private;
830
831 if (!devpriv)
832 return;
833
834 down(&devpriv->limit_sem);
835
836 usb_set_intfdata(intf, NULL);
837
838 kfree(devpriv->usb_rx_buf);
839 kfree(devpriv->usb_tx_buf);
840
841 up(&devpriv->limit_sem);
842 }
843
844 static struct comedi_driver vmk80xx_driver = {
845 .module = THIS_MODULE,
846 .driver_name = "vmk80xx",
847 .auto_attach = vmk80xx_auto_attach,
848 .detach = vmk80xx_detach,
849 };
850
851 static int vmk80xx_usb_probe(struct usb_interface *intf,
852 const struct usb_device_id *id)
853 {
854 return comedi_usb_auto_config(intf, &vmk80xx_driver, id->driver_info);
855 }
856
857 static const struct usb_device_id vmk80xx_usb_id_table[] = {
858 { USB_DEVICE(0x10cf, 0x5500), .driver_info = DEVICE_VMK8055 },
859 { USB_DEVICE(0x10cf, 0x5501), .driver_info = DEVICE_VMK8055 },
860 { USB_DEVICE(0x10cf, 0x5502), .driver_info = DEVICE_VMK8055 },
861 { USB_DEVICE(0x10cf, 0x5503), .driver_info = DEVICE_VMK8055 },
862 { USB_DEVICE(0x10cf, 0x8061), .driver_info = DEVICE_VMK8061 },
863 { USB_DEVICE(0x10cf, 0x8062), .driver_info = DEVICE_VMK8061 },
864 { USB_DEVICE(0x10cf, 0x8063), .driver_info = DEVICE_VMK8061 },
865 { USB_DEVICE(0x10cf, 0x8064), .driver_info = DEVICE_VMK8061 },
866 { USB_DEVICE(0x10cf, 0x8065), .driver_info = DEVICE_VMK8061 },
867 { USB_DEVICE(0x10cf, 0x8066), .driver_info = DEVICE_VMK8061 },
868 { USB_DEVICE(0x10cf, 0x8067), .driver_info = DEVICE_VMK8061 },
869 { USB_DEVICE(0x10cf, 0x8068), .driver_info = DEVICE_VMK8061 },
870 { }
871 };
872 MODULE_DEVICE_TABLE(usb, vmk80xx_usb_id_table);
873
874 static struct usb_driver vmk80xx_usb_driver = {
875 .name = "vmk80xx",
876 .id_table = vmk80xx_usb_id_table,
877 .probe = vmk80xx_usb_probe,
878 .disconnect = comedi_usb_auto_unconfig,
879 };
880 module_comedi_usb_driver(vmk80xx_driver, vmk80xx_usb_driver);
881
882 MODULE_AUTHOR("Manuel Gebele <forensixs@gmx.de>");
883 MODULE_DESCRIPTION("Velleman USB Board Low-Level Driver");
884 MODULE_SUPPORTED_DEVICE("K8055/K8061 aka VM110/VM140");
885 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.05 seconds and 5 git commands to generate.