projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PM: Prevent runtime suspend during system resume
[deliverable/linux.git] / drivers / staging / comedi / drivers / usbdux.c
1 /*
2 comedi/drivers/usbdux.c
3 Copyright (C) 2003-2007 Bernd Porr, Bernd.Porr@f2s.com
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18
19 */
20 /*
21 Driver: usbdux
22 Description: University of Stirling USB DAQ & INCITE Technology Limited
23 Devices: [ITL] USB-DUX (usbdux.o)
24 Author: Bernd Porr <BerndPorr@f2s.com>
25 Updated: 8 Dec 2008
26 Status: Stable
27 Configuration options:
28 You have to upload firmware with the -i option. The
29 firmware is usually installed under /usr/share/usb or
30 /usr/local/share/usb or /lib/firmware.
31
32 Connection scheme for the counter at the digital port:
33 0=/CLK0, 1=UP/DOWN0, 2=RESET0, 4=/CLK1, 5=UP/DOWN1, 6=RESET1.
34 The sampling rate of the counter is approximately 500Hz.
35
36 Please note that under USB2.0 the length of the channel list determines
37 the max sampling rate. If you sample only one channel you get 8kHz
38 sampling rate. If you sample two channels you get 4kHz and so on.
39 */
40 /*
41 * I must give credit here to Chris Baugher who
42 * wrote the driver for AT-MIO-16d. I used some parts of this
43 * driver. I also must give credits to David Brownell
44 * who supported me with the USB development.
45 *
46 * Bernd Porr
47 *
48 *
49 * Revision history:
50 * 0.94: D/A output should work now with any channel list combinations
51 * 0.95: .owner commented out for kernel vers below 2.4.19
52 * sanity checks in ai/ao_cmd
53 * 0.96: trying to get it working with 2.6, moved all memory alloc to comedi's
54 * attach final USB IDs
55 * moved memory allocation completely to the corresponding comedi
56 * functions firmware upload is by fxload and no longer by comedi (due to
57 * enumeration)
58 * 0.97: USB IDs received, adjusted table
59 * 0.98: SMP, locking, memroy alloc: moved all usb memory alloc
60 * to the usb subsystem and moved all comedi related memory
61 * alloc to comedi.
62 * | kernel | registration | usbdux-usb | usbdux-comedi | comedi |
63 * 0.99: USB 2.0: changed protocol to isochronous transfer
64 * IRQ transfer is too buggy and too risky in 2.0
65 * for the high speed ISO transfer is now a working version
66 * available
67 * 0.99b: Increased the iso transfer buffer for high sp.to 10 buffers. Some VIA
68 * chipsets miss out IRQs. Deeper buffering is needed.
69 * 1.00: full USB 2.0 support for the A/D converter. Now: max 8kHz sampling
70 * rate.
71 * Firmware vers 1.00 is needed for this.
72 * Two 16 bit up/down/reset counter with a sampling rate of 1kHz
73 * And loads of cleaning up, in particular streamlining the
74 * bulk transfers.
75 * 1.1: moved EP4 transfers to EP1 to make space for a PWM output on EP4
76 * 1.2: added PWM suport via EP4
77 * 2.0: PWM seems to be stable and is not interfering with the other functions
78 * 2.1: changed PWM API
79 * 2.2: added firmware kernel request to fix an udev problem
80 * 2.3: corrected a bug in bulk timeouts which were far too short
81 * 2.4: fixed a bug which causes the driver to hang when it ran out of data.
82 * Thanks to Jan-Matthias Braun and Ian to spot the bug and fix it.
83 *
84 */
85
86 /* generates loads of debug info */
87 /* #define NOISY_DUX_DEBUGBUG */
88
89 #include <linux/kernel.h>
90 #include <linux/module.h>
91 #include <linux/init.h>
92 #include <linux/slab.h>
93 #include <linux/input.h>
94 #include <linux/usb.h>
95 #include <linux/fcntl.h>
96 #include <linux/compiler.h>
97 #include <linux/firmware.h>
98
99 #include "../comedidev.h"
100
101 /* timeout for the USB-transfer in ms*/
102 #define BULK_TIMEOUT 1000
103
104 /* constants for "firmware" upload and download */
105 #define USBDUXSUB_FIRMWARE 0xA0
106 #define VENDOR_DIR_IN 0xC0
107 #define VENDOR_DIR_OUT 0x40
108
109 /* internal addresses of the 8051 processor */
110 #define USBDUXSUB_CPUCS 0xE600
111
112 /*
113 * the minor device number, major is 180 only for debugging purposes and to
114 * upload special firmware (programming the eeprom etc) which is not compatible
115 * with the comedi framwork
116 */
117 #define USBDUXSUB_MINOR 32
118
119 /* max lenghth of the transfer-buffer for software upload */
120 #define TB_LEN 0x2000
121
122 /* Input endpoint number: ISO/IRQ */
123 #define ISOINEP 6
124
125 /* Output endpoint number: ISO/IRQ */
126 #define ISOOUTEP 2
127
128 /* This EP sends DUX commands to USBDUX */
129 #define COMMAND_OUT_EP 1
130
131 /* This EP receives the DUX commands from USBDUX */
132 #define COMMAND_IN_EP 8
133
134 /* Output endpoint for PWM */
135 #define PWM_EP 4
136
137 /* 300Hz max frequ under PWM */
138 #define MIN_PWM_PERIOD ((long)(1E9/300))
139
140 /* Default PWM frequency */
141 #define PWM_DEFAULT_PERIOD ((long)(1E9/100))
142
143 /* Number of channels */
144 #define NUMCHANNELS 8
145
146 /* Size of one A/D value */
147 #define SIZEADIN ((sizeof(int16_t)))
148
149 /*
150 * Size of the input-buffer IN BYTES
151 * Always multiple of 8 for 8 microframes which is needed in the highspeed mode
152 */
153 #define SIZEINBUF ((8*SIZEADIN))
154
155 /* 16 bytes. */
156 #define SIZEINSNBUF 16
157
158 /* Number of DA channels */
159 #define NUMOUTCHANNELS 8
160
161 /* size of one value for the D/A converter: channel and value */
162 #define SIZEDAOUT ((sizeof(int8_t)+sizeof(int16_t)))
163
164 /*
165 * Size of the output-buffer in bytes
166 * Actually only the first 4 triplets are used but for the
167 * high speed mode we need to pad it to 8 (microframes).
168 */
169 #define SIZEOUTBUF ((8*SIZEDAOUT))
170
171 /*
172 * Size of the buffer for the dux commands: just now max size is determined
173 * by the analogue out + command byte + panic bytes...
174 */
175 #define SIZEOFDUXBUFFER ((8*SIZEDAOUT+2))
176
177 /* Number of in-URBs which receive the data: min=2 */
178 #define NUMOFINBUFFERSFULL 5
179
180 /* Number of out-URBs which send the data: min=2 */
181 #define NUMOFOUTBUFFERSFULL 5
182
183 /* Number of in-URBs which receive the data: min=5 */
184 /* must have more buffers due to buggy USB ctr */
185 #define NUMOFINBUFFERSHIGH 10
186
187 /* Number of out-URBs which send the data: min=5 */
188 /* must have more buffers due to buggy USB ctr */
189 #define NUMOFOUTBUFFERSHIGH 10
190
191 /* Total number of usbdux devices */
192 #define NUMUSBDUX 16
193
194 /* Analogue in subdevice */
195 #define SUBDEV_AD 0
196
197 /* Analogue out subdevice */
198 #define SUBDEV_DA 1
199
200 /* Digital I/O */
201 #define SUBDEV_DIO 2
202
203 /* counter */
204 #define SUBDEV_COUNTER 3
205
206 /* timer aka pwm output */
207 #define SUBDEV_PWM 4
208
209 /* number of retries to get the right dux command */
210 #define RETRIES 10
211
212 /**************************************************/
213 /* comedi constants */
214 static const struct comedi_lrange range_usbdux_ai_range = { 4, {
215 BIP_RANGE
216 (4.096),
217 BIP_RANGE(4.096
218 / 2),
219 UNI_RANGE
220 (4.096),
221 UNI_RANGE(4.096
222 / 2)
223 }
224 };
225
226 static const struct comedi_lrange range_usbdux_ao_range = { 2, {
227 BIP_RANGE
228 (4.096),
229 UNI_RANGE
230 (4.096),
231 }
232 };
233
234 /*
235 * private structure of one subdevice
236 */
237
238 /*
239 * This is the structure which holds all the data of
240 * this driver one sub device just now: A/D
241 */
242 struct usbduxsub {
243 /* attached? */
244 int attached;
245 /* is it associated with a subdevice? */
246 int probed;
247 /* pointer to the usb-device */
248 struct usb_device *usbdev;
249 /* actual number of in-buffers */
250 int numOfInBuffers;
251 /* actual number of out-buffers */
252 int numOfOutBuffers;
253 /* ISO-transfer handling: buffers */
254 struct urb **urbIn;
255 struct urb **urbOut;
256 /* pwm-transfer handling */
257 struct urb *urbPwm;
258 /* PWM period */
259 unsigned int pwmPeriod;
260 /* PWM internal delay for the GPIF in the FX2 */
261 int8_t pwmDelay;
262 /* size of the PWM buffer which holds the bit pattern */
263 int sizePwmBuf;
264 /* input buffer for the ISO-transfer */
265 int16_t *inBuffer;
266 /* input buffer for single insn */
267 int16_t *insnBuffer;
268 /* output buffer for single DA outputs */
269 int16_t *outBuffer;
270 /* interface number */
271 int ifnum;
272 /* interface structure in 2.6 */
273 struct usb_interface *interface;
274 /* comedi device for the interrupt context */
275 struct comedi_device *comedidev;
276 /* is it USB_SPEED_HIGH or not? */
277 short int high_speed;
278 /* asynchronous command is running */
279 short int ai_cmd_running;
280 short int ao_cmd_running;
281 /* pwm is running */
282 short int pwm_cmd_running;
283 /* continous acquisition */
284 short int ai_continous;
285 short int ao_continous;
286 /* number of samples to acquire */
287 int ai_sample_count;
288 int ao_sample_count;
289 /* time between samples in units of the timer */
290 unsigned int ai_timer;
291 unsigned int ao_timer;
292 /* counter between aquisitions */
293 unsigned int ai_counter;
294 unsigned int ao_counter;
295 /* interval in frames/uframes */
296 unsigned int ai_interval;
297 /* D/A commands */
298 int8_t *dac_commands;
299 /* commands */
300 int8_t *dux_commands;
301 struct semaphore sem;
302 };
303
304 /*
305 * The pointer to the private usb-data of the driver is also the private data
306 * for the comedi-device. This has to be global as the usb subsystem needs
307 * global variables. The other reason is that this structure must be there
308 * _before_ any comedi command is issued. The usb subsystem must be initialised
309 * before comedi can access it.
310 */
311 static struct usbduxsub usbduxsub[NUMUSBDUX];
312
313 static DEFINE_SEMAPHORE(start_stop_sem);
314
315 /*
316 * Stops the data acquision
317 * It should be safe to call this function from any context
318 */
319 static int usbduxsub_unlink_InURBs(struct usbduxsub *usbduxsub_tmp)
320 {
321 int i = 0;
322 int err = 0;
323
324 if (usbduxsub_tmp && usbduxsub_tmp->urbIn) {
325 for (i = 0; i < usbduxsub_tmp->numOfInBuffers; i++) {
326 if (usbduxsub_tmp->urbIn[i]) {
327 /* We wait here until all transfers have been
328 * cancelled. */
329 usb_kill_urb(usbduxsub_tmp->urbIn[i]);
330 }
331 dev_dbg(&usbduxsub_tmp->interface->dev,
332 "comedi: usbdux: unlinked InURB %d, err=%d\n",
333 i, err);
334 }
335 }
336 return err;
337 }
338
339 /*
340 * This will stop a running acquisition operation
341 * Is called from within this driver from both the
342 * interrupt context and from comedi
343 */
344 static int usbdux_ai_stop(struct usbduxsub *this_usbduxsub, int do_unlink)
345 {
346 int ret = 0;
347
348 if (!this_usbduxsub) {
349 pr_err("comedi?: usbdux_ai_stop: this_usbduxsub=NULL!\n");
350 return -EFAULT;
351 }
352 dev_dbg(&this_usbduxsub->interface->dev, "comedi: usbdux_ai_stop\n");
353
354 if (do_unlink) {
355 /* stop aquistion */
356 ret = usbduxsub_unlink_InURBs(this_usbduxsub);
357 }
358
359 this_usbduxsub->ai_cmd_running = 0;
360
361 return ret;
362 }
363
364 /*
365 * This will cancel a running acquisition operation.
366 * This is called by comedi but never from inside the driver.
367 */
368 static int usbdux_ai_cancel(struct comedi_device *dev,
369 struct comedi_subdevice *s)
370 {
371 struct usbduxsub *this_usbduxsub;
372 int res = 0;
373
374 /* force unlink of all urbs */
375 this_usbduxsub = dev->private;
376 if (!this_usbduxsub)
377 return -EFAULT;
378
379 dev_dbg(&this_usbduxsub->interface->dev, "comedi: usbdux_ai_cancel\n");
380
381 /* prevent other CPUs from submitting new commands just now */
382 down(&this_usbduxsub->sem);
383 if (!(this_usbduxsub->probed)) {
384 up(&this_usbduxsub->sem);
385 return -ENODEV;
386 }
387 /* unlink only if the urb really has been submitted */
388 res = usbdux_ai_stop(this_usbduxsub, this_usbduxsub->ai_cmd_running);
389 up(&this_usbduxsub->sem);
390 return res;
391 }
392
393 /* analogue IN - interrupt service routine */
394 static void usbduxsub_ai_IsocIrq(struct urb *urb)
395 {
396 int i, err, n;
397 struct usbduxsub *this_usbduxsub;
398 struct comedi_device *this_comedidev;
399 struct comedi_subdevice *s;
400
401 /* the context variable points to the subdevice */
402 this_comedidev = urb->context;
403 /* the private structure of the subdevice is struct usbduxsub */
404 this_usbduxsub = this_comedidev->private;
405 /* subdevice which is the AD converter */
406 s = this_comedidev->subdevices + SUBDEV_AD;
407
408 /* first we test if something unusual has just happened */
409 switch (urb->status) {
410 case 0:
411 /* copy the result in the transfer buffer */
412 memcpy(this_usbduxsub->inBuffer,
413 urb->transfer_buffer, SIZEINBUF);
414 break;
415 case -EILSEQ:
416 /* error in the ISOchronous data */
417 /* we don't copy the data into the transfer buffer */
418 /* and recycle the last data byte */
419 dev_dbg(&urb->dev->dev,
420 "comedi%d: usbdux: CRC error in ISO IN stream.\n",
421 this_usbduxsub->comedidev->minor);
422
423 break;
424
425 case -ECONNRESET:
426 case -ENOENT:
427 case -ESHUTDOWN:
428 case -ECONNABORTED:
429 /* happens after an unlink command */
430 if (this_usbduxsub->ai_cmd_running) {
431 /* we are still running a command */
432 /* tell this comedi */
433 s->async->events |= COMEDI_CB_EOA;
434 s->async->events |= COMEDI_CB_ERROR;
435 comedi_event(this_usbduxsub->comedidev, s);
436 /* stop the transfer w/o unlink */
437 usbdux_ai_stop(this_usbduxsub, 0);
438 }
439 return;
440
441 default:
442 /* a real error on the bus */
443 /* pass error to comedi if we are really running a command */
444 if (this_usbduxsub->ai_cmd_running) {
445 dev_err(&urb->dev->dev,
446 "Non-zero urb status received in ai intr "
447 "context: %d\n", urb->status);
448 s->async->events |= COMEDI_CB_EOA;
449 s->async->events |= COMEDI_CB_ERROR;
450 comedi_event(this_usbduxsub->comedidev, s);
451 /* don't do an unlink here */
452 usbdux_ai_stop(this_usbduxsub, 0);
453 }
454 return;
455 }
456
457 /*
458 * at this point we are reasonably sure that nothing dodgy has happened
459 * are we running a command?
460 */
461 if (unlikely((!(this_usbduxsub->ai_cmd_running)))) {
462 /*
463 * not running a command, do not continue execution if no
464 * asynchronous command is running in particular not resubmit
465 */
466 return;
467 }
468
469 urb->dev = this_usbduxsub->usbdev;
470
471 /* resubmit the urb */
472 err = usb_submit_urb(urb, GFP_ATOMIC);
473 if (unlikely(err < 0)) {
474 dev_err(&urb->dev->dev,
475 "comedi_: urb resubmit failed in int-context! err=%d\n",
476 err);
477 if (err == -EL2NSYNC)
478 dev_err(&urb->dev->dev,
479 "buggy USB host controller or bug in IRQ "
480 "handler!\n");
481 s->async->events |= COMEDI_CB_EOA;
482 s->async->events |= COMEDI_CB_ERROR;
483 comedi_event(this_usbduxsub->comedidev, s);
484 /* don't do an unlink here */
485 usbdux_ai_stop(this_usbduxsub, 0);
486 return;
487 }
488
489 this_usbduxsub->ai_counter--;
490 if (likely(this_usbduxsub->ai_counter > 0))
491 return;
492
493 /* timer zero, transfer measurements to comedi */
494 this_usbduxsub->ai_counter = this_usbduxsub->ai_timer;
495
496 /* test, if we transmit only a fixed number of samples */
497 if (!(this_usbduxsub->ai_continous)) {
498 /* not continuous, fixed number of samples */
499 this_usbduxsub->ai_sample_count--;
500 /* all samples received? */
501 if (this_usbduxsub->ai_sample_count < 0) {
502 /* prevent a resubmit next time */
503 usbdux_ai_stop(this_usbduxsub, 0);
504 /* say comedi that the acquistion is over */
505 s->async->events |= COMEDI_CB_EOA;
506 comedi_event(this_usbduxsub->comedidev, s);
507 return;
508 }
509 }
510 /* get the data from the USB bus and hand it over to comedi */
511 n = s->async->cmd.chanlist_len;
512 for (i = 0; i < n; i++) {
513 /* transfer data */
514 if (CR_RANGE(s->async->cmd.chanlist[i]) <= 1) {
515 err = comedi_buf_put
516 (s->async,
517 le16_to_cpu(this_usbduxsub->inBuffer[i]) ^ 0x800);
518 } else {
519 err = comedi_buf_put
520 (s->async,
521 le16_to_cpu(this_usbduxsub->inBuffer[i]));
522 }
523 if (unlikely(err == 0)) {
524 /* buffer overflow */
525 usbdux_ai_stop(this_usbduxsub, 0);
526 return;
527 }
528 }
529 /* tell comedi that data is there */
530 s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
531 comedi_event(this_usbduxsub->comedidev, s);
532 }
533
534 static int usbduxsub_unlink_OutURBs(struct usbduxsub *usbduxsub_tmp)
535 {
536 int i = 0;
537 int err = 0;
538
539 if (usbduxsub_tmp && usbduxsub_tmp->urbOut) {
540 for (i = 0; i < usbduxsub_tmp->numOfOutBuffers; i++) {
541 if (usbduxsub_tmp->urbOut[i])
542 usb_kill_urb(usbduxsub_tmp->urbOut[i]);
543
544 dev_dbg(&usbduxsub_tmp->interface->dev,
545 "comedi: usbdux: unlinked OutURB %d: res=%d\n",
546 i, err);
547 }
548 }
549 return err;
550 }
551
552 /* This will cancel a running acquisition operation
553 * in any context.
554 */
555 static int usbdux_ao_stop(struct usbduxsub *this_usbduxsub, int do_unlink)
556 {
557 int ret = 0;
558
559 if (!this_usbduxsub)
560 return -EFAULT;
561 dev_dbg(&this_usbduxsub->interface->dev, "comedi: usbdux_ao_cancel\n");
562
563 if (do_unlink)
564 ret = usbduxsub_unlink_OutURBs(this_usbduxsub);
565
566 this_usbduxsub->ao_cmd_running = 0;
567
568 return ret;
569 }
570
571 /* force unlink, is called by comedi */
572 static int usbdux_ao_cancel(struct comedi_device *dev,
573 struct comedi_subdevice *s)
574 {
575 struct usbduxsub *this_usbduxsub = dev->private;
576 int res = 0;
577
578 if (!this_usbduxsub)
579 return -EFAULT;
580
581 /* prevent other CPUs from submitting a command just now */
582 down(&this_usbduxsub->sem);
583 if (!(this_usbduxsub->probed)) {
584 up(&this_usbduxsub->sem);
585 return -ENODEV;
586 }
587 /* unlink only if it is really running */
588 res = usbdux_ao_stop(this_usbduxsub, this_usbduxsub->ao_cmd_running);
589 up(&this_usbduxsub->sem);
590 return res;
591 }
592
593 static void usbduxsub_ao_IsocIrq(struct urb *urb)
594 {
595 int i, ret;
596 int8_t *datap;
597 struct usbduxsub *this_usbduxsub;
598 struct comedi_device *this_comedidev;
599 struct comedi_subdevice *s;
600
601 /* the context variable points to the subdevice */
602 this_comedidev = urb->context;
603 /* the private structure of the subdevice is struct usbduxsub */
604 this_usbduxsub = this_comedidev->private;
605
606 s = this_comedidev->subdevices + SUBDEV_DA;
607
608 switch (urb->status) {
609 case 0:
610 /* success */
611 break;
612
613 case -ECONNRESET:
614 case -ENOENT:
615 case -ESHUTDOWN:
616 case -ECONNABORTED:
617 /* after an unlink command, unplug, ... etc */
618 /* no unlink needed here. Already shutting down. */
619 if (this_usbduxsub->ao_cmd_running) {
620 s->async->events |= COMEDI_CB_EOA;
621 comedi_event(this_usbduxsub->comedidev, s);
622 usbdux_ao_stop(this_usbduxsub, 0);
623 }
624 return;
625
626 default:
627 /* a real error */
628 if (this_usbduxsub->ao_cmd_running) {
629 dev_err(&urb->dev->dev,
630 "comedi_: Non-zero urb status received in ao "
631 "intr context: %d\n", urb->status);
632 s->async->events |= COMEDI_CB_ERROR;
633 s->async->events |= COMEDI_CB_EOA;
634 comedi_event(this_usbduxsub->comedidev, s);
635 /* we do an unlink if we are in the high speed mode */
636 usbdux_ao_stop(this_usbduxsub, 0);
637 }
638 return;
639 }
640
641 /* are we actually running? */
642 if (!(this_usbduxsub->ao_cmd_running))
643 return;
644
645 /* normal operation: executing a command in this subdevice */
646 this_usbduxsub->ao_counter--;
647 if ((int)this_usbduxsub->ao_counter <= 0) {
648 /* timer zero */
649 this_usbduxsub->ao_counter = this_usbduxsub->ao_timer;
650
651 /* handle non continous acquisition */
652 if (!(this_usbduxsub->ao_continous)) {
653 /* fixed number of samples */
654 this_usbduxsub->ao_sample_count--;
655 if (this_usbduxsub->ao_sample_count < 0) {
656 /* all samples transmitted */
657 usbdux_ao_stop(this_usbduxsub, 0);
658 s->async->events |= COMEDI_CB_EOA;
659 comedi_event(this_usbduxsub->comedidev, s);
660 /* no resubmit of the urb */
661 return;
662 }
663 }
664 /* transmit data to the USB bus */
665 ((uint8_t *) (urb->transfer_buffer))[0] =
666 s->async->cmd.chanlist_len;
667 for (i = 0; i < s->async->cmd.chanlist_len; i++) {
668 short temp;
669 if (i >= NUMOUTCHANNELS)
670 break;
671
672 /* pointer to the DA */
673 datap =
674 (&(((int8_t *) urb->transfer_buffer)[i * 3 + 1]));
675 /* get the data from comedi */
676 ret = comedi_buf_get(s->async, &temp);
677 datap[0] = temp;
678 datap[1] = temp >> 8;
679 datap[2] = this_usbduxsub->dac_commands[i];
680 /* printk("data[0]=%x, data[1]=%x, data[2]=%x\n", */
681 /* datap[0],datap[1],datap[2]); */
682 if (ret < 0) {
683 dev_err(&urb->dev->dev,
684 "comedi: buffer underflow\n");
685 s->async->events |= COMEDI_CB_EOA;
686 s->async->events |= COMEDI_CB_OVERFLOW;
687 }
688 /* transmit data to comedi */
689 s->async->events |= COMEDI_CB_BLOCK;
690 comedi_event(this_usbduxsub->comedidev, s);
691 }
692 }
693 urb->transfer_buffer_length = SIZEOUTBUF;
694 urb->dev = this_usbduxsub->usbdev;
695 urb->status = 0;
696 if (this_usbduxsub->ao_cmd_running) {
697 if (this_usbduxsub->high_speed) {
698 /* uframes */
699 urb->interval = 8;
700 } else {
701 /* frames */
702 urb->interval = 1;
703 }
704 urb->number_of_packets = 1;
705 urb->iso_frame_desc[0].offset = 0;
706 urb->iso_frame_desc[0].length = SIZEOUTBUF;
707 urb->iso_frame_desc[0].status = 0;
708 ret = usb_submit_urb(urb, GFP_ATOMIC);
709 if (ret < 0) {
710 dev_err(&urb->dev->dev,
711 "comedi_: ao urb resubm failed in int-cont. "
712 "ret=%d", ret);
713 if (ret == EL2NSYNC)
714 dev_err(&urb->dev->dev,
715 "buggy USB host controller or bug in "
716 "IRQ handling!\n");
717
718 s->async->events |= COMEDI_CB_EOA;
719 s->async->events |= COMEDI_CB_ERROR;
720 comedi_event(this_usbduxsub->comedidev, s);
721 /* don't do an unlink here */
722 usbdux_ao_stop(this_usbduxsub, 0);
723 }
724 }
725 }
726
727 static int usbduxsub_start(struct usbduxsub *usbduxsub)
728 {
729 int errcode = 0;
730 uint8_t local_transfer_buffer[16];
731
732 /* 7f92 to zero */
733 local_transfer_buffer[0] = 0;
734 errcode = usb_control_msg(usbduxsub->usbdev,
735 /* create a pipe for a control transfer */
736 usb_sndctrlpipe(usbduxsub->usbdev, 0),
737 /* bRequest, "Firmware" */
738 USBDUXSUB_FIRMWARE,
739 /* bmRequestType */
740 VENDOR_DIR_OUT,
741 /* Value */
742 USBDUXSUB_CPUCS,
743 /* Index */
744 0x0000,
745 /* address of the transfer buffer */
746 local_transfer_buffer,
747 /* Length */
748 1,
749 /* Timeout */
750 BULK_TIMEOUT);
751 if (errcode < 0) {
752 dev_err(&usbduxsub->interface->dev,
753 "comedi_: control msg failed (start)\n");
754 return errcode;
755 }
756 return 0;
757 }
758
759 static int usbduxsub_stop(struct usbduxsub *usbduxsub)
760 {
761 int errcode = 0;
762
763 uint8_t local_transfer_buffer[16];
764
765 /* 7f92 to one */
766 local_transfer_buffer[0] = 1;
767 errcode = usb_control_msg(usbduxsub->usbdev,
768 usb_sndctrlpipe(usbduxsub->usbdev, 0),
769 /* bRequest, "Firmware" */
770 USBDUXSUB_FIRMWARE,
771 /* bmRequestType */
772 VENDOR_DIR_OUT,
773 /* Value */
774 USBDUXSUB_CPUCS,
775 /* Index */
776 0x0000, local_transfer_buffer,
777 /* Length */
778 1,
779 /* Timeout */
780 BULK_TIMEOUT);
781 if (errcode < 0) {
782 dev_err(&usbduxsub->interface->dev,
783 "comedi_: control msg failed (stop)\n");
784 return errcode;
785 }
786 return 0;
787 }
788
789 static int usbduxsub_upload(struct usbduxsub *usbduxsub,
790 uint8_t *local_transfer_buffer,
791 unsigned int startAddr, unsigned int len)
792 {
793 int errcode;
794
795 errcode = usb_control_msg(usbduxsub->usbdev,
796 usb_sndctrlpipe(usbduxsub->usbdev, 0),
797 /* brequest, firmware */
798 USBDUXSUB_FIRMWARE,
799 /* bmRequestType */
800 VENDOR_DIR_OUT,
801 /* value */
802 startAddr,
803 /* index */
804 0x0000,
805 /* our local safe buffer */
806 local_transfer_buffer,
807 /* length */
808 len,
809 /* timeout */
810 BULK_TIMEOUT);
811 dev_dbg(&usbduxsub->interface->dev, "comedi_: result=%d\n", errcode);
812 if (errcode < 0) {
813 dev_err(&usbduxsub->interface->dev, "comedi_: upload failed\n");
814 return errcode;
815 }
816 return 0;
817 }
818
819 #define FIRMWARE_MAX_LEN 0x2000
820
821 static int firmwareUpload(struct usbduxsub *usbduxsub,
822 const u8 *firmwareBinary, int sizeFirmware)
823 {
824 int ret;
825 uint8_t *fwBuf;
826
827 if (!firmwareBinary)
828 return 0;
829
830 if (sizeFirmware > FIRMWARE_MAX_LEN) {
831 dev_err(&usbduxsub->interface->dev,
832 "usbdux firmware binary it too large for FX2.\n");
833 return -ENOMEM;
834 }
835
836 /* we generate a local buffer for the firmware */
837 fwBuf = kmemdup(firmwareBinary, sizeFirmware, GFP_KERNEL);
838 if (!fwBuf) {
839 dev_err(&usbduxsub->interface->dev,
840 "comedi_: mem alloc for firmware failed\n");
841 return -ENOMEM;
842 }
843
844 ret = usbduxsub_stop(usbduxsub);
845 if (ret < 0) {
846 dev_err(&usbduxsub->interface->dev,
847 "comedi_: can not stop firmware\n");
848 kfree(fwBuf);
849 return ret;
850 }
851
852 ret = usbduxsub_upload(usbduxsub, fwBuf, 0, sizeFirmware);
853 if (ret < 0) {
854 dev_err(&usbduxsub->interface->dev,
855 "comedi_: firmware upload failed\n");
856 kfree(fwBuf);
857 return ret;
858 }
859 ret = usbduxsub_start(usbduxsub);
860 if (ret < 0) {
861 dev_err(&usbduxsub->interface->dev,
862 "comedi_: can not start firmware\n");
863 kfree(fwBuf);
864 return ret;
865 }
866 kfree(fwBuf);
867 return 0;
868 }
869
870 static int usbduxsub_submit_InURBs(struct usbduxsub *usbduxsub)
871 {
872 int i, errFlag;
873
874 if (!usbduxsub)
875 return -EFAULT;
876
877 /* Submit all URBs and start the transfer on the bus */
878 for (i = 0; i < usbduxsub->numOfInBuffers; i++) {
879 /* in case of a resubmission after an unlink... */
880 usbduxsub->urbIn[i]->interval = usbduxsub->ai_interval;
881 usbduxsub->urbIn[i]->context = usbduxsub->comedidev;
882 usbduxsub->urbIn[i]->dev = usbduxsub->usbdev;
883 usbduxsub->urbIn[i]->status = 0;
884 usbduxsub->urbIn[i]->transfer_flags = URB_ISO_ASAP;
885 dev_dbg(&usbduxsub->interface->dev,
886 "comedi%d: submitting in-urb[%d]: %p,%p intv=%d\n",
887 usbduxsub->comedidev->minor, i,
888 (usbduxsub->urbIn[i]->context),
889 (usbduxsub->urbIn[i]->dev),
890 (usbduxsub->urbIn[i]->interval));
891 errFlag = usb_submit_urb(usbduxsub->urbIn[i], GFP_ATOMIC);
892 if (errFlag) {
893 dev_err(&usbduxsub->interface->dev,
894 "comedi_: ai: usb_submit_urb(%d) error %d\n",
895 i, errFlag);
896 return errFlag;
897 }
898 }
899 return 0;
900 }
901
902 static int usbduxsub_submit_OutURBs(struct usbduxsub *usbduxsub)
903 {
904 int i, errFlag;
905
906 if (!usbduxsub)
907 return -EFAULT;
908
909 for (i = 0; i < usbduxsub->numOfOutBuffers; i++) {
910 dev_dbg(&usbduxsub->interface->dev,
911 "comedi_: submitting out-urb[%d]\n", i);
912 /* in case of a resubmission after an unlink... */
913 usbduxsub->urbOut[i]->context = usbduxsub->comedidev;
914 usbduxsub->urbOut[i]->dev = usbduxsub->usbdev;
915 usbduxsub->urbOut[i]->status = 0;
916 usbduxsub->urbOut[i]->transfer_flags = URB_ISO_ASAP;
917 errFlag = usb_submit_urb(usbduxsub->urbOut[i], GFP_ATOMIC);
918 if (errFlag) {
919 dev_err(&usbduxsub->interface->dev,
920 "comedi_: ao: usb_submit_urb(%d) error %d\n",
921 i, errFlag);
922 return errFlag;
923 }
924 }
925 return 0;
926 }
927
928 static int usbdux_ai_cmdtest(struct comedi_device *dev,
929 struct comedi_subdevice *s, struct comedi_cmd *cmd)
930 {
931 int err = 0, tmp, i;
932 unsigned int tmpTimer;
933 struct usbduxsub *this_usbduxsub = dev->private;
934
935 if (!(this_usbduxsub->probed))
936 return -ENODEV;
937
938 dev_dbg(&this_usbduxsub->interface->dev,
939 "comedi%d: usbdux_ai_cmdtest\n", dev->minor);
940
941 /* make sure triggers are valid */
942 /* Only immediate triggers are allowed */
943 tmp = cmd->start_src;
944 cmd->start_src &= TRIG_NOW | TRIG_INT;
945 if (!cmd->start_src || tmp != cmd->start_src)
946 err++;
947
948 /* trigger should happen timed */
949 tmp = cmd->scan_begin_src;
950 /* start a new _scan_ with a timer */
951 cmd->scan_begin_src &= TRIG_TIMER;
952 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
953 err++;
954
955 /* scanning is continuous */
956 tmp = cmd->convert_src;
957 cmd->convert_src &= TRIG_NOW;
958 if (!cmd->convert_src || tmp != cmd->convert_src)
959 err++;
960
961 /* issue a trigger when scan is finished and start a new scan */
962 tmp = cmd->scan_end_src;
963 cmd->scan_end_src &= TRIG_COUNT;
964 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
965 err++;
966
967 /* trigger at the end of count events or not, stop condition or not */
968 tmp = cmd->stop_src;
969 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
970 if (!cmd->stop_src || tmp != cmd->stop_src)
971 err++;
972
973 if (err)
974 return 1;
975
976 /*
977 * step 2: make sure trigger sources are unique and mutually compatible
978 * note that mutual compatibility is not an issue here
979 */
980 if (cmd->scan_begin_src != TRIG_FOLLOW &&
981 cmd->scan_begin_src != TRIG_EXT &&
982 cmd->scan_begin_src != TRIG_TIMER)
983 err++;
984 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
985 err++;
986
987 if (err)
988 return 2;
989
990 /* step 3: make sure arguments are trivially compatible */
991 if (cmd->start_arg != 0) {
992 cmd->start_arg = 0;
993 err++;
994 }
995
996 if (cmd->scan_begin_src == TRIG_FOLLOW) {
997 /* internal trigger */
998 if (cmd->scan_begin_arg != 0) {
999 cmd->scan_begin_arg = 0;
1000 err++;
1001 }
1002 }
1003
1004 if (cmd->scan_begin_src == TRIG_TIMER) {
1005 if (this_usbduxsub->high_speed) {
1006 /*
1007 * In high speed mode microframes are possible.
1008 * However, during one microframe we can roughly
1009 * sample one channel. Thus, the more channels
1010 * are in the channel list the more time we need.
1011 */
1012 i = 1;
1013 /* find a power of 2 for the number of channels */
1014 while (i < (cmd->chanlist_len))
1015 i = i * 2;
1016
1017 if (cmd->scan_begin_arg < (1000000 / 8 * i)) {
1018 cmd->scan_begin_arg = 1000000 / 8 * i;
1019 err++;
1020 }
1021 /* now calc the real sampling rate with all the
1022 * rounding errors */
1023 tmpTimer =
1024 ((unsigned int)(cmd->scan_begin_arg / 125000)) *
1025 125000;
1026 if (cmd->scan_begin_arg != tmpTimer) {
1027 cmd->scan_begin_arg = tmpTimer;
1028 err++;
1029 }
1030 } else {
1031 /* full speed */
1032 /* 1kHz scans every USB frame */
1033 if (cmd->scan_begin_arg < 1000000) {
1034 cmd->scan_begin_arg = 1000000;
1035 err++;
1036 }
1037 /*
1038 * calc the real sampling rate with the rounding errors
1039 */
1040 tmpTimer = ((unsigned int)(cmd->scan_begin_arg /
1041 1000000)) * 1000000;
1042 if (cmd->scan_begin_arg != tmpTimer) {
1043 cmd->scan_begin_arg = tmpTimer;
1044 err++;
1045 }
1046 }
1047 }
1048 /* the same argument */
1049 if (cmd->scan_end_arg != cmd->chanlist_len) {
1050 cmd->scan_end_arg = cmd->chanlist_len;
1051 err++;
1052 }
1053
1054 if (cmd->stop_src == TRIG_COUNT) {
1055 /* any count is allowed */
1056 } else {
1057 /* TRIG_NONE */
1058 if (cmd->stop_arg != 0) {
1059 cmd->stop_arg = 0;
1060 err++;
1061 }
1062 }
1063
1064 if (err)
1065 return 3;
1066
1067 return 0;
1068 }
1069
1070 /*
1071 * creates the ADC command for the MAX1271
1072 * range is the range value from comedi
1073 */
1074 static int8_t create_adc_command(unsigned int chan, int range)
1075 {
1076 int8_t p = (range <= 1);
1077 int8_t r = ((range % 2) == 0);
1078 return (chan << 4) | ((p == 1) << 2) | ((r == 1) << 3);
1079 }
1080
1081 /* bulk transfers to usbdux */
1082
1083 #define SENDADCOMMANDS 0
1084 #define SENDDACOMMANDS 1
1085 #define SENDDIOCONFIGCOMMAND 2
1086 #define SENDDIOBITSCOMMAND 3
1087 #define SENDSINGLEAD 4
1088 #define READCOUNTERCOMMAND 5
1089 #define WRITECOUNTERCOMMAND 6
1090 #define SENDPWMON 7
1091 #define SENDPWMOFF 8
1092
1093 static int send_dux_commands(struct usbduxsub *this_usbduxsub, int cmd_type)
1094 {
1095 int result, nsent;
1096
1097 this_usbduxsub->dux_commands[0] = cmd_type;
1098 #ifdef NOISY_DUX_DEBUGBUG
1099 printk(KERN_DEBUG "comedi%d: usbdux: dux_commands: ",
1100 this_usbduxsub->comedidev->minor);
1101 for (result = 0; result < SIZEOFDUXBUFFER; result++)
1102 printk(" %02x", this_usbduxsub->dux_commands[result]);
1103 printk("\n");
1104 #endif
1105 result = usb_bulk_msg(this_usbduxsub->usbdev,
1106 usb_sndbulkpipe(this_usbduxsub->usbdev,
1107 COMMAND_OUT_EP),
1108 this_usbduxsub->dux_commands, SIZEOFDUXBUFFER,
1109 &nsent, BULK_TIMEOUT);
1110 if (result < 0)
1111 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1112 "could not transmit dux_command to the usb-device, "
1113 "err=%d\n", this_usbduxsub->comedidev->minor, result);
1114
1115 return result;
1116 }
1117
1118 static int receive_dux_commands(struct usbduxsub *this_usbduxsub, int command)
1119 {
1120 int result = (-EFAULT);
1121 int nrec;
1122 int i;
1123
1124 for (i = 0; i < RETRIES; i++) {
1125 result = usb_bulk_msg(this_usbduxsub->usbdev,
1126 usb_rcvbulkpipe(this_usbduxsub->usbdev,
1127 COMMAND_IN_EP),
1128 this_usbduxsub->insnBuffer, SIZEINSNBUF,
1129 &nrec, BULK_TIMEOUT);
1130 if (result < 0) {
1131 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1132 "insn: USB error %d while receiving DUX command"
1133 "\n", this_usbduxsub->comedidev->minor, result);
1134 return result;
1135 }
1136 if (le16_to_cpu(this_usbduxsub->insnBuffer[0]) == command)
1137 return result;
1138 }
1139 /* this is only reached if the data has been requested a couple of
1140 * times */
1141 dev_err(&this_usbduxsub->interface->dev, "comedi%d: insn: "
1142 "wrong data returned from firmware: want cmd %d, got cmd %d.\n",
1143 this_usbduxsub->comedidev->minor, command,
1144 le16_to_cpu(this_usbduxsub->insnBuffer[0]));
1145 return -EFAULT;
1146 }
1147
1148 static int usbdux_ai_inttrig(struct comedi_device *dev,
1149 struct comedi_subdevice *s, unsigned int trignum)
1150 {
1151 int ret;
1152 struct usbduxsub *this_usbduxsub = dev->private;
1153 if (!this_usbduxsub)
1154 return -EFAULT;
1155
1156 down(&this_usbduxsub->sem);
1157 if (!(this_usbduxsub->probed)) {
1158 up(&this_usbduxsub->sem);
1159 return -ENODEV;
1160 }
1161 dev_dbg(&this_usbduxsub->interface->dev,
1162 "comedi%d: usbdux_ai_inttrig\n", dev->minor);
1163
1164 if (trignum != 0) {
1165 dev_err(&this_usbduxsub->interface->dev,
1166 "comedi%d: usbdux_ai_inttrig: invalid trignum\n",
1167 dev->minor);
1168 up(&this_usbduxsub->sem);
1169 return -EINVAL;
1170 }
1171 if (!(this_usbduxsub->ai_cmd_running)) {
1172 this_usbduxsub->ai_cmd_running = 1;
1173 ret = usbduxsub_submit_InURBs(this_usbduxsub);
1174 if (ret < 0) {
1175 dev_err(&this_usbduxsub->interface->dev,
1176 "comedi%d: usbdux_ai_inttrig: "
1177 "urbSubmit: err=%d\n", dev->minor, ret);
1178 this_usbduxsub->ai_cmd_running = 0;
1179 up(&this_usbduxsub->sem);
1180 return ret;
1181 }
1182 s->async->inttrig = NULL;
1183 } else {
1184 dev_err(&this_usbduxsub->interface->dev,
1185 "comedi%d: ai_inttrig but acqu is already running\n",
1186 dev->minor);
1187 }
1188 up(&this_usbduxsub->sem);
1189 return 1;
1190 }
1191
1192 static int usbdux_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1193 {
1194 struct comedi_cmd *cmd = &s->async->cmd;
1195 unsigned int chan, range;
1196 int i, ret;
1197 struct usbduxsub *this_usbduxsub = dev->private;
1198 int result;
1199
1200 if (!this_usbduxsub)
1201 return -EFAULT;
1202
1203 dev_dbg(&this_usbduxsub->interface->dev,
1204 "comedi%d: usbdux_ai_cmd\n", dev->minor);
1205
1206 /* block other CPUs from starting an ai_cmd */
1207 down(&this_usbduxsub->sem);
1208
1209 if (!(this_usbduxsub->probed)) {
1210 up(&this_usbduxsub->sem);
1211 return -ENODEV;
1212 }
1213 if (this_usbduxsub->ai_cmd_running) {
1214 dev_err(&this_usbduxsub->interface->dev, "comedi%d: "
1215 "ai_cmd not possible. Another ai_cmd is running.\n",
1216 dev->minor);
1217 up(&this_usbduxsub->sem);
1218 return -EBUSY;
1219 }
1220 /* set current channel of the running acquisition to zero */
1221 s->async->cur_chan = 0;
1222
1223 this_usbduxsub->dux_commands[1] = cmd->chanlist_len;
1224 for (i = 0; i < cmd->chanlist_len; ++i) {
1225 chan = CR_CHAN(cmd->chanlist[i]);
1226 range = CR_RANGE(cmd->chanlist[i]);
1227 if (i >= NUMCHANNELS) {
1228 dev_err(&this_usbduxsub->interface->dev,
1229 "comedi%d: channel list too long\n",
1230 dev->minor);
1231 break;
1232 }
1233 this_usbduxsub->dux_commands[i + 2] =
1234 create_adc_command(chan, range);
1235 }
1236
1237 dev_dbg(&this_usbduxsub->interface->dev,
1238 "comedi %d: sending commands to the usb device: size=%u\n",
1239 dev->minor, NUMCHANNELS);
1240
1241 result = send_dux_commands(this_usbduxsub, SENDADCOMMANDS);
1242 if (result < 0) {
1243 up(&this_usbduxsub->sem);
1244 return result;
1245 }
1246
1247 if (this_usbduxsub->high_speed) {
1248 /*
1249 * every channel gets a time window of 125us. Thus, if we
1250 * sample all 8 channels we need 1ms. If we sample only one
1251 * channel we need only 125us
1252 */
1253 this_usbduxsub->ai_interval = 1;
1254 /* find a power of 2 for the interval */
1255 while ((this_usbduxsub->ai_interval) < (cmd->chanlist_len)) {
1256 this_usbduxsub->ai_interval =
1257 (this_usbduxsub->ai_interval) * 2;
1258 }
1259 this_usbduxsub->ai_timer = cmd->scan_begin_arg / (125000 *
1260 (this_usbduxsub->
1261 ai_interval));
1262 } else {
1263 /* interval always 1ms */
1264 this_usbduxsub->ai_interval = 1;
1265 this_usbduxsub->ai_timer = cmd->scan_begin_arg / 1000000;
1266 }
1267 if (this_usbduxsub->ai_timer < 1) {
1268 dev_err(&this_usbduxsub->interface->dev, "comedi%d: ai_cmd: "
1269 "timer=%d, scan_begin_arg=%d. "
1270 "Not properly tested by cmdtest?\n", dev->minor,
1271 this_usbduxsub->ai_timer, cmd->scan_begin_arg);
1272 up(&this_usbduxsub->sem);
1273 return -EINVAL;
1274 }
1275 this_usbduxsub->ai_counter = this_usbduxsub->ai_timer;
1276
1277 if (cmd->stop_src == TRIG_COUNT) {
1278 /* data arrives as one packet */
1279 this_usbduxsub->ai_sample_count = cmd->stop_arg;
1280 this_usbduxsub->ai_continous = 0;
1281 } else {
1282 /* continous acquisition */
1283 this_usbduxsub->ai_continous = 1;
1284 this_usbduxsub->ai_sample_count = 0;
1285 }
1286
1287 if (cmd->start_src == TRIG_NOW) {
1288 /* enable this acquisition operation */
1289 this_usbduxsub->ai_cmd_running = 1;
1290 ret = usbduxsub_submit_InURBs(this_usbduxsub);
1291 if (ret < 0) {
1292 this_usbduxsub->ai_cmd_running = 0;
1293 /* fixme: unlink here?? */
1294 up(&this_usbduxsub->sem);
1295 return ret;
1296 }
1297 s->async->inttrig = NULL;
1298 } else {
1299 /* TRIG_INT */
1300 /* don't enable the acquision operation */
1301 /* wait for an internal signal */
1302 s->async->inttrig = usbdux_ai_inttrig;
1303 }
1304 up(&this_usbduxsub->sem);
1305 return 0;
1306 }
1307
1308 /* Mode 0 is used to get a single conversion on demand */
1309 static int usbdux_ai_insn_read(struct comedi_device *dev,
1310 struct comedi_subdevice *s,
1311 struct comedi_insn *insn, unsigned int *data)
1312 {
1313 int i;
1314 unsigned int one = 0;
1315 int chan, range;
1316 int err;
1317 struct usbduxsub *this_usbduxsub = dev->private;
1318
1319 if (!this_usbduxsub)
1320 return 0;
1321
1322 dev_dbg(&this_usbduxsub->interface->dev,
1323 "comedi%d: ai_insn_read, insn->n=%d, insn->subdev=%d\n",
1324 dev->minor, insn->n, insn->subdev);
1325
1326 down(&this_usbduxsub->sem);
1327 if (!(this_usbduxsub->probed)) {
1328 up(&this_usbduxsub->sem);
1329 return -ENODEV;
1330 }
1331 if (this_usbduxsub->ai_cmd_running) {
1332 dev_err(&this_usbduxsub->interface->dev,
1333 "comedi%d: ai_insn_read not possible. "
1334 "Async Command is running.\n", dev->minor);
1335 up(&this_usbduxsub->sem);
1336 return 0;
1337 }
1338
1339 /* sample one channel */
1340 chan = CR_CHAN(insn->chanspec);
1341 range = CR_RANGE(insn->chanspec);
1342 /* set command for the first channel */
1343 this_usbduxsub->dux_commands[1] = create_adc_command(chan, range);
1344
1345 /* adc commands */
1346 err = send_dux_commands(this_usbduxsub, SENDSINGLEAD);
1347 if (err < 0) {
1348 up(&this_usbduxsub->sem);
1349 return err;
1350 }
1351
1352 for (i = 0; i < insn->n; i++) {
1353 err = receive_dux_commands(this_usbduxsub, SENDSINGLEAD);
1354 if (err < 0) {
1355 up(&this_usbduxsub->sem);
1356 return 0;
1357 }
1358 one = le16_to_cpu(this_usbduxsub->insnBuffer[1]);
1359 if (CR_RANGE(insn->chanspec) <= 1)
1360 one = one ^ 0x800;
1361
1362 data[i] = one;
1363 }
1364 up(&this_usbduxsub->sem);
1365 return i;
1366 }
1367
1368 /************************************/
1369 /* analog out */
1370
1371 static int usbdux_ao_insn_read(struct comedi_device *dev,
1372 struct comedi_subdevice *s,
1373 struct comedi_insn *insn, unsigned int *data)
1374 {
1375 int i;
1376 int chan = CR_CHAN(insn->chanspec);
1377 struct usbduxsub *this_usbduxsub = dev->private;
1378
1379 if (!this_usbduxsub)
1380 return -EFAULT;
1381
1382 down(&this_usbduxsub->sem);
1383 if (!(this_usbduxsub->probed)) {
1384 up(&this_usbduxsub->sem);
1385 return -ENODEV;
1386 }
1387 for (i = 0; i < insn->n; i++)
1388 data[i] = this_usbduxsub->outBuffer[chan];
1389
1390 up(&this_usbduxsub->sem);
1391 return i;
1392 }
1393
1394 static int usbdux_ao_insn_write(struct comedi_device *dev,
1395 struct comedi_subdevice *s,
1396 struct comedi_insn *insn, unsigned int *data)
1397 {
1398 int i, err;
1399 int chan = CR_CHAN(insn->chanspec);
1400 struct usbduxsub *this_usbduxsub = dev->private;
1401
1402 if (!this_usbduxsub)
1403 return -EFAULT;
1404
1405 dev_dbg(&this_usbduxsub->interface->dev,
1406 "comedi%d: ao_insn_write\n", dev->minor);
1407
1408 down(&this_usbduxsub->sem);
1409 if (!(this_usbduxsub->probed)) {
1410 up(&this_usbduxsub->sem);
1411 return -ENODEV;
1412 }
1413 if (this_usbduxsub->ao_cmd_running) {
1414 dev_err(&this_usbduxsub->interface->dev,
1415 "comedi%d: ao_insn_write: "
1416 "ERROR: asynchronous ao_cmd is running\n", dev->minor);
1417 up(&this_usbduxsub->sem);
1418 return 0;
1419 }
1420
1421 for (i = 0; i < insn->n; i++) {
1422 dev_dbg(&this_usbduxsub->interface->dev,
1423 "comedi%d: ao_insn_write: data[chan=%d,i=%d]=%d\n",
1424 dev->minor, chan, i, data[i]);
1425
1426 /* number of channels: 1 */
1427 this_usbduxsub->dux_commands[1] = 1;
1428 /* one 16 bit value */
1429 *((int16_t *) (this_usbduxsub->dux_commands + 2)) =
1430 cpu_to_le16(data[i]);
1431 this_usbduxsub->outBuffer[chan] = data[i];
1432 /* channel number */
1433 this_usbduxsub->dux_commands[4] = (chan << 6);
1434 err = send_dux_commands(this_usbduxsub, SENDDACOMMANDS);
1435 if (err < 0) {
1436 up(&this_usbduxsub->sem);
1437 return err;
1438 }
1439 }
1440 up(&this_usbduxsub->sem);
1441
1442 return i;
1443 }
1444
1445 static int usbdux_ao_inttrig(struct comedi_device *dev,
1446 struct comedi_subdevice *s, unsigned int trignum)
1447 {
1448 int ret;
1449 struct usbduxsub *this_usbduxsub = dev->private;
1450
1451 if (!this_usbduxsub)
1452 return -EFAULT;
1453
1454 down(&this_usbduxsub->sem);
1455 if (!(this_usbduxsub->probed)) {
1456 up(&this_usbduxsub->sem);
1457 return -ENODEV;
1458 }
1459 if (trignum != 0) {
1460 dev_err(&this_usbduxsub->interface->dev,
1461 "comedi%d: usbdux_ao_inttrig: invalid trignum\n",
1462 dev->minor);
1463 up(&this_usbduxsub->sem);
1464 return -EINVAL;
1465 }
1466 if (!(this_usbduxsub->ao_cmd_running)) {
1467 this_usbduxsub->ao_cmd_running = 1;
1468 ret = usbduxsub_submit_OutURBs(this_usbduxsub);
1469 if (ret < 0) {
1470 dev_err(&this_usbduxsub->interface->dev,
1471 "comedi%d: usbdux_ao_inttrig: submitURB: "
1472 "err=%d\n", dev->minor, ret);
1473 this_usbduxsub->ao_cmd_running = 0;
1474 up(&this_usbduxsub->sem);
1475 return ret;
1476 }
1477 s->async->inttrig = NULL;
1478 } else {
1479 dev_err(&this_usbduxsub->interface->dev,
1480 "comedi%d: ao_inttrig but acqu is already running.\n",
1481 dev->minor);
1482 }
1483 up(&this_usbduxsub->sem);
1484 return 1;
1485 }
1486
1487 static int usbdux_ao_cmdtest(struct comedi_device *dev,
1488 struct comedi_subdevice *s, struct comedi_cmd *cmd)
1489 {
1490 int err = 0, tmp;
1491 struct usbduxsub *this_usbduxsub = dev->private;
1492
1493 if (!this_usbduxsub)
1494 return -EFAULT;
1495
1496 if (!(this_usbduxsub->probed))
1497 return -ENODEV;
1498
1499 dev_dbg(&this_usbduxsub->interface->dev,
1500 "comedi%d: usbdux_ao_cmdtest\n", dev->minor);
1501
1502 /* make sure triggers are valid */
1503 /* Only immediate triggers are allowed */
1504 tmp = cmd->start_src;
1505 cmd->start_src &= TRIG_NOW | TRIG_INT;
1506 if (!cmd->start_src || tmp != cmd->start_src)
1507 err++;
1508
1509 /* trigger should happen timed */
1510 tmp = cmd->scan_begin_src;
1511 /* just now we scan also in the high speed mode every frame */
1512 /* this is due to ehci driver limitations */
1513 if (0) { /* (this_usbduxsub->high_speed) */
1514 /* start immediately a new scan */
1515 /* the sampling rate is set by the coversion rate */
1516 cmd->scan_begin_src &= TRIG_FOLLOW;
1517 } else {
1518 /* start a new scan (output at once) with a timer */
1519 cmd->scan_begin_src &= TRIG_TIMER;
1520 }
1521 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
1522 err++;
1523
1524 /* scanning is continuous */
1525 tmp = cmd->convert_src;
1526 /* we always output at 1kHz just now all channels at once */
1527 if (0) { /* (this_usbduxsub->high_speed) */
1528 /*
1529 * in usb-2.0 only one conversion it transmitted but with 8kHz/n
1530 */
1531 cmd->convert_src &= TRIG_TIMER;
1532 } else {
1533 /* all conversion events happen simultaneously with a rate of
1534 * 1kHz/n */
1535 cmd->convert_src &= TRIG_NOW;
1536 }
1537 if (!cmd->convert_src || tmp != cmd->convert_src)
1538 err++;
1539
1540 /* issue a trigger when scan is finished and start a new scan */
1541 tmp = cmd->scan_end_src;
1542 cmd->scan_end_src &= TRIG_COUNT;
1543 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
1544 err++;
1545
1546 /* trigger at the end of count events or not, stop condition or not */
1547 tmp = cmd->stop_src;
1548 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
1549 if (!cmd->stop_src || tmp != cmd->stop_src)
1550 err++;
1551
1552 if (err)
1553 return 1;
1554
1555 /*
1556 * step 2: make sure trigger sources are unique and mutually compatible
1557 * note that mutual compatibility is not an issue here
1558 */
1559 if (cmd->scan_begin_src != TRIG_FOLLOW &&
1560 cmd->scan_begin_src != TRIG_EXT &&
1561 cmd->scan_begin_src != TRIG_TIMER)
1562 err++;
1563 if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
1564 err++;
1565
1566 if (err)
1567 return 2;
1568
1569 /* step 3: make sure arguments are trivially compatible */
1570
1571 if (cmd->start_arg != 0) {
1572 cmd->start_arg = 0;
1573 err++;
1574 }
1575
1576 if (cmd->scan_begin_src == TRIG_FOLLOW) {
1577 /* internal trigger */
1578 if (cmd->scan_begin_arg != 0) {
1579 cmd->scan_begin_arg = 0;
1580 err++;
1581 }
1582 }
1583
1584 if (cmd->scan_begin_src == TRIG_TIMER) {
1585 /* timer */
1586 if (cmd->scan_begin_arg < 1000000) {
1587 cmd->scan_begin_arg = 1000000;
1588 err++;
1589 }
1590 }
1591 /* not used now, is for later use */
1592 if (cmd->convert_src == TRIG_TIMER) {
1593 if (cmd->convert_arg < 125000) {
1594 cmd->convert_arg = 125000;
1595 err++;
1596 }
1597 }
1598
1599 /* the same argument */
1600 if (cmd->scan_end_arg != cmd->chanlist_len) {
1601 cmd->scan_end_arg = cmd->chanlist_len;
1602 err++;
1603 }
1604
1605 if (cmd->stop_src == TRIG_COUNT) {
1606 /* any count is allowed */
1607 } else {
1608 /* TRIG_NONE */
1609 if (cmd->stop_arg != 0) {
1610 cmd->stop_arg = 0;
1611 err++;
1612 }
1613 }
1614
1615 dev_dbg(&this_usbduxsub->interface->dev, "comedi%d: err=%d, "
1616 "scan_begin_src=%d, scan_begin_arg=%d, convert_src=%d, "
1617 "convert_arg=%d\n", dev->minor, err, cmd->scan_begin_src,
1618 cmd->scan_begin_arg, cmd->convert_src, cmd->convert_arg);
1619
1620 if (err)
1621 return 3;
1622
1623 return 0;
1624 }
1625
1626 static int usbdux_ao_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
1627 {
1628 struct comedi_cmd *cmd = &s->async->cmd;
1629 unsigned int chan, gain;
1630 int i, ret;
1631 struct usbduxsub *this_usbduxsub = dev->private;
1632
1633 if (!this_usbduxsub)
1634 return -EFAULT;
1635
1636 down(&this_usbduxsub->sem);
1637 if (!(this_usbduxsub->probed)) {
1638 up(&this_usbduxsub->sem);
1639 return -ENODEV;
1640 }
1641 dev_dbg(&this_usbduxsub->interface->dev,
1642 "comedi%d: %s\n", dev->minor, __func__);
1643
1644 /* set current channel of the running acquisition to zero */
1645 s->async->cur_chan = 0;
1646 for (i = 0; i < cmd->chanlist_len; ++i) {
1647 chan = CR_CHAN(cmd->chanlist[i]);
1648 gain = CR_RANGE(cmd->chanlist[i]);
1649 if (i >= NUMOUTCHANNELS) {
1650 dev_err(&this_usbduxsub->interface->dev,
1651 "comedi%d: %s: channel list too long\n",
1652 dev->minor, __func__);
1653 break;
1654 }
1655 this_usbduxsub->dac_commands[i] = (chan << 6);
1656 dev_dbg(&this_usbduxsub->interface->dev,
1657 "comedi%d: dac command for ch %d is %x\n",
1658 dev->minor, i, this_usbduxsub->dac_commands[i]);
1659 }
1660
1661 /* we count in steps of 1ms (125us) */
1662 /* 125us mode not used yet */
1663 if (0) { /* (this_usbduxsub->high_speed) */
1664 /* 125us */
1665 /* timing of the conversion itself: every 125 us */
1666 this_usbduxsub->ao_timer = cmd->convert_arg / 125000;
1667 } else {
1668 /* 1ms */
1669 /* timing of the scan: we get all channels at once */
1670 this_usbduxsub->ao_timer = cmd->scan_begin_arg / 1000000;
1671 dev_dbg(&this_usbduxsub->interface->dev,
1672 "comedi%d: scan_begin_src=%d, scan_begin_arg=%d, "
1673 "convert_src=%d, convert_arg=%d\n", dev->minor,
1674 cmd->scan_begin_src, cmd->scan_begin_arg,
1675 cmd->convert_src, cmd->convert_arg);
1676 dev_dbg(&this_usbduxsub->interface->dev,
1677 "comedi%d: ao_timer=%d (ms)\n",
1678 dev->minor, this_usbduxsub->ao_timer);
1679 if (this_usbduxsub->ao_timer < 1) {
1680 dev_err(&this_usbduxsub->interface->dev,
1681 "comedi%d: usbdux: ao_timer=%d, "
1682 "scan_begin_arg=%d. "
1683 "Not properly tested by cmdtest?\n",
1684 dev->minor, this_usbduxsub->ao_timer,
1685 cmd->scan_begin_arg);
1686 up(&this_usbduxsub->sem);
1687 return -EINVAL;
1688 }
1689 }
1690 this_usbduxsub->ao_counter = this_usbduxsub->ao_timer;
1691
1692 if (cmd->stop_src == TRIG_COUNT) {
1693 /* not continuous */
1694 /* counter */
1695 /* high speed also scans everything at once */
1696 if (0) { /* (this_usbduxsub->high_speed) */
1697 this_usbduxsub->ao_sample_count =
1698 (cmd->stop_arg) * (cmd->scan_end_arg);
1699 } else {
1700 /* there's no scan as the scan has been */
1701 /* perf inside the FX2 */
1702 /* data arrives as one packet */
1703 this_usbduxsub->ao_sample_count = cmd->stop_arg;
1704 }
1705 this_usbduxsub->ao_continous = 0;
1706 } else {
1707 /* continous acquisition */
1708 this_usbduxsub->ao_continous = 1;
1709 this_usbduxsub->ao_sample_count = 0;
1710 }
1711
1712 if (cmd->start_src == TRIG_NOW) {
1713 /* enable this acquisition operation */
1714 this_usbduxsub->ao_cmd_running = 1;
1715 ret = usbduxsub_submit_OutURBs(this_usbduxsub);
1716 if (ret < 0) {
1717 this_usbduxsub->ao_cmd_running = 0;
1718 /* fixme: unlink here?? */
1719 up(&this_usbduxsub->sem);
1720 return ret;
1721 }
1722 s->async->inttrig = NULL;
1723 } else {
1724 /* TRIG_INT */
1725 /* submit the urbs later */
1726 /* wait for an internal signal */
1727 s->async->inttrig = usbdux_ao_inttrig;
1728 }
1729
1730 up(&this_usbduxsub->sem);
1731 return 0;
1732 }
1733
1734 static int usbdux_dio_insn_config(struct comedi_device *dev,
1735 struct comedi_subdevice *s,
1736 struct comedi_insn *insn, unsigned int *data)
1737 {
1738 int chan = CR_CHAN(insn->chanspec);
1739
1740 /* The input or output configuration of each digital line is
1741 * configured by a special insn_config instruction. chanspec
1742 * contains the channel to be changed, and data[0] contains the
1743 * value COMEDI_INPUT or COMEDI_OUTPUT. */
1744
1745 switch (data[0]) {
1746 case INSN_CONFIG_DIO_OUTPUT:
1747 s->io_bits |= 1 << chan; /* 1 means Out */
1748 break;
1749 case INSN_CONFIG_DIO_INPUT:
1750 s->io_bits &= ~(1 << chan);
1751 break;
1752 case INSN_CONFIG_DIO_QUERY:
1753 data[1] =
1754 (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
1755 break;
1756 default:
1757 return -EINVAL;
1758 break;
1759 }
1760 /* we don't tell the firmware here as it would take 8 frames */
1761 /* to submit the information. We do it in the insn_bits. */
1762 return insn->n;
1763 }
1764
1765 static int usbdux_dio_insn_bits(struct comedi_device *dev,
1766 struct comedi_subdevice *s,
1767 struct comedi_insn *insn, unsigned int *data)
1768 {
1769
1770 struct usbduxsub *this_usbduxsub = dev->private;
1771 int err;
1772
1773 if (!this_usbduxsub)
1774 return -EFAULT;
1775
1776 down(&this_usbduxsub->sem);
1777
1778 if (!(this_usbduxsub->probed)) {
1779 up(&this_usbduxsub->sem);
1780 return -ENODEV;
1781 }
1782
1783 /* The insn data is a mask in data[0] and the new data
1784 * in data[1], each channel cooresponding to a bit. */
1785 s->state &= ~data[0];
1786 s->state |= data[0] & data[1];
1787 this_usbduxsub->dux_commands[1] = s->io_bits;
1788 this_usbduxsub->dux_commands[2] = s->state;
1789
1790 /* This command also tells the firmware to return */
1791 /* the digital input lines */
1792 err = send_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND);
1793 if (err < 0) {
1794 up(&this_usbduxsub->sem);
1795 return err;
1796 }
1797 err = receive_dux_commands(this_usbduxsub, SENDDIOBITSCOMMAND);
1798 if (err < 0) {
1799 up(&this_usbduxsub->sem);
1800 return err;
1801 }
1802
1803 data[1] = le16_to_cpu(this_usbduxsub->insnBuffer[1]);
1804 up(&this_usbduxsub->sem);
1805 return insn->n;
1806 }
1807
1808 /* reads the 4 counters, only two are used just now */
1809 static int usbdux_counter_read(struct comedi_device *dev,
1810 struct comedi_subdevice *s,
1811 struct comedi_insn *insn, unsigned int *data)
1812 {
1813 struct usbduxsub *this_usbduxsub = dev->private;
1814 int chan = insn->chanspec;
1815 int err;
1816
1817 if (!this_usbduxsub)
1818 return -EFAULT;
1819
1820 down(&this_usbduxsub->sem);
1821
1822 if (!(this_usbduxsub->probed)) {
1823 up(&this_usbduxsub->sem);
1824 return -ENODEV;
1825 }
1826
1827 err = send_dux_commands(this_usbduxsub, READCOUNTERCOMMAND);
1828 if (err < 0) {
1829 up(&this_usbduxsub->sem);
1830 return err;
1831 }
1832
1833 err = receive_dux_commands(this_usbduxsub, READCOUNTERCOMMAND);
1834 if (err < 0) {
1835 up(&this_usbduxsub->sem);
1836 return err;
1837 }
1838
1839 data[0] = le16_to_cpu(this_usbduxsub->insnBuffer[chan + 1]);
1840 up(&this_usbduxsub->sem);
1841 return 1;
1842 }
1843
1844 static int usbdux_counter_write(struct comedi_device *dev,
1845 struct comedi_subdevice *s,
1846 struct comedi_insn *insn, unsigned int *data)
1847 {
1848 struct usbduxsub *this_usbduxsub = dev->private;
1849 int err;
1850
1851 if (!this_usbduxsub)
1852 return -EFAULT;
1853
1854 down(&this_usbduxsub->sem);
1855
1856 if (!(this_usbduxsub->probed)) {
1857 up(&this_usbduxsub->sem);
1858 return -ENODEV;
1859 }
1860
1861 this_usbduxsub->dux_commands[1] = insn->chanspec;
1862 *((int16_t *) (this_usbduxsub->dux_commands + 2)) = cpu_to_le16(*data);
1863
1864 err = send_dux_commands(this_usbduxsub, WRITECOUNTERCOMMAND);
1865 if (err < 0) {
1866 up(&this_usbduxsub->sem);
1867 return err;
1868 }
1869
1870 up(&this_usbduxsub->sem);
1871
1872 return 1;
1873 }
1874
1875 static int usbdux_counter_config(struct comedi_device *dev,
1876 struct comedi_subdevice *s,
1877 struct comedi_insn *insn, unsigned int *data)
1878 {
1879 /* nothing to do so far */
1880 return 2;
1881 }
1882
1883 /***********************************/
1884 /* PWM */
1885
1886 static int usbduxsub_unlink_PwmURBs(struct usbduxsub *usbduxsub_tmp)
1887 {
1888 int err = 0;
1889
1890 if (usbduxsub_tmp && usbduxsub_tmp->urbPwm) {
1891 if (usbduxsub_tmp->urbPwm)
1892 usb_kill_urb(usbduxsub_tmp->urbPwm);
1893 dev_dbg(&usbduxsub_tmp->interface->dev,
1894 "comedi: unlinked PwmURB: res=%d\n", err);
1895 }
1896 return err;
1897 }
1898
1899 /* This cancels a running acquisition operation
1900 * in any context.
1901 */
1902 static int usbdux_pwm_stop(struct usbduxsub *this_usbduxsub, int do_unlink)
1903 {
1904 int ret = 0;
1905
1906 if (!this_usbduxsub)
1907 return -EFAULT;
1908
1909 dev_dbg(&this_usbduxsub->interface->dev, "comedi: %s\n", __func__);
1910 if (do_unlink)
1911 ret = usbduxsub_unlink_PwmURBs(this_usbduxsub);
1912
1913 this_usbduxsub->pwm_cmd_running = 0;
1914
1915 return ret;
1916 }
1917
1918 /* force unlink - is called by comedi */
1919 static int usbdux_pwm_cancel(struct comedi_device *dev,
1920 struct comedi_subdevice *s)
1921 {
1922 struct usbduxsub *this_usbduxsub = dev->private;
1923 int res = 0;
1924
1925 /* unlink only if it is really running */
1926 res = usbdux_pwm_stop(this_usbduxsub, this_usbduxsub->pwm_cmd_running);
1927
1928 dev_dbg(&this_usbduxsub->interface->dev,
1929 "comedi %d: sending pwm off command to the usb device.\n",
1930 dev->minor);
1931
1932 return send_dux_commands(this_usbduxsub, SENDPWMOFF);
1933 }
1934
1935 static void usbduxsub_pwm_irq(struct urb *urb)
1936 {
1937 int ret;
1938 struct usbduxsub *this_usbduxsub;
1939 struct comedi_device *this_comedidev;
1940 struct comedi_subdevice *s;
1941
1942 /* printk(KERN_DEBUG "PWM: IRQ\n"); */
1943
1944 /* the context variable points to the subdevice */
1945 this_comedidev = urb->context;
1946 /* the private structure of the subdevice is struct usbduxsub */
1947 this_usbduxsub = this_comedidev->private;
1948
1949 s = this_comedidev->subdevices + SUBDEV_DA;
1950
1951 switch (urb->status) {
1952 case 0:
1953 /* success */
1954 break;
1955
1956 case -ECONNRESET:
1957 case -ENOENT:
1958 case -ESHUTDOWN:
1959 case -ECONNABORTED:
1960 /*
1961 * after an unlink command, unplug, ... etc
1962 * no unlink needed here. Already shutting down.
1963 */
1964 if (this_usbduxsub->pwm_cmd_running)
1965 usbdux_pwm_stop(this_usbduxsub, 0);
1966
1967 return;
1968
1969 default:
1970 /* a real error */
1971 if (this_usbduxsub->pwm_cmd_running) {
1972 dev_err(&this_usbduxsub->interface->dev,
1973 "comedi_: Non-zero urb status received in "
1974 "pwm intr context: %d\n", urb->status);
1975 usbdux_pwm_stop(this_usbduxsub, 0);
1976 }
1977 return;
1978 }
1979
1980 /* are we actually running? */
1981 if (!(this_usbduxsub->pwm_cmd_running))
1982 return;
1983
1984 urb->transfer_buffer_length = this_usbduxsub->sizePwmBuf;
1985 urb->dev = this_usbduxsub->usbdev;
1986 urb->status = 0;
1987 if (this_usbduxsub->pwm_cmd_running) {
1988 ret = usb_submit_urb(urb, GFP_ATOMIC);
1989 if (ret < 0) {
1990 dev_err(&this_usbduxsub->interface->dev,
1991 "comedi_: pwm urb resubm failed in int-cont. "
1992 "ret=%d", ret);
1993 if (ret == EL2NSYNC)
1994 dev_err(&this_usbduxsub->interface->dev,
1995 "buggy USB host controller or bug in "
1996 "IRQ handling!\n");
1997
1998 /* don't do an unlink here */
1999 usbdux_pwm_stop(this_usbduxsub, 0);
2000 }
2001 }
2002 }
2003
2004 static int usbduxsub_submit_PwmURBs(struct usbduxsub *usbduxsub)
2005 {
2006 int errFlag;
2007
2008 if (!usbduxsub)
2009 return -EFAULT;
2010
2011 dev_dbg(&usbduxsub->interface->dev, "comedi_: submitting pwm-urb\n");
2012
2013 /* in case of a resubmission after an unlink... */
2014 usb_fill_bulk_urb(usbduxsub->urbPwm,
2015 usbduxsub->usbdev,
2016 usb_sndbulkpipe(usbduxsub->usbdev, PWM_EP),
2017 usbduxsub->urbPwm->transfer_buffer,
2018 usbduxsub->sizePwmBuf, usbduxsub_pwm_irq,
2019 usbduxsub->comedidev);
2020
2021 errFlag = usb_submit_urb(usbduxsub->urbPwm, GFP_ATOMIC);
2022 if (errFlag) {
2023 dev_err(&usbduxsub->interface->dev,
2024 "comedi_: usbdux: pwm: usb_submit_urb error %d\n",
2025 errFlag);
2026 return errFlag;
2027 }
2028 return 0;
2029 }
2030
2031 static int usbdux_pwm_period(struct comedi_device *dev,
2032 struct comedi_subdevice *s, unsigned int period)
2033 {
2034 struct usbduxsub *this_usbduxsub = dev->private;
2035 int fx2delay = 255;
2036
2037 if (period < MIN_PWM_PERIOD) {
2038 dev_err(&this_usbduxsub->interface->dev,
2039 "comedi%d: illegal period setting for pwm.\n",
2040 dev->minor);
2041 return -EAGAIN;
2042 } else {
2043 fx2delay = period / ((int)(6 * 512 * (1.0 / 0.033))) - 6;
2044 if (fx2delay > 255) {
2045 dev_err(&this_usbduxsub->interface->dev,
2046 "comedi%d: period %d for pwm is too low.\n",
2047 dev->minor, period);
2048 return -EAGAIN;
2049 }
2050 }
2051 this_usbduxsub->pwmDelay = fx2delay;
2052 this_usbduxsub->pwmPeriod = period;
2053 dev_dbg(&this_usbduxsub->interface->dev, "%s: frequ=%d, period=%d\n",
2054 __func__, period, fx2delay);
2055 return 0;
2056 }
2057
2058 /* is called from insn so there's no need to do all the sanity checks */
2059 static int usbdux_pwm_start(struct comedi_device *dev,
2060 struct comedi_subdevice *s)
2061 {
2062 int ret, i;
2063 struct usbduxsub *this_usbduxsub = dev->private;
2064
2065 dev_dbg(&this_usbduxsub->interface->dev, "comedi%d: %s\n",
2066 dev->minor, __func__);
2067
2068 if (this_usbduxsub->pwm_cmd_running) {
2069 /* already running */
2070 return 0;
2071 }
2072
2073 this_usbduxsub->dux_commands[1] = ((int8_t) this_usbduxsub->pwmDelay);
2074 ret = send_dux_commands(this_usbduxsub, SENDPWMON);
2075 if (ret < 0)
2076 return ret;
2077
2078 /* initialise the buffer */
2079 for (i = 0; i < this_usbduxsub->sizePwmBuf; i++)
2080 ((char *)(this_usbduxsub->urbPwm->transfer_buffer))[i] = 0;
2081
2082 this_usbduxsub->pwm_cmd_running = 1;
2083 ret = usbduxsub_submit_PwmURBs(this_usbduxsub);
2084 if (ret < 0) {
2085 this_usbduxsub->pwm_cmd_running = 0;
2086 return ret;
2087 }
2088 return 0;
2089 }
2090
2091 /* generates the bit pattern for PWM with the optional sign bit */
2092 static int usbdux_pwm_pattern(struct comedi_device *dev,
2093 struct comedi_subdevice *s, int channel,
2094 unsigned int value, unsigned int sign)
2095 {
2096 struct usbduxsub *this_usbduxsub = dev->private;
2097 int i, szbuf;
2098 char *pBuf;
2099 char pwm_mask;
2100 char sgn_mask;
2101 char c;
2102
2103 if (!this_usbduxsub)
2104 return -EFAULT;
2105
2106 /* this is the DIO bit which carries the PWM data */
2107 pwm_mask = (1 << channel);
2108 /* this is the DIO bit which carries the optional direction bit */
2109 sgn_mask = (16 << channel);
2110 /* this is the buffer which will be filled with the with bit */
2111 /* pattern for one period */
2112 szbuf = this_usbduxsub->sizePwmBuf;
2113 pBuf = (char *)(this_usbduxsub->urbPwm->transfer_buffer);
2114 for (i = 0; i < szbuf; i++) {
2115 c = *pBuf;
2116 /* reset bits */
2117 c = c & (~pwm_mask);
2118 /* set the bit as long as the index is lower than the value */
2119 if (i < value)
2120 c = c | pwm_mask;
2121 /* set the optional sign bit for a relay */
2122 if (!sign) {
2123 /* positive value */
2124 c = c & (~sgn_mask);
2125 } else {
2126 /* negative value */
2127 c = c | sgn_mask;
2128 }
2129 *(pBuf++) = c;
2130 }
2131 return 1;
2132 }
2133
2134 static int usbdux_pwm_write(struct comedi_device *dev,
2135 struct comedi_subdevice *s,
2136 struct comedi_insn *insn, unsigned int *data)
2137 {
2138 struct usbduxsub *this_usbduxsub = dev->private;
2139
2140 if (!this_usbduxsub)
2141 return -EFAULT;
2142
2143 if ((insn->n) != 1) {
2144 /*
2145 * doesn't make sense to have more than one value here because
2146 * it would just overwrite the PWM buffer a couple of times
2147 */
2148 return -EINVAL;
2149 }
2150
2151 /*
2152 * the sign is set via a special INSN only, this gives us 8 bits for
2153 * normal operation
2154 * relay sign 0 by default
2155 */
2156 return usbdux_pwm_pattern(dev, s, CR_CHAN(insn->chanspec), data[0], 0);
2157 }
2158
2159 static int usbdux_pwm_read(struct comedi_device *x1,
2160 struct comedi_subdevice *x2, struct comedi_insn *x3,
2161 unsigned int *x4)
2162 {
2163 /* not needed */
2164 return -EINVAL;
2165 };
2166
2167 /* switches on/off PWM */
2168 static int usbdux_pwm_config(struct comedi_device *dev,
2169 struct comedi_subdevice *s,
2170 struct comedi_insn *insn, unsigned int *data)
2171 {
2172 struct usbduxsub *this_usbduxsub = dev->private;
2173 switch (data[0]) {
2174 case INSN_CONFIG_ARM:
2175 /* switch it on */
2176 dev_dbg(&this_usbduxsub->interface->dev,
2177 "comedi%d: %s: pwm on\n", dev->minor, __func__);
2178 /*
2179 * if not zero the PWM is limited to a certain time which is
2180 * not supported here
2181 */
2182 if (data[1] != 0)
2183 return -EINVAL;
2184 return usbdux_pwm_start(dev, s);
2185 case INSN_CONFIG_DISARM:
2186 dev_dbg(&this_usbduxsub->interface->dev,
2187 "comedi%d: %s: pwm off\n", dev->minor, __func__);
2188 return usbdux_pwm_cancel(dev, s);
2189 case INSN_CONFIG_GET_PWM_STATUS:
2190 /*
2191 * to check if the USB transmission has failed or in case PWM
2192 * was limited to n cycles to check if it has terminated
2193 */
2194 data[1] = this_usbduxsub->pwm_cmd_running;
2195 return 0;
2196 case INSN_CONFIG_PWM_SET_PERIOD:
2197 dev_dbg(&this_usbduxsub->interface->dev,
2198 "comedi%d: %s: setting period\n", dev->minor, __func__);
2199 return usbdux_pwm_period(dev, s, data[1]);
2200 case INSN_CONFIG_PWM_GET_PERIOD:
2201 data[1] = this_usbduxsub->pwmPeriod;
2202 return 0;
2203 case INSN_CONFIG_PWM_SET_H_BRIDGE:
2204 /* value in the first byte and the sign in the second for a
2205 relay */
2206 return usbdux_pwm_pattern(dev, s,
2207 /* the channel number */
2208 CR_CHAN(insn->chanspec),
2209 /* actual PWM data */
2210 data[1],
2211 /* just a sign */
2212 (data[2] != 0));
2213 case INSN_CONFIG_PWM_GET_H_BRIDGE:
2214 /* values are not kept in this driver, nothing to return here */
2215 return -EINVAL;
2216 }
2217 return -EINVAL;
2218 }
2219
2220 /* end of PWM */
2221 /*****************************************************************/
2222
2223 static void tidy_up(struct usbduxsub *usbduxsub_tmp)
2224 {
2225 int i;
2226
2227 if (!usbduxsub_tmp)
2228 return;
2229 dev_dbg(&usbduxsub_tmp->interface->dev, "comedi_: tiding up\n");
2230
2231 /* shows the usb subsystem that the driver is down */
2232 if (usbduxsub_tmp->interface)
2233 usb_set_intfdata(usbduxsub_tmp->interface, NULL);
2234
2235 usbduxsub_tmp->probed = 0;
2236
2237 if (usbduxsub_tmp->urbIn) {
2238 if (usbduxsub_tmp->ai_cmd_running) {
2239 usbduxsub_tmp->ai_cmd_running = 0;
2240 usbduxsub_unlink_InURBs(usbduxsub_tmp);
2241 }
2242 for (i = 0; i < usbduxsub_tmp->numOfInBuffers; i++) {
2243 kfree(usbduxsub_tmp->urbIn[i]->transfer_buffer);
2244 usbduxsub_tmp->urbIn[i]->transfer_buffer = NULL;
2245 usb_kill_urb(usbduxsub_tmp->urbIn[i]);
2246 usb_free_urb(usbduxsub_tmp->urbIn[i]);
2247 usbduxsub_tmp->urbIn[i] = NULL;
2248 }
2249 kfree(usbduxsub_tmp->urbIn);
2250 usbduxsub_tmp->urbIn = NULL;
2251 }
2252 if (usbduxsub_tmp->urbOut) {
2253 if (usbduxsub_tmp->ao_cmd_running) {
2254 usbduxsub_tmp->ao_cmd_running = 0;
2255 usbduxsub_unlink_OutURBs(usbduxsub_tmp);
2256 }
2257 for (i = 0; i < usbduxsub_tmp->numOfOutBuffers; i++) {
2258 kfree(usbduxsub_tmp->urbOut[i]->transfer_buffer);
2259 usbduxsub_tmp->urbOut[i]->transfer_buffer = NULL;
2260 if (usbduxsub_tmp->urbOut[i]) {
2261 usb_kill_urb(usbduxsub_tmp->urbOut[i]);
2262 usb_free_urb(usbduxsub_tmp->urbOut[i]);
2263 usbduxsub_tmp->urbOut[i] = NULL;
2264 }
2265 }
2266 kfree(usbduxsub_tmp->urbOut);
2267 usbduxsub_tmp->urbOut = NULL;
2268 }
2269 if (usbduxsub_tmp->urbPwm) {
2270 if (usbduxsub_tmp->pwm_cmd_running) {
2271 usbduxsub_tmp->pwm_cmd_running = 0;
2272 usbduxsub_unlink_PwmURBs(usbduxsub_tmp);
2273 }
2274 kfree(usbduxsub_tmp->urbPwm->transfer_buffer);
2275 usbduxsub_tmp->urbPwm->transfer_buffer = NULL;
2276 usb_kill_urb(usbduxsub_tmp->urbPwm);
2277 usb_free_urb(usbduxsub_tmp->urbPwm);
2278 usbduxsub_tmp->urbPwm = NULL;
2279 }
2280 kfree(usbduxsub_tmp->inBuffer);
2281 usbduxsub_tmp->inBuffer = NULL;
2282 kfree(usbduxsub_tmp->insnBuffer);
2283 usbduxsub_tmp->insnBuffer = NULL;
2284 kfree(usbduxsub_tmp->outBuffer);
2285 usbduxsub_tmp->outBuffer = NULL;
2286 kfree(usbduxsub_tmp->dac_commands);
2287 usbduxsub_tmp->dac_commands = NULL;
2288 kfree(usbduxsub_tmp->dux_commands);
2289 usbduxsub_tmp->dux_commands = NULL;
2290 usbduxsub_tmp->ai_cmd_running = 0;
2291 usbduxsub_tmp->ao_cmd_running = 0;
2292 usbduxsub_tmp->pwm_cmd_running = 0;
2293 }
2294
2295 /* common part of attach and attach_usb */
2296 static int usbdux_attach_common(struct comedi_device *dev,
2297 struct usbduxsub *udev,
2298 void *aux_data, int aux_len)
2299 {
2300 int ret;
2301 struct comedi_subdevice *s = NULL;
2302 int n_subdevs;
2303
2304 down(&udev->sem);
2305 /* pointer back to the corresponding comedi device */
2306 udev->comedidev = dev;
2307
2308 /* trying to upload the firmware into the chip */
2309 if (aux_data)
2310 firmwareUpload(udev, aux_data, aux_len);
2311
2312 dev->board_name = "usbdux";
2313
2314 /* set number of subdevices */
2315 if (udev->high_speed) {
2316 /* with pwm */
2317 n_subdevs = 5;
2318 } else {
2319 /* without pwm */
2320 n_subdevs = 4;
2321 }
2322
2323 ret = comedi_alloc_subdevices(dev, n_subdevs);
2324 if (ret) {
2325 up(&udev->sem);
2326 return ret;
2327 }
2328
2329 /* private structure is also simply the usb-structure */
2330 dev->private = udev;
2331
2332 /* the first subdevice is the A/D converter */
2333 s = dev->subdevices + SUBDEV_AD;
2334 /* the URBs get the comedi subdevice */
2335 /* which is responsible for reading */
2336 /* this is the subdevice which reads data */
2337 dev->read_subdev = s;
2338 /* the subdevice receives as private structure the */
2339 /* usb-structure */
2340 s->private = NULL;
2341 /* analog input */
2342 s->type = COMEDI_SUBD_AI;
2343 /* readable and ref is to ground */
2344 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
2345 /* 8 channels */
2346 s->n_chan = 8;
2347 /* length of the channellist */
2348 s->len_chanlist = 8;
2349 /* callback functions */
2350 s->insn_read = usbdux_ai_insn_read;
2351 s->do_cmdtest = usbdux_ai_cmdtest;
2352 s->do_cmd = usbdux_ai_cmd;
2353 s->cancel = usbdux_ai_cancel;
2354 /* max value from the A/D converter (12bit) */
2355 s->maxdata = 0xfff;
2356 /* range table to convert to physical units */
2357 s->range_table = (&range_usbdux_ai_range);
2358
2359 /* analog out */
2360 s = dev->subdevices + SUBDEV_DA;
2361 /* analog out */
2362 s->type = COMEDI_SUBD_AO;
2363 /* backward pointer */
2364 dev->write_subdev = s;
2365 /* the subdevice receives as private structure the */
2366 /* usb-structure */
2367 s->private = NULL;
2368 /* are writable */
2369 s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE;
2370 /* 4 channels */
2371 s->n_chan = 4;
2372 /* length of the channellist */
2373 s->len_chanlist = 4;
2374 /* 12 bit resolution */
2375 s->maxdata = 0x0fff;
2376 /* bipolar range */
2377 s->range_table = (&range_usbdux_ao_range);
2378 /* callback */
2379 s->do_cmdtest = usbdux_ao_cmdtest;
2380 s->do_cmd = usbdux_ao_cmd;
2381 s->cancel = usbdux_ao_cancel;
2382 s->insn_read = usbdux_ao_insn_read;
2383 s->insn_write = usbdux_ao_insn_write;
2384
2385 /* digital I/O */
2386 s = dev->subdevices + SUBDEV_DIO;
2387 s->type = COMEDI_SUBD_DIO;
2388 s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
2389 s->n_chan = 8;
2390 s->maxdata = 1;
2391 s->range_table = (&range_digital);
2392 s->insn_bits = usbdux_dio_insn_bits;
2393 s->insn_config = usbdux_dio_insn_config;
2394 /* we don't use it */
2395 s->private = NULL;
2396
2397 /* counter */
2398 s = dev->subdevices + SUBDEV_COUNTER;
2399 s->type = COMEDI_SUBD_COUNTER;
2400 s->subdev_flags = SDF_WRITABLE | SDF_READABLE;
2401 s->n_chan = 4;
2402 s->maxdata = 0xFFFF;
2403 s->insn_read = usbdux_counter_read;
2404 s->insn_write = usbdux_counter_write;
2405 s->insn_config = usbdux_counter_config;
2406
2407 if (udev->high_speed) {
2408 /* timer / pwm */
2409 s = dev->subdevices + SUBDEV_PWM;
2410 s->type = COMEDI_SUBD_PWM;
2411 s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE;
2412 s->n_chan = 8;
2413 /* this defines the max duty cycle resolution */
2414 s->maxdata = udev->sizePwmBuf;
2415 s->insn_write = usbdux_pwm_write;
2416 s->insn_read = usbdux_pwm_read;
2417 s->insn_config = usbdux_pwm_config;
2418 usbdux_pwm_period(dev, s, PWM_DEFAULT_PERIOD);
2419 }
2420 /* finally decide that it's attached */
2421 udev->attached = 1;
2422
2423 up(&udev->sem);
2424
2425 dev_info(&udev->interface->dev, "comedi%d: attached to usbdux.\n",
2426 dev->minor);
2427
2428 return 0;
2429 }
2430
2431 /* is called when comedi-config is called */
2432 static int usbdux_attach(struct comedi_device *dev, struct comedi_devconfig *it)
2433 {
2434 int ret;
2435 int index;
2436 int i;
2437 void *aux_data;
2438 int aux_len;
2439
2440 dev->private = NULL;
2441
2442 aux_data = comedi_aux_data(it->options, 0);
2443 aux_len = it->options[COMEDI_DEVCONF_AUX_DATA_LENGTH];
2444 if (aux_data == NULL)
2445 aux_len = 0;
2446 else if (aux_len == 0)
2447 aux_data = NULL;
2448
2449 down(&start_stop_sem);
2450 /* find a valid device which has been detected by the probe function of
2451 * the usb */
2452 index = -1;
2453 for (i = 0; i < NUMUSBDUX; i++) {
2454 if ((usbduxsub[i].probed) && (!usbduxsub[i].attached)) {
2455 index = i;
2456 break;
2457 }
2458 }
2459
2460 if (index < 0) {
2461 printk(KERN_ERR
2462 "comedi%d: usbdux: error: attach failed, no usbdux devs connected to the usb bus.\n",
2463 dev->minor);
2464 ret = -ENODEV;
2465 } else
2466 ret = usbdux_attach_common(dev, &usbduxsub[index],
2467 aux_data, aux_len);
2468 up(&start_stop_sem);
2469 return ret;
2470 }
2471
2472 /* is called from comedi_usb_auto_config() */
2473 static int usbdux_attach_usb(struct comedi_device *dev,
2474 struct usb_interface *uinterf)
2475 {
2476 int ret;
2477 struct usbduxsub *this_usbduxsub;
2478
2479 dev->private = NULL;
2480
2481 down(&start_stop_sem);
2482 this_usbduxsub = usb_get_intfdata(uinterf);
2483 if (!this_usbduxsub || !this_usbduxsub->probed) {
2484 printk(KERN_ERR
2485 "comedi%d: usbdux: error: attach_usb failed, not connected\n",
2486 dev->minor);
2487 ret = -ENODEV;
2488 } else if (this_usbduxsub->attached) {
2489 printk(KERN_ERR
2490 "comedi%d: usbdux: error: attach_usb failed, already attached\n",
2491 dev->minor);
2492 ret = -ENODEV;
2493 } else
2494 ret = usbdux_attach_common(dev, this_usbduxsub, NULL, 0);
2495 up(&start_stop_sem);
2496 return ret;
2497 }
2498
2499 static void usbdux_detach(struct comedi_device *dev)
2500 {
2501 struct usbduxsub *usb = dev->private;
2502
2503 if (usb) {
2504 down(&usb->sem);
2505 dev->private = NULL;
2506 usb->attached = 0;
2507 usb->comedidev = NULL;
2508 up(&usb->sem);
2509 }
2510 }
2511
2512 static struct comedi_driver usbdux_driver = {
2513 .driver_name = "usbdux",
2514 .module = THIS_MODULE,
2515 .attach = usbdux_attach,
2516 .detach = usbdux_detach,
2517 .attach_usb = usbdux_attach_usb,
2518 };
2519
2520 static void usbdux_firmware_request_complete_handler(const struct firmware *fw,
2521 void *context)
2522 {
2523 struct usbduxsub *usbduxsub_tmp = context;
2524 struct usb_interface *uinterf = usbduxsub_tmp->interface;
2525 int ret;
2526
2527 if (fw == NULL) {
2528 dev_err(&uinterf->dev,
2529 "Firmware complete handler without firmware!\n");
2530 return;
2531 }
2532
2533 /*
2534 * we need to upload the firmware here because fw will be
2535 * freed once we've left this function
2536 */
2537 ret = firmwareUpload(usbduxsub_tmp, fw->data, fw->size);
2538
2539 if (ret) {
2540 dev_err(&uinterf->dev,
2541 "Could not upload firmware (err=%d)\n", ret);
2542 goto out;
2543 }
2544 comedi_usb_auto_config(uinterf, &usbdux_driver);
2545 out:
2546 release_firmware(fw);
2547 }
2548
2549 static int usbdux_usb_probe(struct usb_interface *uinterf,
2550 const struct usb_device_id *id)
2551 {
2552 struct usb_device *udev = interface_to_usbdev(uinterf);
2553 struct device *dev = &uinterf->dev;
2554 int i;
2555 int index;
2556 int ret;
2557
2558 dev_dbg(dev, "comedi_: usbdux_: "
2559 "finding a free structure for the usb-device\n");
2560
2561 down(&start_stop_sem);
2562 /* look for a free place in the usbdux array */
2563 index = -1;
2564 for (i = 0; i < NUMUSBDUX; i++) {
2565 if (!(usbduxsub[i].probed)) {
2566 index = i;
2567 break;
2568 }
2569 }
2570
2571 /* no more space */
2572 if (index == -1) {
2573 dev_err(dev, "Too many usbdux-devices connected.\n");
2574 up(&start_stop_sem);
2575 return -EMFILE;
2576 }
2577 dev_dbg(dev, "comedi_: usbdux: "
2578 "usbduxsub[%d] is ready to connect to comedi.\n", index);
2579
2580 sema_init(&(usbduxsub[index].sem), 1);
2581 /* save a pointer to the usb device */
2582 usbduxsub[index].usbdev = udev;
2583
2584 /* 2.6: save the interface itself */
2585 usbduxsub[index].interface = uinterf;
2586 /* get the interface number from the interface */
2587 usbduxsub[index].ifnum = uinterf->altsetting->desc.bInterfaceNumber;
2588 /* hand the private data over to the usb subsystem */
2589 /* will be needed for disconnect */
2590 usb_set_intfdata(uinterf, &(usbduxsub[index]));
2591
2592 dev_dbg(dev, "comedi_: usbdux: ifnum=%d\n", usbduxsub[index].ifnum);
2593
2594 /* test if it is high speed (USB 2.0) */
2595 usbduxsub[index].high_speed =
2596 (usbduxsub[index].usbdev->speed == USB_SPEED_HIGH);
2597
2598 /* create space for the commands of the DA converter */
2599 usbduxsub[index].dac_commands = kzalloc(NUMOUTCHANNELS, GFP_KERNEL);
2600 if (!usbduxsub[index].dac_commands) {
2601 dev_err(dev, "comedi_: usbdux: "
2602 "error alloc space for dac commands\n");
2603 tidy_up(&(usbduxsub[index]));
2604 up(&start_stop_sem);
2605 return -ENOMEM;
2606 }
2607 /* create space for the commands going to the usb device */
2608 usbduxsub[index].dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL);
2609 if (!usbduxsub[index].dux_commands) {
2610 dev_err(dev, "comedi_: usbdux: "
2611 "error alloc space for dux commands\n");
2612 tidy_up(&(usbduxsub[index]));
2613 up(&start_stop_sem);
2614 return -ENOMEM;
2615 }
2616 /* create space for the in buffer and set it to zero */
2617 usbduxsub[index].inBuffer = kzalloc(SIZEINBUF, GFP_KERNEL);
2618 if (!(usbduxsub[index].inBuffer)) {
2619 dev_err(dev, "comedi_: usbdux: "
2620 "could not alloc space for inBuffer\n");
2621 tidy_up(&(usbduxsub[index]));
2622 up(&start_stop_sem);
2623 return -ENOMEM;
2624 }
2625 /* create space of the instruction buffer */
2626 usbduxsub[index].insnBuffer = kzalloc(SIZEINSNBUF, GFP_KERNEL);
2627 if (!(usbduxsub[index].insnBuffer)) {
2628 dev_err(dev, "comedi_: usbdux: "
2629 "could not alloc space for insnBuffer\n");
2630 tidy_up(&(usbduxsub[index]));
2631 up(&start_stop_sem);
2632 return -ENOMEM;
2633 }
2634 /* create space for the outbuffer */
2635 usbduxsub[index].outBuffer = kzalloc(SIZEOUTBUF, GFP_KERNEL);
2636 if (!(usbduxsub[index].outBuffer)) {
2637 dev_err(dev, "comedi_: usbdux: "
2638 "could not alloc space for outBuffer\n");
2639 tidy_up(&(usbduxsub[index]));
2640 up(&start_stop_sem);
2641 return -ENOMEM;
2642 }
2643 /* setting to alternate setting 3: enabling iso ep and bulk ep. */
2644 i = usb_set_interface(usbduxsub[index].usbdev,
2645 usbduxsub[index].ifnum, 3);
2646 if (i < 0) {
2647 dev_err(dev, "comedi_: usbdux%d: "
2648 "could not set alternate setting 3 in high speed.\n",
2649 index);
2650 tidy_up(&(usbduxsub[index]));
2651 up(&start_stop_sem);
2652 return -ENODEV;
2653 }
2654 if (usbduxsub[index].high_speed)
2655 usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSHIGH;
2656 else
2657 usbduxsub[index].numOfInBuffers = NUMOFINBUFFERSFULL;
2658
2659 usbduxsub[index].urbIn =
2660 kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfInBuffers,
2661 GFP_KERNEL);
2662 if (!(usbduxsub[index].urbIn)) {
2663 dev_err(dev, "comedi_: usbdux: Could not alloc. urbIn array\n");
2664 tidy_up(&(usbduxsub[index]));
2665 up(&start_stop_sem);
2666 return -ENOMEM;
2667 }
2668 for (i = 0; i < usbduxsub[index].numOfInBuffers; i++) {
2669 /* one frame: 1ms */
2670 usbduxsub[index].urbIn[i] = usb_alloc_urb(1, GFP_KERNEL);
2671 if (usbduxsub[index].urbIn[i] == NULL) {
2672 dev_err(dev, "comedi_: usbdux%d: "
2673 "Could not alloc. urb(%d)\n", index, i);
2674 tidy_up(&(usbduxsub[index]));
2675 up(&start_stop_sem);
2676 return -ENOMEM;
2677 }
2678 usbduxsub[index].urbIn[i]->dev = usbduxsub[index].usbdev;
2679 /* will be filled later with a pointer to the comedi-device */
2680 /* and ONLY then the urb should be submitted */
2681 usbduxsub[index].urbIn[i]->context = NULL;
2682 usbduxsub[index].urbIn[i]->pipe =
2683 usb_rcvisocpipe(usbduxsub[index].usbdev, ISOINEP);
2684 usbduxsub[index].urbIn[i]->transfer_flags = URB_ISO_ASAP;
2685 usbduxsub[index].urbIn[i]->transfer_buffer =
2686 kzalloc(SIZEINBUF, GFP_KERNEL);
2687 if (!(usbduxsub[index].urbIn[i]->transfer_buffer)) {
2688 dev_err(dev, "comedi_: usbdux%d: "
2689 "could not alloc. transb.\n", index);
2690 tidy_up(&(usbduxsub[index]));
2691 up(&start_stop_sem);
2692 return -ENOMEM;
2693 }
2694 usbduxsub[index].urbIn[i]->complete = usbduxsub_ai_IsocIrq;
2695 usbduxsub[index].urbIn[i]->number_of_packets = 1;
2696 usbduxsub[index].urbIn[i]->transfer_buffer_length = SIZEINBUF;
2697 usbduxsub[index].urbIn[i]->iso_frame_desc[0].offset = 0;
2698 usbduxsub[index].urbIn[i]->iso_frame_desc[0].length = SIZEINBUF;
2699 }
2700
2701 /* out */
2702 if (usbduxsub[index].high_speed)
2703 usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSHIGH;
2704 else
2705 usbduxsub[index].numOfOutBuffers = NUMOFOUTBUFFERSFULL;
2706
2707 usbduxsub[index].urbOut =
2708 kzalloc(sizeof(struct urb *) * usbduxsub[index].numOfOutBuffers,
2709 GFP_KERNEL);
2710 if (!(usbduxsub[index].urbOut)) {
2711 dev_err(dev, "comedi_: usbdux: "
2712 "Could not alloc. urbOut array\n");
2713 tidy_up(&(usbduxsub[index]));
2714 up(&start_stop_sem);
2715 return -ENOMEM;
2716 }
2717 for (i = 0; i < usbduxsub[index].numOfOutBuffers; i++) {
2718 /* one frame: 1ms */
2719 usbduxsub[index].urbOut[i] = usb_alloc_urb(1, GFP_KERNEL);
2720 if (usbduxsub[index].urbOut[i] == NULL) {
2721 dev_err(dev, "comedi_: usbdux%d: "
2722 "Could not alloc. urb(%d)\n", index, i);
2723 tidy_up(&(usbduxsub[index]));
2724 up(&start_stop_sem);
2725 return -ENOMEM;
2726 }
2727 usbduxsub[index].urbOut[i]->dev = usbduxsub[index].usbdev;
2728 /* will be filled later with a pointer to the comedi-device */
2729 /* and ONLY then the urb should be submitted */
2730 usbduxsub[index].urbOut[i]->context = NULL;
2731 usbduxsub[index].urbOut[i]->pipe =
2732 usb_sndisocpipe(usbduxsub[index].usbdev, ISOOUTEP);
2733 usbduxsub[index].urbOut[i]->transfer_flags = URB_ISO_ASAP;
2734 usbduxsub[index].urbOut[i]->transfer_buffer =
2735 kzalloc(SIZEOUTBUF, GFP_KERNEL);
2736 if (!(usbduxsub[index].urbOut[i]->transfer_buffer)) {
2737 dev_err(dev, "comedi_: usbdux%d: "
2738 "could not alloc. transb.\n", index);
2739 tidy_up(&(usbduxsub[index]));
2740 up(&start_stop_sem);
2741 return -ENOMEM;
2742 }
2743 usbduxsub[index].urbOut[i]->complete = usbduxsub_ao_IsocIrq;
2744 usbduxsub[index].urbOut[i]->number_of_packets = 1;
2745 usbduxsub[index].urbOut[i]->transfer_buffer_length = SIZEOUTBUF;
2746 usbduxsub[index].urbOut[i]->iso_frame_desc[0].offset = 0;
2747 usbduxsub[index].urbOut[i]->iso_frame_desc[0].length =
2748 SIZEOUTBUF;
2749 if (usbduxsub[index].high_speed) {
2750 /* uframes */
2751 usbduxsub[index].urbOut[i]->interval = 8;
2752 } else {
2753 /* frames */
2754 usbduxsub[index].urbOut[i]->interval = 1;
2755 }
2756 }
2757
2758 /* pwm */
2759 if (usbduxsub[index].high_speed) {
2760 /* max bulk ep size in high speed */
2761 usbduxsub[index].sizePwmBuf = 512;
2762 usbduxsub[index].urbPwm = usb_alloc_urb(0, GFP_KERNEL);
2763 if (usbduxsub[index].urbPwm == NULL) {
2764 dev_err(dev, "comedi_: usbdux%d: "
2765 "Could not alloc. pwm urb\n", index);
2766 tidy_up(&(usbduxsub[index]));
2767 up(&start_stop_sem);
2768 return -ENOMEM;
2769 }
2770 usbduxsub[index].urbPwm->transfer_buffer =
2771 kzalloc(usbduxsub[index].sizePwmBuf, GFP_KERNEL);
2772 if (!(usbduxsub[index].urbPwm->transfer_buffer)) {
2773 dev_err(dev, "comedi_: usbdux%d: "
2774 "could not alloc. transb. for pwm\n", index);
2775 tidy_up(&(usbduxsub[index]));
2776 up(&start_stop_sem);
2777 return -ENOMEM;
2778 }
2779 } else {
2780 usbduxsub[index].urbPwm = NULL;
2781 usbduxsub[index].sizePwmBuf = 0;
2782 }
2783
2784 usbduxsub[index].ai_cmd_running = 0;
2785 usbduxsub[index].ao_cmd_running = 0;
2786 usbduxsub[index].pwm_cmd_running = 0;
2787
2788 /* we've reached the bottom of the function */
2789 usbduxsub[index].probed = 1;
2790 up(&start_stop_sem);
2791
2792 ret = request_firmware_nowait(THIS_MODULE,
2793 FW_ACTION_HOTPLUG,
2794 "usbdux_firmware.bin",
2795 &udev->dev,
2796 GFP_KERNEL,
2797 usbduxsub + index,
2798 usbdux_firmware_request_complete_handler);
2799
2800 if (ret) {
2801 dev_err(dev, "Could not load firmware (err=%d)\n", ret);
2802 return ret;
2803 }
2804
2805 dev_info(dev, "comedi_: usbdux%d "
2806 "has been successfully initialised.\n", index);
2807 /* success */
2808 return 0;
2809 }
2810
2811 static void usbdux_usb_disconnect(struct usb_interface *intf)
2812 {
2813 struct usbduxsub *usbduxsub_tmp = usb_get_intfdata(intf);
2814 struct usb_device *udev = interface_to_usbdev(intf);
2815
2816 if (!usbduxsub_tmp) {
2817 dev_err(&intf->dev,
2818 "comedi_: disconnect called with null pointer.\n");
2819 return;
2820 }
2821 if (usbduxsub_tmp->usbdev != udev) {
2822 dev_err(&intf->dev, "comedi_: BUG! called with wrong ptr!!!\n");
2823 return;
2824 }
2825 comedi_usb_auto_unconfig(intf);
2826 down(&start_stop_sem);
2827 down(&usbduxsub_tmp->sem);
2828 tidy_up(usbduxsub_tmp);
2829 up(&usbduxsub_tmp->sem);
2830 up(&start_stop_sem);
2831 dev_dbg(&intf->dev, "comedi_: disconnected from the usb\n");
2832 }
2833
2834 static const struct usb_device_id usbdux_usb_table[] = {
2835 { USB_DEVICE(0x13d8, 0x0001) },
2836 { USB_DEVICE(0x13d8, 0x0002) },
2837 { }
2838 };
2839
2840 MODULE_DEVICE_TABLE(usb, usbdux_usb_table);
2841
2842 static struct usb_driver usbdux_usb_driver = {
2843 .name = "usbdux",
2844 .probe = usbdux_usb_probe,
2845 .disconnect = usbdux_usb_disconnect,
2846 .id_table = usbdux_usb_table,
2847 };
2848 module_comedi_usb_driver(usbdux_driver, usbdux_usb_driver);
2849
2850 MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
2851 MODULE_DESCRIPTION("Stirling/ITL USB-DUX -- Bernd.Porr@f2s.com");
2852 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.22182 seconds and 5 git commands to generate.