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 #include <linux/kernel.h>
41 #include <linux/firmware.h>
42 #include <linux/module.h>
43 #include <linux/init.h>
44 #include <linux/slab.h>
45 #include <linux/input.h>
46 #include <linux/usb.h>
47 #include <linux/smp_lock.h>
48 #include <linux/fcntl.h>
49 #include <linux/compiler.h>
50 #include "comedi_fc.h"
51 #include "../comedidev.h"
54 #define DRIVER_VERSION "v1.0"
55 #define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com"
56 #define DRIVER_DESC "USB-DUXfast, BerndPorr@f2s.com"
57 #define BOARDNAME "usbduxfast"
60 * timeout for the USB-transfer
65 * constants for "firmware" upload and download
67 #define USBDUXFASTSUB_FIRMWARE 0xA0
68 #define VENDOR_DIR_IN 0xC0
69 #define VENDOR_DIR_OUT 0x40
72 * internal adresses of the 8051 processor
74 #define USBDUXFASTSUB_CPUCS 0xE600
77 * max lenghth of the transfer-buffer for software upload
82 * input endpoint number
87 * endpoint for the A/D channellist: bulk OUT
89 #define CHANNELLISTEP 4
94 #define NUMCHANNELS 32
97 * size of the waveform descriptor
102 * size of one A/D value
104 #define SIZEADIN (sizeof(int16_t))
107 * size of the input-buffer IN BYTES
109 #define SIZEINBUF 512
114 #define SIZEINSNBUF 512
117 * size of the buffer for the dux commands in bytes
119 #define SIZEOFDUXBUFFER 256
122 * number of in-URBs which receive the data: min=5
124 #define NUMOFINBUFFERSHIGH 10
127 * total number of usbduxfast devices
129 #define NUMUSBDUXFAST 16
132 * number of subdevices
134 #define N_SUBDEVICES 1
137 * analogue in subdevice
142 * min delay steps for more than one channel
143 * basically when the mux gives up ;-)
145 * steps at 30MHz in the FX2
147 #define MIN_SAMPLING_PERIOD 9
150 * max number of 1/30MHz delay steps
152 #define MAX_SAMPLING_PERIOD 500
155 * number of received packets to ignore before we start handing data
156 * over to comedi, it's quad buffering and we have to ignore 4 packets
158 #define PACKETS_TO_IGNORE 4
163 static const struct comedi_lrange range_usbduxfast_ai_range
= {
164 2, { BIP_RANGE(0.75), BIP_RANGE(0.5) }
168 * private structure of one subdevice
170 * this is the structure which holds all the data of this driver
171 * one sub device just now: A/D
173 struct usbduxfastsub_s
{
174 int attached
; /* is attached? */
175 int probed
; /* is it associated with a subdevice? */
176 struct usb_device
*usbdev
; /* pointer to the usb-device */
177 struct urb
*urbIn
; /* BULK-transfer handling: urb */
178 int8_t *transfer_buffer
;
179 int16_t *insnBuffer
; /* input buffer for single insn */
180 int ifnum
; /* interface number */
181 struct usb_interface
*interface
; /* interface structure */
182 struct comedi_device
*comedidev
; /* comedi device for the interrupt
184 short int ai_cmd_running
; /* asynchronous command is running */
185 short int ai_continous
; /* continous aquisition */
186 long int ai_sample_count
; /* number of samples to aquire */
187 uint8_t *dux_commands
; /* commands */
188 int ignore
; /* counter which ignores the first
190 struct semaphore sem
;
194 * The pointer to the private usb-data of the driver
195 * is also the private data for the comedi-device.
196 * This has to be global as the usb subsystem needs
197 * global variables. The other reason is that this
198 * structure must be there _before_ any comedi
199 * command is issued. The usb subsystem must be
200 * initialised before comedi can access it.
202 static struct usbduxfastsub_s usbduxfastsub
[NUMUSBDUXFAST
];
204 static DECLARE_MUTEX(start_stop_sem
);
207 * bulk transfers to usbduxfast
209 #define SENDADCOMMANDS 0
210 #define SENDINITEP6 1
212 static int send_dux_commands(struct usbduxfastsub_s
*udfs
, int cmd_type
)
216 udfs
->dux_commands
[0] = cmd_type
;
218 #ifdef CONFIG_COMEDI_DEBUG
219 printk(KERN_DEBUG
"comedi%d: usbduxfast: dux_commands: ",
220 udfs
->comedidev
->minor
);
221 for (tmp
= 0; tmp
< SIZEOFDUXBUFFER
; tmp
++)
222 printk(" %02x", udfs
->dux_commands
[tmp
]);
226 tmp
= usb_bulk_msg(udfs
->usbdev
,
227 usb_sndbulkpipe(udfs
->usbdev
, CHANNELLISTEP
),
228 udfs
->dux_commands
, SIZEOFDUXBUFFER
, &nsent
, 10000);
230 printk(KERN_ERR
"comedi%d: could not transmit dux_commands to"
231 "the usb-device, err=%d\n", udfs
->comedidev
->minor
, tmp
);
236 * Stops the data acquision.
237 * It should be safe to call this function from any context.
239 static int usbduxfastsub_unlink_InURBs(struct usbduxfastsub_s
*udfs
)
244 if (udfs
&& udfs
->urbIn
) {
245 udfs
->ai_cmd_running
= 0;
246 /* waits until a running transfer is over */
247 usb_kill_urb(udfs
->urbIn
);
250 #ifdef CONFIG_COMEDI_DEBUG
251 printk(KERN_DEBUG
"comedi: usbduxfast: unlinked InURB: res=%d\n", j
);
257 * This will stop a running acquisition operation.
258 * Is called from within this driver from both the
259 * interrupt context and from comedi.
261 static int usbduxfast_ai_stop(struct usbduxfastsub_s
*udfs
,
267 printk(KERN_ERR
"comedi?: usbduxfast_ai_stop: udfs=NULL!\n");
271 #ifdef CONFIG_COMEDI_DEBUG
272 printk(KERN_DEBUG
"comedi: usbduxfast_ai_stop\n");
275 udfs
->ai_cmd_running
= 0;
278 ret
= usbduxfastsub_unlink_InURBs(udfs
); /* stop aquistion */
284 * This will cancel a running acquisition operation.
285 * This is called by comedi but never from inside the driver.
287 static int usbduxfast_ai_cancel(struct comedi_device
*dev
, struct comedi_subdevice
*s
)
289 struct usbduxfastsub_s
*udfs
;
292 /* force unlink of all urbs */
293 #ifdef CONFIG_COMEDI_DEBUG
294 printk(KERN_DEBUG
"comedi: usbduxfast_ai_cancel\n");
298 printk(KERN_ERR
"comedi: usbduxfast_ai_cancel: udfs=NULL\n");
307 ret
= usbduxfast_ai_stop(udfs
, 1);
315 * interrupt service routine
317 static void usbduxfastsub_ai_Irq(struct urb
*urb PT_REGS_ARG
)
320 struct usbduxfastsub_s
*udfs
;
321 struct comedi_device
*this_comedidev
;
322 struct comedi_subdevice
*s
;
325 /* sanity checks - is the urb there? */
327 printk(KERN_ERR
"comedi_: usbduxfast_: ao int-handler called "
331 /* the context variable points to the subdevice */
332 this_comedidev
= urb
->context
;
333 if (!this_comedidev
) {
334 printk(KERN_ERR
"comedi_: usbduxfast_: urb context is a NULL "
338 /* the private structure of the subdevice is usbduxfastsub_s */
339 udfs
= this_comedidev
->private;
341 printk(KERN_ERR
"comedi_: usbduxfast_: private of comedi "
342 "subdev is a NULL pointer!\n");
345 /* are we running a command? */
346 if (unlikely(!udfs
->ai_cmd_running
)) {
348 * not running a command
349 * do not continue execution if no asynchronous command
350 * is running in particular not resubmit
355 if (unlikely(!udfs
->attached
)) {
356 /* no comedi device there */
359 /* subdevice which is the AD converter */
360 s
= this_comedidev
->subdevices
+ SUBDEV_AD
;
362 /* first we test if something unusual has just happened */
363 switch (urb
->status
) {
368 * happens after an unlink command or when the device
375 /* tell this comedi */
376 s
->async
->events
|= COMEDI_CB_EOA
;
377 s
->async
->events
|= COMEDI_CB_ERROR
;
378 comedi_event(udfs
->comedidev
, s
);
379 /* stop the transfer w/o unlink */
380 usbduxfast_ai_stop(udfs
, 0);
384 printk("comedi%d: usbduxfast: non-zero urb status received in "
385 "ai intr context: %d\n",
386 udfs
->comedidev
->minor
, urb
->status
);
387 s
->async
->events
|= COMEDI_CB_EOA
;
388 s
->async
->events
|= COMEDI_CB_ERROR
;
389 comedi_event(udfs
->comedidev
, s
);
390 usbduxfast_ai_stop(udfs
, 0);
394 p
= urb
->transfer_buffer
;
396 if (!udfs
->ai_continous
) {
397 /* not continous, fixed number of samples */
398 n
= urb
->actual_length
/ sizeof(uint16_t);
399 if (unlikely(udfs
->ai_sample_count
< n
)) {
401 * we have send only a fraction of the bytes
404 cfc_write_array_to_buffer(s
,
405 urb
->transfer_buffer
,
406 udfs
->ai_sample_count
408 usbduxfast_ai_stop(udfs
, 0);
409 /* say comedi that the acquistion is over */
410 s
->async
->events
|= COMEDI_CB_EOA
;
411 comedi_event(udfs
->comedidev
, s
);
414 udfs
->ai_sample_count
-= n
;
416 /* write the full buffer to comedi */
417 cfc_write_array_to_buffer(s
, urb
->transfer_buffer
,
420 /* tell comedi that data is there */
421 comedi_event(udfs
->comedidev
, s
);
424 /* ignore this packet */
429 * command is still running
430 * resubmit urb for BULK transfer
432 urb
->dev
= udfs
->usbdev
;
434 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
436 printk(KERN_ERR
"comedi%d: usbduxfast: urb resubm failed: %d",
437 udfs
->comedidev
->minor
, err
);
438 s
->async
->events
|= COMEDI_CB_EOA
;
439 s
->async
->events
|= COMEDI_CB_ERROR
;
440 comedi_event(udfs
->comedidev
, s
);
441 usbduxfast_ai_stop(udfs
, 0);
445 static int usbduxfastsub_start(struct usbduxfastsub_s
*udfs
)
448 unsigned char local_transfer_buffer
[16];
451 local_transfer_buffer
[0] = 0;
452 ret
= usb_control_msg(udfs
->usbdev
,
453 usb_sndctrlpipe(udfs
->usbdev
, 0),
454 USBDUXFASTSUB_FIRMWARE
, /* bRequest, "Firmware" */
455 VENDOR_DIR_OUT
, /* bmRequestType */
456 USBDUXFASTSUB_CPUCS
, /* Value */
458 local_transfer_buffer
, /* address of the transfer buffer */
460 EZTIMEOUT
); /* Timeout */
462 printk("comedi_: usbduxfast_: control msg failed (start)\n");
469 static int usbduxfastsub_stop(struct usbduxfastsub_s
*udfs
)
472 unsigned char local_transfer_buffer
[16];
475 local_transfer_buffer
[0] = 1;
476 ret
= usb_control_msg(udfs
->usbdev
,
477 usb_sndctrlpipe(udfs
->usbdev
, 0),
478 USBDUXFASTSUB_FIRMWARE
, /* bRequest, "Firmware" */
479 VENDOR_DIR_OUT
, /* bmRequestType */
480 USBDUXFASTSUB_CPUCS
, /* Value */
482 local_transfer_buffer
,
484 EZTIMEOUT
); /* Timeout */
486 printk(KERN_ERR
"comedi_: usbduxfast: control msg failed "
494 static int usbduxfastsub_upload(struct usbduxfastsub_s
*udfs
,
495 unsigned char *local_transfer_buffer
,
496 unsigned int startAddr
, unsigned int len
)
500 #ifdef CONFIG_COMEDI_DEBUG
501 printk(KERN_DEBUG
"comedi: usbduxfast: uploading %d bytes", len
);
502 printk(KERN_DEBUG
" to addr %d, first byte=%d.\n",
503 startAddr
, local_transfer_buffer
[0]);
505 ret
= usb_control_msg(udfs
->usbdev
,
506 usb_sndctrlpipe(udfs
->usbdev
, 0),
507 USBDUXFASTSUB_FIRMWARE
, /* brequest, firmware */
508 VENDOR_DIR_OUT
, /* bmRequestType */
509 startAddr
, /* value */
511 local_transfer_buffer
, /* our local safe buffer */
513 EZTIMEOUT
); /* timeout */
515 #ifdef CONFIG_COMEDI_DEBUG
516 printk(KERN_DEBUG
"comedi_: usbduxfast: result=%d\n", ret
);
520 printk(KERN_ERR
"comedi_: usbduxfast: uppload failed\n");
527 int firmwareUpload(struct usbduxfastsub_s
*udfs
, unsigned char *firmwareBinary
,
535 ret
= usbduxfastsub_stop(udfs
);
537 printk(KERN_ERR
"comedi_: usbduxfast: can not stop firmware\n");
540 ret
= usbduxfastsub_upload(udfs
, firmwareBinary
, 0, sizeFirmware
);
542 printk(KERN_ERR
"comedi_: usbduxfast: firmware upload failed\n");
545 ret
= usbduxfastsub_start(udfs
);
547 printk(KERN_ERR
"comedi_: usbduxfast: can not start firmware\n");
554 int usbduxfastsub_submit_InURBs(struct usbduxfastsub_s
*udfs
)
561 usb_fill_bulk_urb(udfs
->urbIn
, udfs
->usbdev
,
562 usb_rcvbulkpipe(udfs
->usbdev
, BULKINEP
),
563 udfs
->transfer_buffer
,
564 SIZEINBUF
, usbduxfastsub_ai_Irq
, udfs
->comedidev
);
566 #ifdef CONFIG_COMEDI_DEBUG
567 printk(KERN_DEBUG
"comedi%d: usbduxfast: submitting in-urb: "
568 "0x%p,0x%p\n", udfs
->comedidev
->minor
, udfs
->urbIn
->context
,
571 ret
= usb_submit_urb(udfs
->urbIn
, GFP_ATOMIC
);
573 printk(KERN_ERR
"comedi_: usbduxfast: ai: usb_submit_urb error"
580 static int usbduxfast_ai_cmdtest(struct comedi_device
*dev
,
581 struct comedi_subdevice
*s
, struct comedi_cmd
*cmd
)
583 int err
= 0, stop_mask
= 0;
586 struct usbduxfastsub_s
*udfs
= dev
->private;
591 #ifdef CONFIG_COMEDI_DEBUG
592 printk(KERN_DEBUG
"comedi%d: usbduxfast_ai_cmdtest\n", dev
->minor
);
593 printk(KERN_DEBUG
"comedi%d: usbduxfast: convert_arg=%u "
594 "scan_begin_arg=%u\n",
595 dev
->minor
, cmd
->convert_arg
, cmd
->scan_begin_arg
);
597 /* step 1: make sure trigger sources are trivially valid */
599 tmp
= cmd
->start_src
;
600 cmd
->start_src
&= TRIG_NOW
| TRIG_EXT
| TRIG_INT
;
601 if (!cmd
->start_src
|| tmp
!= cmd
->start_src
)
604 tmp
= cmd
->scan_begin_src
;
605 cmd
->scan_begin_src
&= TRIG_TIMER
| TRIG_FOLLOW
| TRIG_EXT
;
606 if (!cmd
->scan_begin_src
|| tmp
!= cmd
->scan_begin_src
)
609 tmp
= cmd
->convert_src
;
610 cmd
->convert_src
&= TRIG_TIMER
| TRIG_EXT
;
611 if (!cmd
->convert_src
|| tmp
!= cmd
->convert_src
)
614 tmp
= cmd
->scan_end_src
;
615 cmd
->scan_end_src
&= TRIG_COUNT
;
616 if (!cmd
->scan_end_src
|| tmp
!= cmd
->scan_end_src
)
620 stop_mask
= TRIG_COUNT
| TRIG_NONE
;
621 cmd
->stop_src
&= stop_mask
;
622 if (!cmd
->stop_src
|| tmp
!= cmd
->stop_src
)
629 * step 2: make sure trigger sources are unique and mutually compatible
632 if (cmd
->start_src
!= TRIG_NOW
&&
633 cmd
->start_src
!= TRIG_EXT
&& cmd
->start_src
!= TRIG_INT
)
635 if (cmd
->scan_begin_src
!= TRIG_TIMER
&&
636 cmd
->scan_begin_src
!= TRIG_FOLLOW
&&
637 cmd
->scan_begin_src
!= TRIG_EXT
)
639 if (cmd
->convert_src
!= TRIG_TIMER
&& cmd
->convert_src
!= TRIG_EXT
)
641 if (cmd
->stop_src
!= TRIG_COUNT
&&
642 cmd
->stop_src
!= TRIG_EXT
&& cmd
->stop_src
!= TRIG_NONE
)
645 /* can't have external stop and start triggers at once */
646 if (cmd
->start_src
== TRIG_EXT
&& cmd
->stop_src
== TRIG_EXT
)
652 /* step 3: make sure arguments are trivially compatible */
654 if (cmd
->start_src
== TRIG_NOW
&& cmd
->start_arg
!= 0) {
659 if (!cmd
->chanlist_len
)
662 if (cmd
->scan_end_arg
!= cmd
->chanlist_len
) {
663 cmd
->scan_end_arg
= cmd
->chanlist_len
;
667 if (cmd
->chanlist_len
== 1)
670 minSamplPer
= MIN_SAMPLING_PERIOD
;
672 if (cmd
->convert_src
== TRIG_TIMER
) {
673 steps
= cmd
->convert_arg
* 30;
674 if (steps
< (minSamplPer
* 1000))
675 steps
= minSamplPer
* 1000;
677 if (steps
> (MAX_SAMPLING_PERIOD
* 1000))
678 steps
= MAX_SAMPLING_PERIOD
* 1000;
682 if (cmd
->convert_arg
!= tmp
) {
683 cmd
->convert_arg
= tmp
;
688 if (cmd
->scan_begin_src
== TRIG_TIMER
)
692 switch (cmd
->stop_src
) {
694 if (!cmd
->stop_arg
) {
700 if (cmd
->stop_arg
!= 0) {
706 * TRIG_EXT doesn't care since it doesn't trigger
707 * off a numbered channel
716 /* step 4: fix up any arguments */
722 static int usbduxfast_ai_inttrig(struct comedi_device
*dev
,
723 struct comedi_subdevice
*s
, unsigned int trignum
)
726 struct usbduxfastsub_s
*udfs
= dev
->private;
736 #ifdef CONFIG_COMEDI_DEBUG
737 printk(KERN_DEBUG
"comedi%d: usbduxfast_ai_inttrig\n", dev
->minor
);
741 printk(KERN_ERR
"comedi%d: usbduxfast_ai_inttrig: invalid"
742 " trignum\n", dev
->minor
);
746 if (!udfs
->ai_cmd_running
) {
747 udfs
->ai_cmd_running
= 1;
748 ret
= usbduxfastsub_submit_InURBs(udfs
);
750 printk(KERN_ERR
"comedi%d: usbduxfast_ai_inttrig: "
751 "urbSubmit: err=%d\n", dev
->minor
, ret
);
752 udfs
->ai_cmd_running
= 0;
756 s
->async
->inttrig
= NULL
;
758 printk(KERN_ERR
"comedi%d: ai_inttrig but acqu is already"
759 " running\n", dev
->minor
);
766 * offsets for the GPIF bytes
767 * the first byte is the command byte
769 #define LENBASE (1+0x00)
770 #define OPBASE (1+0x08)
771 #define OUTBASE (1+0x10)
772 #define LOGBASE (1+0x18)
774 static int usbduxfast_ai_cmd(struct comedi_device
*dev
, struct comedi_subdevice
*s
)
776 struct comedi_cmd
*cmd
= &s
->async
->cmd
;
777 unsigned int chan
, gain
, rngmask
= 0xff;
779 struct usbduxfastsub_s
*udfs
;
781 long steps
, steps_tmp
;
783 #ifdef CONFIG_COMEDI_DEBUG
784 printk(KERN_DEBUG
"comedi%d: usbduxfast_ai_cmd\n", dev
->minor
);
795 if (udfs
->ai_cmd_running
) {
796 printk(KERN_ERR
"comedi%d: ai_cmd not possible. Another ai_cmd"
797 " is running.\n", dev
->minor
);
801 /* set current channel of the running aquisition to zero */
802 s
->async
->cur_chan
= 0;
805 * ignore the first buffers from the device if there
806 * is an error condition
808 udfs
->ignore
= PACKETS_TO_IGNORE
;
810 if (cmd
->chanlist_len
> 0) {
811 gain
= CR_RANGE(cmd
->chanlist
[0]);
812 for (i
= 0; i
< cmd
->chanlist_len
; ++i
) {
813 chan
= CR_CHAN(cmd
->chanlist
[i
]);
815 printk(KERN_ERR
"comedi%d: cmd is accepting "
816 "only consecutive channels.\n",
821 if ((gain
!= CR_RANGE(cmd
->chanlist
[i
]))
822 && (cmd
->chanlist_len
> 3)) {
823 printk(KERN_ERR
"comedi%d: the gain must be"
824 " the same for all channels.\n",
829 if (i
>= NUMCHANNELS
) {
830 printk(KERN_ERR
"comedi%d: channel list too"
831 " long\n", dev
->minor
);
837 if (cmd
->scan_begin_src
== TRIG_TIMER
) {
838 printk(KERN_ERR
"comedi%d: usbduxfast: "
839 "scan_begin_src==TRIG_TIMER not valid.\n", dev
->minor
);
843 if (cmd
->convert_src
== TRIG_TIMER
)
844 steps
= (cmd
->convert_arg
* 30) / 1000;
846 if ((steps
< MIN_SAMPLING_PERIOD
) && (cmd
->chanlist_len
!= 1)) {
847 printk(KERN_ERR
"comedi%d: usbduxfast: ai_cmd: steps=%ld, "
848 "scan_begin_arg=%d. Not properly tested by cmdtest?\n",
849 dev
->minor
, steps
, cmd
->scan_begin_arg
);
853 if (steps
> MAX_SAMPLING_PERIOD
) {
854 printk(KERN_ERR
"comedi%d: usbduxfast: ai_cmd: sampling rate "
855 "too low.\n", dev
->minor
);
859 if ((cmd
->start_src
== TRIG_EXT
) && (cmd
->chanlist_len
!= 1)
860 && (cmd
->chanlist_len
!= 16)) {
861 printk(KERN_ERR
"comedi%d: usbduxfast: ai_cmd: TRIG_EXT only"
862 " with 1 or 16 channels possible.\n", dev
->minor
);
866 #ifdef CONFIG_COMEDI_DEBUG
867 printk(KERN_DEBUG
"comedi%d: usbduxfast: steps=%ld, convert_arg=%u\n",
868 dev
->minor
, steps
, cmd
->convert_arg
);
871 switch (cmd
->chanlist_len
) {
877 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
878 rngmask
= 0xff - 0x04;
883 * for external trigger: looping in this state until
884 * the RDY0 pin becomes zero
887 /* we loop here until ready has been set */
888 if (cmd
->start_src
== TRIG_EXT
) {
889 /* branch back to state 0 */
890 udfs
->dux_commands
[LENBASE
+0] = 0x01;
891 /* deceision state w/o data */
892 udfs
->dux_commands
[OPBASE
+0] = 0x01;
893 udfs
->dux_commands
[OUTBASE
+0] = 0xFF & rngmask
;
895 udfs
->dux_commands
[LOGBASE
+0] = 0x00;
896 } else { /* we just proceed to state 1 */
897 udfs
->dux_commands
[LENBASE
+0] = 1;
898 udfs
->dux_commands
[OPBASE
+0] = 0;
899 udfs
->dux_commands
[OUTBASE
+0] = 0xFF & rngmask
;
900 udfs
->dux_commands
[LOGBASE
+0] = 0;
903 if (steps
< MIN_SAMPLING_PERIOD
) {
904 /* for fast single channel aqu without mux */
907 * we just stay here at state 1 and rexecute
908 * the same state this gives us 30MHz sampling
912 /* branch back to state 1 */
913 udfs
->dux_commands
[LENBASE
+1] = 0x89;
914 /* deceision state with data */
915 udfs
->dux_commands
[OPBASE
+1] = 0x03;
916 udfs
->dux_commands
[OUTBASE
+1] = 0xFF & rngmask
;
918 udfs
->dux_commands
[LOGBASE
+1] = 0xFF;
921 * we loop through two states: data and delay
924 udfs
->dux_commands
[LENBASE
+1] = steps
- 1;
926 udfs
->dux_commands
[OPBASE
+1] = 0x02;
927 udfs
->dux_commands
[OUTBASE
+1] = 0xFF & rngmask
;
929 udfs
->dux_commands
[LOGBASE
+1] = 0;
930 /* branch back to state 1 */
931 udfs
->dux_commands
[LENBASE
+2] = 0x09;
932 /* deceision state w/o data */
933 udfs
->dux_commands
[OPBASE
+2] = 0x01;
934 udfs
->dux_commands
[OUTBASE
+2] = 0xFF & rngmask
;
936 udfs
->dux_commands
[LOGBASE
+2] = 0xFF;
940 * we loop through 3 states: 2x delay and 1x data
941 * this gives a min sampling rate of 60kHz
944 /* we have 1 state with duration 1 */
947 /* do the first part of the delay */
948 udfs
->dux_commands
[LENBASE
+1] = steps
/ 2;
949 udfs
->dux_commands
[OPBASE
+1] = 0;
950 udfs
->dux_commands
[OUTBASE
+1] = 0xFF & rngmask
;
951 udfs
->dux_commands
[LOGBASE
+1] = 0;
953 /* and the second part */
954 udfs
->dux_commands
[LENBASE
+2] = steps
- steps
/ 2;
955 udfs
->dux_commands
[OPBASE
+2] = 0;
956 udfs
->dux_commands
[OUTBASE
+2] = 0xFF & rngmask
;
957 udfs
->dux_commands
[LOGBASE
+2] = 0;
959 /* get the data and branch back */
961 /* branch back to state 1 */
962 udfs
->dux_commands
[LENBASE
+3] = 0x09;
963 /* deceision state w data */
964 udfs
->dux_commands
[OPBASE
+3] = 0x03;
965 udfs
->dux_commands
[OUTBASE
+3] = 0xFF & rngmask
;
967 udfs
->dux_commands
[LOGBASE
+3] = 0xFF;
974 * commit data to the FIFO
977 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
978 rngmask
= 0xff - 0x04;
982 udfs
->dux_commands
[LENBASE
+0] = 1;
984 udfs
->dux_commands
[OPBASE
+0] = 0x02;
985 udfs
->dux_commands
[OUTBASE
+0] = 0xFF & rngmask
;
986 udfs
->dux_commands
[LOGBASE
+0] = 0;
988 /* we have 1 state with duration 1: state 0 */
989 steps_tmp
= steps
- 1;
991 if (CR_RANGE(cmd
->chanlist
[1]) > 0)
992 rngmask
= 0xff - 0x04;
996 /* do the first part of the delay */
997 udfs
->dux_commands
[LENBASE
+1] = steps_tmp
/ 2;
998 udfs
->dux_commands
[OPBASE
+1] = 0;
1000 udfs
->dux_commands
[OUTBASE
+1] = 0xFE & rngmask
;
1001 udfs
->dux_commands
[LOGBASE
+1] = 0;
1003 /* and the second part */
1004 udfs
->dux_commands
[LENBASE
+2] = steps_tmp
- steps_tmp
/ 2;
1005 udfs
->dux_commands
[OPBASE
+2] = 0;
1006 udfs
->dux_commands
[OUTBASE
+2] = 0xFF & rngmask
;
1007 udfs
->dux_commands
[LOGBASE
+2] = 0;
1009 udfs
->dux_commands
[LENBASE
+3] = 1;
1011 udfs
->dux_commands
[OPBASE
+3] = 0x02;
1012 udfs
->dux_commands
[OUTBASE
+3] = 0xFF & rngmask
;
1013 udfs
->dux_commands
[LOGBASE
+3] = 0;
1016 * we have 2 states with duration 1: step 6 and
1019 steps_tmp
= steps
- 2;
1021 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
1022 rngmask
= 0xff - 0x04;
1026 /* do the first part of the delay */
1027 udfs
->dux_commands
[LENBASE
+4] = steps_tmp
/ 2;
1028 udfs
->dux_commands
[OPBASE
+4] = 0;
1030 udfs
->dux_commands
[OUTBASE
+4] = (0xFF - 0x02) & rngmask
;
1031 udfs
->dux_commands
[LOGBASE
+4] = 0;
1033 /* and the second part */
1034 udfs
->dux_commands
[LENBASE
+5] = steps_tmp
- steps_tmp
/ 2;
1035 udfs
->dux_commands
[OPBASE
+5] = 0;
1036 udfs
->dux_commands
[OUTBASE
+5] = 0xFF & rngmask
;
1037 udfs
->dux_commands
[LOGBASE
+5] = 0;
1039 udfs
->dux_commands
[LENBASE
+6] = 1;
1040 udfs
->dux_commands
[OPBASE
+6] = 0;
1041 udfs
->dux_commands
[OUTBASE
+6] = 0xFF & rngmask
;
1042 udfs
->dux_commands
[LOGBASE
+6] = 0;
1049 for (j
= 0; j
< 1; j
++) {
1050 if (CR_RANGE(cmd
->chanlist
[j
]) > 0)
1051 rngmask
= 0xff - 0x04;
1055 * commit data to the FIFO and do the first part
1058 udfs
->dux_commands
[LENBASE
+j
*2] = steps
/ 2;
1060 udfs
->dux_commands
[OPBASE
+j
*2] = 0x02;
1062 udfs
->dux_commands
[OUTBASE
+j
*2] = 0xFF & rngmask
;
1063 udfs
->dux_commands
[LOGBASE
+j
*2] = 0;
1065 if (CR_RANGE(cmd
->chanlist
[j
+ 1]) > 0)
1066 rngmask
= 0xff - 0x04;
1070 /* do the second part of the delay */
1071 udfs
->dux_commands
[LENBASE
+j
*2+1] = steps
- steps
/ 2;
1073 udfs
->dux_commands
[OPBASE
+j
*2+1] = 0;
1075 udfs
->dux_commands
[OUTBASE
+j
*2+1] = 0xFE & rngmask
;
1076 udfs
->dux_commands
[LOGBASE
+j
*2+1] = 0;
1079 /* 2 steps with duration 1: the idele step and step 6: */
1080 steps_tmp
= steps
- 2;
1082 /* commit data to the FIFO and do the first part of the delay */
1083 udfs
->dux_commands
[LENBASE
+4] = steps_tmp
/ 2;
1085 udfs
->dux_commands
[OPBASE
+4] = 0x02;
1086 udfs
->dux_commands
[OUTBASE
+4] = 0xFF & rngmask
;
1087 udfs
->dux_commands
[LOGBASE
+4] = 0;
1089 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
1090 rngmask
= 0xff - 0x04;
1094 /* do the second part of the delay */
1095 udfs
->dux_commands
[LENBASE
+5] = steps_tmp
- steps_tmp
/ 2;
1097 udfs
->dux_commands
[OPBASE
+5] = 0;
1099 udfs
->dux_commands
[OUTBASE
+5] = (0xFF - 0x02) & rngmask
;
1100 udfs
->dux_commands
[LOGBASE
+5] = 0;
1102 udfs
->dux_commands
[LENBASE
+6] = 1;
1103 udfs
->dux_commands
[OPBASE
+6] = 0;
1104 udfs
->dux_commands
[OUTBASE
+6] = 0xFF & rngmask
;
1105 udfs
->dux_commands
[LOGBASE
+6] = 0;
1108 if (CR_RANGE(cmd
->chanlist
[0]) > 0)
1109 rngmask
= 0xff - 0x04;
1113 if (cmd
->start_src
== TRIG_EXT
) {
1115 * we loop here until ready has been set
1118 /* branch back to state 0 */
1119 udfs
->dux_commands
[LENBASE
+0] = 0x01;
1120 /* deceision state w/o data */
1121 udfs
->dux_commands
[OPBASE
+0] = 0x01;
1123 udfs
->dux_commands
[OUTBASE
+0] = (0xFF-0x02) & rngmask
;
1125 udfs
->dux_commands
[LOGBASE
+0] = 0x00;
1128 * we just proceed to state 1
1131 /* 30us reset pulse */
1132 udfs
->dux_commands
[LENBASE
+0] = 255;
1133 udfs
->dux_commands
[OPBASE
+0] = 0;
1135 udfs
->dux_commands
[OUTBASE
+0] = (0xFF-0x02) & rngmask
;
1136 udfs
->dux_commands
[LOGBASE
+0] = 0;
1139 /* commit data to the FIFO */
1140 udfs
->dux_commands
[LENBASE
+1] = 1;
1142 udfs
->dux_commands
[OPBASE
+1] = 0x02;
1143 udfs
->dux_commands
[OUTBASE
+1] = 0xFF & rngmask
;
1144 udfs
->dux_commands
[LOGBASE
+1] = 0;
1146 /* we have 2 states with duration 1 */
1149 /* do the first part of the delay */
1150 udfs
->dux_commands
[LENBASE
+2] = steps
/ 2;
1151 udfs
->dux_commands
[OPBASE
+2] = 0;
1152 udfs
->dux_commands
[OUTBASE
+2] = 0xFE & rngmask
;
1153 udfs
->dux_commands
[LOGBASE
+2] = 0;
1155 /* and the second part */
1156 udfs
->dux_commands
[LENBASE
+3] = steps
- steps
/ 2;
1157 udfs
->dux_commands
[OPBASE
+3] = 0;
1158 udfs
->dux_commands
[OUTBASE
+3] = 0xFF & rngmask
;
1159 udfs
->dux_commands
[LOGBASE
+3] = 0;
1161 /* branch back to state 1 */
1162 udfs
->dux_commands
[LENBASE
+4] = 0x09;
1163 /* deceision state w/o data */
1164 udfs
->dux_commands
[OPBASE
+4] = 0x01;
1165 udfs
->dux_commands
[OUTBASE
+4] = 0xFF & rngmask
;
1166 /* doesn't matter */
1167 udfs
->dux_commands
[LOGBASE
+4] = 0xFF;
1172 printk(KERN_ERR
"comedi %d: unsupported combination of "
1173 "channels\n", dev
->minor
);
1178 #ifdef CONFIG_COMEDI_DEBUG
1179 printk(KERN_DEBUG
"comedi %d: sending commands to the usb device\n",
1182 /* 0 means that the AD commands are sent */
1183 result
= send_dux_commands(udfs
, SENDADCOMMANDS
);
1185 printk(KERN_ERR
"comedi%d: adc command could not be submitted."
1186 "Aborting...\n", dev
->minor
);
1190 if (cmd
->stop_src
== TRIG_COUNT
) {
1191 udfs
->ai_sample_count
= cmd
->stop_arg
* cmd
->scan_end_arg
;
1192 if (udfs
->ai_sample_count
< 1) {
1193 printk(KERN_ERR
"comedi%d: "
1194 "(cmd->stop_arg)*(cmd->scan_end_arg)<1, "
1195 "aborting.\n", dev
->minor
);
1199 udfs
->ai_continous
= 0;
1201 /* continous aquisition */
1202 udfs
->ai_continous
= 1;
1203 udfs
->ai_sample_count
= 0;
1206 if ((cmd
->start_src
== TRIG_NOW
) || (cmd
->start_src
== TRIG_EXT
)) {
1207 /* enable this acquisition operation */
1208 udfs
->ai_cmd_running
= 1;
1209 ret
= usbduxfastsub_submit_InURBs(udfs
);
1211 udfs
->ai_cmd_running
= 0;
1212 /* fixme: unlink here?? */
1216 s
->async
->inttrig
= NULL
;
1220 * don't enable the acquision operation
1221 * wait for an internal signal
1223 s
->async
->inttrig
= usbduxfast_ai_inttrig
;
1231 * Mode 0 is used to get a single conversion on demand.
1233 static int usbduxfast_ai_insn_read(struct comedi_device
*dev
,
1234 struct comedi_subdevice
*s
, struct comedi_insn
*insn
, unsigned int *data
)
1236 int i
, j
, n
, actual_length
;
1237 int chan
, range
, rngmask
;
1239 struct usbduxfastsub_s
*udfs
;
1241 udfs
= dev
->private;
1243 printk(KERN_ERR
"comedi%d: ai_insn_read: no usb dev.\n",
1247 #ifdef CONFIG_COMEDI_DEBUG
1248 printk(KERN_DEBUG
"comedi%d: ai_insn_read, insn->n=%d, "
1249 "insn->subdev=%d\n", dev
->minor
, insn
->n
, insn
->subdev
);
1252 if (!udfs
->probed
) {
1256 if (udfs
->ai_cmd_running
) {
1257 printk(KERN_ERR
"comedi%d: ai_insn_read not possible. Async "
1258 "Command is running.\n", dev
->minor
);
1262 /* sample one channel */
1263 chan
= CR_CHAN(insn
->chanspec
);
1264 range
= CR_RANGE(insn
->chanspec
);
1265 /* set command for the first channel */
1268 rngmask
= 0xff - 0x04;
1272 /* commit data to the FIFO */
1273 udfs
->dux_commands
[LENBASE
+0] = 1;
1275 udfs
->dux_commands
[OPBASE
+0] = 0x02;
1276 udfs
->dux_commands
[OUTBASE
+0] = 0xFF & rngmask
;
1277 udfs
->dux_commands
[LOGBASE
+0] = 0;
1279 /* do the first part of the delay */
1280 udfs
->dux_commands
[LENBASE
+1] = 12;
1281 udfs
->dux_commands
[OPBASE
+1] = 0;
1282 udfs
->dux_commands
[OUTBASE
+1] = 0xFE & rngmask
;
1283 udfs
->dux_commands
[LOGBASE
+1] = 0;
1285 udfs
->dux_commands
[LENBASE
+2] = 1;
1286 udfs
->dux_commands
[OPBASE
+2] = 0;
1287 udfs
->dux_commands
[OUTBASE
+2] = 0xFE & rngmask
;
1288 udfs
->dux_commands
[LOGBASE
+2] = 0;
1290 udfs
->dux_commands
[LENBASE
+3] = 1;
1291 udfs
->dux_commands
[OPBASE
+3] = 0;
1292 udfs
->dux_commands
[OUTBASE
+3] = 0xFE & rngmask
;
1293 udfs
->dux_commands
[LOGBASE
+3] = 0;
1295 udfs
->dux_commands
[LENBASE
+4] = 1;
1296 udfs
->dux_commands
[OPBASE
+4] = 0;
1297 udfs
->dux_commands
[OUTBASE
+4] = 0xFE & rngmask
;
1298 udfs
->dux_commands
[LOGBASE
+4] = 0;
1301 udfs
->dux_commands
[LENBASE
+5] = 12;
1302 udfs
->dux_commands
[OPBASE
+5] = 0;
1303 udfs
->dux_commands
[OUTBASE
+5] = 0xFF & rngmask
;
1304 udfs
->dux_commands
[LOGBASE
+5] = 0;
1306 udfs
->dux_commands
[LENBASE
+6] = 1;
1307 udfs
->dux_commands
[OPBASE
+6] = 0;
1308 udfs
->dux_commands
[OUTBASE
+6] = 0xFF & rngmask
;
1309 udfs
->dux_commands
[LOGBASE
+0] = 0;
1311 #ifdef CONFIG_COMEDI_DEBUG
1312 printk(KERN_DEBUG
"comedi %d: sending commands to the usb device\n",
1315 /* 0 means that the AD commands are sent */
1316 err
= send_dux_commands(udfs
, SENDADCOMMANDS
);
1318 printk(KERN_ERR
"comedi%d: adc command could not be submitted."
1319 "Aborting...\n", dev
->minor
);
1323 #ifdef CONFIG_COMEDI_DEBUG
1324 printk(KERN_DEBUG
"comedi%d: usbduxfast: submitting in-urb: "
1325 "0x%p,0x%p\n", udfs
->comedidev
->minor
, udfs
->urbIn
->context
,
1328 for (i
= 0; i
< PACKETS_TO_IGNORE
; i
++) {
1329 err
= usb_bulk_msg(udfs
->usbdev
,
1330 usb_rcvbulkpipe(udfs
->usbdev
, BULKINEP
),
1331 udfs
->transfer_buffer
, SIZEINBUF
,
1332 &actual_length
, 10000);
1334 printk(KERN_ERR
"comedi%d: insn timeout. No data.\n",
1341 for (i
= 0; i
< insn
->n
;) {
1342 err
= usb_bulk_msg(udfs
->usbdev
,
1343 usb_rcvbulkpipe(udfs
->usbdev
, BULKINEP
),
1344 udfs
->transfer_buffer
, SIZEINBUF
,
1345 &actual_length
, 10000);
1347 printk(KERN_ERR
"comedi%d: insn data error: %d\n",
1352 n
= actual_length
/ sizeof(uint16_t);
1353 if ((n
% 16) != 0) {
1354 printk(KERN_ERR
"comedi%d: insn data packet "
1355 "corrupted.\n", dev
->minor
);
1359 for (j
= chan
; (j
< n
) && (i
< insn
->n
); j
= j
+ 16) {
1360 data
[i
] = ((uint16_t *) (udfs
->transfer_buffer
))[j
];
1368 static unsigned hex2unsigned(char *h
)
1373 hi
= h
[0] - 'A' + 0x0a;
1378 lo
= h
[1] - 'A' + 0x0a;
1382 return hi
* 0x10 + lo
;
1386 #define FIRMWARE_MAX_LEN 0x2000
1389 * taken from David Brownell's fxload and adjusted for this driver
1391 static int read_firmware(struct usbduxfastsub_s
*udfs
, const void *firmwarePtr
,
1395 unsigned char *fp
= (char *)firmwarePtr
;
1396 unsigned char *firmwareBinary
;
1400 firmwareBinary
= kmalloc(FIRMWARE_MAX_LEN
, GFP_KERNEL
);
1401 if (!firmwareBinary
) {
1402 printk(KERN_ERR
"comedi_: usbduxfast: mem alloc for firmware "
1415 while ((i
< size
) && (fp
[i
] != 13) && (fp
[i
] != 10)) {
1419 if (j
>= sizeof(buf
)) {
1420 printk(KERN_ERR
"comedi_: usbduxfast: bogus "
1421 "firmware file!\n");
1422 kfree(firmwareBinary
);
1426 /* get rid of LF/CR/... */
1427 while ((i
< size
) && ((fp
[i
] == 13) || (fp
[i
] == 10)
1432 /* printk("comedi_: buf=%s\n",buf); */
1435 * EXTENSION: "# comment-till-end-of-line",
1436 * for copyrights etc
1441 if (buf
[0] != ':') {
1442 printk(KERN_ERR
"comedi_: usbduxfast: upload: not an "
1443 "ihex record: %s", buf
);
1444 kfree(firmwareBinary
);
1448 /* Read the length field (up to 16 bytes) */
1449 len
= hex2unsigned(buf
+ 1);
1451 /* Read the target offset */
1452 off
= (hex2unsigned(buf
+ 3) * 0x0100) + hex2unsigned(buf
+ 5);
1454 if ((off
+ len
) > maxAddr
)
1455 maxAddr
= off
+ len
;
1457 if (maxAddr
>= FIRMWARE_MAX_LEN
) {
1458 printk(KERN_ERR
"comedi_: usbduxfast: firmware upload "
1459 "goes beyond FX2 RAM boundaries.");
1460 kfree(firmwareBinary
);
1463 /* printk("comedi_: usbduxfast: off=%x, len=%x:",off,len); */
1465 /* Read the record type */
1466 type
= hex2unsigned(buf
+ 7);
1468 /* If this is an EOF record, then make it so. */
1473 printk(KERN_ERR
"comedi_: usbduxfast: unsupported "
1474 "record type: %u\n", type
);
1475 kfree(firmwareBinary
);
1479 for (idx
= 0, cp
= buf
+ 9; idx
< len
; idx
+= 1, cp
+= 2) {
1480 firmwareBinary
[idx
+ off
] = hex2unsigned(cp
);
1481 /* printk("%02x ",firmwareBinary[idx+off]); */
1487 printk(KERN_ERR
"comedi_: usbduxfast: unexpected end "
1493 res
= firmwareUpload(udfs
, firmwareBinary
, maxAddr
+ 1);
1494 kfree(firmwareBinary
);
1498 static void tidy_up(struct usbduxfastsub_s
*udfs
)
1500 #ifdef CONFIG_COMEDI_DEBUG
1501 printk(KERN_DEBUG
"comedi_: usbduxfast: tiding up\n");
1507 /* shows the usb subsystem that the driver is down */
1508 if (udfs
->interface
)
1509 usb_set_intfdata(udfs
->interface
, NULL
);
1514 /* waits until a running transfer is over */
1515 usb_kill_urb(udfs
->urbIn
);
1517 kfree(udfs
->transfer_buffer
);
1518 udfs
->transfer_buffer
= NULL
;
1520 usb_free_urb(udfs
->urbIn
);
1524 kfree(udfs
->insnBuffer
);
1525 udfs
->insnBuffer
= NULL
;
1527 kfree(udfs
->dux_commands
);
1528 udfs
->dux_commands
= NULL
;
1530 udfs
->ai_cmd_running
= 0;
1533 static void usbduxfast_firmware_request_complete_handler(const struct firmware
*fw
,
1536 struct usbduxfastsub_s
*usbduxfastsub_tmp
= context
;
1537 struct usb_device
*usbdev
= usbduxfastsub_tmp
->usbdev
;
1544 * we need to upload the firmware here because fw will be
1545 * freed once we've left this function
1547 ret
= read_firmware(usbduxfastsub_tmp
, fw
->data
, fw
->size
);
1550 dev_err(&usbdev
->dev
,
1551 "Could not upload firmware (err=%d)\n",
1556 comedi_usb_auto_config(usbdev
, BOARDNAME
);
1560 * allocate memory for the urbs and initialise them
1562 static int usbduxfastsub_probe(struct usb_interface
*uinterf
,
1563 const struct usb_device_id
*id
)
1565 struct usb_device
*udev
= interface_to_usbdev(uinterf
);
1570 if (udev
->speed
!= USB_SPEED_HIGH
) {
1571 printk(KERN_ERR
"comedi_: usbduxfast_: This driver needs"
1572 "USB 2.0 to operate. Aborting...\n");
1575 #ifdef CONFIG_COMEDI_DEBUG
1576 printk(KERN_DEBUG
"comedi_: usbduxfast_: finding a free structure for "
1577 "the usb-device\n");
1579 down(&start_stop_sem
);
1580 /* look for a free place in the usbduxfast array */
1582 for (i
= 0; i
< NUMUSBDUXFAST
; i
++) {
1583 if (!usbduxfastsub
[i
].probed
) {
1591 printk(KERN_ERR
"Too many usbduxfast-devices connected.\n");
1592 up(&start_stop_sem
);
1595 #ifdef CONFIG_COMEDI_DEBUG
1596 printk(KERN_DEBUG
"comedi_: usbduxfast: usbduxfastsub[%d] is ready to "
1597 "connect to comedi.\n", index
);
1600 init_MUTEX(&(usbduxfastsub
[index
].sem
));
1601 /* save a pointer to the usb device */
1602 usbduxfastsub
[index
].usbdev
= udev
;
1604 /* save the interface itself */
1605 usbduxfastsub
[index
].interface
= uinterf
;
1606 /* get the interface number from the interface */
1607 usbduxfastsub
[index
].ifnum
= uinterf
->altsetting
->desc
.bInterfaceNumber
;
1609 * hand the private data over to the usb subsystem
1610 * will be needed for disconnect
1612 usb_set_intfdata(uinterf
, &(usbduxfastsub
[index
]));
1614 #ifdef CONFIG_COMEDI_DEBUG
1615 printk(KERN_DEBUG
"comedi_: usbduxfast: ifnum=%d\n",
1616 usbduxfastsub
[index
].ifnum
);
1618 /* create space for the commands going to the usb device */
1619 usbduxfastsub
[index
].dux_commands
= kmalloc(SIZEOFDUXBUFFER
,
1621 if (!usbduxfastsub
[index
].dux_commands
) {
1622 printk(KERN_ERR
"comedi_: usbduxfast: error alloc space for "
1624 tidy_up(&(usbduxfastsub
[index
]));
1625 up(&start_stop_sem
);
1628 /* create space of the instruction buffer */
1629 usbduxfastsub
[index
].insnBuffer
= kmalloc(SIZEINSNBUF
, GFP_KERNEL
);
1630 if (!usbduxfastsub
[index
].insnBuffer
) {
1631 printk(KERN_ERR
"comedi_: usbduxfast: could not alloc space "
1632 "for insnBuffer\n");
1633 tidy_up(&(usbduxfastsub
[index
]));
1634 up(&start_stop_sem
);
1637 /* setting to alternate setting 1: enabling bulk ep */
1638 i
= usb_set_interface(usbduxfastsub
[index
].usbdev
,
1639 usbduxfastsub
[index
].ifnum
, 1);
1641 printk(KERN_ERR
"comedi_: usbduxfast%d: could not switch to "
1642 "alternate setting 1.\n", index
);
1643 tidy_up(&(usbduxfastsub
[index
]));
1644 up(&start_stop_sem
);
1647 usbduxfastsub
[index
].urbIn
= usb_alloc_urb(0, GFP_KERNEL
);
1648 if (!usbduxfastsub
[index
].urbIn
) {
1649 printk(KERN_ERR
"comedi_: usbduxfast%d: Could not alloc."
1651 tidy_up(&(usbduxfastsub
[index
]));
1652 up(&start_stop_sem
);
1655 usbduxfastsub
[index
].transfer_buffer
= kmalloc(SIZEINBUF
, GFP_KERNEL
);
1656 if (!usbduxfastsub
[index
].transfer_buffer
) {
1657 printk(KERN_ERR
"comedi_: usbduxfast%d: could not alloc. "
1658 "transb.\n", index
);
1659 tidy_up(&(usbduxfastsub
[index
]));
1660 up(&start_stop_sem
);
1663 /* we've reached the bottom of the function */
1664 usbduxfastsub
[index
].probed
= 1;
1665 up(&start_stop_sem
);
1667 ret
= request_firmware_nowait(THIS_MODULE
,
1669 "usbduxfast_firmware.hex",
1671 usbduxfastsub
+ index
,
1672 usbduxfast_firmware_request_complete_handler
);
1675 dev_err(&udev
->dev
, "could not load firmware (err=%d)\n",
1680 printk(KERN_INFO
"comedi_: usbduxfast%d has been successfully "
1681 "initialized.\n", index
);
1686 static void usbduxfastsub_disconnect(struct usb_interface
*intf
)
1688 struct usbduxfastsub_s
*udfs
= usb_get_intfdata(intf
);
1689 struct usb_device
*udev
= interface_to_usbdev(intf
);
1692 printk(KERN_ERR
"comedi_: usbduxfast: disconnect called with "
1696 if (udfs
->usbdev
!= udev
) {
1697 printk(KERN_ERR
"comedi_: usbduxfast: BUG! called with wrong "
1702 comedi_usb_auto_unconfig(udev
);
1704 down(&start_stop_sem
);
1708 up(&start_stop_sem
);
1710 #ifdef CONFIG_COMEDI_DEBUG
1711 printk(KERN_DEBUG
"comedi_: usbduxfast: disconnected from the usb\n");
1716 * is called when comedi-config is called
1718 static int usbduxfast_attach(struct comedi_device
*dev
, struct comedi_devconfig
*it
)
1723 struct comedi_subdevice
*s
= NULL
;
1724 dev
->private = NULL
;
1726 down(&start_stop_sem
);
1728 * find a valid device which has been detected by the
1729 * probe function of the usb
1732 for (i
= 0; i
< NUMUSBDUXFAST
; i
++) {
1733 if (usbduxfastsub
[i
].probed
&& !usbduxfastsub
[i
].attached
) {
1740 printk(KERN_ERR
"comedi%d: usbduxfast: error: attach failed, "
1741 "no usbduxfast devs connected to the usb bus.\n",
1743 up(&start_stop_sem
);
1747 down(&(usbduxfastsub
[index
].sem
));
1748 /* pointer back to the corresponding comedi device */
1749 usbduxfastsub
[index
].comedidev
= dev
;
1751 /* trying to upload the firmware into the chip */
1752 if (comedi_aux_data(it
->options
, 0) &&
1753 it
->options
[COMEDI_DEVCONF_AUX_DATA_LENGTH
]) {
1754 read_firmware(&usbduxfastsub
[index
],
1755 comedi_aux_data(it
->options
, 0),
1756 it
->options
[COMEDI_DEVCONF_AUX_DATA_LENGTH
]);
1759 dev
->board_name
= BOARDNAME
;
1761 /* set number of subdevices */
1762 dev
->n_subdevices
= N_SUBDEVICES
;
1764 /* allocate space for the subdevices */
1765 ret
= alloc_subdevices(dev
, N_SUBDEVICES
);
1767 printk(KERN_ERR
"comedi%d: usbduxfast: error alloc space for "
1768 "subdev\n", dev
->minor
);
1769 up(&(usbduxfastsub
[index
].sem
));
1770 up(&start_stop_sem
);
1774 printk(KERN_INFO
"comedi%d: usbduxfast: usb-device %d is attached to "
1775 "comedi.\n", dev
->minor
, index
);
1776 /* private structure is also simply the usb-structure */
1777 dev
->private = usbduxfastsub
+ index
;
1778 /* the first subdevice is the A/D converter */
1779 s
= dev
->subdevices
+ SUBDEV_AD
;
1781 * the URBs get the comedi subdevice which is responsible for reading
1782 * this is the subdevice which reads data
1784 dev
->read_subdev
= s
;
1785 /* the subdevice receives as private structure the usb-structure */
1788 s
->type
= COMEDI_SUBD_AI
;
1789 /* readable and ref is to ground */
1790 s
->subdev_flags
= SDF_READABLE
| SDF_GROUND
| SDF_CMD_READ
;
1793 /* length of the channellist */
1794 s
->len_chanlist
= 16;
1795 /* callback functions */
1796 s
->insn_read
= usbduxfast_ai_insn_read
;
1797 s
->do_cmdtest
= usbduxfast_ai_cmdtest
;
1798 s
->do_cmd
= usbduxfast_ai_cmd
;
1799 s
->cancel
= usbduxfast_ai_cancel
;
1800 /* max value from the A/D converter (12bit+1 bit for overflow) */
1801 s
->maxdata
= 0x1000;
1802 /* range table to convert to physical units */
1803 s
->range_table
= &range_usbduxfast_ai_range
;
1805 /* finally decide that it's attached */
1806 usbduxfastsub
[index
].attached
= 1;
1808 up(&(usbduxfastsub
[index
].sem
));
1809 up(&start_stop_sem
);
1810 printk(KERN_INFO
"comedi%d: successfully attached to usbduxfast.\n",
1816 static int usbduxfast_detach(struct comedi_device
*dev
)
1818 struct usbduxfastsub_s
*udfs
;
1821 printk(KERN_ERR
"comedi?: usbduxfast: detach without dev "
1826 #ifdef CONFIG_COMEDI_DEBUG
1827 printk(KERN_DEBUG
"comedi%d: usbduxfast: detach usb device\n",
1831 udfs
= dev
->private;
1833 printk(KERN_ERR
"comedi?: usbduxfast: detach without ptr to "
1834 "usbduxfastsub[]\n");
1839 down(&start_stop_sem
);
1841 * Don't allow detach to free the private structure
1842 * It's one entry of of usbduxfastsub[]
1844 dev
->private = NULL
;
1846 udfs
->comedidev
= NULL
;
1847 #ifdef CONFIG_COMEDI_DEBUG
1848 printk(KERN_DEBUG
"comedi%d: usbduxfast: detach: successfully "
1849 "removed\n", dev
->minor
);
1851 up(&start_stop_sem
);
1857 * main driver struct
1859 static struct comedi_driver driver_usbduxfast
= {
1860 .driver_name
= "usbduxfast",
1861 .module
= THIS_MODULE
,
1862 .attach
= usbduxfast_attach
,
1863 .detach
= usbduxfast_detach
1867 * Table with the USB-devices: just now only testing IDs
1869 static struct usb_device_id usbduxfastsub_table
[] = {
1870 /* { USB_DEVICE(0x4b4, 0x8613) }, testing */
1871 { USB_DEVICE(0x13d8, 0x0010) }, /* real ID */
1872 { USB_DEVICE(0x13d8, 0x0011) }, /* real ID */
1873 { } /* Terminating entry */
1876 MODULE_DEVICE_TABLE(usb
, usbduxfastsub_table
);
1879 * The usbduxfastsub-driver
1881 static struct usb_driver usbduxfastsub_driver
= {
1882 #ifdef COMEDI_HAVE_USB_DRIVER_OWNER
1883 .owner
= THIS_MODULE
,
1886 .probe
= usbduxfastsub_probe
,
1887 .disconnect
= usbduxfastsub_disconnect
,
1888 .id_table
= usbduxfastsub_table
1892 * Can't use the nice macro as I have also to initialise the USB subsystem:
1893 * registering the usb-system _and_ the comedi-driver
1895 static int __init
init_usbduxfast(void)
1898 KBUILD_MODNAME
": " DRIVER_VERSION
":" DRIVER_DESC
"\n");
1899 usb_register(&usbduxfastsub_driver
);
1900 comedi_driver_register(&driver_usbduxfast
);
1905 * deregistering the comedi driver and the usb-subsystem
1907 static void __exit
exit_usbduxfast(void)
1909 comedi_driver_unregister(&driver_usbduxfast
);
1910 usb_deregister(&usbduxfastsub_driver
);
1913 module_init(init_usbduxfast
);
1914 module_exit(exit_usbduxfast
);
1916 MODULE_AUTHOR(DRIVER_AUTHOR
);
1917 MODULE_DESCRIPTION(DRIVER_DESC
);
1918 MODULE_LICENSE("GPL");