2 * Copyright (C) 2004 Bernd Porr, Bernd.Porr@f2s.com
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 * I must give credit here to Chris Baugher who
21 * wrote the driver for AT-MIO-16d. I used some parts of this
22 * driver. I also must give credits to David Brownell
23 * who supported me with the USB development.
29 * 0.9: Dropping the first data packet which seems to be from the last transfer.
30 * Buffer overflows in the FX2 are handed over to comedi.
31 * 0.92: Dropping now 4 packets. The quad buffer has to be emptied.
32 * Added insn command basically for testing. Sample rate is
34 * 0.99: Ian Abbott pointed out a bug which has been corrected. Thanks!
35 * 0.99a: added external trigger.
36 * 1.00: added firmware kernel request to the driver which fixed
37 * udev coldplug problem
40 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
42 #include <linux/kernel.h>
43 #include <linux/firmware.h>
44 #include <linux/module.h>
45 #include <linux/init.h>
46 #include <linux/slab.h>
47 #include <linux/input.h>
48 #include <linux/usb.h>
49 #include <linux/fcntl.h>
50 #include <linux/compiler.h>
51 #include "comedi_fc.h"
52 #include "../comedidev.h"
55 * timeout for the USB-transfer
60 * constants for "firmware" upload and download
62 #define FIRMWARE "usbduxfast_firmware.bin"
63 #define USBDUXFASTSUB_FIRMWARE 0xA0
64 #define VENDOR_DIR_IN 0xC0
65 #define VENDOR_DIR_OUT 0x40
68 * internal addresses of the 8051 processor
70 #define USBDUXFASTSUB_CPUCS 0xE600
73 * max lenghth of the transfer-buffer for software upload
78 * input endpoint number
83 * endpoint for the A/D channellist: bulk OUT
85 #define CHANNELLISTEP 4
90 #define NUMCHANNELS 32
93 * size of the waveform descriptor
98 * size of one A/D value
100 #define SIZEADIN (sizeof(int16_t))
103 * size of the input-buffer IN BYTES
105 #define SIZEINBUF 512
110 #define SIZEINSNBUF 512
113 * size of the buffer for the dux commands in bytes
115 #define SIZEOFDUXBUFFER 256
118 * number of in-URBs which receive the data: min=5
120 #define NUMOFINBUFFERSHIGH 10
123 * total number of usbduxfast devices
125 #define NUMUSBDUXFAST 16
128 * analogue in subdevice
133 * min delay steps for more than one channel
134 * basically when the mux gives up ;-)
136 * steps at 30MHz in the FX2
138 #define MIN_SAMPLING_PERIOD 9
141 * max number of 1/30MHz delay steps
143 #define MAX_SAMPLING_PERIOD 500
146 * number of received packets to ignore before we start handing data
147 * over to comedi, it's quad buffering and we have to ignore 4 packets
149 #define PACKETS_TO_IGNORE 4
154 static const struct comedi_lrange range_usbduxfast_ai_range
= {
155 2, {BIP_RANGE(0.75), BIP_RANGE(0.5)}
159 * private structure of one subdevice
161 * this is the structure which holds all the data of this driver
162 * one sub device just now: A/D
164 struct usbduxfastsub_s
{
165 int attached
; /* is attached? */
166 int probed
; /* is it associated with a subdevice? */
167 struct usb_device
*usbdev
; /* pointer to the usb-device */
168 struct urb
*urbIn
; /* BULK-transfer handling: urb */
169 int8_t *transfer_buffer
;
170 int16_t *insnBuffer
; /* input buffer for single insn */
171 int ifnum
; /* interface number */
172 struct usb_interface
*interface
; /* interface structure */
173 /* comedi device for the interrupt context */
174 struct comedi_device
*comedidev
;
175 short int ai_cmd_running
; /* asynchronous command is running */
176 short int ai_continous
; /* continous acquisition */
177 long int ai_sample_count
; /* number of samples to acquire */
178 uint8_t *dux_commands
; /* commands */
179 int ignore
; /* counter which ignores the first
181 struct semaphore sem
;
185 * The pointer to the private usb-data of the driver
186 * is also the private data for the comedi-device.
187 * This has to be global as the usb subsystem needs
188 * global variables. The other reason is that this
189 * structure must be there _before_ any comedi
190 * command is issued. The usb subsystem must be
191 * initialised before comedi can access it.
193 static struct usbduxfastsub_s usbduxfastsub
[NUMUSBDUXFAST
];
195 static DEFINE_SEMAPHORE(start_stop_sem
);
198 * bulk transfers to usbduxfast
200 #define SENDADCOMMANDS 0
201 #define SENDINITEP6 1
203 static int send_dux_commands(struct usbduxfastsub_s
*udfs
, int cmd_type
)
207 udfs
->dux_commands
[0] = cmd_type
;
209 #ifdef CONFIG_COMEDI_DEBUG
210 printk(KERN_DEBUG
"comedi%d: usbduxfast: dux_commands: ",
211 udfs
->comedidev
->minor
);
212 for (tmp
= 0; tmp
< SIZEOFDUXBUFFER
; tmp
++)
213 printk(" %02x", udfs
->dux_commands
[tmp
]);
217 tmp
= usb_bulk_msg(udfs
->usbdev
,
218 usb_sndbulkpipe(udfs
->usbdev
, CHANNELLISTEP
),
219 udfs
->dux_commands
, SIZEOFDUXBUFFER
, &nsent
, 10000);
221 dev_err(&udfs
->interface
->dev
,
222 "could not transmit dux_commands to the usb-device, err=%d\n",
228 * Stops the data acquision.
229 * It should be safe to call this function from any context.
231 static int usbduxfastsub_unlink_InURBs(struct usbduxfastsub_s
*udfs
)
236 if (udfs
&& udfs
->urbIn
) {
237 udfs
->ai_cmd_running
= 0;
238 /* waits until a running transfer is over */
239 usb_kill_urb(udfs
->urbIn
);
242 #ifdef CONFIG_COMEDI_DEBUG
243 printk(KERN_DEBUG
"comedi: usbduxfast: unlinked InURB: res=%d\n", j
);
249 * This will stop a running acquisition operation.
250 * Is called from within this driver from both the
251 * interrupt context and from comedi.
253 static int usbduxfast_ai_stop(struct usbduxfastsub_s
*udfs
, int do_unlink
)
258 pr_err("%s: udfs=NULL!\n", __func__
);
261 #ifdef CONFIG_COMEDI_DEBUG
262 printk(KERN_DEBUG
"comedi: usbduxfast_ai_stop\n");
265 udfs
->ai_cmd_running
= 0;
269 ret
= usbduxfastsub_unlink_InURBs(udfs
);
275 * This will cancel a running acquisition operation.
276 * This is called by comedi but never from inside the driver.
278 static int usbduxfast_ai_cancel(struct comedi_device
*dev
,
279 struct comedi_subdevice
*s
)
281 struct usbduxfastsub_s
*udfs
;
284 /* force unlink of all urbs */
285 #ifdef CONFIG_COMEDI_DEBUG
286 printk(KERN_DEBUG
"comedi: usbduxfast_ai_cancel\n");
290 dev_err(dev
->class_dev
, "%s: udfs=NULL\n", __func__
);
299 ret
= usbduxfast_ai_stop(udfs
, 1);
307 * interrupt service routine
309 static void usbduxfastsub_ai_Irq(struct urb
*urb
)
312 struct usbduxfastsub_s
*udfs
;
313 struct comedi_device
*this_comedidev
;
314 struct comedi_subdevice
*s
;
317 /* sanity checks - is the urb there? */
319 pr_err("ao int-handler called with urb=NULL!\n");
322 /* the context variable points to the subdevice */
323 this_comedidev
= urb
->context
;
324 if (!this_comedidev
) {
325 pr_err("urb context is a NULL pointer!\n");
328 /* the private structure of the subdevice is usbduxfastsub_s */
329 udfs
= this_comedidev
->private;
331 pr_err("private of comedi subdev is a NULL pointer!\n");
334 /* are we running a command? */
335 if (unlikely(!udfs
->ai_cmd_running
)) {
337 * not running a command
338 * do not continue execution if no asynchronous command
339 * is running in particular not resubmit
344 if (unlikely(!udfs
->attached
)) {
345 /* no comedi device there */
348 /* subdevice which is the AD converter */
349 s
= &this_comedidev
->subdevices
[SUBDEV_AD
];
351 /* first we test if something unusual has just happened */
352 switch (urb
->status
) {
357 * happens after an unlink command or when the device
364 /* tell this comedi */
365 s
->async
->events
|= COMEDI_CB_EOA
;
366 s
->async
->events
|= COMEDI_CB_ERROR
;
367 comedi_event(udfs
->comedidev
, s
);
368 /* stop the transfer w/o unlink */
369 usbduxfast_ai_stop(udfs
, 0);
373 pr_err("non-zero urb status received in ai intr context: %d\n",
375 s
->async
->events
|= COMEDI_CB_EOA
;
376 s
->async
->events
|= COMEDI_CB_ERROR
;
377 comedi_event(udfs
->comedidev
, s
);
378 usbduxfast_ai_stop(udfs
, 0);
382 p
= urb
->transfer_buffer
;
384 if (!udfs
->ai_continous
) {
385 /* not continuous, fixed number of samples */
386 n
= urb
->actual_length
/ sizeof(uint16_t);
387 if (unlikely(udfs
->ai_sample_count
< n
)) {
389 * we have send only a fraction of the bytes
392 cfc_write_array_to_buffer(s
,
393 urb
->transfer_buffer
,
394 udfs
->ai_sample_count
396 usbduxfast_ai_stop(udfs
, 0);
397 /* tell comedi that the acquistion is over */
398 s
->async
->events
|= COMEDI_CB_EOA
;
399 comedi_event(udfs
->comedidev
, s
);
402 udfs
->ai_sample_count
-= n
;
404 /* write the full buffer to comedi */
405 err
= cfc_write_array_to_buffer(s
, urb
->transfer_buffer
,
407 if (unlikely(err
== 0)) {
408 /* buffer overflow */
409 usbduxfast_ai_stop(udfs
, 0);
413 /* tell comedi that data is there */
414 comedi_event(udfs
->comedidev
, s
);
417 /* ignore this packet */
422 * command is still running
423 * resubmit urb for BULK transfer
425 urb
->dev
= udfs
->usbdev
;
427 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
429 dev_err(&urb
->dev
->dev
,
430 "urb resubm failed: %d", err
);
431 s
->async
->events
|= COMEDI_CB_EOA
;
432 s
->async
->events
|= COMEDI_CB_ERROR
;
433 comedi_event(udfs
->comedidev
, s
);
434 usbduxfast_ai_stop(udfs
, 0);
438 static int usbduxfastsub_start(struct usbduxfastsub_s
*udfs
)
441 unsigned char local_transfer_buffer
[16];
444 local_transfer_buffer
[0] = 0;
445 /* bRequest, "Firmware" */
446 ret
= usb_control_msg(udfs
->usbdev
, usb_sndctrlpipe(udfs
->usbdev
, 0),
447 USBDUXFASTSUB_FIRMWARE
,
448 VENDOR_DIR_OUT
, /* bmRequestType */
449 USBDUXFASTSUB_CPUCS
, /* Value */
451 /* address of the transfer buffer */
452 local_transfer_buffer
,
454 EZTIMEOUT
); /* Timeout */
456 dev_err(&udfs
->interface
->dev
,
457 "control msg failed (start)\n");
464 static int usbduxfastsub_stop(struct usbduxfastsub_s
*udfs
)
467 unsigned char local_transfer_buffer
[16];
470 local_transfer_buffer
[0] = 1;
471 /* bRequest, "Firmware" */
472 ret
= usb_control_msg(udfs
->usbdev
, usb_sndctrlpipe(udfs
->usbdev
, 0),
473 USBDUXFASTSUB_FIRMWARE
,
474 VENDOR_DIR_OUT
, /* bmRequestType */
475 USBDUXFASTSUB_CPUCS
, /* Value */
477 local_transfer_buffer
, 1, /* Length */
478 EZTIMEOUT
); /* Timeout */
480 dev_err(&udfs
->interface
->dev
,
481 "control msg failed (stop)\n");
488 static int usbduxfastsub_upload(struct usbduxfastsub_s
*udfs
,
489 unsigned char *local_transfer_buffer
,
490 unsigned int startAddr
, unsigned int len
)
494 #ifdef CONFIG_COMEDI_DEBUG
495 printk(KERN_DEBUG
"comedi: usbduxfast: uploading %d bytes", len
);
496 printk(KERN_DEBUG
" to addr %d, first byte=%d.\n",
497 startAddr
, local_transfer_buffer
[0]);
499 /* brequest, firmware */
500 ret
= usb_control_msg(udfs
->usbdev
, usb_sndctrlpipe(udfs
->usbdev
, 0),
501 USBDUXFASTSUB_FIRMWARE
,
502 VENDOR_DIR_OUT
, /* bmRequestType */
503 startAddr
, /* value */
505 /* our local safe buffer */
506 local_transfer_buffer
,
508 EZTIMEOUT
); /* timeout */
510 #ifdef CONFIG_COMEDI_DEBUG
511 printk(KERN_DEBUG
"comedi_: usbduxfast: result=%d\n", ret
);
515 dev_err(&udfs
->interface
->dev
, "uppload failed\n");
522 static int usbduxfastsub_submit_InURBs(struct usbduxfastsub_s
*udfs
)
529 usb_fill_bulk_urb(udfs
->urbIn
, udfs
->usbdev
,
530 usb_rcvbulkpipe(udfs
->usbdev
, BULKINEP
),
531 udfs
->transfer_buffer
,
532 SIZEINBUF
, usbduxfastsub_ai_Irq
, udfs
->comedidev
);
534 #ifdef CONFIG_COMEDI_DEBUG
535 printk(KERN_DEBUG
"comedi%d: usbduxfast: submitting in-urb: "
536 "0x%p,0x%p\n", udfs
->comedidev
->minor
, udfs
->urbIn
->context
,
539 ret
= usb_submit_urb(udfs
->urbIn
, GFP_ATOMIC
);
541 dev_err(&udfs
->interface
->dev
,
542 "ai: usb_submit_urb error %d\n", ret
);
548 static int usbduxfast_ai_cmdtest(struct comedi_device
*dev
,
549 struct comedi_subdevice
*s
,
550 struct comedi_cmd
*cmd
)
552 struct usbduxfastsub_s
*udfs
= dev
->private;
560 #ifdef CONFIG_COMEDI_DEBUG
561 printk(KERN_DEBUG
"comedi%d: usbduxfast_ai_cmdtest\n", dev
->minor
);
562 printk(KERN_DEBUG
"comedi%d: usbduxfast: convert_arg=%u "
563 "scan_begin_arg=%u\n",
564 dev
->minor
, cmd
->convert_arg
, cmd
->scan_begin_arg
);
566 /* Step 1 : check if triggers are trivially valid */
568 err
|= cfc_check_trigger_src(&cmd
->start_src
,
569 TRIG_NOW
| TRIG_EXT
| TRIG_INT
);
570 err
|= cfc_check_trigger_src(&cmd
->scan_begin_src
,
571 TRIG_TIMER
| TRIG_FOLLOW
| TRIG_EXT
);
572 err
|= cfc_check_trigger_src(&cmd
->convert_src
, TRIG_TIMER
| TRIG_EXT
);
573 err
|= cfc_check_trigger_src(&cmd
->scan_end_src
, TRIG_COUNT
);
574 err
|= cfc_check_trigger_src(&cmd
->stop_src
, TRIG_COUNT
| TRIG_NONE
);
579 /* Step 2a : make sure trigger sources are unique */
581 err
|= cfc_check_trigger_is_unique(cmd
->start_src
);
582 err
|= cfc_check_trigger_is_unique(cmd
->scan_begin_src
);
583 err
|= cfc_check_trigger_is_unique(cmd
->convert_src
);
584 err
|= cfc_check_trigger_is_unique(cmd
->stop_src
);
586 /* Step 2b : and mutually compatible */
588 /* can't have external stop and start triggers at once */
589 if (cmd
->start_src
== TRIG_EXT
&& cmd
->stop_src
== TRIG_EXT
)
595 /* step 3: make sure arguments are trivially compatible */
597 if (cmd
->start_src
== TRIG_NOW
&& cmd
->start_arg
!= 0) {
602 if (!cmd
->chanlist_len
)
605 if (cmd
->scan_end_arg
!= cmd
->chanlist_len
) {
606 cmd
->scan_end_arg
= cmd
->chanlist_len
;
610 if (cmd
->chanlist_len
== 1)
613 minSamplPer
= MIN_SAMPLING_PERIOD
;
615 if (cmd
->convert_src
== TRIG_TIMER
) {
616 steps
= cmd
->convert_arg
* 30;
617 if (steps
< (minSamplPer
* 1000))
618 steps
= minSamplPer
* 1000;
620 if (steps
> (MAX_SAMPLING_PERIOD
* 1000))
621 steps
= MAX_SAMPLING_PERIOD
* 1000;
625 if (cmd
->convert_arg
!= tmp
) {
626 cmd
->convert_arg
= tmp
;
631 if (cmd
->scan_begin_src
== TRIG_TIMER
)
635 switch (cmd
->stop_src
) {
637 if (!cmd
->stop_arg
) {
643 if (cmd
->stop_arg
!= 0) {
649 * TRIG_EXT doesn't care since it doesn't trigger
650 * off a numbered channel
659 /* step 4: fix up any arguments */
665 static int usbduxfast_ai_inttrig(struct comedi_device
*dev
,
666 struct comedi_subdevice
*s
,
667 unsigned int trignum
)
670 struct usbduxfastsub_s
*udfs
= dev
->private;
680 #ifdef CONFIG_COMEDI_DEBUG
681 printk(KERN_DEBUG
"comedi%d: usbduxfast_ai_inttrig\n", dev
->minor
);
685 dev_err(dev
->class_dev
, "%s: invalid trignum\n", __func__
);
689 if (!udfs
->ai_cmd_running
) {
690 udfs
->ai_cmd_running
= 1;
691 ret
= usbduxfastsub_submit_InURBs(udfs
);
693 dev_err(dev
->class_dev
,
694 "%s: urbSubmit: err=%d\n", __func__
, ret
);
695 udfs
->ai_cmd_running
= 0;
699 s
->async
->inttrig
= NULL
;
701 dev_err(dev
->class_dev
,
702 "ai_inttrig but acqu is already running\n");
709 * offsets for the GPIF bytes
710 * the first byte is the command byte
712 #define LENBASE (1+0x00)
713 #define OPBASE (1+0x08)
714 #define OUTBASE (1+0x10)
715 #define LOGBASE (1+0x18)
717 static int usbduxfast_ai_cmd(struct comedi_device
*dev
,
718 struct comedi_subdevice
*s
)
720 struct comedi_cmd
*cmd
= &s
->async
->cmd
;
721 unsigned int chan
, gain
, rngmask
= 0xff;
723 struct usbduxfastsub_s
*udfs
;
725 long steps
, steps_tmp
;
727 #ifdef CONFIG_COMEDI_DEBUG
728 printk(KERN_DEBUG
"comedi%d: usbduxfast_ai_cmd\n", dev
->minor
);
739 if (udfs
->ai_cmd_running
) {
740 dev_err(dev
->class_dev
,
741 "ai_cmd not possible. Another ai_cmd is running.\n");
745 /* set current channel of the running acquisition to zero */
746 s
->async
->cur_chan
= 0;
749 * ignore the first buffers from the device if there
750 * is an error condition
752 udfs
->ignore
= PACKETS_TO_IGNORE
;
754 if (cmd
->chanlist_len
> 0) {
755 gain
= CR_RANGE(cmd
->chanlist
[0]);
756 for (i
= 0; i
< cmd
->chanlist_len
; ++i
) {
757 chan
= CR_CHAN(cmd
->chanlist
[i
]);
759 dev_err(dev
->class_dev
,
760 "cmd is accepting only consecutive channels.\n");
764 if ((gain
!= CR_RANGE(cmd
->chanlist
[i
]))
765 && (cmd
->chanlist_len
> 3)) {
766 dev_err(dev
->class_dev
,
767 "the gain must be the same for all channels.\n");
771 if (i
>= NUMCHANNELS
) {
772 dev_err(dev
->class_dev
,
773 "channel list too long\n");
779 if (cmd
->scan_begin_src
== TRIG_TIMER
) {
780 dev_err(dev
->class_dev
,
781 "scan_begin_src==TRIG_TIMER not valid.\n");
785 if (cmd
->convert_src
== TRIG_TIMER
)
786 steps
= (cmd
->convert_arg
* 30) / 1000;
788 if ((steps
< MIN_SAMPLING_PERIOD
) && (cmd
->chanlist_len
!= 1)) {
789 dev_err(dev
->class_dev
,
790 "ai_cmd: steps=%ld, scan_begin_arg=%d. Not properly tested by cmdtest?\n",
791 steps
, cmd
->scan_begin_arg
);
795 if (steps
> MAX_SAMPLING_PERIOD
) {
796 dev_err(dev
->class_dev
, "ai_cmd: sampling rate too low.\n");
800 if ((cmd
->start_src
== TRIG_EXT
) && (cmd
->chanlist_len
!= 1)
801 && (cmd
->chanlist_len
!= 16)) {
802 dev_err(dev
->class_dev
,
803 "ai_cmd: TRIG_EXT only with 1 or 16 channels possible.\n");
807 #ifdef CONFIG_COMEDI_DEBUG
808 printk(KERN_DEBUG
"comedi%d: usbduxfast: steps=%ld, convert_arg=%u\n",
809 dev
->minor
, steps
, cmd
->convert_arg
);
812 switch (cmd
->chanlist_len
) {
818 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
819 rngmask
= 0xff - 0x04;
824 * for external trigger: looping in this state until
825 * the RDY0 pin becomes zero
828 /* we loop here until ready has been set */
829 if (cmd
->start_src
== TRIG_EXT
) {
830 /* branch back to state 0 */
831 udfs
->dux_commands
[LENBASE
+ 0] = 0x01;
832 /* deceision state w/o data */
833 udfs
->dux_commands
[OPBASE
+ 0] = 0x01;
834 udfs
->dux_commands
[OUTBASE
+ 0] = 0xFF & rngmask
;
836 udfs
->dux_commands
[LOGBASE
+ 0] = 0x00;
837 } else { /* we just proceed to state 1 */
838 udfs
->dux_commands
[LENBASE
+ 0] = 1;
839 udfs
->dux_commands
[OPBASE
+ 0] = 0;
840 udfs
->dux_commands
[OUTBASE
+ 0] = 0xFF & rngmask
;
841 udfs
->dux_commands
[LOGBASE
+ 0] = 0;
844 if (steps
< MIN_SAMPLING_PERIOD
) {
845 /* for fast single channel aqu without mux */
848 * we just stay here at state 1 and rexecute
849 * the same state this gives us 30MHz sampling
853 /* branch back to state 1 */
854 udfs
->dux_commands
[LENBASE
+ 1] = 0x89;
855 /* deceision state with data */
856 udfs
->dux_commands
[OPBASE
+ 1] = 0x03;
857 udfs
->dux_commands
[OUTBASE
+ 1] =
860 udfs
->dux_commands
[LOGBASE
+ 1] = 0xFF;
863 * we loop through two states: data and delay
866 udfs
->dux_commands
[LENBASE
+ 1] = steps
- 1;
868 udfs
->dux_commands
[OPBASE
+ 1] = 0x02;
869 udfs
->dux_commands
[OUTBASE
+ 1] =
872 udfs
->dux_commands
[LOGBASE
+ 1] = 0;
873 /* branch back to state 1 */
874 udfs
->dux_commands
[LENBASE
+ 2] = 0x09;
875 /* deceision state w/o data */
876 udfs
->dux_commands
[OPBASE
+ 2] = 0x01;
877 udfs
->dux_commands
[OUTBASE
+ 2] =
880 udfs
->dux_commands
[LOGBASE
+ 2] = 0xFF;
884 * we loop through 3 states: 2x delay and 1x data
885 * this gives a min sampling rate of 60kHz
888 /* we have 1 state with duration 1 */
891 /* do the first part of the delay */
892 udfs
->dux_commands
[LENBASE
+ 1] = steps
/ 2;
893 udfs
->dux_commands
[OPBASE
+ 1] = 0;
894 udfs
->dux_commands
[OUTBASE
+ 1] = 0xFF & rngmask
;
895 udfs
->dux_commands
[LOGBASE
+ 1] = 0;
897 /* and the second part */
898 udfs
->dux_commands
[LENBASE
+ 2] = steps
- steps
/ 2;
899 udfs
->dux_commands
[OPBASE
+ 2] = 0;
900 udfs
->dux_commands
[OUTBASE
+ 2] = 0xFF & rngmask
;
901 udfs
->dux_commands
[LOGBASE
+ 2] = 0;
903 /* get the data and branch back */
905 /* branch back to state 1 */
906 udfs
->dux_commands
[LENBASE
+ 3] = 0x09;
907 /* deceision state w data */
908 udfs
->dux_commands
[OPBASE
+ 3] = 0x03;
909 udfs
->dux_commands
[OUTBASE
+ 3] = 0xFF & rngmask
;
911 udfs
->dux_commands
[LOGBASE
+ 3] = 0xFF;
918 * commit data to the FIFO
921 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
922 rngmask
= 0xff - 0x04;
926 udfs
->dux_commands
[LENBASE
+ 0] = 1;
928 udfs
->dux_commands
[OPBASE
+ 0] = 0x02;
929 udfs
->dux_commands
[OUTBASE
+ 0] = 0xFF & rngmask
;
930 udfs
->dux_commands
[LOGBASE
+ 0] = 0;
932 /* we have 1 state with duration 1: state 0 */
933 steps_tmp
= steps
- 1;
935 if (CR_RANGE(cmd
->chanlist
[1]) > 0)
936 rngmask
= 0xff - 0x04;
940 /* do the first part of the delay */
941 udfs
->dux_commands
[LENBASE
+ 1] = steps_tmp
/ 2;
942 udfs
->dux_commands
[OPBASE
+ 1] = 0;
944 udfs
->dux_commands
[OUTBASE
+ 1] = 0xFE & rngmask
;
945 udfs
->dux_commands
[LOGBASE
+ 1] = 0;
947 /* and the second part */
948 udfs
->dux_commands
[LENBASE
+ 2] = steps_tmp
- steps_tmp
/ 2;
949 udfs
->dux_commands
[OPBASE
+ 2] = 0;
950 udfs
->dux_commands
[OUTBASE
+ 2] = 0xFF & rngmask
;
951 udfs
->dux_commands
[LOGBASE
+ 2] = 0;
953 udfs
->dux_commands
[LENBASE
+ 3] = 1;
955 udfs
->dux_commands
[OPBASE
+ 3] = 0x02;
956 udfs
->dux_commands
[OUTBASE
+ 3] = 0xFF & rngmask
;
957 udfs
->dux_commands
[LOGBASE
+ 3] = 0;
960 * we have 2 states with duration 1: step 6 and
963 steps_tmp
= steps
- 2;
965 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
966 rngmask
= 0xff - 0x04;
970 /* do the first part of the delay */
971 udfs
->dux_commands
[LENBASE
+ 4] = steps_tmp
/ 2;
972 udfs
->dux_commands
[OPBASE
+ 4] = 0;
974 udfs
->dux_commands
[OUTBASE
+ 4] = (0xFF - 0x02) & rngmask
;
975 udfs
->dux_commands
[LOGBASE
+ 4] = 0;
977 /* and the second part */
978 udfs
->dux_commands
[LENBASE
+ 5] = steps_tmp
- steps_tmp
/ 2;
979 udfs
->dux_commands
[OPBASE
+ 5] = 0;
980 udfs
->dux_commands
[OUTBASE
+ 5] = 0xFF & rngmask
;
981 udfs
->dux_commands
[LOGBASE
+ 5] = 0;
983 udfs
->dux_commands
[LENBASE
+ 6] = 1;
984 udfs
->dux_commands
[OPBASE
+ 6] = 0;
985 udfs
->dux_commands
[OUTBASE
+ 6] = 0xFF & rngmask
;
986 udfs
->dux_commands
[LOGBASE
+ 6] = 0;
993 for (j
= 0; j
< 1; j
++) {
994 if (CR_RANGE(cmd
->chanlist
[j
]) > 0)
995 rngmask
= 0xff - 0x04;
999 * commit data to the FIFO and do the first part
1002 udfs
->dux_commands
[LENBASE
+ j
* 2] = steps
/ 2;
1004 udfs
->dux_commands
[OPBASE
+ j
* 2] = 0x02;
1006 udfs
->dux_commands
[OUTBASE
+ j
* 2] = 0xFF & rngmask
;
1007 udfs
->dux_commands
[LOGBASE
+ j
* 2] = 0;
1009 if (CR_RANGE(cmd
->chanlist
[j
+ 1]) > 0)
1010 rngmask
= 0xff - 0x04;
1014 /* do the second part of the delay */
1015 udfs
->dux_commands
[LENBASE
+ j
* 2 + 1] =
1018 udfs
->dux_commands
[OPBASE
+ j
* 2 + 1] = 0;
1020 udfs
->dux_commands
[OUTBASE
+ j
* 2 + 1] =
1022 udfs
->dux_commands
[LOGBASE
+ j
* 2 + 1] = 0;
1025 /* 2 steps with duration 1: the idele step and step 6: */
1026 steps_tmp
= steps
- 2;
1028 /* commit data to the FIFO and do the first part of the delay */
1029 udfs
->dux_commands
[LENBASE
+ 4] = steps_tmp
/ 2;
1031 udfs
->dux_commands
[OPBASE
+ 4] = 0x02;
1032 udfs
->dux_commands
[OUTBASE
+ 4] = 0xFF & rngmask
;
1033 udfs
->dux_commands
[LOGBASE
+ 4] = 0;
1035 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
1036 rngmask
= 0xff - 0x04;
1040 /* do the second part of the delay */
1041 udfs
->dux_commands
[LENBASE
+ 5] = steps_tmp
- steps_tmp
/ 2;
1043 udfs
->dux_commands
[OPBASE
+ 5] = 0;
1045 udfs
->dux_commands
[OUTBASE
+ 5] = (0xFF - 0x02) & rngmask
;
1046 udfs
->dux_commands
[LOGBASE
+ 5] = 0;
1048 udfs
->dux_commands
[LENBASE
+ 6] = 1;
1049 udfs
->dux_commands
[OPBASE
+ 6] = 0;
1050 udfs
->dux_commands
[OUTBASE
+ 6] = 0xFF & rngmask
;
1051 udfs
->dux_commands
[LOGBASE
+ 6] = 0;
1054 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
1055 rngmask
= 0xff - 0x04;
1059 if (cmd
->start_src
== TRIG_EXT
) {
1061 * we loop here until ready has been set
1064 /* branch back to state 0 */
1065 udfs
->dux_commands
[LENBASE
+ 0] = 0x01;
1066 /* deceision state w/o data */
1067 udfs
->dux_commands
[OPBASE
+ 0] = 0x01;
1069 udfs
->dux_commands
[OUTBASE
+ 0] =
1070 (0xFF - 0x02) & rngmask
;
1072 udfs
->dux_commands
[LOGBASE
+ 0] = 0x00;
1075 * we just proceed to state 1
1078 /* 30us reset pulse */
1079 udfs
->dux_commands
[LENBASE
+ 0] = 255;
1080 udfs
->dux_commands
[OPBASE
+ 0] = 0;
1082 udfs
->dux_commands
[OUTBASE
+ 0] =
1083 (0xFF - 0x02) & rngmask
;
1084 udfs
->dux_commands
[LOGBASE
+ 0] = 0;
1087 /* commit data to the FIFO */
1088 udfs
->dux_commands
[LENBASE
+ 1] = 1;
1090 udfs
->dux_commands
[OPBASE
+ 1] = 0x02;
1091 udfs
->dux_commands
[OUTBASE
+ 1] = 0xFF & rngmask
;
1092 udfs
->dux_commands
[LOGBASE
+ 1] = 0;
1094 /* we have 2 states with duration 1 */
1097 /* do the first part of the delay */
1098 udfs
->dux_commands
[LENBASE
+ 2] = steps
/ 2;
1099 udfs
->dux_commands
[OPBASE
+ 2] = 0;
1100 udfs
->dux_commands
[OUTBASE
+ 2] = 0xFE & rngmask
;
1101 udfs
->dux_commands
[LOGBASE
+ 2] = 0;
1103 /* and the second part */
1104 udfs
->dux_commands
[LENBASE
+ 3] = steps
- steps
/ 2;
1105 udfs
->dux_commands
[OPBASE
+ 3] = 0;
1106 udfs
->dux_commands
[OUTBASE
+ 3] = 0xFF & rngmask
;
1107 udfs
->dux_commands
[LOGBASE
+ 3] = 0;
1109 /* branch back to state 1 */
1110 udfs
->dux_commands
[LENBASE
+ 4] = 0x09;
1111 /* deceision state w/o data */
1112 udfs
->dux_commands
[OPBASE
+ 4] = 0x01;
1113 udfs
->dux_commands
[OUTBASE
+ 4] = 0xFF & rngmask
;
1114 /* doesn't matter */
1115 udfs
->dux_commands
[LOGBASE
+ 4] = 0xFF;
1120 dev_err(dev
->class_dev
, "unsupported combination of channels\n");
1125 #ifdef CONFIG_COMEDI_DEBUG
1126 printk(KERN_DEBUG
"comedi %d: sending commands to the usb device\n",
1129 /* 0 means that the AD commands are sent */
1130 result
= send_dux_commands(udfs
, SENDADCOMMANDS
);
1132 dev_err(dev
->class_dev
,
1133 "adc command could not be submitted. Aborting...\n");
1137 if (cmd
->stop_src
== TRIG_COUNT
) {
1138 udfs
->ai_sample_count
= cmd
->stop_arg
* cmd
->scan_end_arg
;
1139 if (udfs
->ai_sample_count
< 1) {
1140 dev_err(dev
->class_dev
,
1141 "(cmd->stop_arg)*(cmd->scan_end_arg)<1, aborting.\n");
1145 udfs
->ai_continous
= 0;
1147 /* continous acquisition */
1148 udfs
->ai_continous
= 1;
1149 udfs
->ai_sample_count
= 0;
1152 if ((cmd
->start_src
== TRIG_NOW
) || (cmd
->start_src
== TRIG_EXT
)) {
1153 /* enable this acquisition operation */
1154 udfs
->ai_cmd_running
= 1;
1155 ret
= usbduxfastsub_submit_InURBs(udfs
);
1157 udfs
->ai_cmd_running
= 0;
1158 /* fixme: unlink here?? */
1162 s
->async
->inttrig
= NULL
;
1166 * don't enable the acquision operation
1167 * wait for an internal signal
1169 s
->async
->inttrig
= usbduxfast_ai_inttrig
;
1177 * Mode 0 is used to get a single conversion on demand.
1179 static int usbduxfast_ai_insn_read(struct comedi_device
*dev
,
1180 struct comedi_subdevice
*s
,
1181 struct comedi_insn
*insn
, unsigned int *data
)
1183 int i
, j
, n
, actual_length
;
1184 int chan
, range
, rngmask
;
1186 struct usbduxfastsub_s
*udfs
;
1188 udfs
= dev
->private;
1190 dev_err(dev
->class_dev
, "%s: no usb dev.\n", __func__
);
1193 #ifdef CONFIG_COMEDI_DEBUG
1194 printk(KERN_DEBUG
"comedi%d: ai_insn_read, insn->n=%d, "
1195 "insn->subdev=%d\n", dev
->minor
, insn
->n
, insn
->subdev
);
1198 if (!udfs
->probed
) {
1202 if (udfs
->ai_cmd_running
) {
1203 dev_err(dev
->class_dev
,
1204 "ai_insn_read not possible. Async Command is running.\n");
1208 /* sample one channel */
1209 chan
= CR_CHAN(insn
->chanspec
);
1210 range
= CR_RANGE(insn
->chanspec
);
1211 /* set command for the first channel */
1214 rngmask
= 0xff - 0x04;
1218 /* commit data to the FIFO */
1219 udfs
->dux_commands
[LENBASE
+ 0] = 1;
1221 udfs
->dux_commands
[OPBASE
+ 0] = 0x02;
1222 udfs
->dux_commands
[OUTBASE
+ 0] = 0xFF & rngmask
;
1223 udfs
->dux_commands
[LOGBASE
+ 0] = 0;
1225 /* do the first part of the delay */
1226 udfs
->dux_commands
[LENBASE
+ 1] = 12;
1227 udfs
->dux_commands
[OPBASE
+ 1] = 0;
1228 udfs
->dux_commands
[OUTBASE
+ 1] = 0xFE & rngmask
;
1229 udfs
->dux_commands
[LOGBASE
+ 1] = 0;
1231 udfs
->dux_commands
[LENBASE
+ 2] = 1;
1232 udfs
->dux_commands
[OPBASE
+ 2] = 0;
1233 udfs
->dux_commands
[OUTBASE
+ 2] = 0xFE & rngmask
;
1234 udfs
->dux_commands
[LOGBASE
+ 2] = 0;
1236 udfs
->dux_commands
[LENBASE
+ 3] = 1;
1237 udfs
->dux_commands
[OPBASE
+ 3] = 0;
1238 udfs
->dux_commands
[OUTBASE
+ 3] = 0xFE & rngmask
;
1239 udfs
->dux_commands
[LOGBASE
+ 3] = 0;
1241 udfs
->dux_commands
[LENBASE
+ 4] = 1;
1242 udfs
->dux_commands
[OPBASE
+ 4] = 0;
1243 udfs
->dux_commands
[OUTBASE
+ 4] = 0xFE & rngmask
;
1244 udfs
->dux_commands
[LOGBASE
+ 4] = 0;
1247 udfs
->dux_commands
[LENBASE
+ 5] = 12;
1248 udfs
->dux_commands
[OPBASE
+ 5] = 0;
1249 udfs
->dux_commands
[OUTBASE
+ 5] = 0xFF & rngmask
;
1250 udfs
->dux_commands
[LOGBASE
+ 5] = 0;
1252 udfs
->dux_commands
[LENBASE
+ 6] = 1;
1253 udfs
->dux_commands
[OPBASE
+ 6] = 0;
1254 udfs
->dux_commands
[OUTBASE
+ 6] = 0xFF & rngmask
;
1255 udfs
->dux_commands
[LOGBASE
+ 0] = 0;
1257 #ifdef CONFIG_COMEDI_DEBUG
1258 printk(KERN_DEBUG
"comedi %d: sending commands to the usb device\n",
1261 /* 0 means that the AD commands are sent */
1262 err
= send_dux_commands(udfs
, SENDADCOMMANDS
);
1264 dev_err(dev
->class_dev
,
1265 "adc command could not be submitted. Aborting...\n");
1269 #ifdef CONFIG_COMEDI_DEBUG
1270 printk(KERN_DEBUG
"comedi%d: usbduxfast: submitting in-urb: "
1271 "0x%p,0x%p\n", udfs
->comedidev
->minor
, udfs
->urbIn
->context
,
1274 for (i
= 0; i
< PACKETS_TO_IGNORE
; i
++) {
1275 err
= usb_bulk_msg(udfs
->usbdev
,
1276 usb_rcvbulkpipe(udfs
->usbdev
, BULKINEP
),
1277 udfs
->transfer_buffer
, SIZEINBUF
,
1278 &actual_length
, 10000);
1280 dev_err(dev
->class_dev
, "insn timeout. No data.\n");
1286 for (i
= 0; i
< insn
->n
;) {
1287 err
= usb_bulk_msg(udfs
->usbdev
,
1288 usb_rcvbulkpipe(udfs
->usbdev
, BULKINEP
),
1289 udfs
->transfer_buffer
, SIZEINBUF
,
1290 &actual_length
, 10000);
1292 dev_err(dev
->class_dev
, "insn data error: %d\n", err
);
1296 n
= actual_length
/ sizeof(uint16_t);
1297 if ((n
% 16) != 0) {
1298 dev_err(dev
->class_dev
, "insn data packet corrupted.\n");
1302 for (j
= chan
; (j
< n
) && (i
< insn
->n
); j
= j
+ 16) {
1303 data
[i
] = ((uint16_t *) (udfs
->transfer_buffer
))[j
];
1311 #define FIRMWARE_MAX_LEN 0x2000
1313 static int firmwareUpload(struct usbduxfastsub_s
*usbduxfastsub
,
1314 const u8
*firmwareBinary
, int sizeFirmware
)
1319 if (!firmwareBinary
)
1322 if (sizeFirmware
> FIRMWARE_MAX_LEN
) {
1323 dev_err(&usbduxfastsub
->interface
->dev
,
1324 "comedi_: usbduxfast firmware binary it too large for FX2.\n");
1328 /* we generate a local buffer for the firmware */
1329 fwBuf
= kmemdup(firmwareBinary
, sizeFirmware
, GFP_KERNEL
);
1331 dev_err(&usbduxfastsub
->interface
->dev
,
1332 "comedi_: mem alloc for firmware failed\n");
1336 ret
= usbduxfastsub_stop(usbduxfastsub
);
1338 dev_err(&usbduxfastsub
->interface
->dev
,
1339 "comedi_: can not stop firmware\n");
1344 ret
= usbduxfastsub_upload(usbduxfastsub
, fwBuf
, 0, sizeFirmware
);
1346 dev_err(&usbduxfastsub
->interface
->dev
,
1347 "comedi_: firmware upload failed\n");
1351 ret
= usbduxfastsub_start(usbduxfastsub
);
1353 dev_err(&usbduxfastsub
->interface
->dev
,
1354 "comedi_: can not start firmware\n");
1362 static void tidy_up(struct usbduxfastsub_s
*udfs
)
1364 #ifdef CONFIG_COMEDI_DEBUG
1365 printk(KERN_DEBUG
"comedi_: usbduxfast: tiding up\n");
1371 /* shows the usb subsystem that the driver is down */
1372 if (udfs
->interface
)
1373 usb_set_intfdata(udfs
->interface
, NULL
);
1378 /* waits until a running transfer is over */
1379 usb_kill_urb(udfs
->urbIn
);
1381 kfree(udfs
->transfer_buffer
);
1382 udfs
->transfer_buffer
= NULL
;
1384 usb_free_urb(udfs
->urbIn
);
1388 kfree(udfs
->insnBuffer
);
1389 udfs
->insnBuffer
= NULL
;
1391 kfree(udfs
->dux_commands
);
1392 udfs
->dux_commands
= NULL
;
1394 udfs
->ai_cmd_running
= 0;
1397 static int usbduxfast_attach_common(struct comedi_device
*dev
,
1398 struct usbduxfastsub_s
*udfs
)
1401 struct comedi_subdevice
*s
;
1404 /* pointer back to the corresponding comedi device */
1405 udfs
->comedidev
= dev
;
1406 dev
->board_name
= "usbduxfast";
1407 ret
= comedi_alloc_subdevices(dev
, 1);
1412 /* private structure is also simply the usb-structure */
1413 dev
->private = udfs
;
1414 /* the first subdevice is the A/D converter */
1415 s
= &dev
->subdevices
[SUBDEV_AD
];
1417 * the URBs get the comedi subdevice which is responsible for reading
1418 * this is the subdevice which reads data
1420 dev
->read_subdev
= s
;
1421 /* the subdevice receives as private structure the usb-structure */
1424 s
->type
= COMEDI_SUBD_AI
;
1425 /* readable and ref is to ground */
1426 s
->subdev_flags
= SDF_READABLE
| SDF_GROUND
| SDF_CMD_READ
;
1429 /* length of the channellist */
1430 s
->len_chanlist
= 16;
1431 /* callback functions */
1432 s
->insn_read
= usbduxfast_ai_insn_read
;
1433 s
->do_cmdtest
= usbduxfast_ai_cmdtest
;
1434 s
->do_cmd
= usbduxfast_ai_cmd
;
1435 s
->cancel
= usbduxfast_ai_cancel
;
1436 /* max value from the A/D converter (12bit+1 bit for overflow) */
1437 s
->maxdata
= 0x1000;
1438 /* range table to convert to physical units */
1439 s
->range_table
= &range_usbduxfast_ai_range
;
1440 /* finally decide that it's attached */
1443 dev_info(dev
->class_dev
, "successfully attached to usbduxfast.\n");
1447 static int usbduxfast_auto_attach(struct comedi_device
*dev
,
1448 unsigned long context_unused
)
1450 struct usb_interface
*uinterf
= comedi_to_usb_interface(dev
);
1452 struct usbduxfastsub_s
*udfs
;
1454 dev
->private = NULL
;
1455 down(&start_stop_sem
);
1456 udfs
= usb_get_intfdata(uinterf
);
1457 if (!udfs
|| !udfs
->probed
) {
1458 dev_err(dev
->class_dev
,
1459 "usbduxfast: error: auto_attach failed, not connected\n");
1461 } else if (udfs
->attached
) {
1462 dev_err(dev
->class_dev
,
1463 "usbduxfast: error: auto_attach failed, already attached\n");
1466 ret
= usbduxfast_attach_common(dev
, udfs
);
1467 up(&start_stop_sem
);
1471 static void usbduxfast_detach(struct comedi_device
*dev
)
1473 struct usbduxfastsub_s
*usb
= dev
->private;
1477 down(&start_stop_sem
);
1478 dev
->private = NULL
;
1480 usb
->comedidev
= NULL
;
1481 up(&start_stop_sem
);
1486 static struct comedi_driver usbduxfast_driver
= {
1487 .driver_name
= "usbduxfast",
1488 .module
= THIS_MODULE
,
1489 .auto_attach
= usbduxfast_auto_attach
,
1490 .detach
= usbduxfast_detach
,
1493 static void usbduxfast_firmware_request_complete_handler(const struct firmware
1496 struct usbduxfastsub_s
*usbduxfastsub_tmp
= context
;
1497 struct usb_interface
*uinterf
= usbduxfastsub_tmp
->interface
;
1504 * we need to upload the firmware here because fw will be
1505 * freed once we've left this function
1507 ret
= firmwareUpload(usbduxfastsub_tmp
, fw
->data
, fw
->size
);
1510 dev_err(&uinterf
->dev
,
1511 "Could not upload firmware (err=%d)\n", ret
);
1515 comedi_usb_auto_config(uinterf
, &usbduxfast_driver
);
1517 release_firmware(fw
);
1520 static int usbduxfast_usb_probe(struct usb_interface
*uinterf
,
1521 const struct usb_device_id
*id
)
1523 struct usb_device
*udev
= interface_to_usbdev(uinterf
);
1528 if (udev
->speed
!= USB_SPEED_HIGH
) {
1529 dev_err(&uinterf
->dev
,
1530 "This driver needs USB 2.0 to operate. Aborting...\n");
1533 #ifdef CONFIG_COMEDI_DEBUG
1534 printk(KERN_DEBUG
"comedi_: usbduxfast_: finding a free structure for "
1535 "the usb-device\n");
1537 down(&start_stop_sem
);
1538 /* look for a free place in the usbduxfast array */
1540 for (i
= 0; i
< NUMUSBDUXFAST
; i
++) {
1541 if (!usbduxfastsub
[i
].probed
) {
1549 dev_err(&uinterf
->dev
,
1550 "Too many usbduxfast-devices connected.\n");
1551 up(&start_stop_sem
);
1554 #ifdef CONFIG_COMEDI_DEBUG
1555 printk(KERN_DEBUG
"comedi_: usbduxfast: usbduxfastsub[%d] is ready to "
1556 "connect to comedi.\n", index
);
1559 sema_init(&(usbduxfastsub
[index
].sem
), 1);
1560 /* save a pointer to the usb device */
1561 usbduxfastsub
[index
].usbdev
= udev
;
1563 /* save the interface itself */
1564 usbduxfastsub
[index
].interface
= uinterf
;
1565 /* get the interface number from the interface */
1566 usbduxfastsub
[index
].ifnum
= uinterf
->altsetting
->desc
.bInterfaceNumber
;
1568 * hand the private data over to the usb subsystem
1569 * will be needed for disconnect
1571 usb_set_intfdata(uinterf
, &(usbduxfastsub
[index
]));
1573 #ifdef CONFIG_COMEDI_DEBUG
1574 printk(KERN_DEBUG
"comedi_: usbduxfast: ifnum=%d\n",
1575 usbduxfastsub
[index
].ifnum
);
1577 /* create space for the commands going to the usb device */
1578 usbduxfastsub
[index
].dux_commands
= kmalloc(SIZEOFDUXBUFFER
,
1580 if (!usbduxfastsub
[index
].dux_commands
) {
1581 dev_err(&uinterf
->dev
,
1582 "error alloc space for dac commands\n");
1583 tidy_up(&(usbduxfastsub
[index
]));
1584 up(&start_stop_sem
);
1587 /* create space of the instruction buffer */
1588 usbduxfastsub
[index
].insnBuffer
= kmalloc(SIZEINSNBUF
, GFP_KERNEL
);
1589 if (!usbduxfastsub
[index
].insnBuffer
) {
1590 dev_err(&uinterf
->dev
,
1591 "could not alloc space for insnBuffer\n");
1592 tidy_up(&(usbduxfastsub
[index
]));
1593 up(&start_stop_sem
);
1596 /* setting to alternate setting 1: enabling bulk ep */
1597 i
= usb_set_interface(usbduxfastsub
[index
].usbdev
,
1598 usbduxfastsub
[index
].ifnum
, 1);
1600 dev_err(&uinterf
->dev
,
1601 "usbduxfast%d: could not switch to alternate setting 1.\n",
1603 tidy_up(&(usbduxfastsub
[index
]));
1604 up(&start_stop_sem
);
1607 usbduxfastsub
[index
].urbIn
= usb_alloc_urb(0, GFP_KERNEL
);
1608 if (!usbduxfastsub
[index
].urbIn
) {
1609 dev_err(&uinterf
->dev
,
1610 "usbduxfast%d: Could not alloc. urb\n", index
);
1611 tidy_up(&(usbduxfastsub
[index
]));
1612 up(&start_stop_sem
);
1615 usbduxfastsub
[index
].transfer_buffer
= kmalloc(SIZEINBUF
, GFP_KERNEL
);
1616 if (!usbduxfastsub
[index
].transfer_buffer
) {
1617 dev_err(&uinterf
->dev
,
1618 "usbduxfast%d: could not alloc. transb.\n", index
);
1619 tidy_up(&(usbduxfastsub
[index
]));
1620 up(&start_stop_sem
);
1623 /* we've reached the bottom of the function */
1624 usbduxfastsub
[index
].probed
= 1;
1625 up(&start_stop_sem
);
1627 ret
= request_firmware_nowait(THIS_MODULE
,
1632 usbduxfastsub
+ index
,
1633 usbduxfast_firmware_request_complete_handler
);
1636 dev_err(&uinterf
->dev
, "could not load firmware (err=%d)\n", ret
);
1640 dev_info(&uinterf
->dev
,
1641 "usbduxfast%d has been successfully initialized.\n", index
);
1646 static void usbduxfast_usb_disconnect(struct usb_interface
*intf
)
1648 struct usbduxfastsub_s
*udfs
= usb_get_intfdata(intf
);
1649 struct usb_device
*udev
= interface_to_usbdev(intf
);
1652 dev_err(&intf
->dev
, "disconnect called with null pointer.\n");
1655 if (udfs
->usbdev
!= udev
) {
1656 dev_err(&intf
->dev
, "BUG! called with wrong ptr!!!\n");
1660 comedi_usb_auto_unconfig(intf
);
1662 down(&start_stop_sem
);
1666 up(&start_stop_sem
);
1668 #ifdef CONFIG_COMEDI_DEBUG
1669 printk(KERN_DEBUG
"comedi_: usbduxfast: disconnected from the usb\n");
1673 static const struct usb_device_id usbduxfast_usb_table
[] = {
1674 /* { USB_DEVICE(0x4b4, 0x8613) }, testing */
1675 { USB_DEVICE(0x13d8, 0x0010) }, /* real ID */
1676 { USB_DEVICE(0x13d8, 0x0011) }, /* real ID */
1679 MODULE_DEVICE_TABLE(usb
, usbduxfast_usb_table
);
1681 static struct usb_driver usbduxfast_usb_driver
= {
1682 #ifdef COMEDI_HAVE_USB_DRIVER_OWNER
1683 .owner
= THIS_MODULE
,
1685 .name
= "usbduxfast",
1686 .probe
= usbduxfast_usb_probe
,
1687 .disconnect
= usbduxfast_usb_disconnect
,
1688 .id_table
= usbduxfast_usb_table
,
1690 module_comedi_usb_driver(usbduxfast_driver
, usbduxfast_usb_driver
);
1692 MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
1693 MODULE_DESCRIPTION("USB-DUXfast, BerndPorr@f2s.com");
1694 MODULE_LICENSE("GPL");
1695 MODULE_FIRMWARE(FIRMWARE
);