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, memory 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 */
258 struct urb **urb_out;
259 /* pwm-transfer handling */
262 unsigned int pwm_period;
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 */
270 int16_t *insn_buffer;
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->urb_in) {
328 for (i = 0; i < usbduxsub_tmp->num_in_buffers; i++) {
329 if (usbduxsub_tmp->urb_in[i]) {
330 /* We wait here until all transfers have been
332 usb_kill_urb(usbduxsub_tmp->urb_in[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_isoc_irq(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->in_buffer,
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->in_buffer[i]) ^ 0x800);
524 le16_to_cpu(this_usbduxsub->in_buffer[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->urb_out) {
543 for (i = 0; i < usbduxsub_tmp->num_out_buffers; i++) {
544 if (usbduxsub_tmp->urb_out[i])
545 usb_kill_urb(usbduxsub_tmp->urb_out[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_isoc_irq(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;
735 local_transfer_buffer = kmalloc(1, GFP_KERNEL);
736 if (!local_transfer_buffer)
740 *local_transfer_buffer = 0;
741 errcode = usb_control_msg(usbduxsub->usbdev,
742 /* create a pipe for a control transfer */
743 usb_sndctrlpipe(usbduxsub->usbdev, 0),
744 /* bRequest, "Firmware" */
752 /* address of the transfer buffer */
753 local_transfer_buffer,
759 dev_err(&usbduxsub->interface->dev,
760 "comedi_: control msg failed (start)\n");
762 kfree(local_transfer_buffer);
766 static int usbduxsub_stop(struct usbduxsub *usbduxsub)
769 uint8_t *local_transfer_buffer;
771 local_transfer_buffer = kmalloc(1, GFP_KERNEL);
772 if (!local_transfer_buffer)
776 *local_transfer_buffer = 1;
777 errcode = usb_control_msg(usbduxsub->usbdev,
778 usb_sndctrlpipe(usbduxsub->usbdev, 0),
779 /* bRequest, "Firmware" */
786 0x0000, local_transfer_buffer,
792 dev_err(&usbduxsub->interface->dev,
793 "comedi_: control msg failed (stop)\n");
795 kfree(local_transfer_buffer);
799 static int usbduxsub_upload(struct usbduxsub *usbduxsub,
800 uint8_t *local_transfer_buffer,
801 unsigned int start_addr, unsigned int len)
805 errcode = usb_control_msg(usbduxsub->usbdev,
806 usb_sndctrlpipe(usbduxsub->usbdev, 0),
807 /* brequest, firmware */
815 /* our local safe buffer */
816 local_transfer_buffer,
821 dev_dbg(&usbduxsub->interface->dev, "comedi_: result=%d\n", errcode);
823 dev_err(&usbduxsub->interface->dev, "comedi_: upload failed\n");
829 #define FIRMWARE_MAX_LEN 0x2000
831 static int firmware_upload(struct usbduxsub *usbduxsub,
832 const u8 *firmware_binary, int size_firmware)
837 if (!firmware_binary)
840 if (size_firmware > FIRMWARE_MAX_LEN) {
841 dev_err(&usbduxsub->interface->dev,
842 "usbdux firmware binary it too large for FX2.\n");
846 /* we generate a local buffer for the firmware */
847 fw_buf = kmemdup(firmware_binary, size_firmware, GFP_KERNEL);
849 dev_err(&usbduxsub->interface->dev,
850 "comedi_: mem alloc for firmware failed\n");
854 ret = usbduxsub_stop(usbduxsub);
856 dev_err(&usbduxsub->interface->dev,
857 "comedi_: can not stop firmware\n");
862 ret = usbduxsub_upload(usbduxsub, fw_buf, 0, size_firmware);
864 dev_err(&usbduxsub->interface->dev,
865 "comedi_: firmware upload failed\n");
869 ret = usbduxsub_start(usbduxsub);
871 dev_err(&usbduxsub->interface->dev,
872 "comedi_: can not start firmware\n");
880 static int usbduxsub_submit_inurbs(struct usbduxsub *usbduxsub)
887 /* Submit all URBs and start the transfer on the bus */
888 for (i = 0; i < usbduxsub->num_in_buffers; i++) {
889 /* in case of a resubmission after an unlink... */
890 usbduxsub->urb_in[i]->interval = usbduxsub->ai_interval;
891 usbduxsub->urb_in[i]->context = usbduxsub->comedidev;
892 usbduxsub->urb_in[i]->dev = usbduxsub->usbdev;
893 usbduxsub->urb_in[i]->status = 0;
894 usbduxsub->urb_in[i]->transfer_flags = URB_ISO_ASAP;
895 dev_dbg(&usbduxsub->interface->dev,
896 "comedi%d: submitting in-urb[%d]: %p,%p intv=%d\n",
897 usbduxsub->comedidev->minor, i,
898 (usbduxsub->urb_in[i]->context),
899 (usbduxsub->urb_in[i]->dev),
900 (usbduxsub->urb_in[i]->interval));
901 err_flag = usb_submit_urb(usbduxsub->urb_in[i], GFP_ATOMIC);
903 dev_err(&usbduxsub->interface->dev,
904 "comedi_: ai: usb_submit_urb(%d) error %d\n",
912 static int usbduxsub_submit_outurbs(struct usbduxsub *usbduxsub)
919 for (i = 0; i < usbduxsub->num_out_buffers; i++) {
920 dev_dbg(&usbduxsub->interface->dev,
921 "comedi_: submitting out-urb[%d]\n", i);
922 /* in case of a resubmission after an unlink... */
923 usbduxsub->urb_out[i]->context = usbduxsub->comedidev;
924 usbduxsub->urb_out[i]->dev = usbduxsub->usbdev;
925 usbduxsub->urb_out[i]->status = 0;
926 usbduxsub->urb_out[i]->transfer_flags = URB_ISO_ASAP;
927 err_flag = usb_submit_urb(usbduxsub->urb_out[i], GFP_ATOMIC);
929 dev_err(&usbduxsub->interface->dev,
930 "comedi_: ao: usb_submit_urb(%d) error %d\n",
938 static int usbdux_ai_cmdtest(struct comedi_device *dev,
939 struct comedi_subdevice *s, struct comedi_cmd *cmd)
941 struct usbduxsub *this_usbduxsub = dev->private;
943 unsigned int tmp_timer;
945 if (!(this_usbduxsub->probed))
948 /* Step 1 : check if triggers are trivially valid */
950 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
951 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER);
952 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW);
953 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
954 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
959 /* Step 2a : make sure trigger sources are unique */
961 err |= cfc_check_trigger_is_unique(cmd->start_src);
962 err |= cfc_check_trigger_is_unique(cmd->stop_src);
964 /* Step 2b : and mutually compatible */
969 /* Step 3: check if arguments are trivially valid */
971 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
973 if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
974 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
976 if (cmd->scan_begin_src == TRIG_TIMER) {
977 if (this_usbduxsub->high_speed) {
979 * In high speed mode microframes are possible.
980 * However, during one microframe we can roughly
981 * sample one channel. Thus, the more channels
982 * are in the channel list the more time we need.
985 /* find a power of 2 for the number of channels */
986 while (i < (cmd->chanlist_len))
989 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
991 /* now calc the real sampling rate with all the
994 ((unsigned int)(cmd->scan_begin_arg / 125000)) *
998 /* 1kHz scans every USB frame */
999 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
1002 * calc the real sampling rate with the rounding errors
1004 tmp_timer = ((unsigned int)(cmd->scan_begin_arg /
1005 1000000)) * 1000000;
1007 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg,
1011 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
1013 if (cmd->stop_src == TRIG_COUNT) {
1014 /* any count is allowed */
1017 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
1027 * creates the ADC command for the MAX1271
1028 * range is the range value from comedi
1030 static int8_t create_adc_command(unsigned int chan, int range)
1032 int8_t p = (range <= 1);
1033 int8_t r = ((range % 2) == 0);
1034 return (chan << 4) | ((p == 1) << 2) | ((r == 1) << 3);
1037 /* bulk transfers to usbdux */
1039 #define SENDADCOMMANDS 0
1040 #define SENDDACOMMANDS 1
1041 #define SENDDIOCONFIGCOMMAND 2
1042 #define SENDDIOBITSCOMMAND 3
1043 #define SENDSINGLEAD 4
1044 #define READCOUNTERCOMMAND 5
1045 #define WRITECOUNTERCOMMAND 6
1047 #define SENDPWMOFF 8
1049 static int send_dux_commands(struct usbduxsub *this_usbduxsub, int cmd_type)
1053 this_usbduxsub->dux_commands[0] = cmd_type;
1054 #ifdef NOISY_DUX_DEBUGBUG
1055 printk(KERN_DEBUG "comedi%d: usbdux: dux_commands: ",
1056 this_usbduxsub->comedidev->minor);
1057 for (result = 0; result < SIZEOFDUXBUFFER; result++)
1058 printk(" %02x", this_usbduxsub->dux_commands[result]);
1061 result = usb_bulk_msg(this_usbduxsub->usbdev,
1062 usb_sndbulkpipe(this_usbduxsub->usbdev,
1064 this_usbduxsub->dux_commands, SIZEOFDUXBUFFER,
1065 &nsent, BULK_TIMEOUT);
1067 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1068 "could not transmit dux_command to the usb-device, "
1069 "err=%d\n", this_usbduxsub->comedidev->minor, result);
1074 static int receive_dux_commands(struct usbduxsub *this_usbduxsub, int command)
1076 int result = (-EFAULT);
1080 for (i = 0; i < RETRIES; i++) {
1081 result = usb_bulk_msg(this_usbduxsub->usbdev,
1082 usb_rcvbulkpipe(this_usbduxsub->usbdev,
1084 this_usbduxsub->insn_buffer, SIZEINSNBUF,
1085 &nrec, BULK_TIMEOUT);
1087 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1088 "insn: USB error %d while receiving DUX command"
1089 "\n", this_usbduxsub->comedidev->minor, result);
1092 if (le16_to_cpu(this_usbduxsub->insn_buffer[0]) == command)
1095 /* this is only reached if the data has been requested a couple of
1097 dev_err(&this_usbduxsub->interface->dev, "comedi%d: insn: "
1098 "wrong data returned from firmware: want cmd %d, got cmd %d.\n",
1099 this_usbduxsub->comedidev->minor, command,
1100 le16_to_cpu(this_usbduxsub->insn_buffer[0]));
1104 static int usbdux_ai_inttrig(struct comedi_device *dev,
1105 struct comedi_subdevice *s, unsigned int trignum)
1108 struct usbduxsub *this_usbduxsub = dev->private;
1109 if (!this_usbduxsub)
1112 down(&this_usbduxsub->sem);
1113 if (!(this_usbduxsub->probed)) {
1114 up(&this_usbduxsub->sem);
1117 dev_dbg(&this_usbduxsub->interface->dev,
1118 "comedi%d: usbdux_ai_inttrig\n", dev->minor);
1121 dev_err(&this_usbduxsub->interface->dev,
1122 "comedi%d: usbdux_ai_inttrig: invalid trignum\n",
1124 up(&this_usbduxsub->sem);
1127 if (!(this_usbduxsub->ai_cmd_running)) {
1128 this_usbduxsub->ai_cmd_running = 1;
1129 ret = usbduxsub_submit_inurbs(this_usbduxsub);
1131 dev_err(&this_usbduxsub->interface->dev,
1132 "comedi%d: usbdux_ai_inttrig: "
1133 "urbSubmit: err=%d\n", dev->minor, ret);
1134 this_usbduxsub->ai_cmd_running = 0;
1135 up(&this_usbduxsub->sem);
1138 s->async->inttrig = NULL;
1140 dev_err(&this_usbduxsub->interface->dev,
1141 "comedi%d: ai_inttrig but acqu is already running\n",
1144 up(&this_usbduxsub->sem);
1148 static int usbdux_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1150 struct comedi_cmd *cmd = &s->async->cmd;
1151 unsigned int chan, range;
1153 struct usbduxsub *this_usbduxsub = dev->private;
1156 if (!this_usbduxsub)
1159 dev_dbg(&this_usbduxsub->interface->dev,
1160 "comedi%d: usbdux_ai_cmd\n", dev->minor);
1162 /* block other CPUs from starting an ai_cmd */
1163 down(&this_usbduxsub->sem);
1165 if (!(this_usbduxsub->probed)) {
1166 up(&this_usbduxsub->sem);
1169 if (this_usbduxsub->ai_cmd_running) {
1170 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1171 "ai_cmd not possible. Another ai_cmd is running.\n",
1173 up(&this_usbduxsub->sem);
1176 /* set current channel of the running acquisition to zero */
1177 s->async->cur_chan = 0;
1179 this_usbduxsub->dux_commands[1] = cmd->chanlist_len;
1180 for (i = 0; i < cmd->chanlist_len; ++i) {
1181 chan = CR_CHAN(cmd->chanlist[i]);
1182 range = CR_RANGE(cmd->chanlist[i]);
1183 if (i >= NUMCHANNELS) {
1184 dev_err(&this_usbduxsub->interface->dev,
1185 "comedi%d: channel list too long\n",
1189 this_usbduxsub->dux_commands[i + 2] =
1190 create_adc_command(chan, range);
1193 dev_dbg(&this_usbduxsub->interface->dev,
1194 "comedi %d: sending commands to the usb device: size=%u\n",
1195 dev->minor, NUMCHANNELS);
1197 result = send_dux_commands(this_usbduxsub, SENDADCOMMANDS);
1199 up(&this_usbduxsub->sem);
1203 if (this_usbduxsub->high_speed) {
1205 * every channel gets a time window of 125us. Thus, if we
1206 * sample all 8 channels we need 1ms. If we sample only one
1207 * channel we need only 125us
1209 this_usbduxsub->ai_interval = 1;
1210 /* find a power of 2 for the interval */
1211 while ((this_usbduxsub->ai_interval) < (cmd->chanlist_len)) {
1212 this_usbduxsub->ai_interval =
1213 (this_usbduxsub->ai_interval) * 2;
1215 this_usbduxsub->ai_timer = cmd->scan_begin_arg / (125000 *
1219 /* interval always 1ms */
1220 this_usbduxsub->ai_interval = 1;
1221 this_usbduxsub->ai_timer = cmd->scan_begin_arg / 1000000;
1223 if (this_usbduxsub->ai_timer < 1) {
1224 dev_err(&this_usbduxsub->interface->dev, "comedi%d: ai_cmd: "
1225 "timer=%d, scan_begin_arg=%d. "
1226 "Not properly tested by cmdtest?\n", dev->minor,
1227 this_usbduxsub->ai_timer, cmd->scan_begin_arg);
1228 up(&this_usbduxsub->sem);
1231 this_usbduxsub->ai_counter = this_usbduxsub->ai_timer;
1233 if (cmd->stop_src == TRIG_COUNT) {
1234 /* data arrives as one packet */
1235 this_usbduxsub->ai_sample_count = cmd->stop_arg;
1236 this_usbduxsub->ai_continous = 0;
1238 /* continous acquisition */
1239 this_usbduxsub->ai_continous = 1;
1240 this_usbduxsub->ai_sample_count = 0;
1243 if (cmd->start_src == TRIG_NOW) {
1244 /* enable this acquisition operation */
1245 this_usbduxsub->ai_cmd_running = 1;
1246 ret = usbduxsub_submit_inurbs(this_usbduxsub);
1248 this_usbduxsub->ai_cmd_running = 0;
1249 /* fixme: unlink here?? */
1250 up(&this_usbduxsub->sem);
1253 s->async->inttrig = NULL;
1256 /* don't enable the acquision operation */
1257 /* wait for an internal signal */
1258 s->async->inttrig = usbdux_ai_inttrig;
1260 up(&this_usbduxsub->sem);
1264 /* Mode 0 is used to get a single conversion on demand */
1265 static int usbdux_ai_insn_read(struct comedi_device *dev,
1266 struct comedi_subdevice *s,
1267 struct comedi_insn *insn, unsigned int *data)
1270 unsigned int one = 0;
1273 struct usbduxsub *this_usbduxsub = dev->private;
1275 if (!this_usbduxsub)
1278 dev_dbg(&this_usbduxsub->interface->dev,
1279 "comedi%d: ai_insn_read, insn->n=%d, insn->subdev=%d\n",
1280 dev->minor, insn->n, insn->subdev);
1282 down(&this_usbduxsub->sem);
1283 if (!(this_usbduxsub->probed)) {
1284 up(&this_usbduxsub->sem);
1287 if (this_usbduxsub->ai_cmd_running) {
1288 dev_err(&this_usbduxsub->interface->dev,
1289 "comedi%d: ai_insn_read not possible. "
1290 "Async Command is running.\n", dev->minor);
1291 up(&this_usbduxsub->sem);
1295 /* sample one channel */
1296 chan = CR_CHAN(insn->chanspec);
1297 range = CR_RANGE(insn->chanspec);
1298 /* set command for the first channel */
1299 this_usbduxsub->dux_commands[1] = create_adc_command(chan, range);
1302 err = send_dux_commands(this_usbduxsub, SENDSINGLEAD);
1304 up(&this_usbduxsub->sem);
1308 for (i = 0; i < insn->n; i++) {
1309 err = receive_dux_commands(this_usbduxsub, SENDSINGLEAD);
1311 up(&this_usbduxsub->sem);
1314 one = le16_to_cpu(this_usbduxsub->insn_buffer[1]);
1315 if (CR_RANGE(insn->chanspec) <= 1)
1320 up(&this_usbduxsub->sem);
1324 /************************************/
1327 static int usbdux_ao_insn_read(struct comedi_device *dev,
1328 struct comedi_subdevice *s,
1329 struct comedi_insn *insn, unsigned int *data)
1332 int chan = CR_CHAN(insn->chanspec);
1333 struct usbduxsub *this_usbduxsub = dev->private;
1335 if (!this_usbduxsub)
1338 down(&this_usbduxsub->sem);
1339 if (!(this_usbduxsub->probed)) {
1340 up(&this_usbduxsub->sem);
1343 for (i = 0; i < insn->n; i++)
1344 data[i] = this_usbduxsub->out_buffer[chan];
1346 up(&this_usbduxsub->sem);
1350 static int usbdux_ao_insn_write(struct comedi_device *dev,
1351 struct comedi_subdevice *s,
1352 struct comedi_insn *insn, unsigned int *data)
1355 int chan = CR_CHAN(insn->chanspec);
1356 struct usbduxsub *this_usbduxsub = dev->private;
1358 if (!this_usbduxsub)
1361 dev_dbg(&this_usbduxsub->interface->dev,
1362 "comedi%d: ao_insn_write\n", dev->minor);
1364 down(&this_usbduxsub->sem);
1365 if (!(this_usbduxsub->probed)) {
1366 up(&this_usbduxsub->sem);
1369 if (this_usbduxsub->ao_cmd_running) {
1370 dev_err(&this_usbduxsub->interface->dev,
1371 "comedi%d: ao_insn_write: "
1372 "ERROR: asynchronous ao_cmd is running\n", dev->minor);
1373 up(&this_usbduxsub->sem);
1377 for (i = 0; i < insn->n; i++) {
1378 dev_dbg(&this_usbduxsub->interface->dev,
1379 "comedi%d: ao_insn_write: data[chan=%d,i=%d]=%d\n",
1380 dev->minor, chan, i, data[i]);
1382 /* number of channels: 1 */
1383 this_usbduxsub->dux_commands[1] = 1;
1384 /* one 16 bit value */
1385 *((int16_t *) (this_usbduxsub->dux_commands + 2)) =
1386 cpu_to_le16(data[i]);
1387 this_usbduxsub->out_buffer[chan] = data[i];
1388 /* channel number */
1389 this_usbduxsub->dux_commands[4] = (chan << 6);
1390 err = send_dux_commands(this_usbduxsub, SENDDACOMMANDS);
1392 up(&this_usbduxsub->sem);
1396 up(&this_usbduxsub->sem);
1401 static int usbdux_ao_inttrig(struct comedi_device *dev,
1402 struct comedi_subdevice *s, unsigned int trignum)
1405 struct usbduxsub *this_usbduxsub = dev->private;
1407 if (!this_usbduxsub)
1410 down(&this_usbduxsub->sem);
1411 if (!(this_usbduxsub->probed)) {
1412 up(&this_usbduxsub->sem);
1416 dev_err(&this_usbduxsub->interface->dev,
1417 "comedi%d: usbdux_ao_inttrig: invalid trignum\n",
1419 up(&this_usbduxsub->sem);
1422 if (!(this_usbduxsub->ao_cmd_running)) {
1423 this_usbduxsub->ao_cmd_running = 1;
1424 ret = usbduxsub_submit_outurbs(this_usbduxsub);
1426 dev_err(&this_usbduxsub->interface->dev,
1427 "comedi%d: usbdux_ao_inttrig: submitURB: "
1428 "err=%d\n", dev->minor, ret);
1429 this_usbduxsub->ao_cmd_running = 0;
1430 up(&this_usbduxsub->sem);
1433 s->async->inttrig = NULL;
1435 dev_err(&this_usbduxsub->interface->dev,
1436 "comedi%d: ao_inttrig but acqu is already running.\n",
1439 up(&this_usbduxsub->sem);
1443 static int usbdux_ao_cmdtest(struct comedi_device *dev,
1444 struct comedi_subdevice *s, struct comedi_cmd *cmd)
1446 struct usbduxsub *this_usbduxsub = dev->private;
1450 if (!this_usbduxsub)
1453 if (!(this_usbduxsub->probed))
1456 /* Step 1 : check if triggers are trivially valid */
1458 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT);
1460 if (0) { /* (this_usbduxsub->high_speed) */
1461 /* the sampling rate is set by the coversion rate */
1462 flags = TRIG_FOLLOW;
1464 /* start a new scan (output at once) with a timer */
1467 err |= cfc_check_trigger_src(&cmd->scan_begin_src, flags);
1469 if (0) { /* (this_usbduxsub->high_speed) */
1471 * in usb-2.0 only one conversion it transmitted
1477 * all conversion events happen simultaneously with
1482 err |= cfc_check_trigger_src(&cmd->convert_src, flags);
1484 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
1485 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
1490 /* Step 2a : make sure trigger sources are unique */
1492 err |= cfc_check_trigger_is_unique(cmd->start_src);
1493 err |= cfc_check_trigger_is_unique(cmd->stop_src);
1495 /* Step 2b : and mutually compatible */
1500 /* Step 3: check if arguments are trivially valid */
1502 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
1504 if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */
1505 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
1507 if (cmd->scan_begin_src == TRIG_TIMER)
1508 err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg,
1511 /* not used now, is for later use */
1512 if (cmd->convert_src == TRIG_TIMER)
1513 err |= cfc_check_trigger_arg_min(&cmd->convert_arg, 125000);
1515 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
1517 if (cmd->stop_src == TRIG_COUNT) {
1518 /* any count is allowed */
1521 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
1530 static int usbdux_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1532 struct comedi_cmd *cmd = &s->async->cmd;
1533 unsigned int chan, gain;
1535 struct usbduxsub *this_usbduxsub = dev->private;
1537 if (!this_usbduxsub)
1540 down(&this_usbduxsub->sem);
1541 if (!(this_usbduxsub->probed)) {
1542 up(&this_usbduxsub->sem);
1545 dev_dbg(&this_usbduxsub->interface->dev,
1546 "comedi%d: %s\n", dev->minor, __func__);
1548 /* set current channel of the running acquisition to zero */
1549 s->async->cur_chan = 0;
1550 for (i = 0; i < cmd->chanlist_len; ++i) {
1551 chan = CR_CHAN(cmd->chanlist[i]);
1552 gain = CR_RANGE(cmd->chanlist[i]);
1553 if (i >= NUMOUTCHANNELS) {
1554 dev_err(&this_usbduxsub->interface->dev,
1555 "comedi%d: %s: channel list too long\n",
1556 dev->minor, __func__);
1559 this_usbduxsub->dac_commands[i] = (chan << 6);
1560 dev_dbg(&this_usbduxsub->interface->dev,
1561 "comedi%d: dac command for ch %d is %x\n",
1562 dev->minor, i, this_usbduxsub->dac_commands[i]);
1565 /* we count in steps of 1ms (125us) */
1566 /* 125us mode not used yet */
1567 if (0) { /* (this_usbduxsub->high_speed) */
1569 /* timing of the conversion itself: every 125 us */
1570 this_usbduxsub->ao_timer = cmd->convert_arg / 125000;
1573 /* timing of the scan: we get all channels at once */
1574 this_usbduxsub->ao_timer = cmd->scan_begin_arg / 1000000;
1575 dev_dbg(&this_usbduxsub->interface->dev,
1576 "comedi%d: scan_begin_src=%d, scan_begin_arg=%d, "
1577 "convert_src=%d, convert_arg=%d\n", dev->minor,
1578 cmd->scan_begin_src, cmd->scan_begin_arg,
1579 cmd->convert_src, cmd->convert_arg);
1580 dev_dbg(&this_usbduxsub->interface->dev,
1581 "comedi%d: ao_timer=%d (ms)\n",
1582 dev->minor, this_usbduxsub->ao_timer);
1583 if (this_usbduxsub->ao_timer < 1) {
1584 dev_err(&this_usbduxsub->interface->dev,
1585 "comedi%d: usbdux: ao_timer=%d, "
1586 "scan_begin_arg=%d. "
1587 "Not properly tested by cmdtest?\n",
1588 dev->minor, this_usbduxsub->ao_timer,
1589 cmd->scan_begin_arg);
1590 up(&this_usbduxsub->sem);
1594 this_usbduxsub->ao_counter = this_usbduxsub->ao_timer;
1596 if (cmd->stop_src == TRIG_COUNT) {
1597 /* not continuous */
1599 /* high speed also scans everything at once */
1600 if (0) { /* (this_usbduxsub->high_speed) */
1601 this_usbduxsub->ao_sample_count =
1602 (cmd->stop_arg) * (cmd->scan_end_arg);
1604 /* there's no scan as the scan has been */
1605 /* perf inside the FX2 */
1606 /* data arrives as one packet */
1607 this_usbduxsub->ao_sample_count = cmd->stop_arg;
1609 this_usbduxsub->ao_continous = 0;
1611 /* continous acquisition */
1612 this_usbduxsub->ao_continous = 1;
1613 this_usbduxsub->ao_sample_count = 0;
1616 if (cmd->start_src == TRIG_NOW) {
1617 /* enable this acquisition operation */
1618 this_usbduxsub->ao_cmd_running = 1;
1619 ret = usbduxsub_submit_outurbs(this_usbduxsub);
1621 this_usbduxsub->ao_cmd_running = 0;
1622 /* fixme: unlink here?? */
1623 up(&this_usbduxsub->sem);
1626 s->async->inttrig = NULL;
1629 /* submit the urbs later */
1630 /* wait for an internal signal */
1631 s->async->inttrig = usbdux_ao_inttrig;
1634 up(&this_usbduxsub->sem);
1638 static int usbdux_dio_insn_config(struct comedi_device *dev,
1639 struct comedi_subdevice *s,
1640 struct comedi_insn *insn, unsigned int *data)
1642 int chan = CR_CHAN(insn->chanspec);
1644 /* The input or output configuration of each digital line is
1645 * configured by a special insn_config instruction. chanspec
1646 * contains the channel to be changed, and data[0] contains the
1647 * value COMEDI_INPUT or COMEDI_OUTPUT. */
1650 case INSN_CONFIG_DIO_OUTPUT:
1651 s->io_bits |= 1 << chan; /* 1 means Out */
1653 case INSN_CONFIG_DIO_INPUT:
1654 s->io_bits &= ~(1 << chan);
1656 case INSN_CONFIG_DIO_QUERY:
1658 (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
1664 /* we don't tell the firmware here as it would take 8 frames */
1665 /* to submit the information. We do it in the insn_bits. */
1669 static int usbdux_dio_insn_bits(struct comedi_device *dev,
1670 struct comedi_subdevice *s,
1671 struct comedi_insn *insn, unsigned int *data)
1674 struct usbduxsub *this_usbduxsub = dev->private;
1677 if (!this_usbduxsub)
1680 down(&this_usbduxsub->sem);
1682 if (!(this_usbduxsub->probed)) {
1683 up(&this_usbduxsub->sem);
1687 /* The insn data is a mask in data[0] and the new data
1688 * in data[1], each channel cooresponding to a bit. */
1689 s->state &= ~data[0];
1690 s->state |= data[0] & data[1];
1691 this_usbduxsub->dux_commands[1] = s->io_bits;
1692 this_usbduxsub->dux_commands[2] = s->state;
1694 /* This command also tells the firmware to return */
1695 /* the digital input lines */
1696 err = send_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND);
1698 up(&this_usbduxsub->sem);
1701 err = receive_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND);
1703 up(&this_usbduxsub->sem);
1707 data[1] = le16_to_cpu(this_usbduxsub->insn_buffer[1]);
1708 up(&this_usbduxsub->sem);
1712 /* reads the 4 counters, only two are used just now */
1713 static int usbdux_counter_read(struct comedi_device *dev,
1714 struct comedi_subdevice *s,
1715 struct comedi_insn *insn, unsigned int *data)
1717 struct usbduxsub *this_usbduxsub = dev->private;
1718 int chan = insn->chanspec;
1721 if (!this_usbduxsub)
1724 down(&this_usbduxsub->sem);
1726 if (!(this_usbduxsub->probed)) {
1727 up(&this_usbduxsub->sem);
1731 err = send_dux_commands(this_usbduxsub, READCOUNTERCOMMAND);
1733 up(&this_usbduxsub->sem);
1737 err = receive_dux_commands(this_usbduxsub, READCOUNTERCOMMAND);
1739 up(&this_usbduxsub->sem);
1743 data[0] = le16_to_cpu(this_usbduxsub->insn_buffer[chan + 1]);
1744 up(&this_usbduxsub->sem);
1748 static int usbdux_counter_write(struct comedi_device *dev,
1749 struct comedi_subdevice *s,
1750 struct comedi_insn *insn, unsigned int *data)
1752 struct usbduxsub *this_usbduxsub = dev->private;
1755 if (!this_usbduxsub)
1758 down(&this_usbduxsub->sem);
1760 if (!(this_usbduxsub->probed)) {
1761 up(&this_usbduxsub->sem);
1765 this_usbduxsub->dux_commands[1] = insn->chanspec;
1766 *((int16_t *) (this_usbduxsub->dux_commands + 2)) = cpu_to_le16(*data);
1768 err = send_dux_commands(this_usbduxsub, WRITECOUNTERCOMMAND);
1770 up(&this_usbduxsub->sem);
1774 up(&this_usbduxsub->sem);
1779 static int usbdux_counter_config(struct comedi_device *dev,
1780 struct comedi_subdevice *s,
1781 struct comedi_insn *insn, unsigned int *data)
1783 /* nothing to do so far */
1787 /***********************************/
1790 static int usbduxsub_unlink_pwm_urbs(struct usbduxsub *usbduxsub_tmp)
1794 if (usbduxsub_tmp && usbduxsub_tmp->urb_pwm) {
1795 if (usbduxsub_tmp->urb_pwm)
1796 usb_kill_urb(usbduxsub_tmp->urb_pwm);
1797 dev_dbg(&usbduxsub_tmp->interface->dev,
1798 "comedi: unlinked PwmURB: res=%d\n", err);
1803 /* This cancels a running acquisition operation
1806 static int usbdux_pwm_stop(struct usbduxsub *this_usbduxsub, int do_unlink)
1810 if (!this_usbduxsub)
1813 dev_dbg(&this_usbduxsub->interface->dev, "comedi: %s\n", __func__);
1815 ret = usbduxsub_unlink_pwm_urbs(this_usbduxsub);
1817 this_usbduxsub->pwm_cmd_running = 0;
1822 /* force unlink - is called by comedi */
1823 static int usbdux_pwm_cancel(struct comedi_device *dev,
1824 struct comedi_subdevice *s)
1826 struct usbduxsub *this_usbduxsub = dev->private;
1829 /* unlink only if it is really running */
1830 res = usbdux_pwm_stop(this_usbduxsub, this_usbduxsub->pwm_cmd_running);
1832 dev_dbg(&this_usbduxsub->interface->dev,
1833 "comedi %d: sending pwm off command to the usb device.\n",
1836 return send_dux_commands(this_usbduxsub, SENDPWMOFF);
1839 static void usbduxsub_pwm_irq(struct urb *urb)
1842 struct usbduxsub *this_usbduxsub;
1843 struct comedi_device *this_comedidev;
1844 struct comedi_subdevice *s;
1846 /* printk(KERN_DEBUG "PWM: IRQ\n"); */
1848 /* the context variable points to the subdevice */
1849 this_comedidev = urb->context;
1850 /* the private structure of the subdevice is struct usbduxsub */
1851 this_usbduxsub = this_comedidev->private;
1853 s = &this_comedidev->subdevices[SUBDEV_DA];
1855 switch (urb->status) {
1865 * after an unlink command, unplug, ... etc
1866 * no unlink needed here. Already shutting down.
1868 if (this_usbduxsub->pwm_cmd_running)
1869 usbdux_pwm_stop(this_usbduxsub, 0);
1875 if (this_usbduxsub->pwm_cmd_running) {
1876 dev_err(&this_usbduxsub->interface->dev,
1877 "comedi_: Non-zero urb status received in "
1878 "pwm intr context: %d\n", urb->status);
1879 usbdux_pwm_stop(this_usbduxsub, 0);
1884 /* are we actually running? */
1885 if (!(this_usbduxsub->pwm_cmd_running))
1888 urb->transfer_buffer_length = this_usbduxsub->size_pwm_buf;
1889 urb->dev = this_usbduxsub->usbdev;
1891 if (this_usbduxsub->pwm_cmd_running) {
1892 ret = usb_submit_urb(urb, GFP_ATOMIC);
1894 dev_err(&this_usbduxsub->interface->dev,
1895 "comedi_: pwm urb resubm failed in int-cont. "
1897 if (ret == EL2NSYNC)
1898 dev_err(&this_usbduxsub->interface->dev,
1899 "buggy USB host controller or bug in "
1902 /* don't do an unlink here */
1903 usbdux_pwm_stop(this_usbduxsub, 0);
1908 static int usbduxsub_submit_pwm_urbs(struct usbduxsub *usbduxsub)
1915 dev_dbg(&usbduxsub->interface->dev, "comedi_: submitting pwm-urb\n");
1917 /* in case of a resubmission after an unlink... */
1918 usb_fill_bulk_urb(usbduxsub->urb_pwm,
1920 usb_sndbulkpipe(usbduxsub->usbdev, PWM_EP),
1921 usbduxsub->urb_pwm->transfer_buffer,
1922 usbduxsub->size_pwm_buf, usbduxsub_pwm_irq,
1923 usbduxsub->comedidev);
1925 err_flag = usb_submit_urb(usbduxsub->urb_pwm, GFP_ATOMIC);
1927 dev_err(&usbduxsub->interface->dev,
1928 "comedi_: usbdux: pwm: usb_submit_urb error %d\n",
1935 static int usbdux_pwm_period(struct comedi_device *dev,
1936 struct comedi_subdevice *s, unsigned int period)
1938 struct usbduxsub *this_usbduxsub = dev->private;
1941 if (period < MIN_PWM_PERIOD) {
1942 dev_err(&this_usbduxsub->interface->dev,
1943 "comedi%d: illegal period setting for pwm.\n",
1947 fx2delay = period / ((int)(6 * 512 * (1.0 / 0.033))) - 6;
1948 if (fx2delay > 255) {
1949 dev_err(&this_usbduxsub->interface->dev,
1950 "comedi%d: period %d for pwm is too low.\n",
1951 dev->minor, period);
1955 this_usbduxsub->pwn_delay = fx2delay;
1956 this_usbduxsub->pwm_period = period;
1957 dev_dbg(&this_usbduxsub->interface->dev, "%s: frequ=%d, period=%d\n",
1958 __func__, period, fx2delay);
1962 /* is called from insn so there's no need to do all the sanity checks */
1963 static int usbdux_pwm_start(struct comedi_device *dev,
1964 struct comedi_subdevice *s)
1967 struct usbduxsub *this_usbduxsub = dev->private;
1969 dev_dbg(&this_usbduxsub->interface->dev, "comedi%d: %s\n",
1970 dev->minor, __func__);
1972 if (this_usbduxsub->pwm_cmd_running) {
1973 /* already running */
1977 this_usbduxsub->dux_commands[1] = ((int8_t) this_usbduxsub->pwn_delay);
1978 ret = send_dux_commands(this_usbduxsub, SENDPWMON);
1982 /* initialise the buffer */
1983 for (i = 0; i < this_usbduxsub->size_pwm_buf; i++)
1984 ((char *)(this_usbduxsub->urb_pwm->transfer_buffer))[i] = 0;
1986 this_usbduxsub->pwm_cmd_running = 1;
1987 ret = usbduxsub_submit_pwm_urbs(this_usbduxsub);
1989 this_usbduxsub->pwm_cmd_running = 0;
1995 /* generates the bit pattern for PWM with the optional sign bit */
1996 static int usbdux_pwm_pattern(struct comedi_device *dev,
1997 struct comedi_subdevice *s, int channel,
1998 unsigned int value, unsigned int sign)
2000 struct usbduxsub *this_usbduxsub = dev->private;
2007 if (!this_usbduxsub)
2010 /* this is the DIO bit which carries the PWM data */
2011 pwm_mask = (1 << channel);
2012 /* this is the DIO bit which carries the optional direction bit */
2013 sgn_mask = (16 << channel);
2014 /* this is the buffer which will be filled with the with bit */
2015 /* pattern for one period */
2016 szbuf = this_usbduxsub->size_pwm_buf;
2017 p_buf = (char *)(this_usbduxsub->urb_pwm->transfer_buffer);
2018 for (i = 0; i < szbuf; i++) {
2021 c = c & (~pwm_mask);
2022 /* set the bit as long as the index is lower than the value */
2025 /* set the optional sign bit for a relay */
2027 /* positive value */
2028 c = c & (~sgn_mask);
2030 /* negative value */
2038 static int usbdux_pwm_write(struct comedi_device *dev,
2039 struct comedi_subdevice *s,
2040 struct comedi_insn *insn, unsigned int *data)
2042 struct usbduxsub *this_usbduxsub = dev->private;
2044 if (!this_usbduxsub)
2047 if ((insn->n) != 1) {
2049 * doesn't make sense to have more than one value here because
2050 * it would just overwrite the PWM buffer a couple of times
2056 * the sign is set via a special INSN only, this gives us 8 bits for
2058 * relay sign 0 by default
2060 return usbdux_pwm_pattern(dev, s, CR_CHAN(insn->chanspec), data[0], 0);
2063 static int usbdux_pwm_read(struct comedi_device *x1,
2064 struct comedi_subdevice *x2, struct comedi_insn *x3,
2071 /* switches on/off PWM */
2072 static int usbdux_pwm_config(struct comedi_device *dev,
2073 struct comedi_subdevice *s,
2074 struct comedi_insn *insn, unsigned int *data)
2076 struct usbduxsub *this_usbduxsub = dev->private;
2078 case INSN_CONFIG_ARM:
2080 dev_dbg(&this_usbduxsub->interface->dev,
2081 "comedi%d: %s: pwm on\n", dev->minor, __func__);
2083 * if not zero the PWM is limited to a certain time which is
2084 * not supported here
2088 return usbdux_pwm_start(dev, s);
2089 case INSN_CONFIG_DISARM:
2090 dev_dbg(&this_usbduxsub->interface->dev,
2091 "comedi%d: %s: pwm off\n", dev->minor, __func__);
2092 return usbdux_pwm_cancel(dev, s);
2093 case INSN_CONFIG_GET_PWM_STATUS:
2095 * to check if the USB transmission has failed or in case PWM
2096 * was limited to n cycles to check if it has terminated
2098 data[1] = this_usbduxsub->pwm_cmd_running;
2100 case INSN_CONFIG_PWM_SET_PERIOD:
2101 dev_dbg(&this_usbduxsub->interface->dev,
2102 "comedi%d: %s: setting period\n", dev->minor, __func__);
2103 return usbdux_pwm_period(dev, s, data[1]);
2104 case INSN_CONFIG_PWM_GET_PERIOD:
2105 data[1] = this_usbduxsub->pwm_period;
2107 case INSN_CONFIG_PWM_SET_H_BRIDGE:
2108 /* value in the first byte and the sign in the second for a
2110 return usbdux_pwm_pattern(dev, s,
2111 /* the channel number */
2112 CR_CHAN(insn->chanspec),
2113 /* actual PWM data */
2117 case INSN_CONFIG_PWM_GET_H_BRIDGE:
2118 /* values are not kept in this driver, nothing to return here */
2125 /*****************************************************************/
2127 static void tidy_up(struct usbduxsub *usbduxsub_tmp)
2133 dev_dbg(&usbduxsub_tmp->interface->dev, "comedi_: tiding up\n");
2135 /* shows the usb subsystem that the driver is down */
2136 if (usbduxsub_tmp->interface)
2137 usb_set_intfdata(usbduxsub_tmp->interface, NULL);
2139 usbduxsub_tmp->probed = 0;
2141 if (usbduxsub_tmp->urb_in) {
2142 if (usbduxsub_tmp->ai_cmd_running) {
2143 usbduxsub_tmp->ai_cmd_running = 0;
2144 usbduxsub_unlink_inurbs(usbduxsub_tmp);
2146 for (i = 0; i < usbduxsub_tmp->num_in_buffers; i++) {
2147 kfree(usbduxsub_tmp->urb_in[i]->transfer_buffer);
2148 usbduxsub_tmp->urb_in[i]->transfer_buffer = NULL;
2149 usb_kill_urb(usbduxsub_tmp->urb_in[i]);
2150 usb_free_urb(usbduxsub_tmp->urb_in[i]);
2151 usbduxsub_tmp->urb_in[i] = NULL;
2153 kfree(usbduxsub_tmp->urb_in);
2154 usbduxsub_tmp->urb_in = NULL;
2156 if (usbduxsub_tmp->urb_out) {
2157 if (usbduxsub_tmp->ao_cmd_running) {
2158 usbduxsub_tmp->ao_cmd_running = 0;
2159 usbduxsub_unlink_outurbs(usbduxsub_tmp);
2161 for (i = 0; i < usbduxsub_tmp->num_out_buffers; i++) {
2162 kfree(usbduxsub_tmp->urb_out[i]->transfer_buffer);
2163 usbduxsub_tmp->urb_out[i]->transfer_buffer = NULL;
2164 if (usbduxsub_tmp->urb_out[i]) {
2165 usb_kill_urb(usbduxsub_tmp->urb_out[i]);
2166 usb_free_urb(usbduxsub_tmp->urb_out[i]);
2167 usbduxsub_tmp->urb_out[i] = NULL;
2170 kfree(usbduxsub_tmp->urb_out);
2171 usbduxsub_tmp->urb_out = NULL;
2173 if (usbduxsub_tmp->urb_pwm) {
2174 if (usbduxsub_tmp->pwm_cmd_running) {
2175 usbduxsub_tmp->pwm_cmd_running = 0;
2176 usbduxsub_unlink_pwm_urbs(usbduxsub_tmp);
2178 kfree(usbduxsub_tmp->urb_pwm->transfer_buffer);
2179 usbduxsub_tmp->urb_pwm->transfer_buffer = NULL;
2180 usb_kill_urb(usbduxsub_tmp->urb_pwm);
2181 usb_free_urb(usbduxsub_tmp->urb_pwm);
2182 usbduxsub_tmp->urb_pwm = NULL;
2184 kfree(usbduxsub_tmp->in_buffer);
2185 usbduxsub_tmp->in_buffer = NULL;
2186 kfree(usbduxsub_tmp->insn_buffer);
2187 usbduxsub_tmp->insn_buffer = NULL;
2188 kfree(usbduxsub_tmp->out_buffer);
2189 usbduxsub_tmp->out_buffer = NULL;
2190 kfree(usbduxsub_tmp->dac_commands);
2191 usbduxsub_tmp->dac_commands = NULL;
2192 kfree(usbduxsub_tmp->dux_commands);
2193 usbduxsub_tmp->dux_commands = NULL;
2194 usbduxsub_tmp->ai_cmd_running = 0;
2195 usbduxsub_tmp->ao_cmd_running = 0;
2196 usbduxsub_tmp->pwm_cmd_running = 0;
2199 static int usbdux_attach_common(struct comedi_device *dev,
2200 struct usbduxsub *udev)
2203 struct comedi_subdevice *s = NULL;
2207 /* pointer back to the corresponding comedi device */
2208 udev->comedidev = dev;
2210 /* set number of subdevices */
2211 if (udev->high_speed) {
2219 ret = comedi_alloc_subdevices(dev, n_subdevs);
2225 /* private structure is also simply the usb-structure */
2226 dev->private = udev;
2228 /* the first subdevice is the A/D converter */
2229 s = &dev->subdevices[SUBDEV_AD];
2230 /* the URBs get the comedi subdevice */
2231 /* which is responsible for reading */
2232 /* this is the subdevice which reads data */
2233 dev->read_subdev = s;
2234 /* the subdevice receives as private structure the */
2238 s->type = COMEDI_SUBD_AI;
2239 /* readable and ref is to ground */
2240 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
2243 /* length of the channellist */
2244 s->len_chanlist = 8;
2245 /* callback functions */
2246 s->insn_read = usbdux_ai_insn_read;
2247 s->do_cmdtest = usbdux_ai_cmdtest;
2248 s->do_cmd = usbdux_ai_cmd;
2249 s->cancel = usbdux_ai_cancel;
2250 /* max value from the A/D converter (12bit) */
2252 /* range table to convert to physical units */
2253 s->range_table = (&range_usbdux_ai_range);
2256 s = &dev->subdevices[SUBDEV_DA];
2258 s->type = COMEDI_SUBD_AO;
2259 /* backward pointer */
2260 dev->write_subdev = s;
2261 /* the subdevice receives as private structure the */
2265 s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
2268 /* length of the channellist */
2269 s->len_chanlist = 4;
2270 /* 12 bit resolution */
2271 s->maxdata = 0x0fff;
2273 s->range_table = (&range_usbdux_ao_range);
2275 s->do_cmdtest = usbdux_ao_cmdtest;
2276 s->do_cmd = usbdux_ao_cmd;
2277 s->cancel = usbdux_ao_cancel;
2278 s->insn_read = usbdux_ao_insn_read;
2279 s->insn_write = usbdux_ao_insn_write;
2282 s = &dev->subdevices[SUBDEV_DIO];
2283 s->type = COMEDI_SUBD_DIO;
2284 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
2287 s->range_table = (&range_digital);
2288 s->insn_bits = usbdux_dio_insn_bits;
2289 s->insn_config = usbdux_dio_insn_config;
2290 /* we don't use it */
2294 s = &dev->subdevices[SUBDEV_COUNTER];
2295 s->type = COMEDI_SUBD_COUNTER;
2296 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
2298 s->maxdata = 0xFFFF;
2299 s->insn_read = usbdux_counter_read;
2300 s->insn_write = usbdux_counter_write;
2301 s->insn_config = usbdux_counter_config;
2303 if (udev->high_speed) {
2305 s = &dev->subdevices[SUBDEV_PWM];
2306 s->type = COMEDI_SUBD_PWM;
2307 s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
2309 /* this defines the max duty cycle resolution */
2310 s->maxdata = udev->size_pwm_buf;
2311 s->insn_write = usbdux_pwm_write;
2312 s->insn_read = usbdux_pwm_read;
2313 s->insn_config = usbdux_pwm_config;
2314 usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
2316 /* finally decide that it's attached */
2321 dev_info(&udev->interface->dev, "comedi%d: attached to usbdux.\n",
2327 static int usbdux_auto_attach(struct comedi_device *dev,
2328 unsigned long context_unused)
2330 struct usb_interface *uinterf = comedi_to_usb_interface(dev);
2332 struct usbduxsub *this_usbduxsub;
2334 dev->private = NULL;
2336 down(&start_stop_sem);
2337 this_usbduxsub = usb_get_intfdata(uinterf);
2338 if (!this_usbduxsub || !this_usbduxsub->probed) {
2339 dev_err(dev->class_dev,
2340 "usbdux: error: auto_attach failed, not connected\n");
2342 } else if (this_usbduxsub->attached) {
2343 dev_err(dev->class_dev,
2344 "error: auto_attach failed, already attached\n");
2347 ret = usbdux_attach_common(dev, this_usbduxsub);
2348 up(&start_stop_sem);
2352 static void usbdux_detach(struct comedi_device *dev)
2354 struct usbduxsub *usb = dev->private;
2358 dev->private = NULL;
2360 usb->comedidev = NULL;
2365 static struct comedi_driver usbdux_driver = {
2366 .driver_name = "usbdux",
2367 .module = THIS_MODULE,
2368 .auto_attach = usbdux_auto_attach,
2369 .detach = usbdux_detach,
2372 static void usbdux_firmware_request_complete_handler(const struct firmware *fw,
2375 struct usbduxsub *usbduxsub_tmp = context;
2376 struct usb_interface *uinterf = usbduxsub_tmp->interface;
2380 dev_err(&uinterf->dev,
2381 "Firmware complete handler without firmware!\n");
2386 * we need to upload the firmware here because fw will be
2387 * freed once we've left this function
2389 ret = firmware_upload(usbduxsub_tmp, fw->data, fw->size);
2392 dev_err(&uinterf->dev,
2393 "Could not upload firmware (err=%d)\n", ret);
2396 comedi_usb_auto_config(uinterf, &usbdux_driver, 0);
2398 release_firmware(fw);
2401 static int usbdux_usb_probe(struct usb_interface *uinterf,
2402 const struct usb_device_id *id)
2404 struct usb_device *udev = interface_to_usbdev(uinterf);
2405 struct device *dev = &uinterf->dev;
2410 dev_dbg(dev, "comedi_: usbdux_: "
2411 "finding a free structure for the usb-device\n");
2413 down(&start_stop_sem);
2414 /* look for a free place in the usbdux array */
2416 for (i = 0; i < NUMUSBDUX; i++) {
2417 if (!(usbduxsub[i].probed)) {
2425 dev_err(dev, "Too many usbdux-devices connected.\n");
2426 up(&start_stop_sem);
2429 dev_dbg(dev, "comedi_: usbdux: "
2430 "usbduxsub[%d] is ready to connect to comedi.\n", index);
2432 sema_init(&(usbduxsub[index].sem), 1);
2433 /* save a pointer to the usb device */
2434 usbduxsub[index].usbdev = udev;
2436 /* 2.6: save the interface itself */
2437 usbduxsub[index].interface = uinterf;
2438 /* get the interface number from the interface */
2439 usbduxsub[index].ifnum = uinterf->altsetting->desc.bInterfaceNumber;
2440 /* hand the private data over to the usb subsystem */
2441 /* will be needed for disconnect */
2442 usb_set_intfdata(uinterf, &(usbduxsub[index]));
2444 dev_dbg(dev, "comedi_: usbdux: ifnum=%d\n", usbduxsub[index].ifnum);
2446 /* test if it is high speed (USB 2.0) */
2447 usbduxsub[index].high_speed =
2448 (usbduxsub[index].usbdev->speed == USB_SPEED_HIGH);
2450 /* create space for the commands of the DA converter */
2451 usbduxsub[index].dac_commands = kzalloc(NUMOUTCHANNELS, GFP_KERNEL);
2452 if (!usbduxsub[index].dac_commands) {
2453 tidy_up(&(usbduxsub[index]));
2454 up(&start_stop_sem);
2457 /* create space for the commands going to the usb device */
2458 usbduxsub[index].dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL);
2459 if (!usbduxsub[index].dux_commands) {
2460 tidy_up(&(usbduxsub[index]));
2461 up(&start_stop_sem);
2464 /* create space for the in buffer and set it to zero */
2465 usbduxsub[index].in_buffer = kzalloc(SIZEINBUF, GFP_KERNEL);
2466 if (!(usbduxsub[index].in_buffer)) {
2467 tidy_up(&(usbduxsub[index]));
2468 up(&start_stop_sem);
2471 /* create space of the instruction buffer */
2472 usbduxsub[index].insn_buffer = kzalloc(SIZEINSNBUF, GFP_KERNEL);
2473 if (!(usbduxsub[index].insn_buffer)) {
2474 tidy_up(&(usbduxsub[index]));
2475 up(&start_stop_sem);
2478 /* create space for the outbuffer */
2479 usbduxsub[index].out_buffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
2480 if (!(usbduxsub[index].out_buffer)) {
2481 tidy_up(&(usbduxsub[index]));
2482 up(&start_stop_sem);
2485 /* setting to alternate setting 3: enabling iso ep and bulk ep. */
2486 i = usb_set_interface(usbduxsub[index].usbdev,
2487 usbduxsub[index].ifnum, 3);
2489 dev_err(dev, "comedi_: usbdux%d: "
2490 "could not set alternate setting 3 in high speed.\n",
2492 tidy_up(&(usbduxsub[index]));
2493 up(&start_stop_sem);
2496 if (usbduxsub[index].high_speed)
2497 usbduxsub[index].num_in_buffers = NUMOFINBUFFERSHIGH;
2499 usbduxsub[index].num_in_buffers = NUMOFINBUFFERSFULL;
2501 usbduxsub[index].urb_in =
2502 kcalloc(usbduxsub[index].num_in_buffers, sizeof(struct urb *),
2504 if (!(usbduxsub[index].urb_in)) {
2505 tidy_up(&(usbduxsub[index]));
2506 up(&start_stop_sem);
2509 for (i = 0; i < usbduxsub[index].num_in_buffers; i++) {
2510 /* one frame: 1ms */
2511 usbduxsub[index].urb_in[i] = usb_alloc_urb(1, GFP_KERNEL);
2512 if (usbduxsub[index].urb_in[i] == NULL) {
2513 dev_err(dev, "comedi_: usbdux%d: "
2514 "Could not alloc. urb(%d)\n", index, i);
2515 tidy_up(&(usbduxsub[index]));
2516 up(&start_stop_sem);
2519 usbduxsub[index].urb_in[i]->dev = usbduxsub[index].usbdev;
2520 /* will be filled later with a pointer to the comedi-device */
2521 /* and ONLY then the urb should be submitted */
2522 usbduxsub[index].urb_in[i]->context = NULL;
2523 usbduxsub[index].urb_in[i]->pipe =
2524 usb_rcvisocpipe(usbduxsub[index].usbdev, ISOINEP);
2525 usbduxsub[index].urb_in[i]->transfer_flags = URB_ISO_ASAP;
2526 usbduxsub[index].urb_in[i]->transfer_buffer =
2527 kzalloc(SIZEINBUF, GFP_KERNEL);
2528 if (!(usbduxsub[index].urb_in[i]->transfer_buffer)) {
2529 tidy_up(&(usbduxsub[index]));
2530 up(&start_stop_sem);
2533 usbduxsub[index].urb_in[i]->complete = usbduxsub_ai_isoc_irq;
2534 usbduxsub[index].urb_in[i]->number_of_packets = 1;
2535 usbduxsub[index].urb_in[i]->transfer_buffer_length = SIZEINBUF;
2536 usbduxsub[index].urb_in[i]->iso_frame_desc[0].offset = 0;
2537 usbduxsub[index].urb_in[i]->iso_frame_desc[0].length = SIZEINBUF;
2541 if (usbduxsub[index].high_speed)
2542 usbduxsub[index].num_out_buffers = NUMOFOUTBUFFERSHIGH;
2544 usbduxsub[index].num_out_buffers = NUMOFOUTBUFFERSFULL;
2546 usbduxsub[index].urb_out =
2547 kcalloc(usbduxsub[index].num_out_buffers, sizeof(struct urb *),
2549 if (!(usbduxsub[index].urb_out)) {
2550 tidy_up(&(usbduxsub[index]));
2551 up(&start_stop_sem);
2554 for (i = 0; i < usbduxsub[index].num_out_buffers; i++) {
2555 /* one frame: 1ms */
2556 usbduxsub[index].urb_out[i] = usb_alloc_urb(1, GFP_KERNEL);
2557 if (usbduxsub[index].urb_out[i] == NULL) {
2558 dev_err(dev, "comedi_: usbdux%d: "
2559 "Could not alloc. urb(%d)\n", index, i);
2560 tidy_up(&(usbduxsub[index]));
2561 up(&start_stop_sem);
2564 usbduxsub[index].urb_out[i]->dev = usbduxsub[index].usbdev;
2565 /* will be filled later with a pointer to the comedi-device */
2566 /* and ONLY then the urb should be submitted */
2567 usbduxsub[index].urb_out[i]->context = NULL;
2568 usbduxsub[index].urb_out[i]->pipe =
2569 usb_sndisocpipe(usbduxsub[index].usbdev, ISOOUTEP);
2570 usbduxsub[index].urb_out[i]->transfer_flags = URB_ISO_ASAP;
2571 usbduxsub[index].urb_out[i]->transfer_buffer =
2572 kzalloc(SIZEOUTBUF, GFP_KERNEL);
2573 if (!(usbduxsub[index].urb_out[i]->transfer_buffer)) {
2574 tidy_up(&(usbduxsub[index]));
2575 up(&start_stop_sem);
2578 usbduxsub[index].urb_out[i]->complete = usbduxsub_ao_isoc_irq;
2579 usbduxsub[index].urb_out[i]->number_of_packets = 1;
2580 usbduxsub[index].urb_out[i]->transfer_buffer_length = SIZEOUTBUF;
2581 usbduxsub[index].urb_out[i]->iso_frame_desc[0].offset = 0;
2582 usbduxsub[index].urb_out[i]->iso_frame_desc[0].length =
2584 if (usbduxsub[index].high_speed) {
2586 usbduxsub[index].urb_out[i]->interval = 8;
2589 usbduxsub[index].urb_out[i]->interval = 1;
2594 if (usbduxsub[index].high_speed) {
2595 /* max bulk ep size in high speed */
2596 usbduxsub[index].size_pwm_buf = 512;
2597 usbduxsub[index].urb_pwm = usb_alloc_urb(0, GFP_KERNEL);
2598 if (usbduxsub[index].urb_pwm == NULL) {
2599 dev_err(dev, "comedi_: usbdux%d: "
2600 "Could not alloc. pwm urb\n", index);
2601 tidy_up(&(usbduxsub[index]));
2602 up(&start_stop_sem);
2605 usbduxsub[index].urb_pwm->transfer_buffer =
2606 kzalloc(usbduxsub[index].size_pwm_buf, GFP_KERNEL);
2607 if (!(usbduxsub[index].urb_pwm->transfer_buffer)) {
2608 tidy_up(&(usbduxsub[index]));
2609 up(&start_stop_sem);
2613 usbduxsub[index].urb_pwm = NULL;
2614 usbduxsub[index].size_pwm_buf = 0;
2617 usbduxsub[index].ai_cmd_running = 0;
2618 usbduxsub[index].ao_cmd_running = 0;
2619 usbduxsub[index].pwm_cmd_running = 0;
2621 /* we've reached the bottom of the function */
2622 usbduxsub[index].probed = 1;
2623 up(&start_stop_sem);
2625 ret = request_firmware_nowait(THIS_MODULE,
2631 usbdux_firmware_request_complete_handler);
2634 dev_err(dev, "Could not load firmware (err=%d)\n", ret);
2638 dev_info(dev, "comedi_: usbdux%d "
2639 "has been successfully initialised.\n", index);
2644 static void usbdux_usb_disconnect(struct usb_interface *intf)
2646 struct usbduxsub *usbduxsub_tmp = usb_get_intfdata(intf);
2647 struct usb_device *udev = interface_to_usbdev(intf);
2649 if (!usbduxsub_tmp) {
2651 "comedi_: disconnect called with null pointer.\n");
2654 if (usbduxsub_tmp->usbdev != udev) {
2655 dev_err(&intf->dev, "comedi_: BUG! called with wrong ptr!!!\n");
2658 comedi_usb_auto_unconfig(intf);
2659 down(&start_stop_sem);
2660 down(&usbduxsub_tmp->sem);
2661 tidy_up(usbduxsub_tmp);
2662 up(&usbduxsub_tmp->sem);
2663 up(&start_stop_sem);
2664 dev_dbg(&intf->dev, "comedi_: disconnected from the usb\n");
2667 static const struct usb_device_id usbdux_usb_table[] = {
2668 { USB_DEVICE(0x13d8, 0x0001) },
2669 { USB_DEVICE(0x13d8, 0x0002) },
2673 MODULE_DEVICE_TABLE(usb, usbdux_usb_table);
2675 static struct usb_driver usbdux_usb_driver = {
2677 .probe = usbdux_usb_probe,
2678 .disconnect = usbdux_usb_disconnect,
2679 .id_table = usbdux_usb_table,
2681 module_comedi_usb_driver(usbdux_driver, usbdux_usb_driver);
2683 MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
2684 MODULE_DESCRIPTION("Stirling/ITL USB-DUX -- Bernd.Porr@f2s.com");
2685 MODULE_LICENSE("GPL");
2686 MODULE_FIRMWARE(FIRMWARE);