2 comedi/drivers/usbdux.c
3 Copyright (C) 2003-2007 Bernd Porr, Bernd.Porr@f2s.com
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 Description: University of Stirling USB DAQ & INCITE Technology Limited
23 Devices: [ITL] USB-DUX (usbdux.o)
24 Author: Bernd Porr <BerndPorr@f2s.com>
27 Configuration options:
28 You have to upload firmware with the -i option. The
29 firmware is usually installed under /usr/share/usb or
30 /usr/local/share/usb or /lib/firmware.
32 Connection scheme for the counter at the digital port:
33 0=/CLK0, 1=UP/DOWN0, 2=RESET0, 4=/CLK1, 5=UP/DOWN1, 6=RESET1.
34 The sampling rate of the counter is approximately 500Hz.
36 Please note that under USB2.0 the length of the channel list determines
37 the max sampling rate. If you sample only one channel you get 8kHz
38 sampling rate. If you sample two channels you get 4kHz and so on.
41 * I must give credit here to Chris Baugher who
42 * wrote the driver for AT-MIO-16d. I used some parts of this
43 * driver. I also must give credits to David Brownell
44 * who supported me with the USB development.
50 * 0.94: D/A output should work now with any channel list combinations
51 * 0.95: .owner commented out for kernel vers below 2.4.19
52 * sanity checks in ai/ao_cmd
53 * 0.96: trying to get it working with 2.6, moved all memory alloc to comedi's
54 * attach final USB IDs
55 * moved memory allocation completely to the corresponding comedi
56 * functions firmware upload is by fxload and no longer by comedi (due to
58 * 0.97: USB IDs received, adjusted table
59 * 0.98: SMP, locking, memroy alloc: moved all usb memory alloc
60 * to the usb subsystem and moved all comedi related memory
62 * | kernel | registration | usbdux-usb | usbdux-comedi | comedi |
63 * 0.99: USB 2.0: changed protocol to isochronous transfer
64 * IRQ transfer is too buggy and too risky in 2.0
65 * for the high speed ISO transfer is now a working version
67 * 0.99b: Increased the iso transfer buffer for high sp.to 10 buffers. Some VIA
68 * chipsets miss out IRQs. Deeper buffering is needed.
69 * 1.00: full USB 2.0 support for the A/D converter. Now: max 8kHz sampling
71 * Firmware vers 1.00 is needed for this.
72 * Two 16 bit up/down/reset counter with a sampling rate of 1kHz
73 * And loads of cleaning up, in particular streamlining the
75 * 1.1: moved EP4 transfers to EP1 to make space for a PWM output on EP4
76 * 1.2: added PWM support via EP4
77 * 2.0: PWM seems to be stable and is not interfering with the other functions
78 * 2.1: changed PWM API
79 * 2.2: added firmware kernel request to fix an udev problem
80 * 2.3: corrected a bug in bulk timeouts which were far too short
81 * 2.4: fixed a bug which causes the driver to hang when it ran out of data.
82 * Thanks to Jan-Matthias Braun and Ian to spot the bug and fix it.
86 /* generates loads of debug info */
87 /* #define NOISY_DUX_DEBUGBUG */
89 #include <linux/kernel.h>
90 #include <linux/module.h>
91 #include <linux/init.h>
92 #include <linux/slab.h>
93 #include <linux/input.h>
94 #include <linux/usb.h>
95 #include <linux/fcntl.h>
96 #include <linux/compiler.h>
97 #include <linux/firmware.h>
99 #include "../comedidev.h"
101 #include "comedi_fc.h"
103 /* timeout for the USB-transfer in ms*/
104 #define BULK_TIMEOUT 1000
106 /* constants for "firmware" upload and download */
107 #define FIRMWARE "usbdux_firmware.bin"
108 #define USBDUXSUB_FIRMWARE 0xA0
109 #define VENDOR_DIR_IN 0xC0
110 #define VENDOR_DIR_OUT 0x40
112 /* internal addresses of the 8051 processor */
113 #define USBDUXSUB_CPUCS 0xE600
116 * the minor device number, major is 180 only for debugging purposes and to
117 * upload special firmware (programming the eeprom etc) which is not compatible
118 * with the comedi framwork
120 #define USBDUXSUB_MINOR 32
122 /* max lenghth of the transfer-buffer for software upload */
123 #define TB_LEN 0x2000
125 /* Input endpoint number: ISO/IRQ */
128 /* Output endpoint number: ISO/IRQ */
131 /* This EP sends DUX commands to USBDUX */
132 #define COMMAND_OUT_EP 1
134 /* This EP receives the DUX commands from USBDUX */
135 #define COMMAND_IN_EP 8
137 /* Output endpoint for PWM */
140 /* 300Hz max frequ under PWM */
141 #define MIN_PWM_PERIOD ((long)(1E9/300))
143 /* Default PWM frequency */
144 #define PWM_DEFAULT_PERIOD ((long)(1E9/100))
146 /* Number of channels */
147 #define NUMCHANNELS 8
149 /* Size of one A/D value */
150 #define SIZEADIN ((sizeof(int16_t)))
153 * Size of the input-buffer IN BYTES
154 * Always multiple of 8 for 8 microframes which is needed in the highspeed mode
156 #define SIZEINBUF ((8*SIZEADIN))
159 #define SIZEINSNBUF 16
161 /* Number of DA channels */
162 #define NUMOUTCHANNELS 8
164 /* size of one value for the D/A converter: channel and value */
165 #define SIZEDAOUT ((sizeof(int8_t)+sizeof(int16_t)))
168 * Size of the output-buffer in bytes
169 * Actually only the first 4 triplets are used but for the
170 * high speed mode we need to pad it to 8 (microframes).
172 #define SIZEOUTBUF ((8*SIZEDAOUT))
175 * Size of the buffer for the dux commands: just now max size is determined
176 * by the analogue out + command byte + panic bytes...
178 #define SIZEOFDUXBUFFER ((8*SIZEDAOUT+2))
180 /* Number of in-URBs which receive the data: min=2 */
181 #define NUMOFINBUFFERSFULL 5
183 /* Number of out-URBs which send the data: min=2 */
184 #define NUMOFOUTBUFFERSFULL 5
186 /* Number of in-URBs which receive the data: min=5 */
187 /* must have more buffers due to buggy USB ctr */
188 #define NUMOFINBUFFERSHIGH 10
190 /* Number of out-URBs which send the data: min=5 */
191 /* must have more buffers due to buggy USB ctr */
192 #define NUMOFOUTBUFFERSHIGH 10
194 /* Total number of usbdux devices */
197 /* Analogue in subdevice */
200 /* Analogue out subdevice */
207 #define SUBDEV_COUNTER 3
209 /* timer aka pwm output */
212 /* number of retries to get the right dux command */
215 /**************************************************/
216 /* comedi constants */
217 static const struct comedi_lrange range_usbdux_ai_range = { 4, {
229 static const struct comedi_lrange range_usbdux_ao_range = { 2, {
238 * private structure of one subdevice
242 * This is the structure which holds all the data of
243 * this driver one sub device just now: A/D
248 /* is it associated with a subdevice? */
250 /* pointer to the usb-device */
251 struct usb_device *usbdev;
252 /* actual number of in-buffers */
254 /* actual number of out-buffers */
256 /* ISO-transfer handling: buffers */
259 /* pwm-transfer handling */
262 unsigned int pwmPeriod;
263 /* PWM internal delay for the GPIF in the FX2 */
265 /* size of the PWM buffer which holds the bit pattern */
267 /* input buffer for the ISO-transfer */
269 /* input buffer for single insn */
271 /* output buffer for single DA outputs */
273 /* interface number */
275 /* interface structure in 2.6 */
276 struct usb_interface *interface;
277 /* comedi device for the interrupt context */
278 struct comedi_device *comedidev;
279 /* is it USB_SPEED_HIGH or not? */
280 short int high_speed;
281 /* asynchronous command is running */
282 short int ai_cmd_running;
283 short int ao_cmd_running;
285 short int pwm_cmd_running;
286 /* continous acquisition */
287 short int ai_continous;
288 short int ao_continous;
289 /* number of samples to acquire */
292 /* time between samples in units of the timer */
293 unsigned int ai_timer;
294 unsigned int ao_timer;
295 /* counter between aquisitions */
296 unsigned int ai_counter;
297 unsigned int ao_counter;
298 /* interval in frames/uframes */
299 unsigned int ai_interval;
301 int8_t *dac_commands;
303 int8_t *dux_commands;
304 struct semaphore sem;
308 * The pointer to the private usb-data of the driver is also the private data
309 * for the comedi-device. This has to be global as the usb subsystem needs
310 * global variables. The other reason is that this structure must be there
311 * _before_ any comedi command is issued. The usb subsystem must be initialised
312 * before comedi can access it.
314 static struct usbduxsub usbduxsub[NUMUSBDUX];
316 static DEFINE_SEMAPHORE(start_stop_sem);
319 * Stops the data acquision
320 * It should be safe to call this function from any context
322 static int usbduxsub_unlink_InURBs(struct usbduxsub *usbduxsub_tmp)
327 if (usbduxsub_tmp && usbduxsub_tmp->urbIn) {
328 for (i = 0; i < usbduxsub_tmp->numOfInBuffers; i++) {
329 if (usbduxsub_tmp->urbIn[i]) {
330 /* We wait here until all transfers have been
332 usb_kill_urb(usbduxsub_tmp->urbIn[i]);
334 dev_dbg(&usbduxsub_tmp->interface->dev,
335 "comedi: usbdux: unlinked InURB %d, err=%d\n",
343 * This will stop a running acquisition operation
344 * Is called from within this driver from both the
345 * interrupt context and from comedi
347 static int usbdux_ai_stop(struct usbduxsub *this_usbduxsub, int do_unlink)
351 if (!this_usbduxsub) {
352 pr_err("comedi?: usbdux_ai_stop: this_usbduxsub=NULL!\n");
355 dev_dbg(&this_usbduxsub->interface->dev, "comedi: usbdux_ai_stop\n");
359 ret = usbduxsub_unlink_InURBs(this_usbduxsub);
362 this_usbduxsub->ai_cmd_running = 0;
368 * This will cancel a running acquisition operation.
369 * This is called by comedi but never from inside the driver.
371 static int usbdux_ai_cancel(struct comedi_device *dev,
372 struct comedi_subdevice *s)
374 struct usbduxsub *this_usbduxsub;
377 /* force unlink of all urbs */
378 this_usbduxsub = dev->private;
382 dev_dbg(&this_usbduxsub->interface->dev, "comedi: usbdux_ai_cancel\n");
384 /* prevent other CPUs from submitting new commands just now */
385 down(&this_usbduxsub->sem);
386 if (!(this_usbduxsub->probed)) {
387 up(&this_usbduxsub->sem);
390 /* unlink only if the urb really has been submitted */
391 res = usbdux_ai_stop(this_usbduxsub, this_usbduxsub->ai_cmd_running);
392 up(&this_usbduxsub->sem);
396 /* analogue IN - interrupt service routine */
397 static void usbduxsub_ai_IsocIrq(struct urb *urb)
400 struct usbduxsub *this_usbduxsub;
401 struct comedi_device *this_comedidev;
402 struct comedi_subdevice *s;
404 /* the context variable points to the subdevice */
405 this_comedidev = urb->context;
406 /* the private structure of the subdevice is struct usbduxsub */
407 this_usbduxsub = this_comedidev->private;
408 /* subdevice which is the AD converter */
409 s = &this_comedidev->subdevices[SUBDEV_AD];
411 /* first we test if something unusual has just happened */
412 switch (urb->status) {
414 /* copy the result in the transfer buffer */
415 memcpy(this_usbduxsub->inBuffer,
416 urb->transfer_buffer, SIZEINBUF);
419 /* error in the ISOchronous data */
420 /* we don't copy the data into the transfer buffer */
421 /* and recycle the last data byte */
422 dev_dbg(&urb->dev->dev,
423 "comedi%d: usbdux: CRC error in ISO IN stream.\n",
424 this_usbduxsub->comedidev->minor);
432 /* happens after an unlink command */
433 if (this_usbduxsub->ai_cmd_running) {
434 /* we are still running a command */
435 /* tell this comedi */
436 s->async->events |= COMEDI_CB_EOA;
437 s->async->events |= COMEDI_CB_ERROR;
438 comedi_event(this_usbduxsub->comedidev, s);
439 /* stop the transfer w/o unlink */
440 usbdux_ai_stop(this_usbduxsub, 0);
445 /* a real error on the bus */
446 /* pass error to comedi if we are really running a command */
447 if (this_usbduxsub->ai_cmd_running) {
448 dev_err(&urb->dev->dev,
449 "Non-zero urb status received in ai intr "
450 "context: %d\n", urb->status);
451 s->async->events |= COMEDI_CB_EOA;
452 s->async->events |= COMEDI_CB_ERROR;
453 comedi_event(this_usbduxsub->comedidev, s);
454 /* don't do an unlink here */
455 usbdux_ai_stop(this_usbduxsub, 0);
461 * at this point we are reasonably sure that nothing dodgy has happened
462 * are we running a command?
464 if (unlikely((!(this_usbduxsub->ai_cmd_running)))) {
466 * not running a command, do not continue execution if no
467 * asynchronous command is running in particular not resubmit
472 urb->dev = this_usbduxsub->usbdev;
474 /* resubmit the urb */
475 err = usb_submit_urb(urb, GFP_ATOMIC);
476 if (unlikely(err < 0)) {
477 dev_err(&urb->dev->dev,
478 "comedi_: urb resubmit failed in int-context! err=%d\n",
480 if (err == -EL2NSYNC)
481 dev_err(&urb->dev->dev,
482 "buggy USB host controller or bug in IRQ "
484 s->async->events |= COMEDI_CB_EOA;
485 s->async->events |= COMEDI_CB_ERROR;
486 comedi_event(this_usbduxsub->comedidev, s);
487 /* don't do an unlink here */
488 usbdux_ai_stop(this_usbduxsub, 0);
492 this_usbduxsub->ai_counter--;
493 if (likely(this_usbduxsub->ai_counter > 0))
496 /* timer zero, transfer measurements to comedi */
497 this_usbduxsub->ai_counter = this_usbduxsub->ai_timer;
499 /* test, if we transmit only a fixed number of samples */
500 if (!(this_usbduxsub->ai_continous)) {
501 /* not continuous, fixed number of samples */
502 this_usbduxsub->ai_sample_count--;
503 /* all samples received? */
504 if (this_usbduxsub->ai_sample_count < 0) {
505 /* prevent a resubmit next time */
506 usbdux_ai_stop(this_usbduxsub, 0);
507 /* say comedi that the acquistion is over */
508 s->async->events |= COMEDI_CB_EOA;
509 comedi_event(this_usbduxsub->comedidev, s);
513 /* get the data from the USB bus and hand it over to comedi */
514 n = s->async->cmd.chanlist_len;
515 for (i = 0; i < n; i++) {
517 if (CR_RANGE(s->async->cmd.chanlist[i]) <= 1) {
520 le16_to_cpu(this_usbduxsub->inBuffer[i]) ^ 0x800);
524 le16_to_cpu(this_usbduxsub->inBuffer[i]));
526 if (unlikely(err == 0)) {
527 /* buffer overflow */
528 usbdux_ai_stop(this_usbduxsub, 0);
532 /* tell comedi that data is there */
533 s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
534 comedi_event(this_usbduxsub->comedidev, s);
537 static int usbduxsub_unlink_OutURBs(struct usbduxsub *usbduxsub_tmp)
542 if (usbduxsub_tmp && usbduxsub_tmp->urbOut) {
543 for (i = 0; i < usbduxsub_tmp->numOfOutBuffers; i++) {
544 if (usbduxsub_tmp->urbOut[i])
545 usb_kill_urb(usbduxsub_tmp->urbOut[i]);
547 dev_dbg(&usbduxsub_tmp->interface->dev,
548 "comedi: usbdux: unlinked OutURB %d: res=%d\n",
555 /* This will cancel a running acquisition operation
558 static int usbdux_ao_stop(struct usbduxsub *this_usbduxsub, int do_unlink)
564 dev_dbg(&this_usbduxsub->interface->dev, "comedi: usbdux_ao_cancel\n");
567 ret = usbduxsub_unlink_OutURBs(this_usbduxsub);
569 this_usbduxsub->ao_cmd_running = 0;
574 /* force unlink, is called by comedi */
575 static int usbdux_ao_cancel(struct comedi_device *dev,
576 struct comedi_subdevice *s)
578 struct usbduxsub *this_usbduxsub = dev->private;
584 /* prevent other CPUs from submitting a command just now */
585 down(&this_usbduxsub->sem);
586 if (!(this_usbduxsub->probed)) {
587 up(&this_usbduxsub->sem);
590 /* unlink only if it is really running */
591 res = usbdux_ao_stop(this_usbduxsub, this_usbduxsub->ao_cmd_running);
592 up(&this_usbduxsub->sem);
596 static void usbduxsub_ao_IsocIrq(struct urb *urb)
600 struct usbduxsub *this_usbduxsub;
601 struct comedi_device *this_comedidev;
602 struct comedi_subdevice *s;
604 /* the context variable points to the subdevice */
605 this_comedidev = urb->context;
606 /* the private structure of the subdevice is struct usbduxsub */
607 this_usbduxsub = this_comedidev->private;
609 s = &this_comedidev->subdevices[SUBDEV_DA];
611 switch (urb->status) {
620 /* after an unlink command, unplug, ... etc */
621 /* no unlink needed here. Already shutting down. */
622 if (this_usbduxsub->ao_cmd_running) {
623 s->async->events |= COMEDI_CB_EOA;
624 comedi_event(this_usbduxsub->comedidev, s);
625 usbdux_ao_stop(this_usbduxsub, 0);
631 if (this_usbduxsub->ao_cmd_running) {
632 dev_err(&urb->dev->dev,
633 "comedi_: Non-zero urb status received in ao "
634 "intr context: %d\n", urb->status);
635 s->async->events |= COMEDI_CB_ERROR;
636 s->async->events |= COMEDI_CB_EOA;
637 comedi_event(this_usbduxsub->comedidev, s);
638 /* we do an unlink if we are in the high speed mode */
639 usbdux_ao_stop(this_usbduxsub, 0);
644 /* are we actually running? */
645 if (!(this_usbduxsub->ao_cmd_running))
648 /* normal operation: executing a command in this subdevice */
649 this_usbduxsub->ao_counter--;
650 if ((int)this_usbduxsub->ao_counter <= 0) {
652 this_usbduxsub->ao_counter = this_usbduxsub->ao_timer;
654 /* handle non continous acquisition */
655 if (!(this_usbduxsub->ao_continous)) {
656 /* fixed number of samples */
657 this_usbduxsub->ao_sample_count--;
658 if (this_usbduxsub->ao_sample_count < 0) {
659 /* all samples transmitted */
660 usbdux_ao_stop(this_usbduxsub, 0);
661 s->async->events |= COMEDI_CB_EOA;
662 comedi_event(this_usbduxsub->comedidev, s);
663 /* no resubmit of the urb */
667 /* transmit data to the USB bus */
668 ((uint8_t *) (urb->transfer_buffer))[0] =
669 s->async->cmd.chanlist_len;
670 for (i = 0; i < s->async->cmd.chanlist_len; i++) {
672 if (i >= NUMOUTCHANNELS)
675 /* pointer to the DA */
677 (&(((int8_t *) urb->transfer_buffer)[i * 3 + 1]));
678 /* get the data from comedi */
679 ret = comedi_buf_get(s->async, &temp);
681 datap[1] = temp >> 8;
682 datap[2] = this_usbduxsub->dac_commands[i];
683 /* printk("data[0]=%x, data[1]=%x, data[2]=%x\n", */
684 /* datap[0],datap[1],datap[2]); */
686 dev_err(&urb->dev->dev,
687 "comedi: buffer underflow\n");
688 s->async->events |= COMEDI_CB_EOA;
689 s->async->events |= COMEDI_CB_OVERFLOW;
691 /* transmit data to comedi */
692 s->async->events |= COMEDI_CB_BLOCK;
693 comedi_event(this_usbduxsub->comedidev, s);
696 urb->transfer_buffer_length = SIZEOUTBUF;
697 urb->dev = this_usbduxsub->usbdev;
699 if (this_usbduxsub->ao_cmd_running) {
700 if (this_usbduxsub->high_speed) {
707 urb->number_of_packets = 1;
708 urb->iso_frame_desc[0].offset = 0;
709 urb->iso_frame_desc[0].length = SIZEOUTBUF;
710 urb->iso_frame_desc[0].status = 0;
711 ret = usb_submit_urb(urb, GFP_ATOMIC);
713 dev_err(&urb->dev->dev,
714 "comedi_: ao urb resubm failed in int-cont. "
717 dev_err(&urb->dev->dev,
718 "buggy USB host controller or bug in "
721 s->async->events |= COMEDI_CB_EOA;
722 s->async->events |= COMEDI_CB_ERROR;
723 comedi_event(this_usbduxsub->comedidev, s);
724 /* don't do an unlink here */
725 usbdux_ao_stop(this_usbduxsub, 0);
730 static int usbduxsub_start(struct usbduxsub *usbduxsub)
733 uint8_t local_transfer_buffer[16];
736 local_transfer_buffer[0] = 0;
737 errcode = usb_control_msg(usbduxsub->usbdev,
738 /* create a pipe for a control transfer */
739 usb_sndctrlpipe(usbduxsub->usbdev, 0),
740 /* bRequest, "Firmware" */
748 /* address of the transfer buffer */
749 local_transfer_buffer,
755 dev_err(&usbduxsub->interface->dev,
756 "comedi_: control msg failed (start)\n");
762 static int usbduxsub_stop(struct usbduxsub *usbduxsub)
766 uint8_t local_transfer_buffer[16];
769 local_transfer_buffer[0] = 1;
770 errcode = usb_control_msg(usbduxsub->usbdev,
771 usb_sndctrlpipe(usbduxsub->usbdev, 0),
772 /* bRequest, "Firmware" */
779 0x0000, local_transfer_buffer,
785 dev_err(&usbduxsub->interface->dev,
786 "comedi_: control msg failed (stop)\n");
792 static int usbduxsub_upload(struct usbduxsub *usbduxsub,
793 uint8_t *local_transfer_buffer,
794 unsigned int startAddr, unsigned int len)
798 errcode = usb_control_msg(usbduxsub->usbdev,
799 usb_sndctrlpipe(usbduxsub->usbdev, 0),
800 /* brequest, firmware */
808 /* our local safe buffer */
809 local_transfer_buffer,
814 dev_dbg(&usbduxsub->interface->dev, "comedi_: result=%d\n", errcode);
816 dev_err(&usbduxsub->interface->dev, "comedi_: upload failed\n");
822 #define FIRMWARE_MAX_LEN 0x2000
824 static int firmwareUpload(struct usbduxsub *usbduxsub,
825 const u8 *firmwareBinary, int sizeFirmware)
833 if (sizeFirmware > FIRMWARE_MAX_LEN) {
834 dev_err(&usbduxsub->interface->dev,
835 "usbdux firmware binary it too large for FX2.\n");
839 /* we generate a local buffer for the firmware */
840 fwBuf = kmemdup(firmwareBinary, sizeFirmware, GFP_KERNEL);
842 dev_err(&usbduxsub->interface->dev,
843 "comedi_: mem alloc for firmware failed\n");
847 ret = usbduxsub_stop(usbduxsub);
849 dev_err(&usbduxsub->interface->dev,
850 "comedi_: can not stop firmware\n");
855 ret = usbduxsub_upload(usbduxsub, fwBuf, 0, sizeFirmware);
857 dev_err(&usbduxsub->interface->dev,
858 "comedi_: firmware upload failed\n");
862 ret = usbduxsub_start(usbduxsub);
864 dev_err(&usbduxsub->interface->dev,
865 "comedi_: can not start firmware\n");
873 static int usbduxsub_submit_InURBs(struct usbduxsub *usbduxsub)
880 /* Submit all URBs and start the transfer on the bus */
881 for (i = 0; i < usbduxsub->numOfInBuffers; i++) {
882 /* in case of a resubmission after an unlink... */
883 usbduxsub->urbIn[i]->interval = usbduxsub->ai_interval;
884 usbduxsub->urbIn[i]->context = usbduxsub->comedidev;
885 usbduxsub->urbIn[i]->dev = usbduxsub->usbdev;
886 usbduxsub->urbIn[i]->status = 0;
887 usbduxsub->urbIn[i]->transfer_flags = URB_ISO_ASAP;
888 dev_dbg(&usbduxsub->interface->dev,
889 "comedi%d: submitting in-urb[%d]: %p,%p intv=%d\n",
890 usbduxsub->comedidev->minor, i,
891 (usbduxsub->urbIn[i]->context),
892 (usbduxsub->urbIn[i]->dev),
893 (usbduxsub->urbIn[i]->interval));
894 errFlag = usb_submit_urb(usbduxsub->urbIn[i], GFP_ATOMIC);
896 dev_err(&usbduxsub->interface->dev,
897 "comedi_: ai: usb_submit_urb(%d) error %d\n",
905 static int usbduxsub_submit_OutURBs(struct usbduxsub *usbduxsub)
912 for (i = 0; i < usbduxsub->numOfOutBuffers; i++) {
913 dev_dbg(&usbduxsub->interface->dev,
914 "comedi_: submitting out-urb[%d]\n", i);
915 /* in case of a resubmission after an unlink... */
916 usbduxsub->urbOut[i]->context = usbduxsub->comedidev;
917 usbduxsub->urbOut[i]->dev = usbduxsub->usbdev;
918 usbduxsub->urbOut[i]->status = 0;
919 usbduxsub->urbOut[i]->transfer_flags = URB_ISO_ASAP;
920 errFlag = usb_submit_urb(usbduxsub->urbOut[i], GFP_ATOMIC);
922 dev_err(&usbduxsub->interface->dev,
923 "comedi_: ao: usb_submit_urb(%d) error %d\n",
931 static int usbdux_ai_cmdtest(struct comedi_device *dev,
932 struct comedi_subdevice *s, struct comedi_cmd *cmd)
934 struct usbduxsub *this_usbduxsub = dev->private;
936 unsigned int tmpTimer;
938 if (!(this_usbduxsub->probed))
941 /* Step 1 : check if triggers are trivially valid */
943 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
944 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
945 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
946 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
947 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
952 /* Step 2a : make sure trigger sources are unique */
954 err |= cfc_check_trigger_is_unique(cmd->start_src);
955 err |= cfc_check_trigger_is_unique(cmd->stop_src);
957 /* Step 2b : and mutually compatible */
962 /* Step 3: check if arguments are trivially valid */
964 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
966 if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
967 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
969 if (cmd->scan_begin_src == TRIG_TIMER) {
970 if (this_usbduxsub->high_speed) {
972 * In high speed mode microframes are possible.
973 * However, during one microframe we can roughly
974 * sample one channel. Thus, the more channels
975 * are in the channel list the more time we need.
978 /* find a power of 2 for the number of channels */
979 while (i < (cmd->chanlist_len))
982 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
984 /* now calc the real sampling rate with all the
987 ((unsigned int)(cmd->scan_begin_arg / 125000)) *
991 /* 1kHz scans every USB frame */
992 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
995 * calc the real sampling rate with the rounding errors
997 tmpTimer = ((unsigned int)(cmd->scan_begin_arg /
1000 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg,
1004 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
1006 if (cmd->stop_src == TRIG_COUNT) {
1007 /* any count is allowed */
1010 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
1020 * creates the ADC command for the MAX1271
1021 * range is the range value from comedi
1023 static int8_t create_adc_command(unsigned int chan, int range)
1025 int8_t p = (range <= 1);
1026 int8_t r = ((range % 2) == 0);
1027 return (chan << 4) | ((p == 1) << 2) | ((r == 1) << 3);
1030 /* bulk transfers to usbdux */
1032 #define SENDADCOMMANDS 0
1033 #define SENDDACOMMANDS 1
1034 #define SENDDIOCONFIGCOMMAND 2
1035 #define SENDDIOBITSCOMMAND 3
1036 #define SENDSINGLEAD 4
1037 #define READCOUNTERCOMMAND 5
1038 #define WRITECOUNTERCOMMAND 6
1040 #define SENDPWMOFF 8
1042 static int send_dux_commands(struct usbduxsub *this_usbduxsub, int cmd_type)
1046 this_usbduxsub->dux_commands[0] = cmd_type;
1047 #ifdef NOISY_DUX_DEBUGBUG
1048 printk(KERN_DEBUG "comedi%d: usbdux: dux_commands: ",
1049 this_usbduxsub->comedidev->minor);
1050 for (result = 0; result < SIZEOFDUXBUFFER; result++)
1051 printk(" %02x", this_usbduxsub->dux_commands[result]);
1054 result = usb_bulk_msg(this_usbduxsub->usbdev,
1055 usb_sndbulkpipe(this_usbduxsub->usbdev,
1057 this_usbduxsub->dux_commands, SIZEOFDUXBUFFER,
1058 &nsent, BULK_TIMEOUT);
1060 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1061 "could not transmit dux_command to the usb-device, "
1062 "err=%d\n", this_usbduxsub->comedidev->minor, result);
1067 static int receive_dux_commands(struct usbduxsub *this_usbduxsub, int command)
1069 int result = (-EFAULT);
1073 for (i = 0; i < RETRIES; i++) {
1074 result = usb_bulk_msg(this_usbduxsub->usbdev,
1075 usb_rcvbulkpipe(this_usbduxsub->usbdev,
1077 this_usbduxsub->insnBuffer, SIZEINSNBUF,
1078 &nrec, BULK_TIMEOUT);
1080 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1081 "insn: USB error %d while receiving DUX command"
1082 "\n", this_usbduxsub->comedidev->minor, result);
1085 if (le16_to_cpu(this_usbduxsub->insnBuffer[0]) == command)
1088 /* this is only reached if the data has been requested a couple of
1090 dev_err(&this_usbduxsub->interface->dev, "comedi%d: insn: "
1091 "wrong data returned from firmware: want cmd %d, got cmd %d.\n",
1092 this_usbduxsub->comedidev->minor, command,
1093 le16_to_cpu(this_usbduxsub->insnBuffer[0]));
1097 static int usbdux_ai_inttrig(struct comedi_device *dev,
1098 struct comedi_subdevice *s, unsigned int trignum)
1101 struct usbduxsub *this_usbduxsub = dev->private;
1102 if (!this_usbduxsub)
1105 down(&this_usbduxsub->sem);
1106 if (!(this_usbduxsub->probed)) {
1107 up(&this_usbduxsub->sem);
1110 dev_dbg(&this_usbduxsub->interface->dev,
1111 "comedi%d: usbdux_ai_inttrig\n", dev->minor);
1114 dev_err(&this_usbduxsub->interface->dev,
1115 "comedi%d: usbdux_ai_inttrig: invalid trignum\n",
1117 up(&this_usbduxsub->sem);
1120 if (!(this_usbduxsub->ai_cmd_running)) {
1121 this_usbduxsub->ai_cmd_running = 1;
1122 ret = usbduxsub_submit_InURBs(this_usbduxsub);
1124 dev_err(&this_usbduxsub->interface->dev,
1125 "comedi%d: usbdux_ai_inttrig: "
1126 "urbSubmit: err=%d\n", dev->minor, ret);
1127 this_usbduxsub->ai_cmd_running = 0;
1128 up(&this_usbduxsub->sem);
1131 s->async->inttrig = NULL;
1133 dev_err(&this_usbduxsub->interface->dev,
1134 "comedi%d: ai_inttrig but acqu is already running\n",
1137 up(&this_usbduxsub->sem);
1141 static int usbdux_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1143 struct comedi_cmd *cmd = &s->async->cmd;
1144 unsigned int chan, range;
1146 struct usbduxsub *this_usbduxsub = dev->private;
1149 if (!this_usbduxsub)
1152 dev_dbg(&this_usbduxsub->interface->dev,
1153 "comedi%d: usbdux_ai_cmd\n", dev->minor);
1155 /* block other CPUs from starting an ai_cmd */
1156 down(&this_usbduxsub->sem);
1158 if (!(this_usbduxsub->probed)) {
1159 up(&this_usbduxsub->sem);
1162 if (this_usbduxsub->ai_cmd_running) {
1163 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1164 "ai_cmd not possible. Another ai_cmd is running.\n",
1166 up(&this_usbduxsub->sem);
1169 /* set current channel of the running acquisition to zero */
1170 s->async->cur_chan = 0;
1172 this_usbduxsub->dux_commands[1] = cmd->chanlist_len;
1173 for (i = 0; i < cmd->chanlist_len; ++i) {
1174 chan = CR_CHAN(cmd->chanlist[i]);
1175 range = CR_RANGE(cmd->chanlist[i]);
1176 if (i >= NUMCHANNELS) {
1177 dev_err(&this_usbduxsub->interface->dev,
1178 "comedi%d: channel list too long\n",
1182 this_usbduxsub->dux_commands[i + 2] =
1183 create_adc_command(chan, range);
1186 dev_dbg(&this_usbduxsub->interface->dev,
1187 "comedi %d: sending commands to the usb device: size=%u\n",
1188 dev->minor, NUMCHANNELS);
1190 result = send_dux_commands(this_usbduxsub, SENDADCOMMANDS);
1192 up(&this_usbduxsub->sem);
1196 if (this_usbduxsub->high_speed) {
1198 * every channel gets a time window of 125us. Thus, if we
1199 * sample all 8 channels we need 1ms. If we sample only one
1200 * channel we need only 125us
1202 this_usbduxsub->ai_interval = 1;
1203 /* find a power of 2 for the interval */
1204 while ((this_usbduxsub->ai_interval) < (cmd->chanlist_len)) {
1205 this_usbduxsub->ai_interval =
1206 (this_usbduxsub->ai_interval) * 2;
1208 this_usbduxsub->ai_timer = cmd->scan_begin_arg / (125000 *
1212 /* interval always 1ms */
1213 this_usbduxsub->ai_interval = 1;
1214 this_usbduxsub->ai_timer = cmd->scan_begin_arg / 1000000;
1216 if (this_usbduxsub->ai_timer < 1) {
1217 dev_err(&this_usbduxsub->interface->dev, "comedi%d: ai_cmd: "
1218 "timer=%d, scan_begin_arg=%d. "
1219 "Not properly tested by cmdtest?\n", dev->minor,
1220 this_usbduxsub->ai_timer, cmd->scan_begin_arg);
1221 up(&this_usbduxsub->sem);
1224 this_usbduxsub->ai_counter = this_usbduxsub->ai_timer;
1226 if (cmd->stop_src == TRIG_COUNT) {
1227 /* data arrives as one packet */
1228 this_usbduxsub->ai_sample_count = cmd->stop_arg;
1229 this_usbduxsub->ai_continous = 0;
1231 /* continous acquisition */
1232 this_usbduxsub->ai_continous = 1;
1233 this_usbduxsub->ai_sample_count = 0;
1236 if (cmd->start_src == TRIG_NOW) {
1237 /* enable this acquisition operation */
1238 this_usbduxsub->ai_cmd_running = 1;
1239 ret = usbduxsub_submit_InURBs(this_usbduxsub);
1241 this_usbduxsub->ai_cmd_running = 0;
1242 /* fixme: unlink here?? */
1243 up(&this_usbduxsub->sem);
1246 s->async->inttrig = NULL;
1249 /* don't enable the acquision operation */
1250 /* wait for an internal signal */
1251 s->async->inttrig = usbdux_ai_inttrig;
1253 up(&this_usbduxsub->sem);
1257 /* Mode 0 is used to get a single conversion on demand */
1258 static int usbdux_ai_insn_read(struct comedi_device *dev,
1259 struct comedi_subdevice *s,
1260 struct comedi_insn *insn, unsigned int *data)
1263 unsigned int one = 0;
1266 struct usbduxsub *this_usbduxsub = dev->private;
1268 if (!this_usbduxsub)
1271 dev_dbg(&this_usbduxsub->interface->dev,
1272 "comedi%d: ai_insn_read, insn->n=%d, insn->subdev=%d\n",
1273 dev->minor, insn->n, insn->subdev);
1275 down(&this_usbduxsub->sem);
1276 if (!(this_usbduxsub->probed)) {
1277 up(&this_usbduxsub->sem);
1280 if (this_usbduxsub->ai_cmd_running) {
1281 dev_err(&this_usbduxsub->interface->dev,
1282 "comedi%d: ai_insn_read not possible. "
1283 "Async Command is running.\n", dev->minor);
1284 up(&this_usbduxsub->sem);
1288 /* sample one channel */
1289 chan = CR_CHAN(insn->chanspec);
1290 range = CR_RANGE(insn->chanspec);
1291 /* set command for the first channel */
1292 this_usbduxsub->dux_commands[1] = create_adc_command(chan, range);
1295 err = send_dux_commands(this_usbduxsub, SENDSINGLEAD);
1297 up(&this_usbduxsub->sem);
1301 for (i = 0; i < insn->n; i++) {
1302 err = receive_dux_commands(this_usbduxsub, SENDSINGLEAD);
1304 up(&this_usbduxsub->sem);
1307 one = le16_to_cpu(this_usbduxsub->insnBuffer[1]);
1308 if (CR_RANGE(insn->chanspec) <= 1)
1313 up(&this_usbduxsub->sem);
1317 /************************************/
1320 static int usbdux_ao_insn_read(struct comedi_device *dev,
1321 struct comedi_subdevice *s,
1322 struct comedi_insn *insn, unsigned int *data)
1325 int chan = CR_CHAN(insn->chanspec);
1326 struct usbduxsub *this_usbduxsub = dev->private;
1328 if (!this_usbduxsub)
1331 down(&this_usbduxsub->sem);
1332 if (!(this_usbduxsub->probed)) {
1333 up(&this_usbduxsub->sem);
1336 for (i = 0; i < insn->n; i++)
1337 data[i] = this_usbduxsub->outBuffer[chan];
1339 up(&this_usbduxsub->sem);
1343 static int usbdux_ao_insn_write(struct comedi_device *dev,
1344 struct comedi_subdevice *s,
1345 struct comedi_insn *insn, unsigned int *data)
1348 int chan = CR_CHAN(insn->chanspec);
1349 struct usbduxsub *this_usbduxsub = dev->private;
1351 if (!this_usbduxsub)
1354 dev_dbg(&this_usbduxsub->interface->dev,
1355 "comedi%d: ao_insn_write\n", dev->minor);
1357 down(&this_usbduxsub->sem);
1358 if (!(this_usbduxsub->probed)) {
1359 up(&this_usbduxsub->sem);
1362 if (this_usbduxsub->ao_cmd_running) {
1363 dev_err(&this_usbduxsub->interface->dev,
1364 "comedi%d: ao_insn_write: "
1365 "ERROR: asynchronous ao_cmd is running\n", dev->minor);
1366 up(&this_usbduxsub->sem);
1370 for (i = 0; i < insn->n; i++) {
1371 dev_dbg(&this_usbduxsub->interface->dev,
1372 "comedi%d: ao_insn_write: data[chan=%d,i=%d]=%d\n",
1373 dev->minor, chan, i, data[i]);
1375 /* number of channels: 1 */
1376 this_usbduxsub->dux_commands[1] = 1;
1377 /* one 16 bit value */
1378 *((int16_t *) (this_usbduxsub->dux_commands + 2)) =
1379 cpu_to_le16(data[i]);
1380 this_usbduxsub->outBuffer[chan] = data[i];
1381 /* channel number */
1382 this_usbduxsub->dux_commands[4] = (chan << 6);
1383 err = send_dux_commands(this_usbduxsub, SENDDACOMMANDS);
1385 up(&this_usbduxsub->sem);
1389 up(&this_usbduxsub->sem);
1394 static int usbdux_ao_inttrig(struct comedi_device *dev,
1395 struct comedi_subdevice *s, unsigned int trignum)
1398 struct usbduxsub *this_usbduxsub = dev->private;
1400 if (!this_usbduxsub)
1403 down(&this_usbduxsub->sem);
1404 if (!(this_usbduxsub->probed)) {
1405 up(&this_usbduxsub->sem);
1409 dev_err(&this_usbduxsub->interface->dev,
1410 "comedi%d: usbdux_ao_inttrig: invalid trignum\n",
1412 up(&this_usbduxsub->sem);
1415 if (!(this_usbduxsub->ao_cmd_running)) {
1416 this_usbduxsub->ao_cmd_running = 1;
1417 ret = usbduxsub_submit_OutURBs(this_usbduxsub);
1419 dev_err(&this_usbduxsub->interface->dev,
1420 "comedi%d: usbdux_ao_inttrig: submitURB: "
1421 "err=%d\n", dev->minor, ret);
1422 this_usbduxsub->ao_cmd_running = 0;
1423 up(&this_usbduxsub->sem);
1426 s->async->inttrig = NULL;
1428 dev_err(&this_usbduxsub->interface->dev,
1429 "comedi%d: ao_inttrig but acqu is already running.\n",
1432 up(&this_usbduxsub->sem);
1436 static int usbdux_ao_cmdtest(struct comedi_device *dev,
1437 struct comedi_subdevice *s, struct comedi_cmd *cmd)
1439 struct usbduxsub *this_usbduxsub = dev->private;
1443 if (!this_usbduxsub)
1446 if (!(this_usbduxsub->probed))
1449 /* Step 1 : check if triggers are trivially valid */
1451 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
1453 if (0) { /* (this_usbduxsub->high_speed) */
1454 /* the sampling rate is set by the coversion rate */
1455 flags = TRIG_FOLLOW;
1457 /* start a new scan (output at once) with a timer */
1460 err |= cfc_check_trigger_src(&cmd->scan_begin_src, flags);
1462 if (0) { /* (this_usbduxsub->high_speed) */
1464 * in usb-2.0 only one conversion it transmitted
1470 * all conversion events happen simultaneously with
1475 err |= cfc_check_trigger_src(&cmd->convert_src, flags);
1477 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1478 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1483 /* Step 2a : make sure trigger sources are unique */
1485 err |= cfc_check_trigger_is_unique(cmd->start_src);
1486 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1488 /* Step 2b : and mutually compatible */
1493 /* Step 3: check if arguments are trivially valid */
1495 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
1497 if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
1498 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
1500 if (cmd->scan_begin_src == TRIG_TIMER)
1501 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
1504 /* not used now, is for later use */
1505 if (cmd->convert_src == TRIG_TIMER)
1506 err |= cfc_check_trigger_arg_min(&cmd->convert_arg, 125000);
1508 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
1510 if (cmd->stop_src == TRIG_COUNT) {
1511 /* any count is allowed */
1514 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
1523 static int usbdux_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1525 struct comedi_cmd *cmd = &s->async->cmd;
1526 unsigned int chan, gain;
1528 struct usbduxsub *this_usbduxsub = dev->private;
1530 if (!this_usbduxsub)
1533 down(&this_usbduxsub->sem);
1534 if (!(this_usbduxsub->probed)) {
1535 up(&this_usbduxsub->sem);
1538 dev_dbg(&this_usbduxsub->interface->dev,
1539 "comedi%d: %s\n", dev->minor, __func__);
1541 /* set current channel of the running acquisition to zero */
1542 s->async->cur_chan = 0;
1543 for (i = 0; i < cmd->chanlist_len; ++i) {
1544 chan = CR_CHAN(cmd->chanlist[i]);
1545 gain = CR_RANGE(cmd->chanlist[i]);
1546 if (i >= NUMOUTCHANNELS) {
1547 dev_err(&this_usbduxsub->interface->dev,
1548 "comedi%d: %s: channel list too long\n",
1549 dev->minor, __func__);
1552 this_usbduxsub->dac_commands[i] = (chan << 6);
1553 dev_dbg(&this_usbduxsub->interface->dev,
1554 "comedi%d: dac command for ch %d is %x\n",
1555 dev->minor, i, this_usbduxsub->dac_commands[i]);
1558 /* we count in steps of 1ms (125us) */
1559 /* 125us mode not used yet */
1560 if (0) { /* (this_usbduxsub->high_speed) */
1562 /* timing of the conversion itself: every 125 us */
1563 this_usbduxsub->ao_timer = cmd->convert_arg / 125000;
1566 /* timing of the scan: we get all channels at once */
1567 this_usbduxsub->ao_timer = cmd->scan_begin_arg / 1000000;
1568 dev_dbg(&this_usbduxsub->interface->dev,
1569 "comedi%d: scan_begin_src=%d, scan_begin_arg=%d, "
1570 "convert_src=%d, convert_arg=%d\n", dev->minor,
1571 cmd->scan_begin_src, cmd->scan_begin_arg,
1572 cmd->convert_src, cmd->convert_arg);
1573 dev_dbg(&this_usbduxsub->interface->dev,
1574 "comedi%d: ao_timer=%d (ms)\n",
1575 dev->minor, this_usbduxsub->ao_timer);
1576 if (this_usbduxsub->ao_timer < 1) {
1577 dev_err(&this_usbduxsub->interface->dev,
1578 "comedi%d: usbdux: ao_timer=%d, "
1579 "scan_begin_arg=%d. "
1580 "Not properly tested by cmdtest?\n",
1581 dev->minor, this_usbduxsub->ao_timer,
1582 cmd->scan_begin_arg);
1583 up(&this_usbduxsub->sem);
1587 this_usbduxsub->ao_counter = this_usbduxsub->ao_timer;
1589 if (cmd->stop_src == TRIG_COUNT) {
1590 /* not continuous */
1592 /* high speed also scans everything at once */
1593 if (0) { /* (this_usbduxsub->high_speed) */
1594 this_usbduxsub->ao_sample_count =
1595 (cmd->stop_arg) * (cmd->scan_end_arg);
1597 /* there's no scan as the scan has been */
1598 /* perf inside the FX2 */
1599 /* data arrives as one packet */
1600 this_usbduxsub->ao_sample_count = cmd->stop_arg;
1602 this_usbduxsub->ao_continous = 0;
1604 /* continous acquisition */
1605 this_usbduxsub->ao_continous = 1;
1606 this_usbduxsub->ao_sample_count = 0;
1609 if (cmd->start_src == TRIG_NOW) {
1610 /* enable this acquisition operation */
1611 this_usbduxsub->ao_cmd_running = 1;
1612 ret = usbduxsub_submit_OutURBs(this_usbduxsub);
1614 this_usbduxsub->ao_cmd_running = 0;
1615 /* fixme: unlink here?? */
1616 up(&this_usbduxsub->sem);
1619 s->async->inttrig = NULL;
1622 /* submit the urbs later */
1623 /* wait for an internal signal */
1624 s->async->inttrig = usbdux_ao_inttrig;
1627 up(&this_usbduxsub->sem);
1631 static int usbdux_dio_insn_config(struct comedi_device *dev,
1632 struct comedi_subdevice *s,
1633 struct comedi_insn *insn, unsigned int *data)
1635 int chan = CR_CHAN(insn->chanspec);
1637 /* The input or output configuration of each digital line is
1638 * configured by a special insn_config instruction. chanspec
1639 * contains the channel to be changed, and data[0] contains the
1640 * value COMEDI_INPUT or COMEDI_OUTPUT. */
1643 case INSN_CONFIG_DIO_OUTPUT:
1644 s->io_bits |= 1 << chan; /* 1 means Out */
1646 case INSN_CONFIG_DIO_INPUT:
1647 s->io_bits &= ~(1 << chan);
1649 case INSN_CONFIG_DIO_QUERY:
1651 (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
1657 /* we don't tell the firmware here as it would take 8 frames */
1658 /* to submit the information. We do it in the insn_bits. */
1662 static int usbdux_dio_insn_bits(struct comedi_device *dev,
1663 struct comedi_subdevice *s,
1664 struct comedi_insn *insn, unsigned int *data)
1667 struct usbduxsub *this_usbduxsub = dev->private;
1670 if (!this_usbduxsub)
1673 down(&this_usbduxsub->sem);
1675 if (!(this_usbduxsub->probed)) {
1676 up(&this_usbduxsub->sem);
1680 /* The insn data is a mask in data[0] and the new data
1681 * in data[1], each channel cooresponding to a bit. */
1682 s->state &= ~data[0];
1683 s->state |= data[0] & data[1];
1684 this_usbduxsub->dux_commands[1] = s->io_bits;
1685 this_usbduxsub->dux_commands[2] = s->state;
1687 /* This command also tells the firmware to return */
1688 /* the digital input lines */
1689 err = send_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND);
1691 up(&this_usbduxsub->sem);
1694 err = receive_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND);
1696 up(&this_usbduxsub->sem);
1700 data[1] = le16_to_cpu(this_usbduxsub->insnBuffer[1]);
1701 up(&this_usbduxsub->sem);
1705 /* reads the 4 counters, only two are used just now */
1706 static int usbdux_counter_read(struct comedi_device *dev,
1707 struct comedi_subdevice *s,
1708 struct comedi_insn *insn, unsigned int *data)
1710 struct usbduxsub *this_usbduxsub = dev->private;
1711 int chan = insn->chanspec;
1714 if (!this_usbduxsub)
1717 down(&this_usbduxsub->sem);
1719 if (!(this_usbduxsub->probed)) {
1720 up(&this_usbduxsub->sem);
1724 err = send_dux_commands(this_usbduxsub, READCOUNTERCOMMAND);
1726 up(&this_usbduxsub->sem);
1730 err = receive_dux_commands(this_usbduxsub, READCOUNTERCOMMAND);
1732 up(&this_usbduxsub->sem);
1736 data[0] = le16_to_cpu(this_usbduxsub->insnBuffer[chan + 1]);
1737 up(&this_usbduxsub->sem);
1741 static int usbdux_counter_write(struct comedi_device *dev,
1742 struct comedi_subdevice *s,
1743 struct comedi_insn *insn, unsigned int *data)
1745 struct usbduxsub *this_usbduxsub = dev->private;
1748 if (!this_usbduxsub)
1751 down(&this_usbduxsub->sem);
1753 if (!(this_usbduxsub->probed)) {
1754 up(&this_usbduxsub->sem);
1758 this_usbduxsub->dux_commands[1] = insn->chanspec;
1759 *((int16_t *) (this_usbduxsub->dux_commands + 2)) = cpu_to_le16(*data);
1761 err = send_dux_commands(this_usbduxsub, WRITECOUNTERCOMMAND);
1763 up(&this_usbduxsub->sem);
1767 up(&this_usbduxsub->sem);
1772 static int usbdux_counter_config(struct comedi_device *dev,
1773 struct comedi_subdevice *s,
1774 struct comedi_insn *insn, unsigned int *data)
1776 /* nothing to do so far */
1780 /***********************************/
1783 static int usbduxsub_unlink_PwmURBs(struct usbduxsub *usbduxsub_tmp)
1787 if (usbduxsub_tmp && usbduxsub_tmp->urbPwm) {
1788 if (usbduxsub_tmp->urbPwm)
1789 usb_kill_urb(usbduxsub_tmp->urbPwm);
1790 dev_dbg(&usbduxsub_tmp->interface->dev,
1791 "comedi: unlinked PwmURB: res=%d\n", err);
1796 /* This cancels a running acquisition operation
1799 static int usbdux_pwm_stop(struct usbduxsub *this_usbduxsub, int do_unlink)
1803 if (!this_usbduxsub)
1806 dev_dbg(&this_usbduxsub->interface->dev, "comedi: %s\n", __func__);
1808 ret = usbduxsub_unlink_PwmURBs(this_usbduxsub);
1810 this_usbduxsub->pwm_cmd_running = 0;
1815 /* force unlink - is called by comedi */
1816 static int usbdux_pwm_cancel(struct comedi_device *dev,
1817 struct comedi_subdevice *s)
1819 struct usbduxsub *this_usbduxsub = dev->private;
1822 /* unlink only if it is really running */
1823 res = usbdux_pwm_stop(this_usbduxsub, this_usbduxsub->pwm_cmd_running);
1825 dev_dbg(&this_usbduxsub->interface->dev,
1826 "comedi %d: sending pwm off command to the usb device.\n",
1829 return send_dux_commands(this_usbduxsub, SENDPWMOFF);
1832 static void usbduxsub_pwm_irq(struct urb *urb)
1835 struct usbduxsub *this_usbduxsub;
1836 struct comedi_device *this_comedidev;
1837 struct comedi_subdevice *s;
1839 /* printk(KERN_DEBUG "PWM: IRQ\n"); */
1841 /* the context variable points to the subdevice */
1842 this_comedidev = urb->context;
1843 /* the private structure of the subdevice is struct usbduxsub */
1844 this_usbduxsub = this_comedidev->private;
1846 s = &this_comedidev->subdevices[SUBDEV_DA];
1848 switch (urb->status) {
1858 * after an unlink command, unplug, ... etc
1859 * no unlink needed here. Already shutting down.
1861 if (this_usbduxsub->pwm_cmd_running)
1862 usbdux_pwm_stop(this_usbduxsub, 0);
1868 if (this_usbduxsub->pwm_cmd_running) {
1869 dev_err(&this_usbduxsub->interface->dev,
1870 "comedi_: Non-zero urb status received in "
1871 "pwm intr context: %d\n", urb->status);
1872 usbdux_pwm_stop(this_usbduxsub, 0);
1877 /* are we actually running? */
1878 if (!(this_usbduxsub->pwm_cmd_running))
1881 urb->transfer_buffer_length = this_usbduxsub->sizePwmBuf;
1882 urb->dev = this_usbduxsub->usbdev;
1884 if (this_usbduxsub->pwm_cmd_running) {
1885 ret = usb_submit_urb(urb, GFP_ATOMIC);
1887 dev_err(&this_usbduxsub->interface->dev,
1888 "comedi_: pwm urb resubm failed in int-cont. "
1890 if (ret == EL2NSYNC)
1891 dev_err(&this_usbduxsub->interface->dev,
1892 "buggy USB host controller or bug in "
1895 /* don't do an unlink here */
1896 usbdux_pwm_stop(this_usbduxsub, 0);
1901 static int usbduxsub_submit_PwmURBs(struct usbduxsub *usbduxsub)
1908 dev_dbg(&usbduxsub->interface->dev, "comedi_: submitting pwm-urb\n");
1910 /* in case of a resubmission after an unlink... */
1911 usb_fill_bulk_urb(usbduxsub->urbPwm,
1913 usb_sndbulkpipe(usbduxsub->usbdev, PWM_EP),
1914 usbduxsub->urbPwm->transfer_buffer,
1915 usbduxsub->sizePwmBuf, usbduxsub_pwm_irq,
1916 usbduxsub->comedidev);
1918 errFlag = usb_submit_urb(usbduxsub->urbPwm, GFP_ATOMIC);
1920 dev_err(&usbduxsub->interface->dev,
1921 "comedi_: usbdux: pwm: usb_submit_urb error %d\n",
1928 static int usbdux_pwm_period(struct comedi_device *dev,
1929 struct comedi_subdevice *s, unsigned int period)
1931 struct usbduxsub *this_usbduxsub = dev->private;
1934 if (period < MIN_PWM_PERIOD) {
1935 dev_err(&this_usbduxsub->interface->dev,
1936 "comedi%d: illegal period setting for pwm.\n",
1940 fx2delay = period / ((int)(6 * 512 * (1.0 / 0.033))) - 6;
1941 if (fx2delay > 255) {
1942 dev_err(&this_usbduxsub->interface->dev,
1943 "comedi%d: period %d for pwm is too low.\n",
1944 dev->minor, period);
1948 this_usbduxsub->pwmDelay = fx2delay;
1949 this_usbduxsub->pwmPeriod = period;
1950 dev_dbg(&this_usbduxsub->interface->dev, "%s: frequ=%d, period=%d\n",
1951 __func__, period, fx2delay);
1955 /* is called from insn so there's no need to do all the sanity checks */
1956 static int usbdux_pwm_start(struct comedi_device *dev,
1957 struct comedi_subdevice *s)
1960 struct usbduxsub *this_usbduxsub = dev->private;
1962 dev_dbg(&this_usbduxsub->interface->dev, "comedi%d: %s\n",
1963 dev->minor, __func__);
1965 if (this_usbduxsub->pwm_cmd_running) {
1966 /* already running */
1970 this_usbduxsub->dux_commands[1] = ((int8_t) this_usbduxsub->pwmDelay);
1971 ret = send_dux_commands(this_usbduxsub, SENDPWMON);
1975 /* initialise the buffer */
1976 for (i = 0; i < this_usbduxsub->sizePwmBuf; i++)
1977 ((char *)(this_usbduxsub->urbPwm->transfer_buffer))[i] = 0;
1979 this_usbduxsub->pwm_cmd_running = 1;
1980 ret = usbduxsub_submit_PwmURBs(this_usbduxsub);
1982 this_usbduxsub->pwm_cmd_running = 0;
1988 /* generates the bit pattern for PWM with the optional sign bit */
1989 static int usbdux_pwm_pattern(struct comedi_device *dev,
1990 struct comedi_subdevice *s, int channel,
1991 unsigned int value, unsigned int sign)
1993 struct usbduxsub *this_usbduxsub = dev->private;
2000 if (!this_usbduxsub)
2003 /* this is the DIO bit which carries the PWM data */
2004 pwm_mask = (1 << channel);
2005 /* this is the DIO bit which carries the optional direction bit */
2006 sgn_mask = (16 << channel);
2007 /* this is the buffer which will be filled with the with bit */
2008 /* pattern for one period */
2009 szbuf = this_usbduxsub->sizePwmBuf;
2010 pBuf = (char *)(this_usbduxsub->urbPwm->transfer_buffer);
2011 for (i = 0; i < szbuf; i++) {
2014 c = c & (~pwm_mask);
2015 /* set the bit as long as the index is lower than the value */
2018 /* set the optional sign bit for a relay */
2020 /* positive value */
2021 c = c & (~sgn_mask);
2023 /* negative value */
2031 static int usbdux_pwm_write(struct comedi_device *dev,
2032 struct comedi_subdevice *s,
2033 struct comedi_insn *insn, unsigned int *data)
2035 struct usbduxsub *this_usbduxsub = dev->private;
2037 if (!this_usbduxsub)
2040 if ((insn->n) != 1) {
2042 * doesn't make sense to have more than one value here because
2043 * it would just overwrite the PWM buffer a couple of times
2049 * the sign is set via a special INSN only, this gives us 8 bits for
2051 * relay sign 0 by default
2053 return usbdux_pwm_pattern(dev, s, CR_CHAN(insn->chanspec), data[0], 0);
2056 static int usbdux_pwm_read(struct comedi_device *x1,
2057 struct comedi_subdevice *x2, struct comedi_insn *x3,
2064 /* switches on/off PWM */
2065 static int usbdux_pwm_config(struct comedi_device *dev,
2066 struct comedi_subdevice *s,
2067 struct comedi_insn *insn, unsigned int *data)
2069 struct usbduxsub *this_usbduxsub = dev->private;
2071 case INSN_CONFIG_ARM:
2073 dev_dbg(&this_usbduxsub->interface->dev,
2074 "comedi%d: %s: pwm on\n", dev->minor, __func__);
2076 * if not zero the PWM is limited to a certain time which is
2077 * not supported here
2081 return usbdux_pwm_start(dev, s);
2082 case INSN_CONFIG_DISARM:
2083 dev_dbg(&this_usbduxsub->interface->dev,
2084 "comedi%d: %s: pwm off\n", dev->minor, __func__);
2085 return usbdux_pwm_cancel(dev, s);
2086 case INSN_CONFIG_GET_PWM_STATUS:
2088 * to check if the USB transmission has failed or in case PWM
2089 * was limited to n cycles to check if it has terminated
2091 data[1] = this_usbduxsub->pwm_cmd_running;
2093 case INSN_CONFIG_PWM_SET_PERIOD:
2094 dev_dbg(&this_usbduxsub->interface->dev,
2095 "comedi%d: %s: setting period\n", dev->minor, __func__);
2096 return usbdux_pwm_period(dev, s, data[1]);
2097 case INSN_CONFIG_PWM_GET_PERIOD:
2098 data[1] = this_usbduxsub->pwmPeriod;
2100 case INSN_CONFIG_PWM_SET_H_BRIDGE:
2101 /* value in the first byte and the sign in the second for a
2103 return usbdux_pwm_pattern(dev, s,
2104 /* the channel number */
2105 CR_CHAN(insn->chanspec),
2106 /* actual PWM data */
2110 case INSN_CONFIG_PWM_GET_H_BRIDGE:
2111 /* values are not kept in this driver, nothing to return here */
2118 /*****************************************************************/
2120 static void tidy_up(struct usbduxsub *usbduxsub_tmp)
2126 dev_dbg(&usbduxsub_tmp->interface->dev, "comedi_: tiding up\n");
2128 /* shows the usb subsystem that the driver is down */
2129 if (usbduxsub_tmp->interface)
2130 usb_set_intfdata(usbduxsub_tmp->interface, NULL);
2132 usbduxsub_tmp->probed = 0;
2134 if (usbduxsub_tmp->urbIn) {
2135 if (usbduxsub_tmp->ai_cmd_running) {
2136 usbduxsub_tmp->ai_cmd_running = 0;
2137 usbduxsub_unlink_InURBs(usbduxsub_tmp);
2139 for (i = 0; i < usbduxsub_tmp->numOfInBuffers; i++) {
2140 kfree(usbduxsub_tmp->urbIn[i]->transfer_buffer);
2141 usbduxsub_tmp->urbIn[i]->transfer_buffer = NULL;
2142 usb_kill_urb(usbduxsub_tmp->urbIn[i]);
2143 usb_free_urb(usbduxsub_tmp->urbIn[i]);
2144 usbduxsub_tmp->urbIn[i] = NULL;
2146 kfree(usbduxsub_tmp->urbIn);
2147 usbduxsub_tmp->urbIn = NULL;
2149 if (usbduxsub_tmp->urbOut) {
2150 if (usbduxsub_tmp->ao_cmd_running) {
2151 usbduxsub_tmp->ao_cmd_running = 0;
2152 usbduxsub_unlink_OutURBs(usbduxsub_tmp);
2154 for (i = 0; i < usbduxsub_tmp->numOfOutBuffers; i++) {
2155 kfree(usbduxsub_tmp->urbOut[i]->transfer_buffer);
2156 usbduxsub_tmp->urbOut[i]->transfer_buffer = NULL;
2157 if (usbduxsub_tmp->urbOut[i]) {
2158 usb_kill_urb(usbduxsub_tmp->urbOut[i]);
2159 usb_free_urb(usbduxsub_tmp->urbOut[i]);
2160 usbduxsub_tmp->urbOut[i] = NULL;
2163 kfree(usbduxsub_tmp->urbOut);
2164 usbduxsub_tmp->urbOut = NULL;
2166 if (usbduxsub_tmp->urbPwm) {
2167 if (usbduxsub_tmp->pwm_cmd_running) {
2168 usbduxsub_tmp->pwm_cmd_running = 0;
2169 usbduxsub_unlink_PwmURBs(usbduxsub_tmp);
2171 kfree(usbduxsub_tmp->urbPwm->transfer_buffer);
2172 usbduxsub_tmp->urbPwm->transfer_buffer = NULL;
2173 usb_kill_urb(usbduxsub_tmp->urbPwm);
2174 usb_free_urb(usbduxsub_tmp->urbPwm);
2175 usbduxsub_tmp->urbPwm = NULL;
2177 kfree(usbduxsub_tmp->inBuffer);
2178 usbduxsub_tmp->inBuffer = NULL;
2179 kfree(usbduxsub_tmp->insnBuffer);
2180 usbduxsub_tmp->insnBuffer = NULL;
2181 kfree(usbduxsub_tmp->outBuffer);
2182 usbduxsub_tmp->outBuffer = NULL;
2183 kfree(usbduxsub_tmp->dac_commands);
2184 usbduxsub_tmp->dac_commands = NULL;
2185 kfree(usbduxsub_tmp->dux_commands);
2186 usbduxsub_tmp->dux_commands = NULL;
2187 usbduxsub_tmp->ai_cmd_running = 0;
2188 usbduxsub_tmp->ao_cmd_running = 0;
2189 usbduxsub_tmp->pwm_cmd_running = 0;
2192 static int usbdux_attach_common(struct comedi_device *dev,
2193 struct usbduxsub *udev)
2196 struct comedi_subdevice *s = NULL;
2200 /* pointer back to the corresponding comedi device */
2201 udev->comedidev = dev;
2203 dev->board_name = "usbdux";
2205 /* set number of subdevices */
2206 if (udev->high_speed) {
2214 ret = comedi_alloc_subdevices(dev, n_subdevs);
2220 /* private structure is also simply the usb-structure */
2221 dev->private = udev;
2223 /* the first subdevice is the A/D converter */
2224 s = &dev->subdevices[SUBDEV_AD];
2225 /* the URBs get the comedi subdevice */
2226 /* which is responsible for reading */
2227 /* this is the subdevice which reads data */
2228 dev->read_subdev = s;
2229 /* the subdevice receives as private structure the */
2233 s->type = COMEDI_SUBD_AI;
2234 /* readable and ref is to ground */
2235 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
2238 /* length of the channellist */
2239 s->len_chanlist = 8;
2240 /* callback functions */
2241 s->insn_read = usbdux_ai_insn_read;
2242 s->do_cmdtest = usbdux_ai_cmdtest;
2243 s->do_cmd = usbdux_ai_cmd;
2244 s->cancel = usbdux_ai_cancel;
2245 /* max value from the A/D converter (12bit) */
2247 /* range table to convert to physical units */
2248 s->range_table = (&range_usbdux_ai_range);
2251 s = &dev->subdevices[SUBDEV_DA];
2253 s->type = COMEDI_SUBD_AO;
2254 /* backward pointer */
2255 dev->write_subdev = s;
2256 /* the subdevice receives as private structure the */
2260 s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
2263 /* length of the channellist */
2264 s->len_chanlist = 4;
2265 /* 12 bit resolution */
2266 s->maxdata = 0x0fff;
2268 s->range_table = (&range_usbdux_ao_range);
2270 s->do_cmdtest = usbdux_ao_cmdtest;
2271 s->do_cmd = usbdux_ao_cmd;
2272 s->cancel = usbdux_ao_cancel;
2273 s->insn_read = usbdux_ao_insn_read;
2274 s->insn_write = usbdux_ao_insn_write;
2277 s = &dev->subdevices[SUBDEV_DIO];
2278 s->type = COMEDI_SUBD_DIO;
2279 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
2282 s->range_table = (&range_digital);
2283 s->insn_bits = usbdux_dio_insn_bits;
2284 s->insn_config = usbdux_dio_insn_config;
2285 /* we don't use it */
2289 s = &dev->subdevices[SUBDEV_COUNTER];
2290 s->type = COMEDI_SUBD_COUNTER;
2291 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
2293 s->maxdata = 0xFFFF;
2294 s->insn_read = usbdux_counter_read;
2295 s->insn_write = usbdux_counter_write;
2296 s->insn_config = usbdux_counter_config;
2298 if (udev->high_speed) {
2300 s = &dev->subdevices[SUBDEV_PWM];
2301 s->type = COMEDI_SUBD_PWM;
2302 s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
2304 /* this defines the max duty cycle resolution */
2305 s->maxdata = udev->sizePwmBuf;
2306 s->insn_write = usbdux_pwm_write;
2307 s->insn_read = usbdux_pwm_read;
2308 s->insn_config = usbdux_pwm_config;
2309 usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
2311 /* finally decide that it's attached */
2316 dev_info(&udev->interface->dev, "comedi%d: attached to usbdux.\n",
2322 static int usbdux_auto_attach(struct comedi_device *dev,
2323 unsigned long context_unused)
2325 struct usb_interface *uinterf = comedi_to_usb_interface(dev);
2327 struct usbduxsub *this_usbduxsub;
2329 dev->private = NULL;
2331 down(&start_stop_sem);
2332 this_usbduxsub = usb_get_intfdata(uinterf);
2333 if (!this_usbduxsub || !this_usbduxsub->probed) {
2334 dev_err(dev->class_dev,
2335 "usbdux: error: auto_attach failed, not connected\n");
2337 } else if (this_usbduxsub->attached) {
2338 dev_err(dev->class_dev,
2339 "error: auto_attach failed, already attached\n");
2342 ret = usbdux_attach_common(dev, this_usbduxsub);
2343 up(&start_stop_sem);
2347 static void usbdux_detach(struct comedi_device *dev)
2349 struct usbduxsub *usb = dev->private;
2353 dev->private = NULL;
2355 usb->comedidev = NULL;
2360 static struct comedi_driver usbdux_driver = {
2361 .driver_name = "usbdux",
2362 .module = THIS_MODULE,
2363 .auto_attach = usbdux_auto_attach,
2364 .detach = usbdux_detach,
2367 static void usbdux_firmware_request_complete_handler(const struct firmware *fw,
2370 struct usbduxsub *usbduxsub_tmp = context;
2371 struct usb_interface *uinterf = usbduxsub_tmp->interface;
2375 dev_err(&uinterf->dev,
2376 "Firmware complete handler without firmware!\n");
2381 * we need to upload the firmware here because fw will be
2382 * freed once we've left this function
2384 ret = firmwareUpload(usbduxsub_tmp, fw->data, fw->size);
2387 dev_err(&uinterf->dev,
2388 "Could not upload firmware (err=%d)\n", ret);
2391 comedi_usb_auto_config(uinterf, &usbdux_driver, 0);
2393 release_firmware(fw);
2396 static int usbdux_usb_probe(struct usb_interface *uinterf,
2397 const struct usb_device_id *id)
2399 struct usb_device *udev = interface_to_usbdev(uinterf);
2400 struct device *dev = &uinterf->dev;
2405 dev_dbg(dev, "comedi_: usbdux_: "
2406 "finding a free structure for the usb-device\n");
2408 down(&start_stop_sem);
2409 /* look for a free place in the usbdux array */
2411 for (i = 0; i < NUMUSBDUX; i++) {
2412 if (!(usbduxsub[i].probed)) {
2420 dev_err(dev, "Too many usbdux-devices connected.\n");
2421 up(&start_stop_sem);
2424 dev_dbg(dev, "comedi_: usbdux: "
2425 "usbduxsub[%d] is ready to connect to comedi.\n", index);
2427 sema_init(&(usbduxsub[index].sem), 1);
2428 /* save a pointer to the usb device */
2429 usbduxsub[index].usbdev = udev;
2431 /* 2.6: save the interface itself */
2432 usbduxsub[index].interface = uinterf;
2433 /* get the interface number from the interface */
2434 usbduxsub[index].ifnum = uinterf->altsetting->desc.bInterfaceNumber;
2435 /* hand the private data over to the usb subsystem */
2436 /* will be needed for disconnect */
2437 usb_set_intfdata(uinterf, &(usbduxsub[index]));
2439 dev_dbg(dev, "comedi_: usbdux: ifnum=%d\n", usbduxsub[index].ifnum);
2441 /* test if it is high speed (USB 2.0) */
2442 usbduxsub[index].high_speed =
2443 (usbduxsub[index].usbdev->speed == USB_SPEED_HIGH);
2445 /* create space for the commands of the DA converter */
2446 usbduxsub[index].dac_commands = kzalloc(NUMOUTCHANNELS, GFP_KERNEL);
2447 if (!usbduxsub[index].dac_commands) {
2448 tidy_up(&(usbduxsub[index]));
2449 up(&start_stop_sem);
2452 /* create space for the commands going to the usb device */
2453 usbduxsub[index].dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL);
2454 if (!usbduxsub[index].dux_commands) {
2455 tidy_up(&(usbduxsub[index]));
2456 up(&start_stop_sem);
2459 /* create space for the in buffer and set it to zero */
2460 usbduxsub[index].inBuffer = kzalloc(SIZEINBUF, GFP_KERNEL);
2461 if (!(usbduxsub[index].inBuffer)) {
2462 tidy_up(&(usbduxsub[index]));
2463 up(&start_stop_sem);
2466 /* create space of the instruction buffer */
2467 usbduxsub[index].insnBuffer = kzalloc(SIZEINSNBUF, GFP_KERNEL);
2468 if (!(usbduxsub[index].insnBuffer)) {
2469 tidy_up(&(usbduxsub[index]));
2470 up(&start_stop_sem);
2473 /* create space for the outbuffer */
2474 usbduxsub[index].outBuffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
2475 if (!(usbduxsub[index].outBuffer)) {
2476 tidy_up(&(usbduxsub[index]));
2477 up(&start_stop_sem);
2480 /* setting to alternate setting 3: enabling iso ep and bulk ep. */
2481 i = usb_set_interface(usbduxsub[index].usbdev,
2482 usbduxsub[index].ifnum, 3);
2484 dev_err(dev, "comedi_: usbdux%d: "
2485 "could not set alternate setting 3 in high speed.\n",
2487 tidy_up(&(usbduxsub[index]));
2488 up(&start_stop_sem);
2491 if (usbduxsub[index].high_speed)
2492 usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSHIGH;
2494 usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSFULL;
2496 usbduxsub[index].urbIn =
2497 kcalloc(usbduxsub[index].numOfInBuffers, sizeof(struct urb *),
2499 if (!(usbduxsub[index].urbIn)) {
2500 tidy_up(&(usbduxsub[index]));
2501 up(&start_stop_sem);
2504 for (i = 0; i < usbduxsub[index].numOfInBuffers; i++) {
2505 /* one frame: 1ms */
2506 usbduxsub[index].urbIn[i] = usb_alloc_urb(1, GFP_KERNEL);
2507 if (usbduxsub[index].urbIn[i] == NULL) {
2508 dev_err(dev, "comedi_: usbdux%d: "
2509 "Could not alloc. urb(%d)\n", index, i);
2510 tidy_up(&(usbduxsub[index]));
2511 up(&start_stop_sem);
2514 usbduxsub[index].urbIn[i]->dev = usbduxsub[index].usbdev;
2515 /* will be filled later with a pointer to the comedi-device */
2516 /* and ONLY then the urb should be submitted */
2517 usbduxsub[index].urbIn[i]->context = NULL;
2518 usbduxsub[index].urbIn[i]->pipe =
2519 usb_rcvisocpipe(usbduxsub[index].usbdev, ISOINEP);
2520 usbduxsub[index].urbIn[i]->transfer_flags = URB_ISO_ASAP;
2521 usbduxsub[index].urbIn[i]->transfer_buffer =
2522 kzalloc(SIZEINBUF, GFP_KERNEL);
2523 if (!(usbduxsub[index].urbIn[i]->transfer_buffer)) {
2524 tidy_up(&(usbduxsub[index]));
2525 up(&start_stop_sem);
2528 usbduxsub[index].urbIn[i]->complete = usbduxsub_ai_IsocIrq;
2529 usbduxsub[index].urbIn[i]->number_of_packets = 1;
2530 usbduxsub[index].urbIn[i]->transfer_buffer_length = SIZEINBUF;
2531 usbduxsub[index].urbIn[i]->iso_frame_desc[0].offset = 0;
2532 usbduxsub[index].urbIn[i]->iso_frame_desc[0].length = SIZEINBUF;
2536 if (usbduxsub[index].high_speed)
2537 usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSHIGH;
2539 usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSFULL;
2541 usbduxsub[index].urbOut =
2542 kcalloc(usbduxsub[index].numOfOutBuffers, sizeof(struct urb *),
2544 if (!(usbduxsub[index].urbOut)) {
2545 tidy_up(&(usbduxsub[index]));
2546 up(&start_stop_sem);
2549 for (i = 0; i < usbduxsub[index].numOfOutBuffers; i++) {
2550 /* one frame: 1ms */
2551 usbduxsub[index].urbOut[i] = usb_alloc_urb(1, GFP_KERNEL);
2552 if (usbduxsub[index].urbOut[i] == NULL) {
2553 dev_err(dev, "comedi_: usbdux%d: "
2554 "Could not alloc. urb(%d)\n", index, i);
2555 tidy_up(&(usbduxsub[index]));
2556 up(&start_stop_sem);
2559 usbduxsub[index].urbOut[i]->dev = usbduxsub[index].usbdev;
2560 /* will be filled later with a pointer to the comedi-device */
2561 /* and ONLY then the urb should be submitted */
2562 usbduxsub[index].urbOut[i]->context = NULL;
2563 usbduxsub[index].urbOut[i]->pipe =
2564 usb_sndisocpipe(usbduxsub[index].usbdev, ISOOUTEP);
2565 usbduxsub[index].urbOut[i]->transfer_flags = URB_ISO_ASAP;
2566 usbduxsub[index].urbOut[i]->transfer_buffer =
2567 kzalloc(SIZEOUTBUF, GFP_KERNEL);
2568 if (!(usbduxsub[index].urbOut[i]->transfer_buffer)) {
2569 tidy_up(&(usbduxsub[index]));
2570 up(&start_stop_sem);
2573 usbduxsub[index].urbOut[i]->complete = usbduxsub_ao_IsocIrq;
2574 usbduxsub[index].urbOut[i]->number_of_packets = 1;
2575 usbduxsub[index].urbOut[i]->transfer_buffer_length = SIZEOUTBUF;
2576 usbduxsub[index].urbOut[i]->iso_frame_desc[0].offset = 0;
2577 usbduxsub[index].urbOut[i]->iso_frame_desc[0].length =
2579 if (usbduxsub[index].high_speed) {
2581 usbduxsub[index].urbOut[i]->interval = 8;
2584 usbduxsub[index].urbOut[i]->interval = 1;
2589 if (usbduxsub[index].high_speed) {
2590 /* max bulk ep size in high speed */
2591 usbduxsub[index].sizePwmBuf = 512;
2592 usbduxsub[index].urbPwm = usb_alloc_urb(0, GFP_KERNEL);
2593 if (usbduxsub[index].urbPwm == NULL) {
2594 dev_err(dev, "comedi_: usbdux%d: "
2595 "Could not alloc. pwm urb\n", index);
2596 tidy_up(&(usbduxsub[index]));
2597 up(&start_stop_sem);
2600 usbduxsub[index].urbPwm->transfer_buffer =
2601 kzalloc(usbduxsub[index].sizePwmBuf, GFP_KERNEL);
2602 if (!(usbduxsub[index].urbPwm->transfer_buffer)) {
2603 tidy_up(&(usbduxsub[index]));
2604 up(&start_stop_sem);
2608 usbduxsub[index].urbPwm = NULL;
2609 usbduxsub[index].sizePwmBuf = 0;
2612 usbduxsub[index].ai_cmd_running = 0;
2613 usbduxsub[index].ao_cmd_running = 0;
2614 usbduxsub[index].pwm_cmd_running = 0;
2616 /* we've reached the bottom of the function */
2617 usbduxsub[index].probed = 1;
2618 up(&start_stop_sem);
2620 ret = request_firmware_nowait(THIS_MODULE,
2626 usbdux_firmware_request_complete_handler);
2629 dev_err(dev, "Could not load firmware (err=%d)\n", ret);
2633 dev_info(dev, "comedi_: usbdux%d "
2634 "has been successfully initialised.\n", index);
2639 static void usbdux_usb_disconnect(struct usb_interface *intf)
2641 struct usbduxsub *usbduxsub_tmp = usb_get_intfdata(intf);
2642 struct usb_device *udev = interface_to_usbdev(intf);
2644 if (!usbduxsub_tmp) {
2646 "comedi_: disconnect called with null pointer.\n");
2649 if (usbduxsub_tmp->usbdev != udev) {
2650 dev_err(&intf->dev, "comedi_: BUG! called with wrong ptr!!!\n");
2653 comedi_usb_auto_unconfig(intf);
2654 down(&start_stop_sem);
2655 down(&usbduxsub_tmp->sem);
2656 tidy_up(usbduxsub_tmp);
2657 up(&usbduxsub_tmp->sem);
2658 up(&start_stop_sem);
2659 dev_dbg(&intf->dev, "comedi_: disconnected from the usb\n");
2662 static const struct usb_device_id usbdux_usb_table[] = {
2663 { USB_DEVICE(0x13d8, 0x0001) },
2664 { USB_DEVICE(0x13d8, 0x0002) },
2668 MODULE_DEVICE_TABLE(usb, usbdux_usb_table);
2670 static struct usb_driver usbdux_usb_driver = {
2672 .probe = usbdux_usb_probe,
2673 .disconnect = usbdux_usb_disconnect,
2674 .id_table = usbdux_usb_table,
2676 module_comedi_usb_driver(usbdux_driver, usbdux_usb_driver);
2678 MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
2679 MODULE_DESCRIPTION("Stirling/ITL USB-DUX -- Bernd.Porr@f2s.com");
2680 MODULE_LICENSE("GPL");
2681 MODULE_FIRMWARE(FIRMWARE);