Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1 | /* |
H Hartley Sweeten | 31de28a | 2013-05-23 13:09:45 -0700 | [diff] [blame] | 2 | * usbduxsigma.c |
| 3 | * Copyright (C) 2011 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. |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 14 | */ |
H Hartley Sweeten | 31de28a | 2013-05-23 13:09:45 -0700 | [diff] [blame] | 15 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 16 | /* |
H Hartley Sweeten | 31de28a | 2013-05-23 13:09:45 -0700 | [diff] [blame] | 17 | * Driver: usbduxsigma |
| 18 | * Description: University of Stirling USB DAQ & INCITE Technology Limited |
| 19 | * Devices: (ITL) USB-DUX [usbduxsigma] |
| 20 | * Author: Bernd Porr <BerndPorr@f2s.com> |
| 21 | * Updated: 8 Nov 2011 |
| 22 | * Status: testing |
| 23 | */ |
| 24 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 25 | /* |
| 26 | * I must give credit here to Chris Baugher who |
| 27 | * wrote the driver for AT-MIO-16d. I used some parts of this |
| 28 | * driver. I also must give credits to David Brownell |
| 29 | * who supported me with the USB development. |
| 30 | * |
| 31 | * Note: the raw data from the A/D converter is 24 bit big endian |
| 32 | * anything else is little endian to/from the dux board |
| 33 | * |
| 34 | * |
| 35 | * Revision history: |
Alexandru Guduleasa | 3ee0206 | 2012-03-09 22:29:01 +0200 | [diff] [blame] | 36 | * 0.1: initial version |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 37 | * 0.2: all basic functions implemented, digital I/O only for one port |
| 38 | * 0.3: proper vendor ID and driver name |
| 39 | * 0.4: fixed D/A voltage range |
| 40 | * 0.5: various bug fixes, health check at startup |
Bernd Porr | 8b78607 | 2011-11-08 21:21:37 +0000 | [diff] [blame] | 41 | * 0.6: corrected wrong input range |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 42 | */ |
| 43 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 44 | #include <linux/kernel.h> |
| 45 | #include <linux/module.h> |
| 46 | #include <linux/init.h> |
| 47 | #include <linux/slab.h> |
| 48 | #include <linux/input.h> |
| 49 | #include <linux/usb.h> |
| 50 | #include <linux/fcntl.h> |
| 51 | #include <linux/compiler.h> |
H Hartley Sweeten | fb62a3f | 2013-05-20 14:32:29 -0700 | [diff] [blame] | 52 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 53 | #include "comedi_fc.h" |
| 54 | #include "../comedidev.h" |
| 55 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 56 | /* timeout for the USB-transfer in ms*/ |
| 57 | #define BULK_TIMEOUT 1000 |
| 58 | |
| 59 | /* constants for "firmware" upload and download */ |
H Hartley Sweeten | 46c8780 | 2013-05-23 12:57:25 -0700 | [diff] [blame] | 60 | #define FIRMWARE "usbduxsigma_firmware.bin" |
| 61 | #define FIRMWARE_MAX_LEN 0x4000 |
| 62 | #define USBDUXSUB_FIRMWARE 0xa0 |
| 63 | #define VENDOR_DIR_IN 0xc0 |
| 64 | #define VENDOR_DIR_OUT 0x40 |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 65 | |
| 66 | /* internal addresses of the 8051 processor */ |
| 67 | #define USBDUXSUB_CPUCS 0xE600 |
| 68 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 69 | /* 300Hz max frequ under PWM */ |
| 70 | #define MIN_PWM_PERIOD ((long)(1E9/300)) |
| 71 | |
| 72 | /* Default PWM frequency */ |
| 73 | #define PWM_DEFAULT_PERIOD ((long)(1E9/100)) |
| 74 | |
| 75 | /* Number of channels (16 AD and offset)*/ |
| 76 | #define NUMCHANNELS 16 |
| 77 | |
H Hartley Sweeten | 44d3fca | 2013-05-23 13:04:53 -0700 | [diff] [blame] | 78 | #define USBDUXSIGMA_NUM_AO_CHAN 4 |
| 79 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 80 | /* Size of one A/D value */ |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 81 | #define SIZEADIN ((sizeof(uint32_t))) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 82 | |
| 83 | /* |
| 84 | * Size of the async input-buffer IN BYTES, the DIO state is transmitted |
| 85 | * as the first byte. |
| 86 | */ |
| 87 | #define SIZEINBUF (((NUMCHANNELS+1)*SIZEADIN)) |
| 88 | |
| 89 | /* 16 bytes. */ |
| 90 | #define SIZEINSNBUF 16 |
| 91 | |
| 92 | /* Number of DA channels */ |
| 93 | #define NUMOUTCHANNELS 8 |
| 94 | |
| 95 | /* size of one value for the D/A converter: channel and value */ |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 96 | #define SIZEDAOUT ((sizeof(uint8_t)+sizeof(uint16_t))) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 97 | |
| 98 | /* |
| 99 | * Size of the output-buffer in bytes |
| 100 | * Actually only the first 4 triplets are used but for the |
| 101 | * high speed mode we need to pad it to 8 (microframes). |
| 102 | */ |
| 103 | #define SIZEOUTBUF ((8*SIZEDAOUT)) |
| 104 | |
| 105 | /* |
| 106 | * Size of the buffer for the dux commands: just now max size is determined |
| 107 | * by the analogue out + command byte + panic bytes... |
| 108 | */ |
| 109 | #define SIZEOFDUXBUFFER ((8*SIZEDAOUT+2)) |
| 110 | |
| 111 | /* Number of in-URBs which receive the data: min=2 */ |
| 112 | #define NUMOFINBUFFERSFULL 5 |
| 113 | |
| 114 | /* Number of out-URBs which send the data: min=2 */ |
| 115 | #define NUMOFOUTBUFFERSFULL 5 |
| 116 | |
| 117 | /* Number of in-URBs which receive the data: min=5 */ |
| 118 | /* must have more buffers due to buggy USB ctr */ |
| 119 | #define NUMOFINBUFFERSHIGH 10 |
| 120 | |
| 121 | /* Number of out-URBs which send the data: min=5 */ |
| 122 | /* must have more buffers due to buggy USB ctr */ |
| 123 | #define NUMOFOUTBUFFERSHIGH 10 |
| 124 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 125 | /* number of retries to get the right dux command */ |
| 126 | #define RETRIES 10 |
| 127 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 128 | /* bulk transfer commands to usbduxsigma */ |
| 129 | #define USBBUXSIGMA_AD_CMD 0 |
| 130 | #define USBDUXSIGMA_DA_CMD 1 |
| 131 | #define USBDUXSIGMA_DIO_CFG_CMD 2 |
| 132 | #define USBDUXSIGMA_DIO_BITS_CMD 3 |
| 133 | #define USBDUXSIGMA_SINGLE_AD_CMD 4 |
| 134 | #define USBDUXSIGMA_PWM_ON_CMD 7 |
| 135 | #define USBDUXSIGMA_PWM_OFF_CMD 8 |
| 136 | |
H Hartley Sweeten | c2cf0cd | 2013-05-23 13:07:35 -0700 | [diff] [blame] | 137 | static const struct comedi_lrange usbduxsigma_ai_range = { |
| 138 | 1, { |
| 139 | BIP_RANGE(2.65 / 2.0) |
| 140 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 141 | }; |
| 142 | |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 143 | struct usbduxsigma_private { |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 144 | /* actual number of in-buffers */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 145 | int n_ai_urbs; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 146 | /* actual number of out-buffers */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 147 | int n_ao_urbs; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 148 | /* ISO-transfer handling: buffers */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 149 | struct urb **ai_urbs; |
| 150 | struct urb **ao_urbs; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 151 | /* pwm-transfer handling */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 152 | struct urb *pwm_urb; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 153 | /* PWM period */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 154 | unsigned int pwm_period; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 155 | /* PWM internal delay for the GPIF in the FX2 */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 156 | uint8_t pwm_delay; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 157 | /* size of the PWM buffer which holds the bit pattern */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 158 | int pwm_buf_sz; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 159 | /* input buffer for the ISO-transfer */ |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 160 | uint32_t *in_buf; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 161 | /* input buffer for single insn */ |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 162 | uint8_t *insn_buf; |
H Hartley Sweeten | 44d3fca | 2013-05-23 13:04:53 -0700 | [diff] [blame] | 163 | |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 164 | uint8_t ao_chanlist[USBDUXSIGMA_NUM_AO_CHAN]; |
H Hartley Sweeten | 44d3fca | 2013-05-23 13:04:53 -0700 | [diff] [blame] | 165 | unsigned int ao_readback[USBDUXSIGMA_NUM_AO_CHAN]; |
H Hartley Sweeten | cf9b4634 | 2013-05-23 13:02:25 -0700 | [diff] [blame] | 166 | |
| 167 | unsigned high_speed:1; |
| 168 | unsigned ai_cmd_running:1; |
| 169 | unsigned ai_continuous:1; |
| 170 | unsigned ao_cmd_running:1; |
| 171 | unsigned ao_continuous:1; |
| 172 | unsigned pwm_cmd_running:1; |
| 173 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 174 | /* number of samples to acquire */ |
| 175 | int ai_sample_count; |
| 176 | int ao_sample_count; |
| 177 | /* time between samples in units of the timer */ |
| 178 | unsigned int ai_timer; |
| 179 | unsigned int ao_timer; |
Alexandru Guduleasa | 3ee0206 | 2012-03-09 22:29:01 +0200 | [diff] [blame] | 180 | /* counter between acquisitions */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 181 | unsigned int ai_counter; |
| 182 | unsigned int ao_counter; |
| 183 | /* interval in frames/uframes */ |
| 184 | unsigned int ai_interval; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 185 | /* commands */ |
| 186 | uint8_t *dux_commands; |
| 187 | struct semaphore sem; |
| 188 | }; |
| 189 | |
H Hartley Sweeten | e0bc079 | 2013-07-29 17:43:36 -0700 | [diff] [blame] | 190 | static void usbduxsigma_unlink_urbs(struct urb **urbs, int num_urbs) |
| 191 | { |
| 192 | int i; |
| 193 | |
| 194 | for (i = 0; i < num_urbs; i++) |
| 195 | usb_kill_urb(urbs[i]); |
| 196 | } |
| 197 | |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 198 | static void usbduxsigma_ai_stop(struct comedi_device *dev, int do_unlink) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 199 | { |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 200 | struct usbduxsigma_private *devpriv = dev->private; |
| 201 | |
H Hartley Sweeten | e0bc079 | 2013-07-29 17:43:36 -0700 | [diff] [blame] | 202 | if (do_unlink && devpriv->ai_urbs) |
| 203 | usbduxsigma_unlink_urbs(devpriv->ai_urbs, devpriv->n_ai_urbs); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 204 | |
H Hartley Sweeten | 19d61fd | 2013-05-23 12:40:10 -0700 | [diff] [blame] | 205 | devpriv->ai_cmd_running = 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 206 | } |
| 207 | |
H Hartley Sweeten | cca5bf1 | 2013-05-23 13:06:55 -0700 | [diff] [blame] | 208 | static int usbduxsigma_ai_cancel(struct comedi_device *dev, |
| 209 | struct comedi_subdevice *s) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 210 | { |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 211 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 212 | |
H Hartley Sweeten | eac456c | 2013-05-23 12:42:01 -0700 | [diff] [blame] | 213 | down(&devpriv->sem); |
| 214 | /* unlink only if it is really running */ |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 215 | usbduxsigma_ai_stop(dev, devpriv->ai_cmd_running); |
H Hartley Sweeten | eac456c | 2013-05-23 12:42:01 -0700 | [diff] [blame] | 216 | up(&devpriv->sem); |
H Hartley Sweeten | 05d4c6f | 2013-05-23 12:40:45 -0700 | [diff] [blame] | 217 | |
| 218 | return 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 219 | } |
| 220 | |
H Hartley Sweeten | 702cd2d | 2013-05-23 13:06:37 -0700 | [diff] [blame] | 221 | static void usbduxsigma_ai_urb_complete(struct urb *urb) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 222 | { |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 223 | struct comedi_device *dev = urb->context; |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 224 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 225 | struct comedi_subdevice *s = dev->read_subdev; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 226 | unsigned int dio_state; |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 227 | uint32_t val; |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 228 | int ret; |
| 229 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 230 | |
| 231 | /* first we test if something unusual has just happened */ |
| 232 | switch (urb->status) { |
| 233 | case 0: |
| 234 | /* copy the result in the transfer buffer */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 235 | memcpy(devpriv->in_buf, urb->transfer_buffer, SIZEINBUF); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 236 | break; |
| 237 | case -EILSEQ: |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 238 | /* |
| 239 | * error in the ISOchronous data |
| 240 | * we don't copy the data into the transfer buffer |
| 241 | * and recycle the last data byte |
| 242 | */ |
H Hartley Sweeten | 7333d50 | 2013-05-23 13:08:51 -0700 | [diff] [blame] | 243 | dev_dbg(dev->class_dev, "CRC error in ISO IN stream\n"); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 244 | |
| 245 | break; |
| 246 | |
| 247 | case -ECONNRESET: |
| 248 | case -ENOENT: |
| 249 | case -ESHUTDOWN: |
| 250 | case -ECONNABORTED: |
| 251 | /* happens after an unlink command */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 252 | if (devpriv->ai_cmd_running) { |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 253 | usbduxsigma_ai_stop(dev, 0); /* w/o unlink */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 254 | /* we are still running a command, tell comedi */ |
| 255 | s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR); |
| 256 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 257 | } |
| 258 | return; |
| 259 | |
| 260 | default: |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 261 | /* |
| 262 | * a real error on the bus |
| 263 | * pass error to comedi if we are really running a command |
| 264 | */ |
| 265 | if (devpriv->ai_cmd_running) { |
| 266 | dev_err(dev->class_dev, |
| 267 | "%s: non-zero urb status (%d)\n", |
| 268 | __func__, urb->status); |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 269 | usbduxsigma_ai_stop(dev, 0); /* w/o unlink */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 270 | s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR); |
| 271 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 272 | } |
| 273 | return; |
| 274 | } |
| 275 | |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 276 | if (unlikely(!devpriv->ai_cmd_running)) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 277 | return; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 278 | |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 279 | urb->dev = comedi_to_usb_dev(dev); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 280 | |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 281 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
| 282 | if (unlikely(ret < 0)) { |
| 283 | dev_err(dev->class_dev, "%s: urb resubmit failed (%d)\n", |
| 284 | __func__, ret); |
| 285 | if (ret == -EL2NSYNC) |
| 286 | dev_err(dev->class_dev, |
| 287 | "buggy USB host controller or bug in IRQ handler\n"); |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 288 | usbduxsigma_ai_stop(dev, 0); /* w/o unlink */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 289 | s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR); |
| 290 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 291 | return; |
| 292 | } |
| 293 | |
| 294 | /* get the state of the dio pins to allow external trigger */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 295 | dio_state = be32_to_cpu(devpriv->in_buf[0]); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 296 | |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 297 | devpriv->ai_counter--; |
| 298 | if (likely(devpriv->ai_counter > 0)) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 299 | return; |
| 300 | |
| 301 | /* timer zero, transfer measurements to comedi */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 302 | devpriv->ai_counter = devpriv->ai_timer; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 303 | |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 304 | if (!devpriv->ai_continuous) { |
Alexandru Guduleasa | 3ee0206 | 2012-03-09 22:29:01 +0200 | [diff] [blame] | 305 | /* not continuous, fixed number of samples */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 306 | devpriv->ai_sample_count--; |
| 307 | if (devpriv->ai_sample_count < 0) { |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 308 | usbduxsigma_ai_stop(dev, 0); /* w/o unlink */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 309 | /* acquistion is over, tell comedi */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 310 | s->async->events |= COMEDI_CB_EOA; |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 311 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 312 | return; |
| 313 | } |
| 314 | } |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 315 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 316 | /* get the data from the USB bus and hand it over to comedi */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 317 | for (i = 0; i < s->async->cmd.chanlist_len; i++) { |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 318 | /* transfer data, note first byte is the DIO state */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 319 | val = be32_to_cpu(devpriv->in_buf[i+1]); |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 320 | val &= 0x00ffffff; /* strip status byte */ |
| 321 | val ^= 0x00800000; /* convert to unsigned */ |
| 322 | |
| 323 | ret = cfc_write_array_to_buffer(s, &val, sizeof(uint32_t)); |
| 324 | if (unlikely(ret == 0)) { |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 325 | /* buffer overflow */ |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 326 | usbduxsigma_ai_stop(dev, 0); /* w/o unlink */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 327 | return; |
| 328 | } |
| 329 | } |
| 330 | /* tell comedi that data is there */ |
H Hartley Sweeten | 147b25a | 2013-05-23 12:45:16 -0700 | [diff] [blame] | 331 | s->async->events |= (COMEDI_CB_BLOCK | COMEDI_CB_EOS); |
| 332 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 333 | } |
| 334 | |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 335 | static void usbduxsigma_ao_stop(struct comedi_device *dev, int do_unlink) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 336 | { |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 337 | struct usbduxsigma_private *devpriv = dev->private; |
| 338 | |
H Hartley Sweeten | e0bc079 | 2013-07-29 17:43:36 -0700 | [diff] [blame] | 339 | if (do_unlink && devpriv->ao_urbs) |
| 340 | usbduxsigma_unlink_urbs(devpriv->ao_urbs, devpriv->n_ao_urbs); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 341 | |
H Hartley Sweeten | 19d61fd | 2013-05-23 12:40:10 -0700 | [diff] [blame] | 342 | devpriv->ao_cmd_running = 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 343 | } |
| 344 | |
H Hartley Sweeten | cca5bf1 | 2013-05-23 13:06:55 -0700 | [diff] [blame] | 345 | static int usbduxsigma_ao_cancel(struct comedi_device *dev, |
| 346 | struct comedi_subdevice *s) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 347 | { |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 348 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 349 | |
H Hartley Sweeten | eac456c | 2013-05-23 12:42:01 -0700 | [diff] [blame] | 350 | down(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 351 | /* unlink only if it is really running */ |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 352 | usbduxsigma_ao_stop(dev, devpriv->ao_cmd_running); |
H Hartley Sweeten | eac456c | 2013-05-23 12:42:01 -0700 | [diff] [blame] | 353 | up(&devpriv->sem); |
H Hartley Sweeten | 05d4c6f | 2013-05-23 12:40:45 -0700 | [diff] [blame] | 354 | |
| 355 | return 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 356 | } |
| 357 | |
H Hartley Sweeten | 702cd2d | 2013-05-23 13:06:37 -0700 | [diff] [blame] | 358 | static void usbduxsigma_ao_urb_complete(struct urb *urb) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 359 | { |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 360 | struct comedi_device *dev = urb->context; |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 361 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 362 | struct comedi_subdevice *s = dev->write_subdev; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 363 | uint8_t *datap; |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 364 | int len; |
| 365 | int ret; |
| 366 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 367 | |
| 368 | switch (urb->status) { |
| 369 | case 0: |
| 370 | /* success */ |
| 371 | break; |
| 372 | |
| 373 | case -ECONNRESET: |
| 374 | case -ENOENT: |
| 375 | case -ESHUTDOWN: |
| 376 | case -ECONNABORTED: |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 377 | /* happens after an unlink command */ |
| 378 | if (devpriv->ao_cmd_running) { |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 379 | usbduxsigma_ao_stop(dev, 0); /* w/o unlink */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 380 | s->async->events |= COMEDI_CB_EOA; |
H Hartley Sweeten | f62024e | 2013-05-23 12:51:37 -0700 | [diff] [blame] | 381 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 382 | } |
| 383 | return; |
| 384 | |
| 385 | default: |
| 386 | /* a real error */ |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 387 | if (devpriv->ao_cmd_running) { |
| 388 | dev_err(dev->class_dev, |
| 389 | "%s: non-zero urb status (%d)\n", |
| 390 | __func__, urb->status); |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 391 | usbduxsigma_ao_stop(dev, 0); /* w/o unlink */ |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 392 | s->async->events |= (COMEDI_CB_ERROR | COMEDI_CB_EOA); |
H Hartley Sweeten | f62024e | 2013-05-23 12:51:37 -0700 | [diff] [blame] | 393 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 394 | } |
| 395 | return; |
| 396 | } |
| 397 | |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 398 | if (!devpriv->ao_cmd_running) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 399 | return; |
| 400 | |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 401 | devpriv->ao_counter--; |
| 402 | if ((int)devpriv->ao_counter <= 0) { |
| 403 | /* timer zero, transfer from comedi */ |
| 404 | devpriv->ao_counter = devpriv->ao_timer; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 405 | |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 406 | if (!devpriv->ao_continuous) { |
| 407 | /* not continuous, fixed number of samples */ |
| 408 | devpriv->ao_sample_count--; |
| 409 | if (devpriv->ao_sample_count < 0) { |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 410 | usbduxsigma_ao_stop(dev, 0); /* w/o unlink */ |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 411 | /* acquistion is over, tell comedi */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 412 | s->async->events |= COMEDI_CB_EOA; |
H Hartley Sweeten | f62024e | 2013-05-23 12:51:37 -0700 | [diff] [blame] | 413 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 414 | return; |
| 415 | } |
| 416 | } |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 417 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 418 | /* transmit data to the USB bus */ |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 419 | datap = urb->transfer_buffer; |
| 420 | len = s->async->cmd.chanlist_len; |
| 421 | *datap++ = len; |
| 422 | for (i = 0; i < len; i++) { |
H Hartley Sweeten | 315a276 | 2013-07-29 17:46:46 -0700 | [diff] [blame] | 423 | unsigned int chan = devpriv->ao_chanlist[i]; |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 424 | unsigned short val; |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 425 | |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 426 | ret = comedi_buf_get(s->async, &val); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 427 | if (ret < 0) { |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 428 | dev_err(dev->class_dev, "buffer underflow\n"); |
| 429 | s->async->events |= (COMEDI_CB_EOA | |
| 430 | COMEDI_CB_OVERFLOW); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 431 | } |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 432 | *datap++ = val; |
H Hartley Sweeten | 44d3fca | 2013-05-23 13:04:53 -0700 | [diff] [blame] | 433 | *datap++ = chan; |
| 434 | devpriv->ao_readback[chan] = val; |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 435 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 436 | s->async->events |= COMEDI_CB_BLOCK; |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 437 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 438 | } |
| 439 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 440 | |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 441 | urb->transfer_buffer_length = SIZEOUTBUF; |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 442 | urb->dev = comedi_to_usb_dev(dev); |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 443 | urb->status = 0; |
| 444 | if (devpriv->high_speed) |
| 445 | urb->interval = 8; /* uframes */ |
| 446 | else |
| 447 | urb->interval = 1; /* frames */ |
| 448 | urb->number_of_packets = 1; |
| 449 | urb->iso_frame_desc[0].offset = 0; |
| 450 | urb->iso_frame_desc[0].length = SIZEOUTBUF; |
| 451 | urb->iso_frame_desc[0].status = 0; |
| 452 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
| 453 | if (ret < 0) { |
| 454 | dev_err(dev->class_dev, |
| 455 | "%s: urb resubmit failed (%d)\n", |
| 456 | __func__, ret); |
| 457 | if (ret == EL2NSYNC) |
| 458 | dev_err(dev->class_dev, |
| 459 | "buggy USB host controller or bug in IRQ handler\n"); |
H Hartley Sweeten | 3b081a4 | 2013-05-23 13:07:14 -0700 | [diff] [blame] | 460 | usbduxsigma_ao_stop(dev, 0); /* w/o unlink */ |
H Hartley Sweeten | 641b78f | 2013-05-23 12:45:51 -0700 | [diff] [blame] | 461 | s->async->events |= (COMEDI_CB_EOA | COMEDI_CB_ERROR); |
| 462 | comedi_event(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 463 | } |
| 464 | } |
| 465 | |
H Hartley Sweeten | de0a1e97 | 2013-05-23 12:46:40 -0700 | [diff] [blame] | 466 | static int usbduxsigma_submit_urbs(struct comedi_device *dev, |
| 467 | struct urb **urbs, int num_urbs, |
| 468 | int input_urb) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 469 | { |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 470 | struct usb_device *usb = comedi_to_usb_dev(dev); |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 471 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | de0a1e97 | 2013-05-23 12:46:40 -0700 | [diff] [blame] | 472 | struct urb *urb; |
| 473 | int ret; |
| 474 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 475 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 476 | /* Submit all URBs and start the transfer on the bus */ |
H Hartley Sweeten | de0a1e97 | 2013-05-23 12:46:40 -0700 | [diff] [blame] | 477 | for (i = 0; i < num_urbs; i++) { |
| 478 | urb = urbs[i]; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 479 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 480 | /* in case of a resubmission after an unlink... */ |
H Hartley Sweeten | de0a1e97 | 2013-05-23 12:46:40 -0700 | [diff] [blame] | 481 | if (input_urb) |
| 482 | urb->interval = devpriv->ai_interval; |
| 483 | urb->context = dev; |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 484 | urb->dev = usb; |
H Hartley Sweeten | de0a1e97 | 2013-05-23 12:46:40 -0700 | [diff] [blame] | 485 | urb->status = 0; |
| 486 | urb->transfer_flags = URB_ISO_ASAP; |
| 487 | |
| 488 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
| 489 | if (ret) |
| 490 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 491 | } |
| 492 | return 0; |
| 493 | } |
| 494 | |
H Hartley Sweeten | fffe823 | 2013-05-23 13:09:08 -0700 | [diff] [blame] | 495 | static int usbduxsigma_chans_to_interval(int num_chan) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 496 | { |
H Hartley Sweeten | fffe823 | 2013-05-23 13:09:08 -0700 | [diff] [blame] | 497 | if (num_chan <= 2) |
| 498 | return 2; /* 4kHz */ |
| 499 | if (num_chan <= 8) |
| 500 | return 4; /* 2kHz */ |
| 501 | return 8; /* 1kHz */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 502 | } |
| 503 | |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 504 | static int usbduxsigma_ai_cmdtest(struct comedi_device *dev, |
| 505 | struct comedi_subdevice *s, |
| 506 | struct comedi_cmd *cmd) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 507 | { |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 508 | struct usbduxsigma_private *devpriv = dev->private; |
| 509 | int high_speed = devpriv->high_speed; |
H Hartley Sweeten | fffe823 | 2013-05-23 13:09:08 -0700 | [diff] [blame] | 510 | int interval = usbduxsigma_chans_to_interval(cmd->chanlist_len); |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 511 | int err = 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 512 | |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 513 | /* Step 1 : check if triggers are trivially valid */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 514 | |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 515 | err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT); |
| 516 | err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_TIMER); |
| 517 | err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW); |
| 518 | err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT); |
| 519 | err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 520 | |
| 521 | if (err) |
| 522 | return 1; |
| 523 | |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 524 | /* Step 2a : make sure trigger sources are unique */ |
| 525 | |
| 526 | err |= cfc_check_trigger_is_unique(cmd->start_src); |
| 527 | err |= cfc_check_trigger_is_unique(cmd->stop_src); |
| 528 | |
| 529 | /* Step 2b : and mutually compatible */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 530 | |
| 531 | if (err) |
| 532 | return 2; |
| 533 | |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 534 | /* Step 3: check if arguments are trivially valid */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 535 | |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 536 | err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0); |
| 537 | |
| 538 | if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */ |
| 539 | err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 540 | |
| 541 | if (cmd->scan_begin_src == TRIG_TIMER) { |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 542 | unsigned int tmp; |
| 543 | |
| 544 | if (high_speed) { |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 545 | /* |
| 546 | * In high speed mode microframes are possible. |
| 547 | * However, during one microframe we can roughly |
| 548 | * sample two channels. Thus, the more channels |
| 549 | * are in the channel list the more time we need. |
| 550 | */ |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 551 | err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg, |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 552 | (1000000 / 8 * interval)); |
| 553 | |
| 554 | tmp = (cmd->scan_begin_arg / 125000) * 125000; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 555 | } else { |
| 556 | /* full speed */ |
| 557 | /* 1kHz scans every USB frame */ |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 558 | err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg, |
| 559 | 1000000); |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 560 | |
| 561 | tmp = (cmd->scan_begin_arg / 1000000) * 1000000; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 562 | } |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 563 | err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, tmp); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 564 | } |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 565 | |
| 566 | err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 567 | |
| 568 | if (cmd->stop_src == TRIG_COUNT) { |
| 569 | /* any count is allowed */ |
| 570 | } else { |
| 571 | /* TRIG_NONE */ |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 572 | err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 573 | } |
| 574 | |
| 575 | if (err) |
| 576 | return 3; |
| 577 | |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 578 | /* Step 4: fix up any arguments */ |
| 579 | |
| 580 | if (high_speed) { |
| 581 | /* |
| 582 | * every 2 channels get a time window of 125us. Thus, if we |
| 583 | * sample all 16 channels we need 1ms. If we sample only one |
| 584 | * channel we need only 125us |
| 585 | */ |
| 586 | devpriv->ai_interval = interval; |
| 587 | devpriv->ai_timer = cmd->scan_begin_arg / (125000 * interval); |
| 588 | } else { |
| 589 | /* interval always 1ms */ |
| 590 | devpriv->ai_interval = 1; |
| 591 | devpriv->ai_timer = cmd->scan_begin_arg / 1000000; |
| 592 | } |
| 593 | if (devpriv->ai_timer < 1) |
| 594 | err |= -EINVAL; |
| 595 | |
| 596 | if (cmd->stop_src == TRIG_COUNT) { |
| 597 | /* data arrives as one packet */ |
| 598 | devpriv->ai_sample_count = cmd->stop_arg; |
| 599 | devpriv->ai_continuous = 0; |
| 600 | } else { |
| 601 | /* continuous acquisition */ |
| 602 | devpriv->ai_continuous = 1; |
| 603 | devpriv->ai_sample_count = 0; |
| 604 | } |
| 605 | |
| 606 | if (err) |
| 607 | return 4; |
| 608 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 609 | return 0; |
| 610 | } |
| 611 | |
| 612 | /* |
| 613 | * creates the ADC command for the MAX1271 |
| 614 | * range is the range value from comedi |
| 615 | */ |
| 616 | static void create_adc_command(unsigned int chan, |
| 617 | uint8_t *muxsg0, |
| 618 | uint8_t *muxsg1) |
| 619 | { |
| 620 | if (chan < 8) |
| 621 | (*muxsg0) = (*muxsg0) | (1 << chan); |
| 622 | else if (chan < 16) |
| 623 | (*muxsg1) = (*muxsg1) | (1 << (chan-8)); |
| 624 | } |
| 625 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 626 | static int usbbuxsigma_send_cmd(struct comedi_device *dev, int cmd_type) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 627 | { |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 628 | struct usb_device *usb = comedi_to_usb_dev(dev); |
| 629 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | 502f9a3 | 2013-05-23 12:50:31 -0700 | [diff] [blame] | 630 | int nsent; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 631 | |
H Hartley Sweeten | 502f9a3 | 2013-05-23 12:50:31 -0700 | [diff] [blame] | 632 | devpriv->dux_commands[0] = cmd_type; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 633 | |
H Hartley Sweeten | b509a76 | 2013-07-29 17:43:55 -0700 | [diff] [blame] | 634 | return usb_bulk_msg(usb, usb_sndbulkpipe(usb, 1), |
H Hartley Sweeten | 502f9a3 | 2013-05-23 12:50:31 -0700 | [diff] [blame] | 635 | devpriv->dux_commands, SIZEOFDUXBUFFER, |
| 636 | &nsent, BULK_TIMEOUT); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 637 | } |
| 638 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 639 | static int usbduxsigma_receive_cmd(struct comedi_device *dev, int command) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 640 | { |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 641 | struct usb_device *usb = comedi_to_usb_dev(dev); |
| 642 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 643 | int nrec; |
H Hartley Sweeten | 125a77f | 2013-05-23 12:50:51 -0700 | [diff] [blame] | 644 | int ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 645 | int i; |
| 646 | |
| 647 | for (i = 0; i < RETRIES; i++) { |
H Hartley Sweeten | b509a76 | 2013-07-29 17:43:55 -0700 | [diff] [blame] | 648 | ret = usb_bulk_msg(usb, usb_rcvbulkpipe(usb, 8), |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 649 | devpriv->insn_buf, SIZEINSNBUF, |
H Hartley Sweeten | 125a77f | 2013-05-23 12:50:51 -0700 | [diff] [blame] | 650 | &nrec, BULK_TIMEOUT); |
| 651 | if (ret < 0) |
| 652 | return ret; |
| 653 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 654 | if (devpriv->insn_buf[0] == command) |
H Hartley Sweeten | 125a77f | 2013-05-23 12:50:51 -0700 | [diff] [blame] | 655 | return 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 656 | } |
H Hartley Sweeten | 125a77f | 2013-05-23 12:50:51 -0700 | [diff] [blame] | 657 | /* |
| 658 | * This is only reached if the data has been requested a |
| 659 | * couple of times and the command was not received. |
| 660 | */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 661 | return -EFAULT; |
| 662 | } |
| 663 | |
H Hartley Sweeten | 8eea6db | 2013-05-23 12:53:23 -0700 | [diff] [blame] | 664 | static int usbduxsigma_ai_inttrig(struct comedi_device *dev, |
| 665 | struct comedi_subdevice *s, |
| 666 | unsigned int trignum) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 667 | { |
H Hartley Sweeten | 7333d50 | 2013-05-23 13:08:51 -0700 | [diff] [blame] | 668 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 669 | int ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 670 | |
H Hartley Sweeten | 8eea6db | 2013-05-23 12:53:23 -0700 | [diff] [blame] | 671 | if (trignum != 0) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 672 | return -EINVAL; |
H Hartley Sweeten | 8eea6db | 2013-05-23 12:53:23 -0700 | [diff] [blame] | 673 | |
| 674 | down(&devpriv->sem); |
| 675 | if (!devpriv->ai_cmd_running) { |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 676 | devpriv->ai_cmd_running = 1; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 677 | ret = usbduxsigma_submit_urbs(dev, devpriv->ai_urbs, |
| 678 | devpriv->n_ai_urbs, 1); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 679 | if (ret < 0) { |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 680 | devpriv->ai_cmd_running = 0; |
H Hartley Sweeten | 8eea6db | 2013-05-23 12:53:23 -0700 | [diff] [blame] | 681 | up(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 682 | return ret; |
| 683 | } |
| 684 | s->async->inttrig = NULL; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 685 | } |
H Hartley Sweeten | 8eea6db | 2013-05-23 12:53:23 -0700 | [diff] [blame] | 686 | up(&devpriv->sem); |
| 687 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 688 | return 1; |
| 689 | } |
| 690 | |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 691 | static int usbduxsigma_ai_cmd(struct comedi_device *dev, |
| 692 | struct comedi_subdevice *s) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 693 | { |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 694 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 695 | struct comedi_cmd *cmd = &s->async->cmd; |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 696 | unsigned int len = cmd->chanlist_len; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 697 | uint8_t muxsg0 = 0; |
| 698 | uint8_t muxsg1 = 0; |
| 699 | uint8_t sysred = 0; |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 700 | int ret; |
| 701 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 702 | |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 703 | down(&devpriv->sem); |
| 704 | |
Alexandru Guduleasa | 3ee0206 | 2012-03-09 22:29:01 +0200 | [diff] [blame] | 705 | /* set current channel of the running acquisition to zero */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 706 | s->async->cur_chan = 0; |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 707 | for (i = 0; i < len; i++) { |
| 708 | unsigned int chan = CR_CHAN(cmd->chanlist[i]); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 709 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 710 | create_adc_command(chan, &muxsg0, &muxsg1); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 711 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 712 | |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 713 | devpriv->dux_commands[1] = len; /* num channels per time step */ |
| 714 | devpriv->dux_commands[2] = 0x12; /* CONFIG0 */ |
| 715 | devpriv->dux_commands[3] = 0x03; /* CONFIG1: 23kHz sample, delay 0us */ |
| 716 | devpriv->dux_commands[4] = 0x00; /* CONFIG3: diff. channels off */ |
| 717 | devpriv->dux_commands[5] = muxsg0; |
| 718 | devpriv->dux_commands[6] = muxsg1; |
| 719 | devpriv->dux_commands[7] = sysred; |
| 720 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 721 | ret = usbbuxsigma_send_cmd(dev, USBBUXSIGMA_AD_CMD); |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 722 | if (ret < 0) { |
| 723 | up(&devpriv->sem); |
| 724 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 725 | } |
| 726 | |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 727 | devpriv->ai_counter = devpriv->ai_timer; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 728 | |
| 729 | if (cmd->start_src == TRIG_NOW) { |
| 730 | /* enable this acquisition operation */ |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 731 | devpriv->ai_cmd_running = 1; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 732 | ret = usbduxsigma_submit_urbs(dev, devpriv->ai_urbs, |
| 733 | devpriv->n_ai_urbs, 1); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 734 | if (ret < 0) { |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 735 | devpriv->ai_cmd_running = 0; |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 736 | up(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 737 | return ret; |
| 738 | } |
| 739 | s->async->inttrig = NULL; |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 740 | } else { /* TRIG_INT */ |
| 741 | /* wait for an internal signal and submit the urbs later */ |
H Hartley Sweeten | 8eea6db | 2013-05-23 12:53:23 -0700 | [diff] [blame] | 742 | s->async->inttrig = usbduxsigma_ai_inttrig; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 743 | } |
H Hartley Sweeten | b986be8 | 2013-05-23 13:05:38 -0700 | [diff] [blame] | 744 | |
| 745 | up(&devpriv->sem); |
| 746 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 747 | return 0; |
| 748 | } |
| 749 | |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 750 | static int usbduxsigma_ai_insn_read(struct comedi_device *dev, |
| 751 | struct comedi_subdevice *s, |
| 752 | struct comedi_insn *insn, |
| 753 | unsigned int *data) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 754 | { |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 755 | struct usbduxsigma_private *devpriv = dev->private; |
| 756 | unsigned int chan = CR_CHAN(insn->chanspec); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 757 | uint8_t muxsg0 = 0; |
| 758 | uint8_t muxsg1 = 0; |
| 759 | uint8_t sysred = 0; |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 760 | int ret; |
| 761 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 762 | |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 763 | down(&devpriv->sem); |
| 764 | if (devpriv->ai_cmd_running) { |
| 765 | up(&devpriv->sem); |
| 766 | return -EBUSY; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 767 | } |
| 768 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 769 | create_adc_command(chan, &muxsg0, &muxsg1); |
| 770 | |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 771 | /* Mode 0 is used to get a single conversion on demand */ |
| 772 | devpriv->dux_commands[1] = 0x16; /* CONFIG0: chopper on */ |
| 773 | devpriv->dux_commands[2] = 0x80; /* CONFIG1: 2kHz sampling rate */ |
| 774 | devpriv->dux_commands[3] = 0x00; /* CONFIG3: diff. channels off */ |
| 775 | devpriv->dux_commands[4] = muxsg0; |
| 776 | devpriv->dux_commands[5] = muxsg1; |
| 777 | devpriv->dux_commands[6] = sysred; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 778 | |
| 779 | /* adc commands */ |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 780 | ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD); |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 781 | if (ret < 0) { |
| 782 | up(&devpriv->sem); |
| 783 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 784 | } |
| 785 | |
| 786 | for (i = 0; i < insn->n; i++) { |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 787 | uint32_t val; |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 788 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 789 | ret = usbduxsigma_receive_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD); |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 790 | if (ret < 0) { |
| 791 | up(&devpriv->sem); |
| 792 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 793 | } |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 794 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 795 | /* 32 bits big endian from the A/D converter */ |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 796 | val = be32_to_cpu(*((uint32_t *)((devpriv->insn_buf) + 1))); |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 797 | val &= 0x00ffffff; /* strip status byte */ |
| 798 | val ^= 0x00800000; /* convert to unsigned */ |
| 799 | |
| 800 | data[i] = val; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 801 | } |
H Hartley Sweeten | c5db3b7 | 2013-05-23 13:05:19 -0700 | [diff] [blame] | 802 | up(&devpriv->sem); |
| 803 | |
| 804 | return insn->n; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 805 | } |
| 806 | |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 807 | static int usbduxsigma_ao_insn_read(struct comedi_device *dev, |
| 808 | struct comedi_subdevice *s, |
| 809 | struct comedi_insn *insn, |
| 810 | unsigned int *data) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 811 | { |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 812 | struct usbduxsigma_private *devpriv = dev->private; |
| 813 | unsigned int chan = CR_CHAN(insn->chanspec); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 814 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 815 | |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 816 | down(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 817 | for (i = 0; i < insn->n; i++) |
H Hartley Sweeten | 44d3fca | 2013-05-23 13:04:53 -0700 | [diff] [blame] | 818 | data[i] = devpriv->ao_readback[chan]; |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 819 | up(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 820 | |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 821 | return insn->n; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 822 | } |
| 823 | |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 824 | static int usbduxsigma_ao_insn_write(struct comedi_device *dev, |
| 825 | struct comedi_subdevice *s, |
| 826 | struct comedi_insn *insn, |
| 827 | unsigned int *data) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 828 | { |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 829 | struct usbduxsigma_private *devpriv = dev->private; |
| 830 | unsigned int chan = CR_CHAN(insn->chanspec); |
| 831 | int ret; |
| 832 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 833 | |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 834 | down(&devpriv->sem); |
| 835 | if (devpriv->ao_cmd_running) { |
| 836 | up(&devpriv->sem); |
| 837 | return -EBUSY; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 838 | } |
| 839 | |
| 840 | for (i = 0; i < insn->n; i++) { |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 841 | devpriv->dux_commands[1] = 1; /* num channels */ |
| 842 | devpriv->dux_commands[2] = data[i]; /* value */ |
| 843 | devpriv->dux_commands[3] = chan; /* channel number */ |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 844 | ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_DA_CMD); |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 845 | if (ret < 0) { |
| 846 | up(&devpriv->sem); |
| 847 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 848 | } |
H Hartley Sweeten | 44d3fca | 2013-05-23 13:04:53 -0700 | [diff] [blame] | 849 | devpriv->ao_readback[chan] = data[i]; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 850 | } |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 851 | up(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 852 | |
H Hartley Sweeten | 2dd87ac | 2013-05-23 13:04:31 -0700 | [diff] [blame] | 853 | return insn->n; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 854 | } |
| 855 | |
H Hartley Sweeten | 2d4462d | 2013-05-23 12:52:59 -0700 | [diff] [blame] | 856 | static int usbduxsigma_ao_inttrig(struct comedi_device *dev, |
| 857 | struct comedi_subdevice *s, |
| 858 | unsigned int trignum) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 859 | { |
H Hartley Sweeten | 2d4462d | 2013-05-23 12:52:59 -0700 | [diff] [blame] | 860 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 861 | int ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 862 | |
H Hartley Sweeten | 2d4462d | 2013-05-23 12:52:59 -0700 | [diff] [blame] | 863 | if (trignum != 0) |
| 864 | return -EINVAL; |
| 865 | |
| 866 | down(&devpriv->sem); |
| 867 | if (!devpriv->ao_cmd_running) { |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 868 | devpriv->ao_cmd_running = 1; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 869 | ret = usbduxsigma_submit_urbs(dev, devpriv->ao_urbs, |
| 870 | devpriv->n_ao_urbs, 0); |
H Hartley Sweeten | 2d4462d | 2013-05-23 12:52:59 -0700 | [diff] [blame] | 871 | if (ret < 0) { |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 872 | devpriv->ao_cmd_running = 0; |
H Hartley Sweeten | 2d4462d | 2013-05-23 12:52:59 -0700 | [diff] [blame] | 873 | up(&devpriv->sem); |
| 874 | return ret; |
| 875 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 876 | s->async->inttrig = NULL; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 877 | } |
H Hartley Sweeten | 2d4462d | 2013-05-23 12:52:59 -0700 | [diff] [blame] | 878 | up(&devpriv->sem); |
| 879 | |
| 880 | return 1; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 881 | } |
| 882 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 883 | static int usbduxsigma_ao_cmdtest(struct comedi_device *dev, |
| 884 | struct comedi_subdevice *s, |
| 885 | struct comedi_cmd *cmd) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 886 | { |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 887 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 888 | int err = 0; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 889 | int high_speed; |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 890 | unsigned int flags; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 891 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 892 | /* high speed conversions are not used yet */ |
H Hartley Sweeten | 57ded31 | 2013-05-23 13:09:25 -0700 | [diff] [blame] | 893 | high_speed = 0; /* (devpriv->high_speed) */ |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 894 | |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 895 | /* Step 1 : check if triggers are trivially valid */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 896 | |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 897 | err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_INT); |
| 898 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 899 | if (high_speed) { |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 900 | /* |
| 901 | * start immediately a new scan |
| 902 | * the sampling rate is set by the coversion rate |
| 903 | */ |
| 904 | flags = TRIG_FOLLOW; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 905 | } else { |
| 906 | /* start a new scan (output at once) with a timer */ |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 907 | flags = TRIG_TIMER; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 908 | } |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 909 | err |= cfc_check_trigger_src(&cmd->scan_begin_src, flags); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 910 | |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 911 | err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_NOW); |
| 912 | err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT); |
| 913 | err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 914 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 915 | if (err) { |
| 916 | up(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 917 | return 1; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 918 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 919 | |
H Hartley Sweeten | 27020ff | 2012-09-26 14:11:10 -0700 | [diff] [blame] | 920 | /* Step 2a : make sure trigger sources are unique */ |
| 921 | |
| 922 | err |= cfc_check_trigger_is_unique(cmd->start_src); |
| 923 | err |= cfc_check_trigger_is_unique(cmd->stop_src); |
| 924 | |
| 925 | /* Step 2b : and mutually compatible */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 926 | |
| 927 | if (err) |
| 928 | return 2; |
| 929 | |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 930 | /* Step 3: check if arguments are trivially valid */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 931 | |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 932 | err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 933 | |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 934 | if (cmd->scan_begin_src == TRIG_FOLLOW) /* internal trigger */ |
| 935 | err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 936 | |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 937 | if (cmd->scan_begin_src == TRIG_TIMER) |
| 938 | err |= cfc_check_trigger_arg_min(&cmd->scan_begin_arg, |
| 939 | 1000000); |
| 940 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 941 | /* not used now, is for later use */ |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 942 | if (cmd->convert_src == TRIG_TIMER) |
| 943 | err |= cfc_check_trigger_arg_min(&cmd->convert_arg, 125000); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 944 | |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 945 | err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, cmd->chanlist_len); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 946 | |
| 947 | if (cmd->stop_src == TRIG_COUNT) { |
| 948 | /* any count is allowed */ |
| 949 | } else { |
| 950 | /* TRIG_NONE */ |
H Hartley Sweeten | 7ec2659 | 2012-11-13 18:00:21 -0700 | [diff] [blame] | 951 | err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 952 | } |
| 953 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 954 | if (err) |
| 955 | return 3; |
| 956 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 957 | /* Step 4: fix up any arguments */ |
| 958 | |
| 959 | /* we count in timer steps */ |
| 960 | if (high_speed) { |
| 961 | /* timing of the conversion itself: every 125 us */ |
| 962 | devpriv->ao_timer = cmd->convert_arg / 125000; |
| 963 | } else { |
| 964 | /* |
| 965 | * timing of the scan: every 1ms |
| 966 | * we get all channels at once |
| 967 | */ |
| 968 | devpriv->ao_timer = cmd->scan_begin_arg / 1000000; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 969 | } |
H Hartley Sweeten | dd64d1e | 2013-05-23 13:05:59 -0700 | [diff] [blame] | 970 | if (devpriv->ao_timer < 1) |
| 971 | err |= -EINVAL; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 972 | |
| 973 | if (cmd->stop_src == TRIG_COUNT) { |
| 974 | /* not continuous, use counter */ |
| 975 | if (high_speed) { |
| 976 | /* high speed also scans everything at once */ |
| 977 | devpriv->ao_sample_count = cmd->stop_arg * |
| 978 | cmd->scan_end_arg; |
| 979 | } else { |
| 980 | /* |
| 981 | * There's no scan as the scan has been |
| 982 | * handled inside the FX2. Data arrives as |
| 983 | * one packet. |
| 984 | */ |
| 985 | devpriv->ao_sample_count = cmd->stop_arg; |
| 986 | } |
| 987 | devpriv->ao_continuous = 0; |
| 988 | } else { |
| 989 | /* continuous acquisition */ |
| 990 | devpriv->ao_continuous = 1; |
| 991 | devpriv->ao_sample_count = 0; |
| 992 | } |
| 993 | |
| 994 | if (err) |
| 995 | return 4; |
| 996 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 997 | return 0; |
| 998 | } |
| 999 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1000 | static int usbduxsigma_ao_cmd(struct comedi_device *dev, |
| 1001 | struct comedi_subdevice *s) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1002 | { |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1003 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1004 | struct comedi_cmd *cmd = &s->async->cmd; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1005 | int ret; |
| 1006 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1007 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1008 | down(&devpriv->sem); |
| 1009 | |
Alexandru Guduleasa | 3ee0206 | 2012-03-09 22:29:01 +0200 | [diff] [blame] | 1010 | /* set current channel of the running acquisition to zero */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1011 | s->async->cur_chan = 0; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1012 | for (i = 0; i < cmd->chanlist_len; ++i) |
H Hartley Sweeten | 315a276 | 2013-07-29 17:46:46 -0700 | [diff] [blame] | 1013 | devpriv->ao_chanlist[i] = CR_CHAN(cmd->chanlist[i]); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1014 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1015 | devpriv->ao_counter = devpriv->ao_timer; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1016 | |
| 1017 | if (cmd->start_src == TRIG_NOW) { |
| 1018 | /* enable this acquisition operation */ |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 1019 | devpriv->ao_cmd_running = 1; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1020 | ret = usbduxsigma_submit_urbs(dev, devpriv->ao_urbs, |
| 1021 | devpriv->n_ao_urbs, 0); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1022 | if (ret < 0) { |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 1023 | devpriv->ao_cmd_running = 0; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1024 | up(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1025 | return ret; |
| 1026 | } |
| 1027 | s->async->inttrig = NULL; |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1028 | } else { /* TRIG_INT */ |
| 1029 | /* wait for an internal signal and submit the urbs later */ |
H Hartley Sweeten | 2d4462d | 2013-05-23 12:52:59 -0700 | [diff] [blame] | 1030 | s->async->inttrig = usbduxsigma_ao_inttrig; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1031 | } |
| 1032 | |
H Hartley Sweeten | fb1ef62 | 2013-05-23 13:04:11 -0700 | [diff] [blame] | 1033 | up(&devpriv->sem); |
| 1034 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1035 | return 0; |
| 1036 | } |
| 1037 | |
H Hartley Sweeten | 62f85ed | 2013-05-23 13:00:56 -0700 | [diff] [blame] | 1038 | static int usbduxsigma_dio_insn_config(struct comedi_device *dev, |
| 1039 | struct comedi_subdevice *s, |
| 1040 | struct comedi_insn *insn, |
| 1041 | unsigned int *data) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1042 | { |
H Hartley Sweeten | ddf62f2 | 2013-08-06 09:32:33 -0700 | [diff] [blame] | 1043 | int ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1044 | |
H Hartley Sweeten | ddf62f2 | 2013-08-06 09:32:33 -0700 | [diff] [blame] | 1045 | ret = comedi_dio_insn_config(dev, s, insn, data, 0); |
| 1046 | if (ret) |
| 1047 | return ret; |
H Hartley Sweeten | 62f85ed | 2013-05-23 13:00:56 -0700 | [diff] [blame] | 1048 | |
| 1049 | /* |
| 1050 | * We don't tell the firmware here as it would take 8 frames |
| 1051 | * to submit the information. We do it in the (*insn_bits). |
| 1052 | */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1053 | return insn->n; |
| 1054 | } |
| 1055 | |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1056 | static int usbduxsigma_dio_insn_bits(struct comedi_device *dev, |
| 1057 | struct comedi_subdevice *s, |
| 1058 | struct comedi_insn *insn, |
| 1059 | unsigned int *data) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1060 | { |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1061 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1062 | int ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1063 | |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1064 | down(&devpriv->sem); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1065 | |
H Hartley Sweeten | 77e9487 | 2013-08-30 11:05:38 -0700 | [diff] [blame] | 1066 | comedi_dio_update_state(s, data); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1067 | |
H Hartley Sweeten | 77e9487 | 2013-08-30 11:05:38 -0700 | [diff] [blame] | 1068 | /* Always update the hardware. See the (*insn_config). */ |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1069 | devpriv->dux_commands[1] = s->io_bits & 0xff; |
| 1070 | devpriv->dux_commands[4] = s->state & 0xff; |
| 1071 | devpriv->dux_commands[2] = (s->io_bits >> 8) & 0xff; |
| 1072 | devpriv->dux_commands[5] = (s->state >> 8) & 0xff; |
| 1073 | devpriv->dux_commands[3] = (s->io_bits >> 16) & 0xff; |
| 1074 | devpriv->dux_commands[6] = (s->state >> 16) & 0xff; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1075 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 1076 | ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_DIO_BITS_CMD); |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1077 | if (ret < 0) |
| 1078 | goto done; |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 1079 | ret = usbduxsigma_receive_cmd(dev, USBDUXSIGMA_DIO_BITS_CMD); |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1080 | if (ret < 0) |
| 1081 | goto done; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1082 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1083 | s->state = devpriv->insn_buf[1] | |
| 1084 | (devpriv->insn_buf[2] << 8) | |
| 1085 | (devpriv->insn_buf[3] << 16); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1086 | |
H Hartley Sweeten | 77a52e6 | 2013-05-23 13:00:36 -0700 | [diff] [blame] | 1087 | data[1] = s->state; |
| 1088 | ret = insn->n; |
| 1089 | |
| 1090 | done: |
| 1091 | up(&devpriv->sem); |
| 1092 | |
| 1093 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1094 | } |
| 1095 | |
H Hartley Sweeten | 8cd6f5e | 2013-05-23 13:03:45 -0700 | [diff] [blame] | 1096 | static void usbduxsigma_pwm_stop(struct comedi_device *dev, int do_unlink) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1097 | { |
H Hartley Sweeten | 8cd6f5e | 2013-05-23 13:03:45 -0700 | [diff] [blame] | 1098 | struct usbduxsigma_private *devpriv = dev->private; |
| 1099 | |
H Hartley Sweeten | f31260f | 2013-05-23 12:44:39 -0700 | [diff] [blame] | 1100 | if (do_unlink) { |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1101 | if (devpriv->pwm_urb) |
| 1102 | usb_kill_urb(devpriv->pwm_urb); |
H Hartley Sweeten | f31260f | 2013-05-23 12:44:39 -0700 | [diff] [blame] | 1103 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1104 | |
H Hartley Sweeten | 19d61fd | 2013-05-23 12:40:10 -0700 | [diff] [blame] | 1105 | devpriv->pwm_cmd_running = 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1106 | } |
| 1107 | |
H Hartley Sweeten | fd24519 | 2013-05-23 13:03:26 -0700 | [diff] [blame] | 1108 | static int usbduxsigma_pwm_cancel(struct comedi_device *dev, |
| 1109 | struct comedi_subdevice *s) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1110 | { |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 1111 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1112 | |
| 1113 | /* unlink only if it is really running */ |
H Hartley Sweeten | 8cd6f5e | 2013-05-23 13:03:45 -0700 | [diff] [blame] | 1114 | usbduxsigma_pwm_stop(dev, devpriv->pwm_cmd_running); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1115 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 1116 | return usbbuxsigma_send_cmd(dev, USBDUXSIGMA_PWM_OFF_CMD); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1117 | } |
| 1118 | |
H Hartley Sweeten | 702cd2d | 2013-05-23 13:06:37 -0700 | [diff] [blame] | 1119 | static void usbduxsigma_pwm_urb_complete(struct urb *urb) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1120 | { |
H Hartley Sweeten | 7fb13b5 | 2013-05-23 12:47:48 -0700 | [diff] [blame] | 1121 | struct comedi_device *dev = urb->context; |
H Hartley Sweeten | eead8c6 | 2013-05-23 12:48:12 -0700 | [diff] [blame] | 1122 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1123 | int ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1124 | |
| 1125 | switch (urb->status) { |
| 1126 | case 0: |
| 1127 | /* success */ |
| 1128 | break; |
| 1129 | |
| 1130 | case -ECONNRESET: |
| 1131 | case -ENOENT: |
| 1132 | case -ESHUTDOWN: |
| 1133 | case -ECONNABORTED: |
H Hartley Sweeten | 7fb13b5 | 2013-05-23 12:47:48 -0700 | [diff] [blame] | 1134 | /* happens after an unlink command */ |
| 1135 | if (devpriv->pwm_cmd_running) |
H Hartley Sweeten | 8cd6f5e | 2013-05-23 13:03:45 -0700 | [diff] [blame] | 1136 | usbduxsigma_pwm_stop(dev, 0); /* w/o unlink */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1137 | return; |
| 1138 | |
| 1139 | default: |
| 1140 | /* a real error */ |
H Hartley Sweeten | 7fb13b5 | 2013-05-23 12:47:48 -0700 | [diff] [blame] | 1141 | if (devpriv->pwm_cmd_running) { |
| 1142 | dev_err(dev->class_dev, |
| 1143 | "%s: non-zero urb status (%d)\n", |
| 1144 | __func__, urb->status); |
H Hartley Sweeten | 8cd6f5e | 2013-05-23 13:03:45 -0700 | [diff] [blame] | 1145 | usbduxsigma_pwm_stop(dev, 0); /* w/o unlink */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1146 | } |
| 1147 | return; |
| 1148 | } |
| 1149 | |
H Hartley Sweeten | 7fb13b5 | 2013-05-23 12:47:48 -0700 | [diff] [blame] | 1150 | if (!devpriv->pwm_cmd_running) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1151 | return; |
| 1152 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1153 | urb->transfer_buffer_length = devpriv->pwm_buf_sz; |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 1154 | urb->dev = comedi_to_usb_dev(dev); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1155 | urb->status = 0; |
H Hartley Sweeten | 7fb13b5 | 2013-05-23 12:47:48 -0700 | [diff] [blame] | 1156 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
| 1157 | if (ret < 0) { |
| 1158 | dev_err(dev->class_dev, "%s: urb resubmit failed (%d)\n", |
| 1159 | __func__, ret); |
| 1160 | if (ret == EL2NSYNC) |
| 1161 | dev_err(dev->class_dev, |
| 1162 | "buggy USB host controller or bug in IRQ handler\n"); |
H Hartley Sweeten | 8cd6f5e | 2013-05-23 13:03:45 -0700 | [diff] [blame] | 1163 | usbduxsigma_pwm_stop(dev, 0); /* w/o unlink */ |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1164 | } |
| 1165 | } |
| 1166 | |
H Hartley Sweeten | 6028f4c | 2013-05-23 12:51:14 -0700 | [diff] [blame] | 1167 | static int usbduxsigma_submit_pwm_urb(struct comedi_device *dev) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1168 | { |
H Hartley Sweeten | 6028f4c | 2013-05-23 12:51:14 -0700 | [diff] [blame] | 1169 | struct usb_device *usb = comedi_to_usb_dev(dev); |
| 1170 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1171 | struct urb *urb = devpriv->pwm_urb; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1172 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1173 | /* in case of a resubmission after an unlink... */ |
H Hartley Sweeten | b509a76 | 2013-07-29 17:43:55 -0700 | [diff] [blame] | 1174 | usb_fill_bulk_urb(urb, usb, usb_sndbulkpipe(usb, 4), |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1175 | urb->transfer_buffer, devpriv->pwm_buf_sz, |
H Hartley Sweeten | 702cd2d | 2013-05-23 13:06:37 -0700 | [diff] [blame] | 1176 | usbduxsigma_pwm_urb_complete, dev); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1177 | |
H Hartley Sweeten | 6028f4c | 2013-05-23 12:51:14 -0700 | [diff] [blame] | 1178 | return usb_submit_urb(urb, GFP_ATOMIC); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1179 | } |
| 1180 | |
H Hartley Sweeten | 440b216 | 2013-05-23 13:02:45 -0700 | [diff] [blame] | 1181 | static int usbduxsigma_pwm_period(struct comedi_device *dev, |
| 1182 | struct comedi_subdevice *s, |
| 1183 | unsigned int period) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1184 | { |
H Hartley Sweeten | 440b216 | 2013-05-23 13:02:45 -0700 | [diff] [blame] | 1185 | struct usbduxsigma_private *devpriv = dev->private; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1186 | int fx2delay = 255; |
| 1187 | |
| 1188 | if (period < MIN_PWM_PERIOD) { |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1189 | return -EAGAIN; |
| 1190 | } else { |
H Hartley Sweeten | 440b216 | 2013-05-23 13:02:45 -0700 | [diff] [blame] | 1191 | fx2delay = (period / (6 * 512 * 1000 / 33)) - 6; |
H Hartley Sweeten | 38f4e42 | 2013-05-23 13:01:18 -0700 | [diff] [blame] | 1192 | if (fx2delay > 255) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1193 | return -EAGAIN; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1194 | } |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1195 | devpriv->pwm_delay = fx2delay; |
| 1196 | devpriv->pwm_period = period; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1197 | return 0; |
| 1198 | } |
| 1199 | |
H Hartley Sweeten | a65b091 | 2013-05-23 12:59:24 -0700 | [diff] [blame] | 1200 | static int usbduxsigma_pwm_start(struct comedi_device *dev, |
| 1201 | struct comedi_subdevice *s) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1202 | { |
H Hartley Sweeten | a65b091 | 2013-05-23 12:59:24 -0700 | [diff] [blame] | 1203 | struct usbduxsigma_private *devpriv = dev->private; |
| 1204 | int ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1205 | |
H Hartley Sweeten | a65b091 | 2013-05-23 12:59:24 -0700 | [diff] [blame] | 1206 | if (devpriv->pwm_cmd_running) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1207 | return 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1208 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1209 | devpriv->dux_commands[1] = devpriv->pwm_delay; |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 1210 | ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_PWM_ON_CMD); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1211 | if (ret < 0) |
| 1212 | return ret; |
| 1213 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1214 | memset(devpriv->pwm_urb->transfer_buffer, 0, devpriv->pwm_buf_sz); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1215 | |
H Hartley Sweeten | a65b091 | 2013-05-23 12:59:24 -0700 | [diff] [blame] | 1216 | devpriv->pwm_cmd_running = 1; |
H Hartley Sweeten | 9c922a9 | 2013-07-25 16:21:13 -0700 | [diff] [blame] | 1217 | ret = usbduxsigma_submit_pwm_urb(dev); |
| 1218 | if (ret < 0) { |
| 1219 | devpriv->pwm_cmd_running = 0; |
| 1220 | return ret; |
| 1221 | } |
H Hartley Sweeten | 6028f4c | 2013-05-23 12:51:14 -0700 | [diff] [blame] | 1222 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1223 | return 0; |
| 1224 | } |
| 1225 | |
H Hartley Sweeten | aa25b91 | 2013-07-29 17:46:07 -0700 | [diff] [blame] | 1226 | static void usbduxsigma_pwm_pattern(struct comedi_device *dev, |
| 1227 | struct comedi_subdevice *s, |
| 1228 | unsigned int chan, |
| 1229 | unsigned int value, |
| 1230 | unsigned int sign) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1231 | { |
H Hartley Sweeten | ab58a6e | 2013-05-23 12:58:43 -0700 | [diff] [blame] | 1232 | struct usbduxsigma_private *devpriv = dev->private; |
| 1233 | char pwm_mask = (1 << chan); /* DIO bit for the PWM data */ |
| 1234 | char sgn_mask = (16 << chan); /* DIO bit for the sign */ |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1235 | char *buf = (char *)(devpriv->pwm_urb->transfer_buffer); |
| 1236 | int szbuf = devpriv->pwm_buf_sz; |
H Hartley Sweeten | ab58a6e | 2013-05-23 12:58:43 -0700 | [diff] [blame] | 1237 | int i; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1238 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1239 | for (i = 0; i < szbuf; i++) { |
H Hartley Sweeten | ab58a6e | 2013-05-23 12:58:43 -0700 | [diff] [blame] | 1240 | char c = *buf; |
| 1241 | |
| 1242 | c &= ~pwm_mask; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1243 | if (i < value) |
H Hartley Sweeten | ab58a6e | 2013-05-23 12:58:43 -0700 | [diff] [blame] | 1244 | c |= pwm_mask; |
| 1245 | if (!sign) |
| 1246 | c &= ~sgn_mask; |
| 1247 | else |
| 1248 | c |= sgn_mask; |
| 1249 | *buf++ = c; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1250 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1251 | } |
| 1252 | |
H Hartley Sweeten | 4ced8c6 | 2013-05-23 12:58:23 -0700 | [diff] [blame] | 1253 | static int usbduxsigma_pwm_write(struct comedi_device *dev, |
| 1254 | struct comedi_subdevice *s, |
| 1255 | struct comedi_insn *insn, |
| 1256 | unsigned int *data) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1257 | { |
H Hartley Sweeten | 4ced8c6 | 2013-05-23 12:58:23 -0700 | [diff] [blame] | 1258 | unsigned int chan = CR_CHAN(insn->chanspec); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1259 | |
| 1260 | /* |
H Hartley Sweeten | 4ced8c6 | 2013-05-23 12:58:23 -0700 | [diff] [blame] | 1261 | * It doesn't make sense to support more than one value here |
| 1262 | * because it would just overwrite the PWM buffer. |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1263 | */ |
H Hartley Sweeten | 4ced8c6 | 2013-05-23 12:58:23 -0700 | [diff] [blame] | 1264 | if (insn->n != 1) |
| 1265 | return -EINVAL; |
| 1266 | |
| 1267 | /* |
| 1268 | * The sign is set via a special INSN only, this gives us 8 bits |
| 1269 | * for normal operation, sign is 0 by default. |
| 1270 | */ |
H Hartley Sweeten | aa25b91 | 2013-07-29 17:46:07 -0700 | [diff] [blame] | 1271 | usbduxsigma_pwm_pattern(dev, s, chan, data[0], 0); |
| 1272 | |
| 1273 | return insn->n; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1274 | } |
| 1275 | |
H Hartley Sweeten | 8939787 | 2013-05-23 12:57:45 -0700 | [diff] [blame] | 1276 | static int usbduxsigma_pwm_config(struct comedi_device *dev, |
| 1277 | struct comedi_subdevice *s, |
| 1278 | struct comedi_insn *insn, |
| 1279 | unsigned int *data) |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1280 | { |
H Hartley Sweeten | 8939787 | 2013-05-23 12:57:45 -0700 | [diff] [blame] | 1281 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | ab58a6e | 2013-05-23 12:58:43 -0700 | [diff] [blame] | 1282 | unsigned int chan = CR_CHAN(insn->chanspec); |
H Hartley Sweeten | 8939787 | 2013-05-23 12:57:45 -0700 | [diff] [blame] | 1283 | |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1284 | switch (data[0]) { |
| 1285 | case INSN_CONFIG_ARM: |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1286 | /* |
| 1287 | * if not zero the PWM is limited to a certain time which is |
| 1288 | * not supported here |
| 1289 | */ |
| 1290 | if (data[1] != 0) |
| 1291 | return -EINVAL; |
H Hartley Sweeten | a65b091 | 2013-05-23 12:59:24 -0700 | [diff] [blame] | 1292 | return usbduxsigma_pwm_start(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1293 | case INSN_CONFIG_DISARM: |
H Hartley Sweeten | fd24519 | 2013-05-23 13:03:26 -0700 | [diff] [blame] | 1294 | return usbduxsigma_pwm_cancel(dev, s); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1295 | case INSN_CONFIG_GET_PWM_STATUS: |
H Hartley Sweeten | 8939787 | 2013-05-23 12:57:45 -0700 | [diff] [blame] | 1296 | data[1] = devpriv->pwm_cmd_running; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1297 | return 0; |
| 1298 | case INSN_CONFIG_PWM_SET_PERIOD: |
H Hartley Sweeten | 440b216 | 2013-05-23 13:02:45 -0700 | [diff] [blame] | 1299 | return usbduxsigma_pwm_period(dev, s, data[1]); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1300 | case INSN_CONFIG_PWM_GET_PERIOD: |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1301 | data[1] = devpriv->pwm_period; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1302 | return 0; |
| 1303 | case INSN_CONFIG_PWM_SET_H_BRIDGE: |
H Hartley Sweeten | 8939787 | 2013-05-23 12:57:45 -0700 | [diff] [blame] | 1304 | /* |
| 1305 | * data[1] = value |
| 1306 | * data[2] = sign (for a relay) |
| 1307 | */ |
H Hartley Sweeten | aa25b91 | 2013-07-29 17:46:07 -0700 | [diff] [blame] | 1308 | usbduxsigma_pwm_pattern(dev, s, chan, data[1], (data[2] != 0)); |
| 1309 | return 0; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1310 | case INSN_CONFIG_PWM_GET_H_BRIDGE: |
| 1311 | /* values are not kept in this driver, nothing to return */ |
| 1312 | return -EINVAL; |
| 1313 | } |
| 1314 | return -EINVAL; |
| 1315 | } |
| 1316 | |
H Hartley Sweeten | 9838f53 | 2013-05-23 12:55:08 -0700 | [diff] [blame] | 1317 | static int usbduxsigma_getstatusinfo(struct comedi_device *dev, int chan) |
| 1318 | { |
| 1319 | struct usbduxsigma_private *devpriv = dev->private; |
| 1320 | uint8_t sysred; |
| 1321 | uint32_t val; |
| 1322 | int ret; |
| 1323 | |
| 1324 | switch (chan) { |
| 1325 | default: |
| 1326 | case 0: |
| 1327 | sysred = 0; /* ADC zero */ |
| 1328 | break; |
| 1329 | case 1: |
| 1330 | sysred = 1; /* ADC offset */ |
| 1331 | break; |
| 1332 | case 2: |
| 1333 | sysred = 4; /* VCC */ |
| 1334 | break; |
| 1335 | case 3: |
| 1336 | sysred = 8; /* temperature */ |
| 1337 | break; |
| 1338 | case 4: |
| 1339 | sysred = 16; /* gain */ |
| 1340 | break; |
| 1341 | case 5: |
| 1342 | sysred = 32; /* ref */ |
| 1343 | break; |
| 1344 | } |
| 1345 | |
| 1346 | devpriv->dux_commands[1] = 0x12; /* CONFIG0 */ |
| 1347 | devpriv->dux_commands[2] = 0x80; /* CONFIG1: 2kHz sampling rate */ |
| 1348 | devpriv->dux_commands[3] = 0x00; /* CONFIG3: diff. channels off */ |
| 1349 | devpriv->dux_commands[4] = 0; |
| 1350 | devpriv->dux_commands[5] = 0; |
| 1351 | devpriv->dux_commands[6] = sysred; |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 1352 | ret = usbbuxsigma_send_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD); |
H Hartley Sweeten | 9838f53 | 2013-05-23 12:55:08 -0700 | [diff] [blame] | 1353 | if (ret < 0) |
| 1354 | return ret; |
| 1355 | |
H Hartley Sweeten | 2bdd6d2 | 2013-05-23 13:06:18 -0700 | [diff] [blame] | 1356 | ret = usbduxsigma_receive_cmd(dev, USBDUXSIGMA_SINGLE_AD_CMD); |
H Hartley Sweeten | 9838f53 | 2013-05-23 12:55:08 -0700 | [diff] [blame] | 1357 | if (ret < 0) |
| 1358 | return ret; |
| 1359 | |
| 1360 | /* 32 bits big endian from the A/D converter */ |
Ian Abbott | f1d376b | 2013-10-16 14:40:38 +0100 | [diff] [blame] | 1361 | val = be32_to_cpu(*((uint32_t *)((devpriv->insn_buf)+1))); |
H Hartley Sweeten | 9838f53 | 2013-05-23 12:55:08 -0700 | [diff] [blame] | 1362 | val &= 0x00ffffff; /* strip status byte */ |
| 1363 | val ^= 0x00800000; /* convert to unsigned */ |
| 1364 | |
| 1365 | return (int)val; |
| 1366 | } |
| 1367 | |
H Hartley Sweeten | 46c8780 | 2013-05-23 12:57:25 -0700 | [diff] [blame] | 1368 | static int usbduxsigma_firmware_upload(struct comedi_device *dev, |
| 1369 | const u8 *data, size_t size, |
| 1370 | unsigned long context) |
| 1371 | { |
| 1372 | struct usb_device *usb = comedi_to_usb_dev(dev); |
| 1373 | uint8_t *buf; |
| 1374 | uint8_t *tmp; |
| 1375 | int ret; |
| 1376 | |
| 1377 | if (!data) |
| 1378 | return 0; |
| 1379 | |
| 1380 | if (size > FIRMWARE_MAX_LEN) { |
| 1381 | dev_err(dev->class_dev, "firmware binary too large for FX2\n"); |
| 1382 | return -ENOMEM; |
| 1383 | } |
| 1384 | |
| 1385 | /* we generate a local buffer for the firmware */ |
| 1386 | buf = kmemdup(data, size, GFP_KERNEL); |
| 1387 | if (!buf) |
| 1388 | return -ENOMEM; |
| 1389 | |
| 1390 | /* we need a malloc'ed buffer for usb_control_msg() */ |
| 1391 | tmp = kmalloc(1, GFP_KERNEL); |
| 1392 | if (!tmp) { |
| 1393 | kfree(buf); |
| 1394 | return -ENOMEM; |
| 1395 | } |
| 1396 | |
| 1397 | /* stop the current firmware on the device */ |
| 1398 | *tmp = 1; /* 7f92 to one */ |
| 1399 | ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0), |
| 1400 | USBDUXSUB_FIRMWARE, |
| 1401 | VENDOR_DIR_OUT, |
| 1402 | USBDUXSUB_CPUCS, 0x0000, |
| 1403 | tmp, 1, |
| 1404 | BULK_TIMEOUT); |
| 1405 | if (ret < 0) { |
| 1406 | dev_err(dev->class_dev, "can not stop firmware\n"); |
| 1407 | goto done; |
| 1408 | } |
| 1409 | |
| 1410 | /* upload the new firmware to the device */ |
| 1411 | ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0), |
| 1412 | USBDUXSUB_FIRMWARE, |
| 1413 | VENDOR_DIR_OUT, |
| 1414 | 0, 0x0000, |
| 1415 | buf, size, |
| 1416 | BULK_TIMEOUT); |
| 1417 | if (ret < 0) { |
| 1418 | dev_err(dev->class_dev, "firmware upload failed\n"); |
| 1419 | goto done; |
| 1420 | } |
| 1421 | |
| 1422 | /* start the new firmware on the device */ |
| 1423 | *tmp = 0; /* 7f92 to zero */ |
| 1424 | ret = usb_control_msg(usb, usb_sndctrlpipe(usb, 0), |
| 1425 | USBDUXSUB_FIRMWARE, |
| 1426 | VENDOR_DIR_OUT, |
| 1427 | USBDUXSUB_CPUCS, 0x0000, |
| 1428 | tmp, 1, |
| 1429 | BULK_TIMEOUT); |
| 1430 | if (ret < 0) |
| 1431 | dev_err(dev->class_dev, "can not start firmware\n"); |
| 1432 | |
| 1433 | done: |
| 1434 | kfree(tmp); |
| 1435 | kfree(buf); |
| 1436 | return ret; |
| 1437 | } |
| 1438 | |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 1439 | static int usbduxsigma_alloc_usb_buffers(struct comedi_device *dev) |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1440 | { |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 1441 | struct usb_device *usb = comedi_to_usb_dev(dev); |
| 1442 | struct usbduxsigma_private *devpriv = dev->private; |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1443 | struct urb *urb; |
| 1444 | int i; |
| 1445 | |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1446 | devpriv->dux_commands = kzalloc(SIZEOFDUXBUFFER, GFP_KERNEL); |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1447 | devpriv->in_buf = kzalloc(SIZEINBUF, GFP_KERNEL); |
| 1448 | devpriv->insn_buf = kzalloc(SIZEINSNBUF, GFP_KERNEL); |
| 1449 | devpriv->ai_urbs = kcalloc(devpriv->n_ai_urbs, sizeof(*urb), |
| 1450 | GFP_KERNEL); |
| 1451 | devpriv->ao_urbs = kcalloc(devpriv->n_ao_urbs, sizeof(*urb), |
| 1452 | GFP_KERNEL); |
H Hartley Sweeten | 315a276 | 2013-07-29 17:46:46 -0700 | [diff] [blame] | 1453 | if (!devpriv->dux_commands || !devpriv->in_buf || !devpriv->insn_buf || |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1454 | !devpriv->ai_urbs || !devpriv->ao_urbs) |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1455 | return -ENOMEM; |
| 1456 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1457 | for (i = 0; i < devpriv->n_ai_urbs; i++) { |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1458 | /* one frame: 1ms */ |
| 1459 | urb = usb_alloc_urb(1, GFP_KERNEL); |
| 1460 | if (!urb) |
| 1461 | return -ENOMEM; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1462 | devpriv->ai_urbs[i] = urb; |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1463 | urb->dev = usb; |
| 1464 | /* will be filled later with a pointer to the comedi-device */ |
| 1465 | /* and ONLY then the urb should be submitted */ |
| 1466 | urb->context = NULL; |
H Hartley Sweeten | b509a76 | 2013-07-29 17:43:55 -0700 | [diff] [blame] | 1467 | urb->pipe = usb_rcvisocpipe(usb, 6); |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1468 | urb->transfer_flags = URB_ISO_ASAP; |
| 1469 | urb->transfer_buffer = kzalloc(SIZEINBUF, GFP_KERNEL); |
| 1470 | if (!urb->transfer_buffer) |
| 1471 | return -ENOMEM; |
H Hartley Sweeten | 702cd2d | 2013-05-23 13:06:37 -0700 | [diff] [blame] | 1472 | urb->complete = usbduxsigma_ai_urb_complete; |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1473 | urb->number_of_packets = 1; |
| 1474 | urb->transfer_buffer_length = SIZEINBUF; |
| 1475 | urb->iso_frame_desc[0].offset = 0; |
| 1476 | urb->iso_frame_desc[0].length = SIZEINBUF; |
| 1477 | } |
| 1478 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1479 | for (i = 0; i < devpriv->n_ao_urbs; i++) { |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1480 | /* one frame: 1ms */ |
| 1481 | urb = usb_alloc_urb(1, GFP_KERNEL); |
| 1482 | if (!urb) |
| 1483 | return -ENOMEM; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1484 | devpriv->ao_urbs[i] = urb; |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1485 | urb->dev = usb; |
| 1486 | /* will be filled later with a pointer to the comedi-device */ |
| 1487 | /* and ONLY then the urb should be submitted */ |
| 1488 | urb->context = NULL; |
H Hartley Sweeten | b509a76 | 2013-07-29 17:43:55 -0700 | [diff] [blame] | 1489 | urb->pipe = usb_sndisocpipe(usb, 2); |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1490 | urb->transfer_flags = URB_ISO_ASAP; |
| 1491 | urb->transfer_buffer = kzalloc(SIZEOUTBUF, GFP_KERNEL); |
| 1492 | if (!urb->transfer_buffer) |
| 1493 | return -ENOMEM; |
H Hartley Sweeten | 702cd2d | 2013-05-23 13:06:37 -0700 | [diff] [blame] | 1494 | urb->complete = usbduxsigma_ao_urb_complete; |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1495 | urb->number_of_packets = 1; |
| 1496 | urb->transfer_buffer_length = SIZEOUTBUF; |
| 1497 | urb->iso_frame_desc[0].offset = 0; |
| 1498 | urb->iso_frame_desc[0].length = SIZEOUTBUF; |
| 1499 | if (devpriv->high_speed) |
| 1500 | urb->interval = 8; /* uframes */ |
| 1501 | else |
| 1502 | urb->interval = 1; /* frames */ |
| 1503 | } |
| 1504 | |
H Hartley Sweeten | 1c379e9 | 2013-07-29 17:47:06 -0700 | [diff] [blame] | 1505 | if (devpriv->pwm_buf_sz) { |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1506 | urb = usb_alloc_urb(0, GFP_KERNEL); |
| 1507 | if (!urb) |
| 1508 | return -ENOMEM; |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1509 | devpriv->pwm_urb = urb; |
H Hartley Sweeten | 1c379e9 | 2013-07-29 17:47:06 -0700 | [diff] [blame] | 1510 | |
| 1511 | urb->transfer_buffer = kzalloc(devpriv->pwm_buf_sz, |
| 1512 | GFP_KERNEL); |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1513 | if (!urb->transfer_buffer) |
| 1514 | return -ENOMEM; |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1515 | } |
| 1516 | |
| 1517 | return 0; |
| 1518 | } |
| 1519 | |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1520 | static void usbduxsigma_free_usb_buffers(struct comedi_device *dev) |
| 1521 | { |
| 1522 | struct usbduxsigma_private *devpriv = dev->private; |
| 1523 | struct urb *urb; |
| 1524 | int i; |
| 1525 | |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1526 | urb = devpriv->pwm_urb; |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1527 | if (urb) { |
| 1528 | kfree(urb->transfer_buffer); |
| 1529 | usb_free_urb(urb); |
| 1530 | } |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1531 | if (devpriv->ao_urbs) { |
| 1532 | for (i = 0; i < devpriv->n_ao_urbs; i++) { |
| 1533 | urb = devpriv->ao_urbs[i]; |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1534 | if (urb) { |
| 1535 | kfree(urb->transfer_buffer); |
| 1536 | usb_free_urb(urb); |
| 1537 | } |
| 1538 | } |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1539 | kfree(devpriv->ao_urbs); |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1540 | } |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1541 | if (devpriv->ai_urbs) { |
| 1542 | for (i = 0; i < devpriv->n_ai_urbs; i++) { |
| 1543 | urb = devpriv->ai_urbs[i]; |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1544 | if (urb) { |
| 1545 | kfree(urb->transfer_buffer); |
| 1546 | usb_free_urb(urb); |
| 1547 | } |
| 1548 | } |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1549 | kfree(devpriv->ai_urbs); |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1550 | } |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1551 | kfree(devpriv->insn_buf); |
| 1552 | kfree(devpriv->in_buf); |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1553 | kfree(devpriv->dux_commands); |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1554 | } |
| 1555 | |
Ian Abbott | 807e65b | 2012-10-30 13:30:03 +0000 | [diff] [blame] | 1556 | static int usbduxsigma_auto_attach(struct comedi_device *dev, |
| 1557 | unsigned long context_unused) |
H Hartley Sweeten | ab5455a | 2012-06-20 12:02:15 -0700 | [diff] [blame] | 1558 | { |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1559 | struct usb_interface *intf = comedi_to_usb_interface(dev); |
| 1560 | struct usb_device *usb = comedi_to_usb_dev(dev); |
| 1561 | struct usbduxsigma_private *devpriv; |
H Hartley Sweeten | 259ed07 | 2013-07-29 17:48:50 -0700 | [diff] [blame] | 1562 | struct comedi_subdevice *s; |
| 1563 | int offset; |
H Hartley Sweeten | ab5455a | 2012-06-20 12:02:15 -0700 | [diff] [blame] | 1564 | int ret; |
H Hartley Sweeten | 0b23728 | 2013-05-20 14:32:01 -0700 | [diff] [blame] | 1565 | |
H Hartley Sweeten | 0bdab50 | 2013-06-24 16:55:44 -0700 | [diff] [blame] | 1566 | devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv)); |
H Hartley Sweeten | 9319d4a | 2013-05-23 12:49:26 -0700 | [diff] [blame] | 1567 | if (!devpriv) |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1568 | return -ENOMEM; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1569 | |
H Hartley Sweeten | 902add4 | 2013-05-23 12:48:41 -0700 | [diff] [blame] | 1570 | sema_init(&devpriv->sem, 1); |
H Hartley Sweeten | 259ed07 | 2013-07-29 17:48:50 -0700 | [diff] [blame] | 1571 | |
H Hartley Sweeten | 902add4 | 2013-05-23 12:48:41 -0700 | [diff] [blame] | 1572 | usb_set_intfdata(intf, devpriv); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1573 | |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1574 | devpriv->high_speed = (usb->speed == USB_SPEED_HIGH); |
H Hartley Sweeten | 902add4 | 2013-05-23 12:48:41 -0700 | [diff] [blame] | 1575 | if (devpriv->high_speed) { |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1576 | devpriv->n_ai_urbs = NUMOFINBUFFERSHIGH; |
| 1577 | devpriv->n_ao_urbs = NUMOFOUTBUFFERSHIGH; |
H Hartley Sweeten | 1c379e9 | 2013-07-29 17:47:06 -0700 | [diff] [blame] | 1578 | devpriv->pwm_buf_sz = 512; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1579 | } else { |
H Hartley Sweeten | aae2f26 | 2013-05-23 13:08:33 -0700 | [diff] [blame] | 1580 | devpriv->n_ai_urbs = NUMOFINBUFFERSFULL; |
| 1581 | devpriv->n_ao_urbs = NUMOFOUTBUFFERSFULL; |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1582 | } |
| 1583 | |
H Hartley Sweeten | a59a28a | 2013-05-23 12:51:56 -0700 | [diff] [blame] | 1584 | ret = usbduxsigma_alloc_usb_buffers(dev); |
H Hartley Sweeten | 1fc56e8 | 2013-05-23 12:55:28 -0700 | [diff] [blame] | 1585 | if (ret) |
H Hartley Sweeten | 65989c0 | 2013-05-23 12:49:02 -0700 | [diff] [blame] | 1586 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1587 | |
H Hartley Sweeten | 259ed07 | 2013-07-29 17:48:50 -0700 | [diff] [blame] | 1588 | /* setting to alternate setting 3: enabling iso ep and bulk ep. */ |
| 1589 | ret = usb_set_interface(usb, intf->altsetting->desc.bInterfaceNumber, |
| 1590 | 3); |
| 1591 | if (ret < 0) { |
| 1592 | dev_err(dev->class_dev, |
| 1593 | "could not set alternate setting 3 in high speed\n"); |
| 1594 | return ret; |
| 1595 | } |
| 1596 | |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1597 | ret = comedi_load_firmware(dev, &usb->dev, FIRMWARE, |
| 1598 | usbduxsigma_firmware_upload, 0); |
| 1599 | if (ret) |
| 1600 | return ret; |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1601 | |
H Hartley Sweeten | 259ed07 | 2013-07-29 17:48:50 -0700 | [diff] [blame] | 1602 | ret = comedi_alloc_subdevices(dev, (devpriv->high_speed) ? 4 : 3); |
| 1603 | if (ret) |
| 1604 | return ret; |
| 1605 | |
| 1606 | /* Analog Input subdevice */ |
| 1607 | s = &dev->subdevices[0]; |
| 1608 | dev->read_subdev = s; |
| 1609 | s->type = COMEDI_SUBD_AI; |
| 1610 | s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_CMD_READ | SDF_LSAMPL; |
| 1611 | s->n_chan = NUMCHANNELS; |
| 1612 | s->len_chanlist = NUMCHANNELS; |
| 1613 | s->maxdata = 0x00ffffff; |
| 1614 | s->range_table = &usbduxsigma_ai_range; |
| 1615 | s->insn_read = usbduxsigma_ai_insn_read; |
| 1616 | s->do_cmdtest = usbduxsigma_ai_cmdtest; |
| 1617 | s->do_cmd = usbduxsigma_ai_cmd; |
| 1618 | s->cancel = usbduxsigma_ai_cancel; |
| 1619 | |
| 1620 | /* Analog Output subdevice */ |
| 1621 | s = &dev->subdevices[1]; |
| 1622 | dev->write_subdev = s; |
| 1623 | s->type = COMEDI_SUBD_AO; |
| 1624 | s->subdev_flags = SDF_WRITABLE | SDF_GROUND | SDF_CMD_WRITE; |
| 1625 | s->n_chan = USBDUXSIGMA_NUM_AO_CHAN; |
| 1626 | s->len_chanlist = s->n_chan; |
| 1627 | s->maxdata = 0x00ff; |
| 1628 | s->range_table = &range_unipolar2_5; |
| 1629 | s->insn_write = usbduxsigma_ao_insn_write; |
| 1630 | s->insn_read = usbduxsigma_ao_insn_read; |
| 1631 | s->do_cmdtest = usbduxsigma_ao_cmdtest; |
| 1632 | s->do_cmd = usbduxsigma_ao_cmd; |
| 1633 | s->cancel = usbduxsigma_ao_cancel; |
| 1634 | |
| 1635 | /* Digital I/O subdevice */ |
| 1636 | s = &dev->subdevices[2]; |
| 1637 | s->type = COMEDI_SUBD_DIO; |
| 1638 | s->subdev_flags = SDF_READABLE | SDF_WRITABLE; |
| 1639 | s->n_chan = 24; |
| 1640 | s->maxdata = 1; |
| 1641 | s->range_table = &range_digital; |
| 1642 | s->insn_bits = usbduxsigma_dio_insn_bits; |
| 1643 | s->insn_config = usbduxsigma_dio_insn_config; |
| 1644 | |
| 1645 | if (devpriv->high_speed) { |
| 1646 | /* Timer / pwm subdevice */ |
| 1647 | s = &dev->subdevices[3]; |
| 1648 | s->type = COMEDI_SUBD_PWM; |
| 1649 | s->subdev_flags = SDF_WRITABLE | SDF_PWM_HBRIDGE; |
| 1650 | s->n_chan = 8; |
| 1651 | s->maxdata = devpriv->pwm_buf_sz; |
| 1652 | s->insn_write = usbduxsigma_pwm_write; |
| 1653 | s->insn_config = usbduxsigma_pwm_config; |
| 1654 | |
| 1655 | usbduxsigma_pwm_period(dev, s, PWM_DEFAULT_PERIOD); |
| 1656 | } |
| 1657 | |
| 1658 | offset = usbduxsigma_getstatusinfo(dev, 0); |
| 1659 | if (offset < 0) |
| 1660 | dev_err(dev->class_dev, |
| 1661 | "Communication to USBDUXSIGMA failed! Check firmware and cabling\n"); |
| 1662 | |
| 1663 | dev_info(dev->class_dev, "attached, ADC_zero = %x\n", offset); |
| 1664 | |
| 1665 | return 0; |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1666 | } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1667 | |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1668 | static void usbduxsigma_detach(struct comedi_device *dev) |
| 1669 | { |
H Hartley Sweeten | 137beb7 | 2013-05-23 12:55:48 -0700 | [diff] [blame] | 1670 | struct usb_interface *intf = comedi_to_usb_interface(dev); |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1671 | struct usbduxsigma_private *devpriv = dev->private; |
| 1672 | |
H Hartley Sweeten | 1da4390 | 2013-07-29 17:47:44 -0700 | [diff] [blame] | 1673 | usb_set_intfdata(intf, NULL); |
| 1674 | |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1675 | if (!devpriv) |
| 1676 | return; |
| 1677 | |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1678 | down(&devpriv->sem); |
H Hartley Sweeten | 71d7e1e | 2013-07-29 17:47:26 -0700 | [diff] [blame] | 1679 | |
| 1680 | /* force unlink all urbs */ |
| 1681 | usbduxsigma_ai_stop(dev, 1); |
| 1682 | usbduxsigma_ao_stop(dev, 1); |
| 1683 | usbduxsigma_pwm_stop(dev, 1); |
| 1684 | |
H Hartley Sweeten | e0b12e6 | 2013-05-23 12:56:36 -0700 | [diff] [blame] | 1685 | usbduxsigma_free_usb_buffers(dev); |
H Hartley Sweeten | 71d7e1e | 2013-07-29 17:47:26 -0700 | [diff] [blame] | 1686 | |
H Hartley Sweeten | 1823fcb | 2013-05-23 12:49:50 -0700 | [diff] [blame] | 1687 | up(&devpriv->sem); |
| 1688 | } |
| 1689 | |
| 1690 | static struct comedi_driver usbduxsigma_driver = { |
| 1691 | .driver_name = "usbduxsigma", |
| 1692 | .module = THIS_MODULE, |
| 1693 | .auto_attach = usbduxsigma_auto_attach, |
| 1694 | .detach = usbduxsigma_detach, |
| 1695 | }; |
| 1696 | |
| 1697 | static int usbduxsigma_usb_probe(struct usb_interface *intf, |
| 1698 | const struct usb_device_id *id) |
| 1699 | { |
H Hartley Sweeten | 5f1d72e | 2013-05-23 12:56:59 -0700 | [diff] [blame] | 1700 | return comedi_usb_auto_config(intf, &usbduxsigma_driver, 0); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1701 | } |
| 1702 | |
H Hartley Sweeten | ab5455a | 2012-06-20 12:02:15 -0700 | [diff] [blame] | 1703 | static const struct usb_device_id usbduxsigma_usb_table[] = { |
| 1704 | { USB_DEVICE(0x13d8, 0x0020) }, |
| 1705 | { USB_DEVICE(0x13d8, 0x0021) }, |
| 1706 | { USB_DEVICE(0x13d8, 0x0022) }, |
| 1707 | { } |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1708 | }; |
H Hartley Sweeten | ab5455a | 2012-06-20 12:02:15 -0700 | [diff] [blame] | 1709 | MODULE_DEVICE_TABLE(usb, usbduxsigma_usb_table); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1710 | |
H Hartley Sweeten | b7418f4 | 2012-06-20 12:01:27 -0700 | [diff] [blame] | 1711 | static struct usb_driver usbduxsigma_usb_driver = { |
H Hartley Sweeten | ab5455a | 2012-06-20 12:02:15 -0700 | [diff] [blame] | 1712 | .name = "usbduxsigma", |
| 1713 | .probe = usbduxsigma_usb_probe, |
H Hartley Sweeten | 9319d4a | 2013-05-23 12:49:26 -0700 | [diff] [blame] | 1714 | .disconnect = comedi_usb_auto_unconfig, |
H Hartley Sweeten | ab5455a | 2012-06-20 12:02:15 -0700 | [diff] [blame] | 1715 | .id_table = usbduxsigma_usb_table, |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1716 | }; |
H Hartley Sweeten | b7418f4 | 2012-06-20 12:01:27 -0700 | [diff] [blame] | 1717 | module_comedi_usb_driver(usbduxsigma_driver, usbduxsigma_usb_driver); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1718 | |
H Hartley Sweeten | ab5455a | 2012-06-20 12:02:15 -0700 | [diff] [blame] | 1719 | MODULE_AUTHOR("Bernd Porr, BerndPorr@f2s.com"); |
| 1720 | MODULE_DESCRIPTION("Stirling/ITL USB-DUX SIGMA -- Bernd.Porr@f2s.com"); |
Bernd Porr | dd89e20 | 2011-07-30 11:15:02 +0100 | [diff] [blame] | 1721 | MODULE_LICENSE("GPL"); |
Tim Gardner | a1d95cf | 2012-08-16 11:19:11 -0600 | [diff] [blame] | 1722 | MODULE_FIRMWARE(FIRMWARE); |