Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/staging/comedi/drivers/usbduxfast.c

  1 /*
  2  *  Copyright (C) 2004 Bernd Porr, Bernd.Porr@f2s.com
  3  *
  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.
  8  *
  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.
 13  */
 14 
 15 /*
 16  * I must give credit here to Chris Baugher who
 17  * wrote the driver for AT-MIO-16d. I used some parts of this
 18  * driver. I also must give credits to David Brownell
 19  * who supported me with the USB development.
 20  *
 21  * Bernd Porr
 22  *
 23  *
 24  * Revision history:
 25  * 0.9: Dropping the first data packet which seems to be from the last transfer.
 26  *      Buffer overflows in the FX2 are handed over to comedi.
 27  * 0.92: Dropping now 4 packets. The quad buffer has to be emptied.
 28  *       Added insn command basically for testing. Sample rate is
 29  *       1MHz/16ch=62.5kHz
 30  * 0.99: Ian Abbott pointed out a bug which has been corrected. Thanks!
 31  * 0.99a: added external trigger.
 32  * 1.00: added firmware kernel request to the driver which fixed
 33  *       udev coldplug problem
 34  */
 35 
 36 #include <linux/kernel.h>
 37 #include <linux/module.h>
 38 #include <linux/slab.h>
 39 #include <linux/input.h>
 40 #include <linux/usb.h>
 41 #include <linux/fcntl.h>
 42 #include <linux/compiler.h>
 43 #include "comedi_fc.h"
 44 #include "../comedidev.h"
 45 
 46 /*
 47  * timeout for the USB-transfer
 48  */
 49 #define EZTIMEOUT       30
 50 
 51 /*
 52  * constants for "firmware" upload and download
 53  */
 54 #define FIRMWARE                "usbduxfast_firmware.bin"
 55 #define FIRMWARE_MAX_LEN        0x2000
 56 #define USBDUXFASTSUB_FIRMWARE  0xA0
 57 #define VENDOR_DIR_IN           0xC0
 58 #define VENDOR_DIR_OUT          0x40
 59 
 60 /*
 61  * internal addresses of the 8051 processor
 62  */
 63 #define USBDUXFASTSUB_CPUCS     0xE600
 64 
 65 /*
 66  * max lenghth of the transfer-buffer for software upload
 67  */
 68 #define TB_LEN  0x2000
 69 
 70 /*
 71  * input endpoint number
 72  */
 73 #define BULKINEP        6
 74 
 75 /*
 76  * endpoint for the A/D channellist: bulk OUT
 77  */
 78 #define CHANNELLISTEP   4
 79 
 80 /*
 81  * number of channels
 82  */
 83 #define NUMCHANNELS     32
 84 
 85 /*
 86  * size of the waveform descriptor
 87  */
 88 #define WAVESIZE        0x20
 89 
 90 /*
 91  * size of one A/D value
 92  */
 93 #define SIZEADIN        (sizeof(int16_t))
 94 
 95 /*
 96  * size of the input-buffer IN BYTES
 97  */
 98 #define SIZEINBUF       512
 99 
