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/fcntl.h>
48 #include <linux/compiler.h>
49 #include "comedi_fc.h"
50 #include "../comedidev.h"
52 #define DRIVER_VERSION "v1.0"
53 #define DRIVER_AUTHOR "Bernd Porr, BerndPorr@f2s.com"
54 #define DRIVER_DESC "USB-DUXfast, BerndPorr@f2s.com"
55 #define BOARDNAME "usbduxfast"
58 * timeout for the USB-transfer
63 * constants for "firmware" upload and download
65 #define USBDUXFASTSUB_FIRMWARE 0xA0
66 #define VENDOR_DIR_IN 0xC0
67 #define VENDOR_DIR_OUT 0x40
70 * internal addresses of the 8051 processor
72 #define USBDUXFASTSUB_CPUCS 0xE600
75 * max lenghth of the transfer-buffer for software upload
80 * input endpoint number
85 * endpoint for the A/D channellist: bulk OUT
87 #define CHANNELLISTEP 4
92 #define NUMCHANNELS 32
95 * size of the waveform descriptor
100 * size of one A/D value
102 #define SIZEADIN (sizeof(int16_t))
105 * size of the input-buffer IN BYTES
107 #define SIZEINBUF 512
112 #define SIZEINSNBUF 512
115 * size of the buffer for the dux commands in bytes
117 #define SIZEOFDUXBUFFER 256
120 * number of in-URBs which receive the data: min=5
122 #define NUMOFINBUFFERSHIGH 10
125 * total number of usbduxfast devices
127 #define NUMUSBDUXFAST 16
130 * number of subdevices
132 #define N_SUBDEVICES 1
135 * analogue in subdevice
140 * min delay steps for more than one channel
141 * basically when the mux gives up ;-)
143 * steps at 30MHz in the FX2
145 #define MIN_SAMPLING_PERIOD 9
148 * max number of 1/30MHz delay steps
150 #define MAX_SAMPLING_PERIOD 500
153 * number of received packets to ignore before we start handing data
154 * over to comedi, it's quad buffering and we have to ignore 4 packets
156 #define PACKETS_TO_IGNORE 4
161 static const struct comedi_lrange range_usbduxfast_ai_range = {
162 2, {BIP_RANGE(0.75), BIP_RANGE(0.5)}
166 * private structure of one subdevice
168 * this is the structure which holds all the data of this driver
169 * one sub device just now: A/D
171 struct usbduxfastsub_s {
172 int attached; /* is attached? */
173 int probed; /* is it associated with a subdevice? */
174 struct usb_device *usbdev; /* pointer to the usb-device */
175 struct urb *urbIn; /* BULK-transfer handling: urb */
176 int8_t *transfer_buffer;
177 int16_t *insnBuffer; /* input buffer for single insn */
178 int ifnum; /* interface number */
179 struct usb_interface *interface; /* interface structure */
180 /* comedi device for the interrupt context */
181 struct comedi_device *comedidev;
182 short int ai_cmd_running; /* asynchronous command is running */
183 short int ai_continous; /* continous acquisition */
184 long int ai_sample_count; /* number of samples to acquire */
185 uint8_t *dux_commands; /* commands */
186 int ignore; /* counter which ignores the first
188 struct semaphore sem;
192 * The pointer to the private usb-data of the driver
193 * is also the private data for the comedi-device.
194 * This has to be global as the usb subsystem needs
195 * global variables. The other reason is that this
196 * structure must be there _before_ any comedi
197 * command is issued. The usb subsystem must be
198 * initialised before comedi can access it.
200 static struct usbduxfastsub_s usbduxfastsub[NUMUSBDUXFAST];
202 static DEFINE_SEMAPHORE(start_stop_sem);
204 static struct comedi_driver driver_usbduxfast; /* see below for initializer */
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, int do_unlink)
266 printk(KERN_ERR "comedi?: usbduxfast_ai_stop: udfs=NULL!\n");
269 #ifdef CONFIG_COMEDI_DEBUG
270 printk(KERN_DEBUG "comedi: usbduxfast_ai_stop\n");
273 udfs->ai_cmd_running = 0;
277 ret = usbduxfastsub_unlink_InURBs(udfs);
283 * This will cancel a running acquisition operation.
284 * This is called by comedi but never from inside the driver.
286 static int usbduxfast_ai_cancel(struct comedi_device *dev,
287 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)
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 continuous, 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 /* tell 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 err = cfc_write_array_to_buffer(s, urb->transfer_buffer,
419 if (unlikely(err == 0)) {
420 /* buffer overflow */
421 usbduxfast_ai_stop(udfs, 0);
425 /* tell comedi that data is there */
426 comedi_event(udfs->comedidev, s);
429 /* ignore this packet */
434 * command is still running
435 * resubmit urb for BULK transfer
437 urb->dev = udfs->usbdev;
439 err = usb_submit_urb(urb, GFP_ATOMIC);
441 printk(KERN_ERR "comedi%d: usbduxfast: urb resubm failed: %d",
442 udfs->comedidev->minor, err);
443 s->async->events |= COMEDI_CB_EOA;
444 s->async->events |= COMEDI_CB_ERROR;
445 comedi_event(udfs->comedidev, s);
446 usbduxfast_ai_stop(udfs, 0);
450 static int usbduxfastsub_start(struct usbduxfastsub_s *udfs)
453 unsigned char local_transfer_buffer[16];
456 local_transfer_buffer[0] = 0;
457 /* bRequest, "Firmware" */
458 ret = usb_control_msg(udfs->usbdev, usb_sndctrlpipe(udfs->usbdev, 0),
459 USBDUXFASTSUB_FIRMWARE,
460 VENDOR_DIR_OUT, /* bmRequestType */
461 USBDUXFASTSUB_CPUCS, /* Value */
463 /* address of the transfer buffer */
464 local_transfer_buffer,
466 EZTIMEOUT); /* Timeout */
468 printk("comedi_: usbduxfast_: control msg failed (start)\n");
475 static int usbduxfastsub_stop(struct usbduxfastsub_s *udfs)
478 unsigned char local_transfer_buffer[16];
481 local_transfer_buffer[0] = 1;
482 /* bRequest, "Firmware" */
483 ret = usb_control_msg(udfs->usbdev, usb_sndctrlpipe(udfs->usbdev, 0),
484 USBDUXFASTSUB_FIRMWARE,
485 VENDOR_DIR_OUT, /* bmRequestType */
486 USBDUXFASTSUB_CPUCS, /* Value */
488 local_transfer_buffer, 1, /* Length */
489 EZTIMEOUT); /* Timeout */
491 printk(KERN_ERR "comedi_: usbduxfast: control msg failed "
499 static int usbduxfastsub_upload(struct usbduxfastsub_s *udfs,
500 unsigned char *local_transfer_buffer,
501 unsigned int startAddr, unsigned int len)
505 #ifdef CONFIG_COMEDI_DEBUG
506 printk(KERN_DEBUG "comedi: usbduxfast: uploading %d bytes", len);
507 printk(KERN_DEBUG " to addr %d, first byte=%d.\n",
508 startAddr, local_transfer_buffer[0]);
510 /* brequest, firmware */
511 ret = usb_control_msg(udfs->usbdev, usb_sndctrlpipe(udfs->usbdev, 0),
512 USBDUXFASTSUB_FIRMWARE,
513 VENDOR_DIR_OUT, /* bmRequestType */
514 startAddr, /* value */
516 /* our local safe buffer */
517 local_transfer_buffer,
519 EZTIMEOUT); /* timeout */
521 #ifdef CONFIG_COMEDI_DEBUG
522 printk(KERN_DEBUG "comedi_: usbduxfast: result=%d\n", ret);
526 printk(KERN_ERR "comedi_: usbduxfast: uppload failed\n");
533 static int usbduxfastsub_submit_InURBs(struct usbduxfastsub_s *udfs)
540 usb_fill_bulk_urb(udfs->urbIn, udfs->usbdev,
541 usb_rcvbulkpipe(udfs->usbdev, BULKINEP),
542 udfs->transfer_buffer,
543 SIZEINBUF, usbduxfastsub_ai_Irq, udfs->comedidev);
545 #ifdef CONFIG_COMEDI_DEBUG
546 printk(KERN_DEBUG "comedi%d: usbduxfast: submitting in-urb: "
547 "0x%p,0x%p\n", udfs->comedidev->minor, udfs->urbIn->context,
550 ret = usb_submit_urb(udfs->urbIn, GFP_ATOMIC);
552 printk(KERN_ERR "comedi_: usbduxfast: ai: usb_submit_urb error"
559 static int usbduxfast_ai_cmdtest(struct comedi_device *dev,
560 struct comedi_subdevice *s,
561 struct comedi_cmd *cmd)
563 int err = 0, stop_mask = 0;
566 struct usbduxfastsub_s *udfs = dev->private;
571 #ifdef CONFIG_COMEDI_DEBUG
572 printk(KERN_DEBUG "comedi%d: usbduxfast_ai_cmdtest\n", dev->minor);
573 printk(KERN_DEBUG "comedi%d: usbduxfast: convert_arg=%u "
574 "scan_begin_arg=%u\n",
575 dev->minor, cmd->convert_arg, cmd->scan_begin_arg);
577 /* step 1: make sure trigger sources are trivially valid */
579 tmp = cmd->start_src;
580 cmd->start_src &= TRIG_NOW | TRIG_EXT | TRIG_INT;
581 if (!cmd->start_src || tmp != cmd->start_src)
584 tmp = cmd->scan_begin_src;
585 cmd->scan_begin_src &= TRIG_TIMER | TRIG_FOLLOW | TRIG_EXT;
586 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
589 tmp = cmd->convert_src;
590 cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
591 if (!cmd->convert_src || tmp != cmd->convert_src)
594 tmp = cmd->scan_end_src;
595 cmd->scan_end_src &= TRIG_COUNT;
596 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
600 stop_mask = TRIG_COUNT | TRIG_NONE;
601 cmd->stop_src &= stop_mask;
602 if (!cmd->stop_src || tmp != cmd->stop_src)
609 * step 2: make sure trigger sources are unique and mutually compatible
612 if (cmd->start_src != TRIG_NOW &&
613 cmd->start_src != TRIG_EXT && cmd->start_src != TRIG_INT)
615 if (cmd->scan_begin_src != TRIG_TIMER &&
616 cmd->scan_begin_src != TRIG_FOLLOW &&
617 cmd->scan_begin_src != TRIG_EXT)
619 if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
621 if (cmd->stop_src != TRIG_COUNT &&
622 cmd->stop_src != TRIG_EXT && cmd->stop_src != TRIG_NONE)
625 /* can't have external stop and start triggers at once */
626 if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT)
632 /* step 3: make sure arguments are trivially compatible */
634 if (cmd->start_src == TRIG_NOW && cmd->start_arg != 0) {
639 if (!cmd->chanlist_len)
642 if (cmd->scan_end_arg != cmd->chanlist_len) {
643 cmd->scan_end_arg = cmd->chanlist_len;
647 if (cmd->chanlist_len == 1)
650 minSamplPer = MIN_SAMPLING_PERIOD;
652 if (cmd->convert_src == TRIG_TIMER) {
653 steps = cmd->convert_arg * 30;
654 if (steps < (minSamplPer * 1000))
655 steps = minSamplPer * 1000;
657 if (steps > (MAX_SAMPLING_PERIOD * 1000))
658 steps = MAX_SAMPLING_PERIOD * 1000;
662 if (cmd->convert_arg != tmp) {
663 cmd->convert_arg = tmp;
668 if (cmd->scan_begin_src == TRIG_TIMER)
672 switch (cmd->stop_src) {
674 if (!cmd->stop_arg) {
680 if (cmd->stop_arg != 0) {
686 * TRIG_EXT doesn't care since it doesn't trigger
687 * off a numbered channel
696 /* step 4: fix up any arguments */
702 static int usbduxfast_ai_inttrig(struct comedi_device *dev,
703 struct comedi_subdevice *s,
704 unsigned int trignum)
707 struct usbduxfastsub_s *udfs = dev->private;
717 #ifdef CONFIG_COMEDI_DEBUG
718 printk(KERN_DEBUG "comedi%d: usbduxfast_ai_inttrig\n", dev->minor);
722 printk(KERN_ERR "comedi%d: usbduxfast_ai_inttrig: invalid"
723 " trignum\n", dev->minor);
727 if (!udfs->ai_cmd_running) {
728 udfs->ai_cmd_running = 1;
729 ret = usbduxfastsub_submit_InURBs(udfs);
731 printk(KERN_ERR "comedi%d: usbduxfast_ai_inttrig: "
732 "urbSubmit: err=%d\n", dev->minor, ret);
733 udfs->ai_cmd_running = 0;
737 s->async->inttrig = NULL;
739 printk(KERN_ERR "comedi%d: ai_inttrig but acqu is already"
740 " running\n", dev->minor);
747 * offsets for the GPIF bytes
748 * the first byte is the command byte
750 #define LENBASE (1+0x00)
751 #define OPBASE (1+0x08)
752 #define OUTBASE (1+0x10)
753 #define LOGBASE (1+0x18)
755 static int usbduxfast_ai_cmd(struct comedi_device *dev,
756 struct comedi_subdevice *s)
758 struct comedi_cmd *cmd = &s->async->cmd;
759 unsigned int chan, gain, rngmask = 0xff;
761 struct usbduxfastsub_s *udfs;
763 long steps, steps_tmp;
765 #ifdef CONFIG_COMEDI_DEBUG
766 printk(KERN_DEBUG "comedi%d: usbduxfast_ai_cmd\n", dev->minor);
777 if (udfs->ai_cmd_running) {
778 printk(KERN_ERR "comedi%d: ai_cmd not possible. Another ai_cmd"
779 " is running.\n", dev->minor);
783 /* set current channel of the running acquisition to zero */
784 s->async->cur_chan = 0;
787 * ignore the first buffers from the device if there
788 * is an error condition
790 udfs->ignore = PACKETS_TO_IGNORE;
792 if (cmd->chanlist_len > 0) {
793 gain = CR_RANGE(cmd->chanlist[0]);
794 for (i = 0; i < cmd->chanlist_len; ++i) {
795 chan = CR_CHAN(cmd->chanlist[i]);
797 printk(KERN_ERR "comedi%d: cmd is accepting "
798 "only consecutive channels.\n",
803 if ((gain != CR_RANGE(cmd->chanlist[i]))
804 && (cmd->chanlist_len > 3)) {
805 printk(KERN_ERR "comedi%d: the gain must be"
806 " the same for all channels.\n",
811 if (i >= NUMCHANNELS) {
812 printk(KERN_ERR "comedi%d: channel list too"
813 " long\n", dev->minor);
819 if (cmd->scan_begin_src == TRIG_TIMER) {
820 printk(KERN_ERR "comedi%d: usbduxfast: "
821 "scan_begin_src==TRIG_TIMER not valid.\n", dev->minor);
825 if (cmd->convert_src == TRIG_TIMER)
826 steps = (cmd->convert_arg * 30) / 1000;
828 if ((steps < MIN_SAMPLING_PERIOD) && (cmd->chanlist_len != 1)) {
829 printk(KERN_ERR "comedi%d: usbduxfast: ai_cmd: steps=%ld, "
830 "scan_begin_arg=%d. Not properly tested by cmdtest?\n",
831 dev->minor, steps, cmd->scan_begin_arg);
835 if (steps > MAX_SAMPLING_PERIOD) {
836 printk(KERN_ERR "comedi%d: usbduxfast: ai_cmd: sampling rate "
837 "too low.\n", dev->minor);
841 if ((cmd->start_src == TRIG_EXT) && (cmd->chanlist_len != 1)
842 && (cmd->chanlist_len != 16)) {
843 printk(KERN_ERR "comedi%d: usbduxfast: ai_cmd: TRIG_EXT only"
844 " with 1 or 16 channels possible.\n", dev->minor);
848 #ifdef CONFIG_COMEDI_DEBUG
849 printk(KERN_DEBUG "comedi%d: usbduxfast: steps=%ld, convert_arg=%u\n",
850 dev->minor, steps, cmd->convert_arg);
853 switch (cmd->chanlist_len) {
859 if (CR_RANGE(cmd->chanlist[0]) > 0)
860 rngmask = 0xff - 0x04;
865 * for external trigger: looping in this state until
866 * the RDY0 pin becomes zero
869 /* we loop here until ready has been set */
870 if (cmd->start_src == TRIG_EXT) {
871 /* branch back to state 0 */
872 udfs->dux_commands[LENBASE + 0] = 0x01;
873 /* deceision state w/o data */
874 udfs->dux_commands[OPBASE + 0] = 0x01;
875 udfs->dux_commands[OUTBASE + 0] = 0xFF & rngmask;
877 udfs->dux_commands[LOGBASE + 0] = 0x00;
878 } else { /* we just proceed to state 1 */
879 udfs->dux_commands[LENBASE + 0] = 1;
880 udfs->dux_commands[OPBASE + 0] = 0;
881 udfs->dux_commands[OUTBASE + 0] = 0xFF & rngmask;
882 udfs->dux_commands[LOGBASE + 0] = 0;
885 if (steps < MIN_SAMPLING_PERIOD) {
886 /* for fast single channel aqu without mux */
889 * we just stay here at state 1 and rexecute
890 * the same state this gives us 30MHz sampling
894 /* branch back to state 1 */
895 udfs->dux_commands[LENBASE + 1] = 0x89;
896 /* deceision state with data */
897 udfs->dux_commands[OPBASE + 1] = 0x03;
898 udfs->dux_commands[OUTBASE + 1] =
901 udfs->dux_commands[LOGBASE + 1] = 0xFF;
904 * we loop through two states: data and delay
907 udfs->dux_commands[LENBASE + 1] = steps - 1;
909 udfs->dux_commands[OPBASE + 1] = 0x02;
910 udfs->dux_commands[OUTBASE + 1] =
913 udfs->dux_commands[LOGBASE + 1] = 0;
914 /* branch back to state 1 */
915 udfs->dux_commands[LENBASE + 2] = 0x09;
916 /* deceision state w/o data */
917 udfs->dux_commands[OPBASE + 2] = 0x01;
918 udfs->dux_commands[OUTBASE + 2] =
921 udfs->dux_commands[LOGBASE + 2] = 0xFF;
925 * we loop through 3 states: 2x delay and 1x data
926 * this gives a min sampling rate of 60kHz
929 /* we have 1 state with duration 1 */
932 /* do the first part of the delay */
933 udfs->dux_commands[LENBASE + 1] = steps / 2;
934 udfs->dux_commands[OPBASE + 1] = 0;
935 udfs->dux_commands[OUTBASE + 1] = 0xFF & rngmask;
936 udfs->dux_commands[LOGBASE + 1] = 0;
938 /* and the second part */
939 udfs->dux_commands[LENBASE + 2] = steps - steps / 2;
940 udfs->dux_commands[OPBASE + 2] = 0;
941 udfs->dux_commands[OUTBASE + 2] = 0xFF & rngmask;
942 udfs->dux_commands[LOGBASE + 2] = 0;
944 /* get the data and branch back */
946 /* branch back to state 1 */
947 udfs->dux_commands[LENBASE + 3] = 0x09;
948 /* deceision state w data */
949 udfs->dux_commands[OPBASE + 3] = 0x03;
950 udfs->dux_commands[OUTBASE + 3] = 0xFF & rngmask;
952 udfs->dux_commands[LOGBASE + 3] = 0xFF;
959 * commit data to the FIFO
962 if (CR_RANGE(cmd->chanlist[0]) > 0)
963 rngmask = 0xff - 0x04;
967 udfs->dux_commands[LENBASE + 0] = 1;
969 udfs->dux_commands[OPBASE + 0] = 0x02;
970 udfs->dux_commands[OUTBASE + 0] = 0xFF & rngmask;
971 udfs->dux_commands[LOGBASE + 0] = 0;
973 /* we have 1 state with duration 1: state 0 */
974 steps_tmp = steps - 1;
976 if (CR_RANGE(cmd->chanlist[1]) > 0)
977 rngmask = 0xff - 0x04;
981 /* do the first part of the delay */
982 udfs->dux_commands[LENBASE + 1] = steps_tmp / 2;
983 udfs->dux_commands[OPBASE + 1] = 0;
985 udfs->dux_commands[OUTBASE + 1] = 0xFE & rngmask;
986 udfs->dux_commands[LOGBASE + 1] = 0;
988 /* and the second part */
989 udfs->dux_commands[LENBASE + 2] = steps_tmp - steps_tmp / 2;
990 udfs->dux_commands[OPBASE + 2] = 0;
991 udfs->dux_commands[OUTBASE + 2] = 0xFF & rngmask;
992 udfs->dux_commands[LOGBASE + 2] = 0;
994 udfs->dux_commands[LENBASE + 3] = 1;
996 udfs->dux_commands[OPBASE + 3] = 0x02;
997 udfs->dux_commands[OUTBASE + 3] = 0xFF & rngmask;
998 udfs->dux_commands[LOGBASE + 3] = 0;
1001 * we have 2 states with duration 1: step 6 and
1004 steps_tmp = steps - 2;
1006 if (CR_RANGE(cmd->chanlist[0]) > 0)
1007 rngmask = 0xff - 0x04;
1011 /* do the first part of the delay */
1012 udfs->dux_commands[LENBASE + 4] = steps_tmp / 2;
1013 udfs->dux_commands[OPBASE + 4] = 0;
1015 udfs->dux_commands[OUTBASE + 4] = (0xFF - 0x02) & rngmask;
1016 udfs->dux_commands[LOGBASE + 4] = 0;
1018 /* and the second part */
1019 udfs->dux_commands[LENBASE + 5] = steps_tmp - steps_tmp / 2;
1020 udfs->dux_commands[OPBASE + 5] = 0;
1021 udfs->dux_commands[OUTBASE + 5] = 0xFF & rngmask;
1022 udfs->dux_commands[LOGBASE + 5] = 0;
1024 udfs->dux_commands[LENBASE + 6] = 1;
1025 udfs->dux_commands[OPBASE + 6] = 0;
1026 udfs->dux_commands[OUTBASE + 6] = 0xFF & rngmask;
1027 udfs->dux_commands[LOGBASE + 6] = 0;
1034 for (j = 0; j < 1; j++) {
1035 if (CR_RANGE(cmd->chanlist[j]) > 0)
1036 rngmask = 0xff - 0x04;
1040 * commit data to the FIFO and do the first part
1043 udfs->dux_commands[LENBASE + j * 2] = steps / 2;
1045 udfs->dux_commands[OPBASE + j * 2] = 0x02;
1047 udfs->dux_commands[OUTBASE + j * 2] = 0xFF & rngmask;
1048 udfs->dux_commands[LOGBASE + j * 2] = 0;
1050 if (CR_RANGE(cmd->chanlist[j + 1]) > 0)
1051 rngmask = 0xff - 0x04;
1055 /* do the second part of the delay */
1056 udfs->dux_commands[LENBASE + j * 2 + 1] =
1059 udfs->dux_commands[OPBASE + j * 2 + 1] = 0;
1061 udfs->dux_commands[OUTBASE + j * 2 + 1] =
1063 udfs->dux_commands[LOGBASE + j * 2 + 1] = 0;
1066 /* 2 steps with duration 1: the idele step and step 6: */
1067 steps_tmp = steps - 2;
1069 /* commit data to the FIFO and do the first part of the delay */
1070 udfs->dux_commands[LENBASE + 4] = steps_tmp / 2;
1072 udfs->dux_commands[OPBASE + 4] = 0x02;
1073 udfs->dux_commands[OUTBASE + 4] = 0xFF & rngmask;
1074 udfs->dux_commands[LOGBASE + 4] = 0;
1076 if (CR_RANGE(cmd->chanlist[0]) > 0)
1077 rngmask = 0xff - 0x04;
1081 /* do the second part of the delay */
1082 udfs->dux_commands[LENBASE + 5] = steps_tmp - steps_tmp / 2;
1084 udfs->dux_commands[OPBASE + 5] = 0;
1086 udfs->dux_commands[OUTBASE + 5] = (0xFF - 0x02) & rngmask;
1087 udfs->dux_commands[LOGBASE + 5] = 0;
1089 udfs->dux_commands[LENBASE + 6] = 1;
1090 udfs->dux_commands[OPBASE + 6] = 0;
1091 udfs->dux_commands[OUTBASE + 6] = 0xFF & rngmask;
1092 udfs->dux_commands[LOGBASE + 6] = 0;
1095 if (CR_RANGE(cmd->chanlist[0]) > 0)
1096 rngmask = 0xff - 0x04;
1100 if (cmd->start_src == TRIG_EXT) {
1102 * we loop here until ready has been set
1105 /* branch back to state 0 */
1106 udfs->dux_commands[LENBASE + 0] = 0x01;
1107 /* deceision state w/o data */
1108 udfs->dux_commands[OPBASE + 0] = 0x01;
1110 udfs->dux_commands[OUTBASE + 0] =
1111 (0xFF - 0x02) & rngmask;
1113 udfs->dux_commands[LOGBASE + 0] = 0x00;
1116 * we just proceed to state 1
1119 /* 30us reset pulse */
1120 udfs->dux_commands[LENBASE + 0] = 255;
1121 udfs->dux_commands[OPBASE + 0] = 0;
1123 udfs->dux_commands[OUTBASE + 0] =
1124 (0xFF - 0x02) & rngmask;
1125 udfs->dux_commands[LOGBASE + 0] = 0;
1128 /* commit data to the FIFO */
1129 udfs->dux_commands[LENBASE + 1] = 1;
1131 udfs->dux_commands[OPBASE + 1] = 0x02;
1132 udfs->dux_commands[OUTBASE + 1] = 0xFF & rngmask;
1133 udfs->dux_commands[LOGBASE + 1] = 0;
1135 /* we have 2 states with duration 1 */
1138 /* do the first part of the delay */
1139 udfs->dux_commands[LENBASE + 2] = steps / 2;
1140 udfs->dux_commands[OPBASE + 2] = 0;
1141 udfs->dux_commands[OUTBASE + 2] = 0xFE & rngmask;
1142 udfs->dux_commands[LOGBASE + 2] = 0;
1144 /* and the second part */
1145 udfs->dux_commands[LENBASE + 3] = steps - steps / 2;
1146 udfs->dux_commands[OPBASE + 3] = 0;
1147 udfs->dux_commands[OUTBASE + 3] = 0xFF & rngmask;
1148 udfs->dux_commands[LOGBASE + 3] = 0;
1150 /* branch back to state 1 */
1151 udfs->dux_commands[LENBASE + 4] = 0x09;
1152 /* deceision state w/o data */
1153 udfs->dux_commands[OPBASE + 4] = 0x01;
1154 udfs->dux_commands[OUTBASE + 4] = 0xFF & rngmask;
1155 /* doesn't matter */
1156 udfs->dux_commands[LOGBASE + 4] = 0xFF;
1161 printk(KERN_ERR "comedi %d: unsupported combination of "
1162 "channels\n", dev->minor);
1167 #ifdef CONFIG_COMEDI_DEBUG
1168 printk(KERN_DEBUG "comedi %d: sending commands to the usb device\n",
1171 /* 0 means that the AD commands are sent */
1172 result = send_dux_commands(udfs, SENDADCOMMANDS);
1174 printk(KERN_ERR "comedi%d: adc command could not be submitted."
1175 "Aborting...\n", dev->minor);
1179 if (cmd->stop_src == TRIG_COUNT) {
1180 udfs->ai_sample_count = cmd->stop_arg * cmd->scan_end_arg;
1181 if (udfs->ai_sample_count < 1) {
1182 printk(KERN_ERR "comedi%d: "
1183 "(cmd->stop_arg)*(cmd->scan_end_arg)<1, "
1184 "aborting.\n", dev->minor);
1188 udfs->ai_continous = 0;
1190 /* continous acquisition */
1191 udfs->ai_continous = 1;
1192 udfs->ai_sample_count = 0;
1195 if ((cmd->start_src == TRIG_NOW) || (cmd->start_src == TRIG_EXT)) {
1196 /* enable this acquisition operation */
1197 udfs->ai_cmd_running = 1;
1198 ret = usbduxfastsub_submit_InURBs(udfs);
1200 udfs->ai_cmd_running = 0;
1201 /* fixme: unlink here?? */
1205 s->async->inttrig = NULL;
1209 * don't enable the acquision operation
1210 * wait for an internal signal
1212 s->async->inttrig = usbduxfast_ai_inttrig;
1220 * Mode 0 is used to get a single conversion on demand.
1222 static int usbduxfast_ai_insn_read(struct comedi_device *dev,
1223 struct comedi_subdevice *s,
1224 struct comedi_insn *insn, unsigned int *data)
1226 int i, j, n, actual_length;
1227 int chan, range, rngmask;
1229 struct usbduxfastsub_s *udfs;
1231 udfs = dev->private;
1233 printk(KERN_ERR "comedi%d: ai_insn_read: no usb dev.\n",
1237 #ifdef CONFIG_COMEDI_DEBUG
1238 printk(KERN_DEBUG "comedi%d: ai_insn_read, insn->n=%d, "
1239 "insn->subdev=%d\n", dev->minor, insn->n, insn->subdev);
1242 if (!udfs->probed) {
1246 if (udfs->ai_cmd_running) {
1247 printk(KERN_ERR "comedi%d: ai_insn_read not possible. Async "
1248 "Command is running.\n", dev->minor);
1252 /* sample one channel */
1253 chan = CR_CHAN(insn->chanspec);
1254 range = CR_RANGE(insn->chanspec);
1255 /* set command for the first channel */
1258 rngmask = 0xff - 0x04;
1262 /* commit data to the FIFO */
1263 udfs->dux_commands[LENBASE + 0] = 1;
1265 udfs->dux_commands[OPBASE + 0] = 0x02;
1266 udfs->dux_commands[OUTBASE + 0] = 0xFF & rngmask;
1267 udfs->dux_commands[LOGBASE + 0] = 0;
1269 /* do the first part of the delay */
1270 udfs->dux_commands[LENBASE + 1] = 12;
1271 udfs->dux_commands[OPBASE + 1] = 0;
1272 udfs->dux_commands[OUTBASE + 1] = 0xFE & rngmask;
1273 udfs->dux_commands[LOGBASE + 1] = 0;
1275 udfs->dux_commands[LENBASE + 2] = 1;
1276 udfs->dux_commands[OPBASE + 2] = 0;
1277 udfs->dux_commands[OUTBASE + 2] = 0xFE & rngmask;
1278 udfs->dux_commands[LOGBASE + 2] = 0;
1280 udfs->dux_commands[LENBASE + 3] = 1;
1281 udfs->dux_commands[OPBASE + 3] = 0;
1282 udfs->dux_commands[OUTBASE + 3] = 0xFE & rngmask;
1283 udfs->dux_commands[LOGBASE + 3] = 0;
1285 udfs->dux_commands[LENBASE + 4] = 1;
1286 udfs->dux_commands[OPBASE + 4] = 0;
1287 udfs->dux_commands[OUTBASE + 4] = 0xFE & rngmask;
1288 udfs->dux_commands[LOGBASE + 4] = 0;
1291 udfs->dux_commands[LENBASE + 5] = 12;
1292 udfs->dux_commands[OPBASE + 5] = 0;
1293 udfs->dux_commands[OUTBASE + 5] = 0xFF & rngmask;
1294 udfs->dux_commands[LOGBASE + 5] = 0;
1296 udfs->dux_commands[LENBASE + 6] = 1;
1297 udfs->dux_commands[OPBASE + 6] = 0;
1298 udfs->dux_commands[OUTBASE + 6] = 0xFF & rngmask;
1299 udfs->dux_commands[LOGBASE + 0] = 0;
1301 #ifdef CONFIG_COMEDI_DEBUG
1302 printk(KERN_DEBUG "comedi %d: sending commands to the usb device\n",
1305 /* 0 means that the AD commands are sent */
1306 err = send_dux_commands(udfs, SENDADCOMMANDS);
1308 printk(KERN_ERR "comedi%d: adc command could not be submitted."
1309 "Aborting...\n", dev->minor);
1313 #ifdef CONFIG_COMEDI_DEBUG
1314 printk(KERN_DEBUG "comedi%d: usbduxfast: submitting in-urb: "
1315 "0x%p,0x%p\n", udfs->comedidev->minor, udfs->urbIn->context,
1318 for (i = 0; i < PACKETS_TO_IGNORE; i++) {
1319 err = usb_bulk_msg(udfs->usbdev,
1320 usb_rcvbulkpipe(udfs->usbdev, BULKINEP),
1321 udfs->transfer_buffer, SIZEINBUF,
1322 &actual_length, 10000);
1324 printk(KERN_ERR "comedi%d: insn timeout. No data.\n",
1331 for (i = 0; i < insn->n;) {
1332 err = usb_bulk_msg(udfs->usbdev,
1333 usb_rcvbulkpipe(udfs->usbdev, BULKINEP),
1334 udfs->transfer_buffer, SIZEINBUF,
1335 &actual_length, 10000);
1337 printk(KERN_ERR "comedi%d: insn data error: %d\n",
1342 n = actual_length / sizeof(uint16_t);
1343 if ((n % 16) != 0) {
1344 printk(KERN_ERR "comedi%d: insn data packet "
1345 "corrupted.\n", dev->minor);
1349 for (j = chan; (j < n) && (i < insn->n); j = j + 16) {
1350 data[i] = ((uint16_t *) (udfs->transfer_buffer))[j];
1358 #define FIRMWARE_MAX_LEN 0x2000
1360 static int firmwareUpload(struct usbduxfastsub_s *usbduxfastsub,
1361 const u8 *firmwareBinary, int sizeFirmware)
1366 if (!firmwareBinary)
1369 if (sizeFirmware > FIRMWARE_MAX_LEN) {
1370 dev_err(&usbduxfastsub->interface->dev,
1371 "comedi_: usbduxfast firmware binary it too large for FX2.\n");
1375 /* we generate a local buffer for the firmware */
1376 fwBuf = kmemdup(firmwareBinary, sizeFirmware, GFP_KERNEL);
1378 dev_err(&usbduxfastsub->interface->dev,
1379 "comedi_: mem alloc for firmware failed\n");
1383 ret = usbduxfastsub_stop(usbduxfastsub);
1385 dev_err(&usbduxfastsub->interface->dev,
1386 "comedi_: can not stop firmware\n");
1391 ret = usbduxfastsub_upload(usbduxfastsub, fwBuf, 0, sizeFirmware);
1393 dev_err(&usbduxfastsub->interface->dev,
1394 "comedi_: firmware upload failed\n");
1398 ret = usbduxfastsub_start(usbduxfastsub);
1400 dev_err(&usbduxfastsub->interface->dev,
1401 "comedi_: can not start firmware\n");
1409 static void tidy_up(struct usbduxfastsub_s *udfs)
1411 #ifdef CONFIG_COMEDI_DEBUG
1412 printk(KERN_DEBUG "comedi_: usbduxfast: tiding up\n");
1418 /* shows the usb subsystem that the driver is down */
1419 if (udfs->interface)
1420 usb_set_intfdata(udfs->interface, NULL);
1425 /* waits until a running transfer is over */
1426 usb_kill_urb(udfs->urbIn);
1428 kfree(udfs->transfer_buffer);
1429 udfs->transfer_buffer = NULL;
1431 usb_free_urb(udfs->urbIn);
1435 kfree(udfs->insnBuffer);
1436 udfs->insnBuffer = NULL;
1438 kfree(udfs->dux_commands);
1439 udfs->dux_commands = NULL;
1441 udfs->ai_cmd_running = 0;
1444 static void usbduxfast_firmware_request_complete_handler(const struct firmware
1447 struct usbduxfastsub_s *usbduxfastsub_tmp = context;
1448 struct usb_interface *uinterf = usbduxfastsub_tmp->interface;
1455 * we need to upload the firmware here because fw will be
1456 * freed once we've left this function
1458 ret = firmwareUpload(usbduxfastsub_tmp, fw->data, fw->size);
1461 dev_err(&uinterf->dev,
1462 "Could not upload firmware (err=%d)\n", ret);
1466 comedi_usb_auto_config(uinterf, &driver_usbduxfast);
1468 release_firmware(fw);
1472 * allocate memory for the urbs and initialise them
1474 static int usbduxfastsub_probe(struct usb_interface *uinterf,
1475 const struct usb_device_id *id)
1477 struct usb_device *udev = interface_to_usbdev(uinterf);
1482 if (udev->speed != USB_SPEED_HIGH) {
1483 printk(KERN_ERR "comedi_: usbduxfast_: This driver needs"
1484 "USB 2.0 to operate. Aborting...\n");
1487 #ifdef CONFIG_COMEDI_DEBUG
1488 printk(KERN_DEBUG "comedi_: usbduxfast_: finding a free structure for "
1489 "the usb-device\n");
1491 down(&start_stop_sem);
1492 /* look for a free place in the usbduxfast array */
1494 for (i = 0; i < NUMUSBDUXFAST; i++) {
1495 if (!usbduxfastsub[i].probed) {
1503 printk(KERN_ERR "Too many usbduxfast-devices connected.\n");
1504 up(&start_stop_sem);
1507 #ifdef CONFIG_COMEDI_DEBUG
1508 printk(KERN_DEBUG "comedi_: usbduxfast: usbduxfastsub[%d] is ready to "
1509 "connect to comedi.\n", index);
1512 sema_init(&(usbduxfastsub[index].sem), 1);
1513 /* save a pointer to the usb device */
1514 usbduxfastsub[index].usbdev = udev;
1516 /* save the interface itself */
1517 usbduxfastsub[index].interface = uinterf;
1518 /* get the interface number from the interface */
1519 usbduxfastsub[index].ifnum = uinterf->altsetting->desc.bInterfaceNumber;
1521 * hand the private data over to the usb subsystem
1522 * will be needed for disconnect
1524 usb_set_intfdata(uinterf, &(usbduxfastsub[index]));
1526 #ifdef CONFIG_COMEDI_DEBUG
1527 printk(KERN_DEBUG "comedi_: usbduxfast: ifnum=%d\n",
1528 usbduxfastsub[index].ifnum);
1530 /* create space for the commands going to the usb device */
1531 usbduxfastsub[index].dux_commands = kmalloc(SIZEOFDUXBUFFER,
1533 if (!usbduxfastsub[index].dux_commands) {
1534 printk(KERN_ERR "comedi_: usbduxfast: error alloc space for "
1536 tidy_up(&(usbduxfastsub[index]));
1537 up(&start_stop_sem);
1540 /* create space of the instruction buffer */
1541 usbduxfastsub[index].insnBuffer = kmalloc(SIZEINSNBUF, GFP_KERNEL);
1542 if (!usbduxfastsub[index].insnBuffer) {
1543 printk(KERN_ERR "comedi_: usbduxfast: could not alloc space "
1544 "for insnBuffer\n");
1545 tidy_up(&(usbduxfastsub[index]));
1546 up(&start_stop_sem);
1549 /* setting to alternate setting 1: enabling bulk ep */
1550 i = usb_set_interface(usbduxfastsub[index].usbdev,
1551 usbduxfastsub[index].ifnum, 1);
1553 printk(KERN_ERR "comedi_: usbduxfast%d: could not switch to "
1554 "alternate setting 1.\n", index);
1555 tidy_up(&(usbduxfastsub[index]));
1556 up(&start_stop_sem);
1559 usbduxfastsub[index].urbIn = usb_alloc_urb(0, GFP_KERNEL);
1560 if (!usbduxfastsub[index].urbIn) {
1561 printk(KERN_ERR "comedi_: usbduxfast%d: Could not alloc."
1563 tidy_up(&(usbduxfastsub[index]));
1564 up(&start_stop_sem);
1567 usbduxfastsub[index].transfer_buffer = kmalloc(SIZEINBUF, GFP_KERNEL);
1568 if (!usbduxfastsub[index].transfer_buffer) {
1569 printk(KERN_ERR "comedi_: usbduxfast%d: could not alloc. "
1570 "transb.\n", index);
1571 tidy_up(&(usbduxfastsub[index]));
1572 up(&start_stop_sem);
1575 /* we've reached the bottom of the function */
1576 usbduxfastsub[index].probed = 1;
1577 up(&start_stop_sem);
1579 ret = request_firmware_nowait(THIS_MODULE,
1581 "usbduxfast_firmware.bin",
1584 usbduxfastsub + index,
1585 usbduxfast_firmware_request_complete_handler);
1588 dev_err(&udev->dev, "could not load firmware (err=%d)\n", ret);
1592 printk(KERN_INFO "comedi_: usbduxfast%d has been successfully "
1593 "initialized.\n", index);
1598 static void usbduxfastsub_disconnect(struct usb_interface *intf)
1600 struct usbduxfastsub_s *udfs = usb_get_intfdata(intf);
1601 struct usb_device *udev = interface_to_usbdev(intf);
1604 printk(KERN_ERR "comedi_: usbduxfast: disconnect called with "
1608 if (udfs->usbdev != udev) {
1609 printk(KERN_ERR "comedi_: usbduxfast: BUG! called with wrong "
1614 comedi_usb_auto_unconfig(intf);
1616 down(&start_stop_sem);
1620 up(&start_stop_sem);
1622 #ifdef CONFIG_COMEDI_DEBUG
1623 printk(KERN_DEBUG "comedi_: usbduxfast: disconnected from the usb\n");
1628 * is called when comedi-config is called
1630 static int usbduxfast_attach(struct comedi_device *dev,
1631 struct comedi_devconfig *it)
1636 struct comedi_subdevice *s = NULL;
1637 dev->private = NULL;
1639 down(&start_stop_sem);
1641 * find a valid device which has been detected by the
1642 * probe function of the usb
1645 for (i = 0; i < NUMUSBDUXFAST; i++) {
1646 if (usbduxfastsub[i].probed && !usbduxfastsub[i].attached) {
1653 printk(KERN_ERR "comedi%d: usbduxfast: error: attach failed, "
1654 "no usbduxfast devs connected to the usb bus.\n",
1656 up(&start_stop_sem);
1660 down(&(usbduxfastsub[index].sem));
1661 /* pointer back to the corresponding comedi device */
1662 usbduxfastsub[index].comedidev = dev;
1664 /* trying to upload the firmware into the chip */
1665 if (comedi_aux_data(it->options, 0) &&
1666 it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]) {
1667 firmwareUpload(&usbduxfastsub[index],
1668 comedi_aux_data(it->options, 0),
1669 it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH]);
1672 dev->board_name = BOARDNAME;
1674 /* set number of subdevices */
1675 dev->n_subdevices = N_SUBDEVICES;
1677 /* allocate space for the subdevices */
1678 ret = alloc_subdevices(dev, N_SUBDEVICES);
1680 printk(KERN_ERR "comedi%d: usbduxfast: error alloc space for "
1681 "subdev\n", dev->minor);
1682 up(&(usbduxfastsub[index].sem));
1683 up(&start_stop_sem);
1687 printk(KERN_INFO "comedi%d: usbduxfast: usb-device %d is attached to "
1688 "comedi.\n", dev->minor, index);
1689 /* private structure is also simply the usb-structure */
1690 dev->private = usbduxfastsub + index;
1691 /* the first subdevice is the A/D converter */
1692 s = dev->subdevices + SUBDEV_AD;
1694 * the URBs get the comedi subdevice which is responsible for reading
1695 * this is the subdevice which reads data
1697 dev->read_subdev = s;
1698 /* the subdevice receives as private structure the usb-structure */
1701 s->type = COMEDI_SUBD_AI;
1702 /* readable and ref is to ground */
1703 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
1706 /* length of the channellist */
1707 s->len_chanlist = 16;
1708 /* callback functions */
1709 s->insn_read = usbduxfast_ai_insn_read;
1710 s->do_cmdtest = usbduxfast_ai_cmdtest;
1711 s->do_cmd = usbduxfast_ai_cmd;
1712 s->cancel = usbduxfast_ai_cancel;
1713 /* max value from the A/D converter (12bit+1 bit for overflow) */
1714 s->maxdata = 0x1000;
1715 /* range table to convert to physical units */
1716 s->range_table = &range_usbduxfast_ai_range;
1718 /* finally decide that it's attached */
1719 usbduxfastsub[index].attached = 1;
1721 up(&(usbduxfastsub[index].sem));
1722 up(&start_stop_sem);
1723 printk(KERN_INFO "comedi%d: successfully attached to usbduxfast.\n",
1729 static void usbduxfast_detach(struct comedi_device *dev)
1731 struct usbduxfastsub_s *usb = dev->private;
1735 down(&start_stop_sem);
1736 dev->private = NULL;
1738 usb->comedidev = NULL;
1739 up(&start_stop_sem);
1745 * main driver struct
1747 static struct comedi_driver driver_usbduxfast = {
1748 .driver_name = "usbduxfast",
1749 .module = THIS_MODULE,
1750 .attach = usbduxfast_attach,
1751 .detach = usbduxfast_detach
1755 * Table with the USB-devices: just now only testing IDs
1757 static const struct usb_device_id usbduxfastsub_table[] = {
1758 /* { USB_DEVICE(0x4b4, 0x8613) }, testing */
1759 {USB_DEVICE(0x13d8, 0x0010)}, /* real ID */
1760 {USB_DEVICE(0x13d8, 0x0011)}, /* real ID */
1761 {} /* Terminating entry */
1764 MODULE_DEVICE_TABLE(usb, usbduxfastsub_table);
1767 * The usbduxfastsub-driver
1769 static struct usb_driver usbduxfastsub_driver = {
1770 #ifdef COMEDI_HAVE_USB_DRIVER_OWNER
1771 .owner = THIS_MODULE,
1774 .probe = usbduxfastsub_probe,
1775 .disconnect = usbduxfastsub_disconnect,
1776 .id_table = usbduxfastsub_table
1780 * Can't use the nice macro as I have also to initialise the USB subsystem:
1781 * registering the usb-system _and_ the comedi-driver
1783 static int __init init_usbduxfast(void)
1786 KBUILD_MODNAME ": " DRIVER_VERSION ":" DRIVER_DESC "\n");
1787 usb_register(&usbduxfastsub_driver);
1788 comedi_driver_register(&driver_usbduxfast);
1793 * deregistering the comedi driver and the usb-subsystem
1795 static void __exit exit_usbduxfast(void)
1797 comedi_driver_unregister(&driver_usbduxfast);
1798 usb_deregister(&usbduxfastsub_driver);
1801 module_init(init_usbduxfast);
1802 module_exit(exit_usbduxfast);
1804 MODULE_AUTHOR(DRIVER_AUTHOR);
1805 MODULE_DESCRIPTION(DRIVER_DESC);
1806 MODULE_LICENSE("GPL");