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