100 /*
101  * 16 bytes
102  */
103 #define SIZEINSNBUF     512
104 
105 /*
106  * size of the buffer for the dux commands in bytes
107  */
108 #define SIZEOFDUXBUF    256
109 
110 /*
111  * number of in-URBs which receive the data: min=5
112  */
113 #define NUMOFINBUFFERSHIGH      10
114 
115 /*
116  * min delay steps for more than one channel
117  * basically when the mux gives up ;-)
118  *
119  * steps at 30MHz in the FX2
120  */
121 #define MIN_SAMPLING_PERIOD     9
122 
123 /*
124  * max number of 1/30MHz delay steps
125  */
126 #define MAX_SAMPLING_PERIOD     500
127 
128 /*
129  * number of received packets to ignore before we start handing data
130  * over to comedi, it's quad buffering and we have to ignore 4 packets
131  */
132 #define PACKETS_TO_IGNORE       4
133 
134 /*
135  * comedi constants
136  */
137 static const struct comedi_lrange range_usbduxfast_ai_range = {
138         2, {
139                 BIP_RANGE(0.75),
140                 BIP_RANGE(0.5)
141         }
142 };
143 
144 /*
145  * private structure of one subdevice
146  *
147  * this is the structure which holds all the data of this driver
148  * one sub device just now: A/D
149  */
150 struct usbduxfast_private {
151         struct urb *urb;        /* BULK-transfer handling: urb */
152         uint8_t *duxbuf;
153         int8_t *inbuf;
154         short int ai_cmd_running;       /* asynchronous command is running */
155         long int ai_sample_count;       /* number of samples to acquire */
156         int ignore;             /* counter which ignores the first
157                                    buffers */
158         struct semaphore sem;
159 };
160 
161 /*
162  * bulk transfers to usbduxfast
163  */
164 #define SENDADCOMMANDS            0
165 #define SENDINITEP6               1
166 
167 static int usbduxfast_send_cmd(struct comedi_device *dev, int cmd_type)
168 {
169         struct usb_device *usb = comedi_to_usb_dev(dev);
170         struct usbduxfast_private *devpriv = dev->private;
171         int nsent;
172         int ret;
173 
174         devpriv->duxbuf[0] = cmd_type;
175 
176         ret = usb_bulk_msg(usb, usb_sndbulkpipe(usb, CHANNELLISTEP),
177                            devpriv->duxbuf, SIZEOFDUXBUF,
178                            &nsent, 10000);
179         if (ret < 0)
180                 dev_err(dev->class_dev,
181                         "could not transmit command to the usb-device, err=%d\n",
182                         ret);
183         return ret;
184 }
185 
186 static void usbduxfast_cmd_data(struct comedi_device *dev, int index,
187                                 uint8_t len, uint8_t op, uint8_t out,
188                                 uint8_t log)
189 {
190         struct usbduxfast_private *devpriv = dev->private;
191 
192         /* Set the GPIF bytes, the first byte is the command byte */
193         devpriv->duxbuf[1 + 0x00 + index] = len;
194         devpriv->duxbuf[1 + 0x08 + index] = op;
195         devpriv->duxbuf[1 + 0x10 + index] = out;
196         devpriv->duxbuf[1 + 0x18 + index] = log;
197 }
198 
199 static int usbduxfast_ai_stop(struct comedi_device *dev, int do_unlink)
200 {
201         struct usbduxfast_private *devpriv = dev->private;
202 
203         /* stop aquistion */
204         devpriv->ai_cmd_running = 0;
205 
206         if (do_unlink && devpriv->urb) {
207                 /* kill the running transfer */
208                 usb_kill_urb(devpriv->urb);
209         }
210 
211         return 0;
212 }
213 
214 static int usbduxfast_ai_cancel(struct comedi_device *dev,
215                                 struct comedi_subdevice *s)
216 {
217         struct usbduxfast_private *devpriv = dev->private;
218         int ret;
219 
220         if (!devpriv)
221                 return -EFAULT;
222 
223         down(&devpriv->sem);
224         ret = usbduxfast_ai_stop(dev, 1);
225         up(&devpriv->sem);
226 
227         return ret;
228 }
229 
230 /*
231  * analogue IN
232  * interrupt service routine
233  */
234 static void usbduxfast_ai_interrupt(struct urb *urb)
235 {
236         struct comedi_device *dev = urb->context;
237         struct comedi_subdevice *s = dev->read_subdev;
238         struct comedi_async *async = s->async;
239         struct comedi_cmd *cmd = &async->cmd;
240         struct usb_device *usb = comedi_to_usb_dev(dev);
241         struct usbduxfast_private *devpriv = dev->private;
242         int n, err;
243 
244         /* are we running a command? */
245         if (unlikely(!devpriv->ai_cmd_running)) {
246                 /*
247                  * not running a command
248                  * do not continue execution if no asynchronous command
249                  * is running in particular not resubmit
250                  */
251                 return;
252         }
253 
254         /* first we test if something unusual has just happened */
255         switch (urb->status) {
256         case 0:
257                 break;
258 
259                 /*
260                  * happens after an unlink command or when the device
261                  * is plugged out
262                  */
263         case -ECONNRESET:
264         case -ENOENT:
265         case -ESHUTDOWN:
266         case -ECONNABORTED:
267                 /* tell this comedi */
268                 async->events |= COMEDI_CB_EOA;
269                 async->events |= COMEDI_CB_ERROR;
270                 comedi_event(dev, s);
271                 /* stop the transfer w/o unlink */
272                 usbduxfast_ai_stop(dev, 0);
273                 return;
274 
275         default:
276                 dev_err(dev->class_dev,
277                         "non-zero urb status received in ai intr context: %d\n",
278                         urb->status);
279                 async->events |= COMEDI_CB_EOA;
280                 async->events |= COMEDI_CB_ERROR;
281                 comedi_event(dev, s);
282                 usbduxfast_ai_stop(dev, 0);
283                 return;
284         }
285 
286         if (!devpriv->ignore) {
287                 if (cmd->stop_src == TRIG_COUNT) {
288                         /* not continuous, fixed number of samples */
289                         n = urb->actual_length / sizeof(uint16_t);
290                         if (unlikely(devpriv->ai_sample_count < n)) {
291                                 unsigned int num_bytes;
292 
293                                 /* partial sample received */
294                                 num_bytes = devpriv->ai_sample_count *
295                                             sizeof(uint16_t);
296                                 cfc_write_array_to_buffer(s,
297                                                           urb->transfer_buffer,
298                                                           num_bytes);
299                                 usbduxfast_ai_stop(dev, 0);
300                                 /* tell comedi that the acquistion is over */
301                                 async->events |= COMEDI_CB_EOA;
302                                 comedi_event(dev, s);
303                                 return;
304                         }
305                         devpriv->ai_sample_count -= n;
306                 }
307                 /* write the full buffer to comedi */
308                 err = cfc_write_array_to_buffer(s, urb->transfer_buffer,
309                                                 urb->actual_length);
310                 if (unlikely(err == 0)) {
311                         /* buffer overflow */
312                         usbduxfast_ai_stop(dev, 0);
313                         return;
314                 }
315 
316                 /* tell comedi that data is there */
317                 comedi_event(dev, s);
318         } else {
319                 /* ignore this packet */
320                 devpriv->ignore--;
321         }
322 
323         /*
324          * command is still running
325          * resubmit urb for BULK transfer
326          */
327         urb->dev = usb;
328         urb->status = 0;
329         err = usb_submit_urb(urb, GFP_ATOMIC);
330         if (err < 0) {
331                 dev_err(dev->class_dev,
332                         "urb resubm failed: %d", err);
333                 async->events |= COMEDI_CB_EOA;
334                 async->events |= COMEDI_CB_ERROR;
335                 comedi_event(dev, s);
336                 usbduxfast_ai_stop(dev, 0);
337         }
338 }
339 
340 static int usbduxfast_submit_urb(struct comedi_device *dev)
341 {
342         struct usb_device *usb = comedi_to_usb_dev(dev);
343         struct usbduxfast_private *devpriv = dev->private;
344         int ret;
345 
346         if (!devpriv)
347                 return -EFAULT;
348 
349         usb_fill_bulk_urb(devpriv->urb, usb, usb_rcvbulkpipe(usb, BULKINEP),
350                           devpriv->inbuf, SIZEINBUF,
351                           usbduxfast_ai_interrupt, dev);
352 
353         ret = usb_submit_urb(devpriv->urb, GFP_ATOMIC);
354         if (ret) {
355                 dev_err(dev->class_dev, "usb_submit_urb error %d\n", ret);
356                 return ret;
357         }
358         return 0;
359 }
360 
361 static int usbduxfast_ai_cmdtest(struct comedi_device *dev,
362                                  struct comedi_subdevice *s,
363                                  struct comedi_cmd *cmd)
364 {
365         int err = 0;
366         long int steps, tmp;
367         int min_sample_period;
368 
369         /* Step 1 : check if triggers are trivially valid */
370 
371         err |= cfc_check_trigger_src(&cmd->start_src,
372                                         TRIG_NOW | TRIG_EXT | TRIG_INT);
373         err |= cfc_check_trigger_src(&cmd->scan_begin_src,
374                                         TRIG_FOLLOW | TRIG_EXT);
375         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_TIMER | TRIG_EXT);
376         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
377         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
378 
379         if (err)
380                 return 1;
381 
382         /* Step 2a : make sure trigger sources are unique */
383 
384         err |= cfc_check_trigger_is_unique(cmd->start_src);
385         err |= cfc_check_trigger_is_unique(cmd->scan_begin_src);
386         err |= cfc_check_trigger_is_unique(cmd->convert_src);
387         err |= cfc_check_trigger_is_unique(cmd->stop_src);
388 
389         /* Step 2b : and mutually compatible */
390 
391         /* can't have external stop and start triggers at once */
392         if (cmd->start_src == TRIG_EXT && cmd->stop_src == TRIG_EXT)
393                 err |= -EINVAL;
394 
395         if (err)
396                 return 2;
397 
398         /* Step 3: check if arguments are trivially valid */
399 
400         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
401 
402         if (!cmd->chanlist_len)
403                 err |= -EINVAL;
404 
405         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len);
406 
407         if (cmd->chanlist_len == 1)
408                 min_sample_period = 1;
409         else
410                 min_sample_period = MIN_SAMPLING_PERIOD;
411 
412         if (cmd->convert_src == TRIG_TIMER) {
413                 steps = cmd->convert_arg * 30;
414                 if (steps < (min_sample_period * 1000))
415                         steps = min_sample_period * 1000;
416 
417                 if (steps > (MAX_SAMPLING_PERIOD * 1000))
418                         steps = MAX_SAMPLING_PERIOD * 1000;
419 
420                 /* calc arg again */
421                 tmp = steps / 30;
422                 err |= cfc_check_trigger_arg_is(&cmd->convert_arg, tmp);
423         }
424 
425         /* stop source */
426         switch (cmd->stop_src) {
427         case TRIG_COUNT:
428                 err |= cfc_check_trigger_arg_min(&cmd->stop_arg, 1);
429                 break;
430         case TRIG_NONE:
431                 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
432                 break;
433                 /*
434                  * TRIG_EXT doesn't care since it doesn't trigger
435                  * off a numbered channel
436                  */
437         default:
438                 break;
439         }
440 
441         if (err)
442                 return 3;
443 
444         /* step 4: fix up any arguments */
445 
446         return 0;
447 
448 }
449 
450 static int usbduxfast_ai_inttrig(struct comedi_device *dev,
451                                  struct comedi_subdevice *s,
452                                  unsigned int trig_num)
453 {
454         struct usbduxfast_private *devpriv = dev->private;
455         struct comedi_cmd *cmd = &s->async->cmd;
456         int ret;
457 
458         if (!devpriv)
459                 return -EFAULT;
460 
461         if (trig_num != cmd->start_arg)
462                 return -EINVAL;
463 
464         down(&devpriv->sem);
465 
466         if (!devpriv->ai_cmd_running) {
467                 devpriv->ai_cmd_running = 1;
468                 ret = usbduxfast_submit_urb(dev);
469                 if (ret < 0) {
470                         dev_err(dev->class_dev, "urbSubmit: err=%d\n", ret);
471                         devpriv->ai_cmd_running = 0;
472                         up(&devpriv->sem);
473                         return ret;
474                 }
475                 s->async->inttrig = NULL;
476         } else {
477                 dev_err(dev->class_dev, "ai is already running\n");
478         }
479         up(&devpriv->sem);
480         return 1;
481 }
482 
483 static int usbduxfast_ai_cmd(struct comedi_device *dev,
484                              struct comedi_subdevice *s)
485 {
486         struct usbduxfast_private *devpriv = dev->private;
487         struct comedi_cmd *cmd = &s->async->cmd;
488         unsigned int chan, gain, rngmask = 0xff;
489         int i, j, ret;
490         int result;
491         long steps, steps_tmp;
492 
493         if (!devpriv)
494                 return -EFAULT;
495 
496         down(&devpriv->sem);
497         if (devpriv->ai_cmd_running) {
498                 dev_err(dev->class_dev, "ai_cmd not possible\n");
499                 up(&devpriv->sem);
500                 return -EBUSY;
501         }
502         /* set current channel of the running acquisition to zero */
503         s->async->cur_chan = 0;
504 
505         /*
506          * ignore the first buffers from the device if there
507          * is an error condition
508          */
509         devpriv->ignore = PACKETS_TO_IGNORE;
510 
511         gain = CR_RANGE(cmd->chanlist[0]);
512         for (i = 0; i < cmd->chanlist_len; ++i) {
513                 chan = CR_CHAN(cmd->chanlist[i]);
514                 if (chan != i) {
515                         dev_err(dev->class_dev,
516                                 "channels are not consecutive\n");
517                         up(&devpriv->sem);
518                         return -EINVAL;
519                 }
520                 if ((gain != CR_RANGE(cmd->chanlist[i]))
521                         && (cmd->chanlist_len > 3)) {
522                         dev_err(dev->class_dev,
523                                 "gain must be the same for all channels\n");
524                         up(&devpriv->sem);
525                         return -EINVAL;
526                 }
527                 if (i >= NUMCHANNELS) {
528                         dev_err(dev->class_dev, "chanlist too long\n");
529                         break;
530                 }
531         }
532         steps = 0;
533         if (cmd->convert_src == TRIG_TIMER)
534                 steps = (cmd->convert_arg * 30) / 1000;
535 
536         if ((steps < MIN_SAMPLING_PERIOD) && (cmd->chanlist_len != 1)) {
537                 dev_err(dev->class_dev,
538                         "steps=%ld, scan_begin_arg=%d. Not properly tested by cmdtest?\n",
539                         steps, cmd->scan_begin_arg);
540                 up(&devpriv->sem);
541                 return -EINVAL;
542         }
543         if (steps > MAX_SAMPLING_PERIOD) {
544                 dev_err(dev->class_dev, "sampling rate too low\n");
545                 up(&devpriv->sem);
546                 return -EINVAL;
547         }
548         if ((cmd->start_src == TRIG_EXT) && (cmd->chanlist_len != 1)
549             && (cmd->chanlist_len != 16)) {
550                 dev_err(dev->class_dev,
551                         "TRIG_EXT only with 1 or 16 channels possible\n");
552                 up(&devpriv->sem);
553                 return -EINVAL;
554         }
555 
556         switch (cmd->chanlist_len) {
557         case 1:
558                 /*
559                  * one channel
560                  */
561 
562                 if (CR_RANGE(cmd->chanlist[0]) > 0)
563                         rngmask = 0xff - 0x04;
564                 else
565                         rngmask = 0xff;
566 
567                 /*
568                  * for external trigger: looping in this state until
569                  * the RDY0 pin becomes zero
570                  */
571 
572                 /* we loop here until ready has been set */
573                 if (cmd->start_src == TRIG_EXT) {
574                         /* branch back to state 0 */
575                         /* deceision state w/o data */
576                         /* RDY0 = 0 */
577                         usbduxfast_cmd_data(dev, 0, 0x01, 0x01, rngmask, 0x00);
578                 } else {        /* we just proceed to state 1 */
579                         usbduxfast_cmd_data(dev, 0, 0x01, 0x00, rngmask, 0x00);
580                 }
581 
582                 if (steps < MIN_SAMPLING_PERIOD) {
583                         /* for fast single channel aqu without mux */
584                         if (steps <= 1) {
585                                 /*
586                                  * we just stay here at state 1 and rexecute
587                                  * the same state this gives us 30MHz sampling
588                                  * rate
589                                  */
590 
591                                 /* branch back to state 1 */
592                                 /* deceision state with data */
593                                 /* doesn't matter */
594                                 usbduxfast_cmd_data(dev, 1,
595                                                     0x89, 0x03, rngmask, 0xff);
596                         } else {
597                                 /*
598                                  * we loop through two states: data and delay
599                                  * max rate is 15MHz
600                                  */
601                                 /* data */
602                                 /* doesn't matter */
603                                 usbduxfast_cmd_data(dev, 1, steps - 1,
604                                                     0x02, rngmask, 0x00);
605 
606                                 /* branch back to state 1 */
607                                 /* deceision state w/o data */
608                                 /* doesn't matter */
609                                 usbduxfast_cmd_data(dev, 2,
610                                                     0x09, 0x01, rngmask, 0xff);
611                         }
612                 } else {
613                         /*
614                          * we loop through 3 states: 2x delay and 1x data
615                          * this gives a min sampling rate of 60kHz
616                          */
617 
618                         /* we have 1 state with duration 1 */
619                         steps = steps - 1;
620 
621                         /* do the first part of the delay */
622                         usbduxfast_cmd_data(dev, 1,
623                                             steps / 2, 0x00, rngmask, 0x00);
624 
625                         /* and the second part */
626                         usbduxfast_cmd_data(dev, 2, steps - steps / 2,
627                                             0x00, rngmask, 0x00);
628 
629                         /* get the data and branch back */
630 
631                         /* branch back to state 1 */
632                         /* deceision state w data */
633                         /* doesn't matter */
634                         usbduxfast_cmd_data(dev, 3,
635                                             0x09, 0x03, rngmask, 0xff);
636                 }
637                 break;
638 
639         case 2:
640                 /*
641                  * two channels
642                  * commit data to the FIFO
643                  */
644 
645                 if (CR_RANGE(cmd->chanlist[0]) > 0)
646                         rngmask = 0xff - 0x04;
647                 else
648                         rngmask = 0xff;
649 
650                 /* data */
651                 usbduxfast_cmd_data(dev, 0, 0x01, 0x02, rngmask, 0x00);
652 
653                 /* we have 1 state with duration 1: state 0 */
654                 steps_tmp = steps - 1;
655 
656                 if (CR_RANGE(cmd->chanlist[1]) > 0)
657                         rngmask = 0xff - 0x04;
658                 else
659                         rngmask = 0xff;
660 
661                 /* do the first part of the delay */
662                 /* count */
663                 usbduxfast_cmd_data(dev, 1, steps_tmp / 2,
664                                     0x00, 0xfe & rngmask, 0x00);
665 
666                 /* and the second part */
667                 usbduxfast_cmd_data(dev, 2, steps_tmp  - steps_tmp / 2,
668                                     0x00, rngmask, 0x00);
669 
670                 /* data */
671                 usbduxfast_cmd_data(dev, 3, 0x01, 0x02, rngmask, 0x00);
672 
673                 /*
674                  * we have 2 states with duration 1: step 6 and
675                  * the IDLE state
676                  */
677                 steps_tmp = steps - 2;
678 
679                 if (CR_RANGE(cmd->chanlist[0]) > 0)
680                         rngmask = 0xff - 0x04;
681                 else
682                         rngmask = 0xff;
683 
684                 /* do the first part of the delay */
685                 /* reset */
686                 usbduxfast_cmd_data(dev, 4, steps_tmp / 2,
687                                     0x00, (0xff - 0x02) & rngmask, 0x00);
688 
689                 /* and the second part */
690                 usbduxfast_cmd_data(dev, 5, steps_tmp - steps_tmp / 2,
691                                     0x00, rngmask, 0x00);
692 
693                 usbduxfast_cmd_data(dev, 6, 0x01, 0x00, rngmask, 0x00);
694                 break;
695 
696         case 3:
697                 /*
698                  * three channels
699                  */
700                 for (j = 0; j < 1; j++) {
701                         int index = j * 2;
702 
703                         if (CR_RANGE(cmd->chanlist[j]) > 0)
704                                 rngmask = 0xff - 0x04;
705                         else
706                                 rngmask = 0xff;
707                         /*
708                          * commit data to the FIFO and do the first part
709                          * of the delay
710                          */
711                         /* data */
712                         /* no change */
713                         usbduxfast_cmd_data(dev, index, steps / 2,
714                                             0x02, rngmask, 0x00);
715 
716                         if (CR_RANGE(cmd->chanlist[j + 1]) > 0)
717                                 rngmask = 0xff - 0x04;
718                         else
719                                 rngmask = 0xff;
720 
721                         /* do the second part of the delay */
722                         /* no data */
723                         /* count */
724                         usbduxfast_cmd_data(dev, index + 1, steps - steps / 2,
725                                             0x00, 0xfe & rngmask, 0x00);
726                 }
727 
728                 /* 2 steps with duration 1: the idele step and step 6: */
729                 steps_tmp = steps - 2;
730 
731                 /* commit data to the FIFO and do the first part of the delay */
732                 /* data */
733                 usbduxfast_cmd_data(dev, 4, steps_tmp / 2,
734                                     0x02, rngmask, 0x00);
735 
736                 if (CR_RANGE(cmd->chanlist[0]) > 0)
737                         rngmask = 0xff - 0x04;
738                 else
739                         rngmask = 0xff;
740 
741                 /* do the second part of the delay */
742                 /* no data */
743                 /* reset */
744                 usbduxfast_cmd_data(dev, 5, steps_tmp - steps_tmp / 2,
745                                     0x00, (0xff - 0x02) & rngmask, 0x00);
746 
747                 usbduxfast_cmd_data(dev, 6, 0x01, 0x00, rngmask, 0x00);
748                 break;
749 
750         case 16:
751                 if (CR_RANGE(cmd->chanlist[0]) > 0)
752                         rngmask = 0xff - 0x04;
753                 else
754                         rngmask = 0xff;
755 
756                 if (cmd->start_src == TRIG_EXT) {
757                         /*
758                          * we loop here until ready has been set
759                          */
760 
761                         /* branch back to state 0 */
762                         /* deceision state w/o data */
763                         /* reset */
764                         /* RDY0 = 0 */
765                         usbduxfast_cmd_data(dev, 0, 0x01, 0x01,
766                                             (0xff - 0x02) & rngmask, 0x00);
767                 } else {
768                         /*
769                          * we just proceed to state 1
770                          */
771 
772                         /* 30us reset pulse */
773                         /* reset */
774                         usbduxfast_cmd_data(dev, 0, 0xff, 0x00,
775                                             (0xff - 0x02) & rngmask, 0x00);
776                 }
777 
778                 /* commit data to the FIFO */
779                 /* data */
780                 usbduxfast_cmd_data(dev, 1, 0x01, 0x02, rngmask, 0x00);
781 
782                 /* we have 2 states with duration 1 */
783                 steps = steps - 2;
784 
785                 /* do the first part of the delay */
786                 usbduxfast_cmd_data(dev, 2, steps / 2,
787                                     0x00, 0xfe & rngmask, 0x00);
788 
789                 /* and the second part */
790                 usbduxfast_cmd_data(dev, 3, steps - steps / 2,
791                                     0x00, rngmask, 0x00);
792 
793                 /* branch back to state 1 */
794                 /* deceision state w/o data */
795                 /* doesn't matter */
796                 usbduxfast_cmd_data(dev, 4, 0x09, 0x01, rngmask, 0xff);
797 
798                 break;
799 
800         default:
801                 dev_err(dev->class_dev, "unsupported combination of channels\n");
802                 up(&devpriv->sem);
803                 return -EFAULT;
804         }
805 
806         /* 0 means that the AD commands are sent */
807         result = usbduxfast_send_cmd(dev, SENDADCOMMANDS);
808         if (result < 0) {
809                 up(&devpriv->sem);
810                 return result;
811         }
812 
813         if (cmd->stop_src == TRIG_COUNT)
814                 devpriv->ai_sample_count = cmd->stop_arg * cmd->scan_end_arg;
815         else    /* TRIG_NONE */
816                 devpriv->ai_sample_count = 0;
817 
818         if ((cmd->start_src == TRIG_NOW) || (cmd->start_src == TRIG_EXT)) {
819                 /* enable this acquisition operation */
820                 devpriv->ai_cmd_running = 1;
821                 ret = usbduxfast_submit_urb(dev);
822                 if (ret < 0) {
823                         devpriv->ai_cmd_running = 0;
824                         /* fixme: unlink here?? */
825                         up(&devpriv->sem);
826                         return ret;
827                 }
828                 s->async->inttrig = NULL;
829         } else {        /* TRIG_INT */
830                 s->async->inttrig = usbduxfast_ai_inttrig;
831         }
832         up(&devpriv->sem);
833 
834         return 0;
835 }
836 
837 /*
838  * Mode 0 is used to get a single conversion on demand.
839  */
840 static int usbduxfast_ai_insn_read(struct comedi_device *dev,
841                                    struct comedi_subdevice *s,
842                                    struct comedi_insn *insn,
843                                    unsigned int *data)
844 {
845         struct usb_device *usb = comedi_to_usb_dev(dev);
846         struct usbduxfast_private *devpriv = dev->private;
847         unsigned int chan = CR_CHAN(insn->chanspec);
848         unsigned int range = CR_RANGE(insn->chanspec);
849         uint8_t rngmask = range ? (0xff - 0x04) : 0xff;
850         int i, j, n, actual_length;
851         int ret;
852 
853         down(&devpriv->sem);
854 
855         if (devpriv->ai_cmd_running) {
856                 dev_err(dev->class_dev,
857                         "ai_insn_read not possible, async cmd is running\n");
858                 up(&devpriv->sem);
859                 return -EBUSY;
860         }
861 
862         /* set command for the first channel */
863 
864         /* commit data to the FIFO */
865         /* data */
866         usbduxfast_cmd_data(dev, 0, 0x01, 0x02, rngmask, 0x00);
867 
868         /* do the first part of the delay */
869         usbduxfast_cmd_data(dev, 1, 0x0c, 0x00, 0xfe & rngmask, 0x00);
870         usbduxfast_cmd_data(dev, 2, 0x01, 0x00, 0xfe & rngmask, 0x00);
871         usbduxfast_cmd_data(dev, 3, 0x01, 0x00, 0xfe & rngmask, 0x00);
872         usbduxfast_cmd_data(dev, 4, 0x01, 0x00, 0xfe & rngmask, 0x00);
873 
874         /* second part */
875         usbduxfast_cmd_data(dev, 5, 0x0c, 0x00, rngmask, 0x00);
876         usbduxfast_cmd_data(dev, 6, 0x01, 0x00, rngmask, 0x00);
877 
878         ret = usbduxfast_send_cmd(dev, SENDADCOMMANDS);
879         if (ret < 0) {
880                 up(&devpriv->sem);
881                 return ret;
882         }
883 
884         for (i = 0; i < PACKETS_TO_IGNORE; i++) {
885                 ret = usb_bulk_msg(usb, usb_rcvbulkpipe(usb, BULKINEP),
886                                    devpriv->inbuf, SIZEINBUF,
887                                    &actual_length, 10000);
888                 if (ret < 0) {
889                         dev_err(dev->class_dev, "insn timeout, no data\n");
890                         up(&devpriv->sem);
891                         return ret;
892                 }
893         }
894 
895         for (i = 0; i < insn->n;) {
896                 ret = usb_bulk_msg(usb, usb_rcvbulkpipe(usb, BULKINEP),
897                                    devpriv->inbuf, SIZEINBUF,
898                                    &actual_length, 10000);
899                 if (ret < 0) {
900                         dev_err(dev->class_dev, "insn data error: %d\n", ret);
901                         up(&devpriv->sem);
902                         return ret;
903                 }
904                 n = actual_length / sizeof(uint16_t);
905                 if ((n % 16) != 0) {
906                         dev_err(dev->class_dev, "insn data packet corrupted\n");
907                         up(&devpriv->sem);
908                         return -EINVAL;
909                 }
910                 for (j = chan; (j < n) && (i < insn->n); j = j + 16) {
911                         data[i] = ((uint16_t *) (devpriv->inbuf))[j];
912                         i++;
913                 }
914         }
915 
916         up(&devpriv->sem);
917 
918         return insn->n;
919 }
920 
921 static int usbduxfast_attach_common(struct comedi_device *dev)
922 {
923         struct usbduxfast_private *devpriv = dev->private;
924         struct comedi_subdevice *s;
925         int ret;
926 
927         down(&devpriv->sem);
928 
929         ret = comedi_alloc_subdevices(dev, 1);
930         if (ret) {
931                 up(&devpriv->sem);
932                 return ret;
933         }
934 
935         /* Analog Input subdevice */
936         s = &dev->subdevices[0];
937         dev->read_subdev = s;
938         s->type         = COMEDI_SUBD_AI;
939         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ;
940         s->n_chan       = 16;
941         s->len_chanlist = 16;
942         s->insn_read    = usbduxfast_ai_insn_read;
943         s->do_cmdtest   = usbduxfast_ai_cmdtest;
944         s->do_cmd       = usbduxfast_ai_cmd;
945         s->cancel       = usbduxfast_ai_cancel;
946         s->maxdata      = 0x1000;
947         s->range_table  = &range_usbduxfast_ai_range;
948 
949         up(&devpriv->sem);
950 
951         return 0;
952 }
953 
954 static int usbduxfast_upload_firmware(struct comedi_device *dev,
955                                       const u8 *data, size_t size,
956                                       unsigned long context)
957 {
958         struct usb_device *usb = comedi_to_usb_dev(dev);
959         uint8_t *buf;
960         unsigned char *tmp;
961         int ret;
962 
963         if (!data)
964                 return 0;
965 
966         if (size > FIRMWARE_MAX_LEN) {
967                 dev_err(dev->class_dev, "firmware binary too large for FX2\n");
968                 return -ENOMEM;
969         }
970 
971         /* we generate a local buffer for the firmware */
972         buf = kmemdup(data, size, GFP_KERNEL);
973         if (!buf)
974                 return -ENOMEM;
975 
976         /* we need a malloc'ed buffer for usb_control_msg() */
977         tmp = kmalloc(1, GFP_KERNEL);
978         if (!tmp) {
979                 kfree(buf);
980                 return -ENOMEM;
981         }
982 
983         /* stop the current firmware on the device */
984         *tmp = 1;       /* 7f92 to one */
985         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
986                               USBDUXFASTSUB_FIRMWARE,
987                               VENDOR_DIR_OUT,
988                               USBDUXFASTSUB_CPUCS, 0x0000,
989                               tmp, 1,
990                               EZTIMEOUT);
991         if (ret < 0) {
992                 dev_err(dev->class_dev, "can not stop firmware\n");
993                 goto done;
994         }
995 
996         /* upload the new firmware to the device */
997         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
998                               USBDUXFASTSUB_FIRMWARE,
999                               VENDOR_DIR_OUT,
1000                               0, 0x0000,
1001                               buf, size,
1002                               EZTIMEOUT);
1003         if (ret < 0) {
1004                 dev_err(dev->class_dev, "firmware upload failed\n");
1005                 goto done;
1006         }
1007 
1008         /* start the new firmware on the device */
1009         *tmp = 0;       /* 7f92 to zero */
1010         ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0),
1011                               USBDUXFASTSUB_FIRMWARE,
1012                               VENDOR_DIR_OUT,
1013                               USBDUXFASTSUB_CPUCS, 0x0000,
1014                               tmp, 1,
1015                               EZTIMEOUT);
1016         if (ret < 0)
1017                 dev_err(dev->class_dev, "can not start firmware\n");
1018 
1019 done:
1020         kfree(tmp);
1021         kfree(buf);
1022         return ret;
1023 }
1024 
1025 static int usbduxfast_auto_attach(struct comedi_device *dev,
1026                                   unsigned long context_unused)
1027 {
1028         struct usb_interface *intf = comedi_to_usb_interface(dev);
1029         struct usb_device *usb = comedi_to_usb_dev(dev);
1030         struct usbduxfast_private *devpriv;
1031         int ret;
1032 
1033         if (usb->speed != USB_SPEED_HIGH) {
1034                 dev_err(dev->class_dev,
1035                         "This driver needs USB 2.0 to operate. Aborting...\n");
1036                 return -ENODEV;
1037         }
1038 
1039         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1040         if (!devpriv)
1041                 return -ENOMEM;
1042 
1043         sema_init(&devpriv->sem, 1);
1044         usb_set_intfdata(intf, devpriv);
1045 
1046         devpriv->duxbuf = kmalloc(SIZEOFDUXBUF, GFP_KERNEL);
1047         if (!devpriv->duxbuf)
1048                 return -ENOMEM;
1049 
1050         ret = usb_set_interface(usb,
1051                                 intf->altsetting->desc.bInterfaceNumber, 1);
1052         if (ret < 0) {
1053                 dev_err(dev->class_dev,
1054                         "could not switch to alternate setting 1\n");
1055                 return -ENODEV;
1056         }
1057 
1058         devpriv->urb = usb_alloc_urb(0, GFP_KERNEL);
1059         if (!devpriv->urb) {
1060                 dev_err(dev->class_dev, "Could not alloc. urb\n");
1061                 return -ENOMEM;
1062         }
1063 
1064         devpriv->inbuf = kmalloc(SIZEINBUF, GFP_KERNEL);
1065         if (!devpriv->inbuf)
1066                 return -ENOMEM;
1067 
1068         ret = comedi_load_firmware(dev, &usb->dev, FIRMWARE,
1069                                    usbduxfast_upload_firmware, 0);
1070         if (ret)
1071                 return ret;
1072 
1073         return usbduxfast_attach_common(dev);
1074 }
1075 
1076 static void usbduxfast_detach(struct comedi_device *dev)
1077 {
1078         struct usb_interface *intf = comedi_to_usb_interface(dev);
1079         struct usbduxfast_private *devpriv = dev->private;
1080 
1081         if (!devpriv)
1082                 return;
1083 
1084         down(&devpriv->sem);
1085 
1086         usb_set_intfdata(intf, NULL);
1087 
1088         if (devpriv->urb) {
1089                 /* waits until a running transfer is over */
1090                 usb_kill_urb(devpriv->urb);
1091 
1092                 kfree(devpriv->inbuf);
1093                 devpriv->inbuf = NULL;
1094 
1095                 usb_free_urb(devpriv->urb);
1096                 devpriv->urb = NULL;
1097         }
1098 
1099         kfree(devpriv->duxbuf);
1100         devpriv->duxbuf = NULL;
1101 
1102         devpriv->ai_cmd_running = 0;
1103 
1104         up(&devpriv->sem);
1105 }
1106 
1107 static struct comedi_driver usbduxfast_driver = {
1108         .driver_name    = "usbduxfast",
1109         .module         = THIS_MODULE,
1110         .auto_attach    = usbduxfast_auto_attach,
1111         .detach         = usbduxfast_detach,
1112 };
1113 
1114 static int usbduxfast_usb_probe(struct usb_interface *intf,
1115                                 const struct usb_device_id *id)
1116 {
1117         return comedi_usb_auto_config(intf, &usbduxfast_driver, 0);
1118 }
1119 
1120 static const struct usb_device_id usbduxfast_usb_table[] = {
1121         /* { USB_DEVICE(0x4b4, 0x8613) }, testing */
1122         { USB_DEVICE(0x13d8, 0x0010) }, /* real ID */
1123         { USB_DEVICE(0x13d8, 0x0011) }, /* real ID */
1124         { }
1125 };
1126 MODULE_DEVICE_TABLE(usb, usbduxfast_usb_table);
1127 
1128 static struct usb_driver usbduxfast_usb_driver = {
1129         .name           = "usbduxfast",
1130         .probe          = usbduxfast_usb_probe,
1131         .disconnect     = comedi_usb_auto_unconfig,
1132         .id_table       = usbduxfast_usb_table,
1133 };
1134 module_comedi_usb_driver(usbduxfast_driver, usbduxfast_usb_driver);
1135 
1136 MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com");
1137 MODULE_DESCRIPTION("USB-DUXfast, BerndPorr@f2s.com");
1138 MODULE_LICENSE("GPL");
1139 MODULE_FIRMWARE(FIRMWARE);
1140 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us