?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/panthor: Don't add write fences to the shared BOs
[drm/drm-misc.git] / drivers / comedi / drivers / cb_pcidas.c
blob8bb9b0623869fe94058799efbf900d86979f36f0
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * cb_pcidas.c
4 * Developed by Ivan Martinez and Frank Mori Hess, with valuable help from
5 * David Schleef and the rest of the Comedi developers comunity.
6 *
7 * Copyright (C) 2001-2003 Ivan Martinez <imr@oersted.dtu.dk>
8 * Copyright (C) 2001,2002 Frank Mori Hess <fmhess@users.sourceforge.net>
9 *
10 * COMEDI - Linux Control and Measurement Device Interface
11 * Copyright (C) 1997-8 David A. Schleef <ds@schleef.org>
12 */
13
14 /*
15 * Driver: cb_pcidas
16 * Description: MeasurementComputing PCI-DAS series
17 * with the AMCC S5933 PCI controller
18 * Devices: [Measurement Computing] PCI-DAS1602/16 (cb_pcidas),
19 * PCI-DAS1602/16jr, PCI-DAS1602/12, PCI-DAS1200, PCI-DAS1200jr,
20 * PCI-DAS1000, PCI-DAS1001, PCI_DAS1002
21 * Author: Ivan Martinez <imr@oersted.dtu.dk>,
22 * Frank Mori Hess <fmhess@users.sourceforge.net>
23 * Updated: 2003-3-11
24 *
25 * Status:
26 * There are many reports of the driver being used with most of the
27 * supported cards. Despite no detailed log is maintained, it can
28 * be said that the driver is quite tested and stable.
29 *
30 * The boards may be autocalibrated using the comedi_calibrate
31 * utility.
32 *
33 * Configuration options: not applicable, uses PCI auto config
34 *
35 * For commands, the scanned channels must be consecutive
36 * (i.e. 4-5-6-7, 2-3-4,...), and must all have the same
37 * range and aref.
38 *
39 * AI Triggering:
40 * For start_src == TRIG_EXT, the A/D EXTERNAL TRIGGER IN (pin 45) is used.
41 * For 1602 series, the start_arg is interpreted as follows:
42 * start_arg == 0 => gated trigger (level high)
43 * start_arg == CR_INVERT => gated trigger (level low)
44 * start_arg == CR_EDGE => Rising edge
45 * start_arg == CR_EDGE | CR_INVERT => Falling edge
46 * For the other boards the trigger will be done on rising edge
47 */
48
49 /*
50 * TODO:
51 * analog triggering on 1602 series
52 */
53
54 #include <linux/module.h>
55 #include <linux/delay.h>
56 #include <linux/interrupt.h>
57 #include <linux/comedi/comedi_pci.h>
58 #include <linux/comedi/comedi_8255.h>
59 #include <linux/comedi/comedi_8254.h>
60
61 #include "amcc_s5933.h"
62
63 #define AI_BUFFER_SIZE 1024 /* max ai fifo size */
64 #define AO_BUFFER_SIZE 1024 /* max ao fifo size */
65
66 /*
67 * PCI BAR1 Register map (devpriv->pcibar1)
68 */
69 #define PCIDAS_CTRL_REG 0x00 /* INTERRUPT / ADC FIFO register */
70 #define PCIDAS_CTRL_INT(x) (((x) & 0x3) << 0)
71 #define PCIDAS_CTRL_INT_NONE PCIDAS_CTRL_INT(0) /* no int selected */
72 #define PCIDAS_CTRL_INT_EOS PCIDAS_CTRL_INT(1) /* int on end of scan */
73 #define PCIDAS_CTRL_INT_FHF PCIDAS_CTRL_INT(2) /* int on fifo half full */
74 #define PCIDAS_CTRL_INT_FNE PCIDAS_CTRL_INT(3) /* int on fifo not empty */
75 #define PCIDAS_CTRL_INT_MASK PCIDAS_CTRL_INT(3) /* mask of int select bits */
76 #define PCIDAS_CTRL_INTE BIT(2) /* int enable */
77 #define PCIDAS_CTRL_DAHFIE BIT(3) /* dac half full int enable */
78 #define PCIDAS_CTRL_EOAIE BIT(4) /* end of acq. int enable */
79 #define PCIDAS_CTRL_DAHFI BIT(5) /* dac half full status / clear */
80 #define PCIDAS_CTRL_EOAI BIT(6) /* end of acq. int status / clear */
81 #define PCIDAS_CTRL_INT_CLR BIT(7) /* int status / clear */
82 #define PCIDAS_CTRL_EOBI BIT(9) /* end of burst int status */
83 #define PCIDAS_CTRL_ADHFI BIT(10) /* half-full int status */
84 #define PCIDAS_CTRL_ADNEI BIT(11) /* fifo not empty int status (latch) */
85 #define PCIDAS_CTRL_ADNE BIT(12) /* fifo not empty status (realtime) */
86 #define PCIDAS_CTRL_DAEMIE BIT(12) /* dac empty int enable */
87 #define PCIDAS_CTRL_LADFUL BIT(13) /* fifo overflow / clear */
88 #define PCIDAS_CTRL_DAEMI BIT(14) /* dac fifo empty int status / clear */
89
90 #define PCIDAS_CTRL_AI_INT (PCIDAS_CTRL_EOAI | PCIDAS_CTRL_EOBI | \
91 PCIDAS_CTRL_ADHFI | PCIDAS_CTRL_ADNEI | \
92 PCIDAS_CTRL_LADFUL)
93 #define PCIDAS_CTRL_AO_INT (PCIDAS_CTRL_DAHFI | PCIDAS_CTRL_DAEMI)
94
95 #define PCIDAS_AI_REG 0x02 /* ADC CHANNEL MUX AND CONTROL reg */
96 #define PCIDAS_AI_FIRST(x) ((x) & 0xf)
97 #define PCIDAS_AI_LAST(x) (((x) & 0xf) << 4)
98 #define PCIDAS_AI_CHAN(x) (PCIDAS_AI_FIRST(x) | PCIDAS_AI_LAST(x))
99 #define PCIDAS_AI_GAIN(x) (((x) & 0x3) << 8)
100 #define PCIDAS_AI_SE BIT(10) /* Inputs in single-ended mode */
101 #define PCIDAS_AI_UNIP BIT(11) /* Analog front-end unipolar mode */
102 #define PCIDAS_AI_PACER(x) (((x) & 0x3) << 12)
103 #define PCIDAS_AI_PACER_SW PCIDAS_AI_PACER(0) /* software pacer */
104 #define PCIDAS_AI_PACER_INT PCIDAS_AI_PACER(1) /* int. pacer */
105 #define PCIDAS_AI_PACER_EXTN PCIDAS_AI_PACER(2) /* ext. falling edge */
106 #define PCIDAS_AI_PACER_EXTP PCIDAS_AI_PACER(3) /* ext. rising edge */
107 #define PCIDAS_AI_PACER_MASK PCIDAS_AI_PACER(3) /* pacer source bits */
108 #define PCIDAS_AI_EOC BIT(14) /* adc not busy */
109
110 #define PCIDAS_TRIG_REG 0x04 /* TRIGGER CONTROL/STATUS register */
111 #define PCIDAS_TRIG_SEL(x) (((x) & 0x3) << 0)
112 #define PCIDAS_TRIG_SEL_NONE PCIDAS_TRIG_SEL(0) /* no start trigger */
113 #define PCIDAS_TRIG_SEL_SW PCIDAS_TRIG_SEL(1) /* software start trigger */
114 #define PCIDAS_TRIG_SEL_EXT PCIDAS_TRIG_SEL(2) /* ext. start trigger */
115 #define PCIDAS_TRIG_SEL_ANALOG PCIDAS_TRIG_SEL(3) /* ext. analog trigger */
116 #define PCIDAS_TRIG_SEL_MASK PCIDAS_TRIG_SEL(3) /* start trigger mask */
117 #define PCIDAS_TRIG_POL BIT(2) /* invert trigger (1602 only) */
118 #define PCIDAS_TRIG_MODE BIT(3) /* edge/level triggered (1602 only) */
119 #define PCIDAS_TRIG_EN BIT(4) /* enable external start trigger */
120 #define PCIDAS_TRIG_BURSTE BIT(5) /* burst mode enable */
121 #define PCIDAS_TRIG_CLR BIT(7) /* clear external trigger */
122
123 #define PCIDAS_CALIB_REG 0x06 /* CALIBRATION register */
124 #define PCIDAS_CALIB_8800_SEL BIT(8) /* select 8800 caldac */
125 #define PCIDAS_CALIB_TRIM_SEL BIT(9) /* select ad7376 trim pot */
126 #define PCIDAS_CALIB_DAC08_SEL BIT(10) /* select dac08 caldac */
127 #define PCIDAS_CALIB_SRC(x) (((x) & 0x7) << 11)
128 #define PCIDAS_CALIB_EN BIT(14) /* calibration source enable */
129 #define PCIDAS_CALIB_DATA BIT(15) /* serial data bit going to caldac */
130
131 #define PCIDAS_AO_REG 0x08 /* dac control and status register */
132 #define PCIDAS_AO_EMPTY BIT(0) /* fifo empty, write clear (1602) */
133 #define PCIDAS_AO_DACEN BIT(1) /* dac enable */
134 #define PCIDAS_AO_START BIT(2) /* start/arm fifo (1602) */
135 #define PCIDAS_AO_PACER(x) (((x) & 0x3) << 3) /* (1602) */
136 #define PCIDAS_AO_PACER_SW PCIDAS_AO_PACER(0) /* software pacer */
137 #define PCIDAS_AO_PACER_INT PCIDAS_AO_PACER(1) /* int. pacer */
138 #define PCIDAS_AO_PACER_EXTN PCIDAS_AO_PACER(2) /* ext. falling edge */
139 #define PCIDAS_AO_PACER_EXTP PCIDAS_AO_PACER(3) /* ext. rising edge */
140 #define PCIDAS_AO_PACER_MASK PCIDAS_AO_PACER(3) /* pacer source bits */
141 #define PCIDAS_AO_CHAN_EN(c) BIT(5 + ((c) & 0x1))
142 #define PCIDAS_AO_CHAN_MASK (PCIDAS_AO_CHAN_EN(0) | PCIDAS_AO_CHAN_EN(1))
143 #define PCIDAS_AO_UPDATE_BOTH BIT(7) /* update both dacs */
144 #define PCIDAS_AO_RANGE(c, r) (((r) & 0x3) << (8 + 2 * ((c) & 0x1)))
145 #define PCIDAS_AO_RANGE_MASK(c) PCIDAS_AO_RANGE((c), 0x3)
146
147 /*
148 * PCI BAR2 Register map (devpriv->pcibar2)
149 */
150 #define PCIDAS_AI_DATA_REG 0x00
151 #define PCIDAS_AI_FIFO_CLR_REG 0x02
152
153 /*
154 * PCI BAR3 Register map (dev->iobase)
155 */
156 #define PCIDAS_AI_8254_BASE 0x00
157 #define PCIDAS_8255_BASE 0x04
158 #define PCIDAS_AO_8254_BASE 0x08
159
160 /*
161 * PCI BAR4 Register map (devpriv->pcibar4)
162 */
163 #define PCIDAS_AO_DATA_REG(x) (0x00 + ((x) * 2))
164 #define PCIDAS_AO_FIFO_REG 0x00
165 #define PCIDAS_AO_FIFO_CLR_REG 0x02
166
167 /* analog input ranges for most boards */
168 static const struct comedi_lrange cb_pcidas_ranges = {
169 8, {
170 BIP_RANGE(10),
171 BIP_RANGE(5),
172 BIP_RANGE(2.5),
173 BIP_RANGE(1.25),
174 UNI_RANGE(10),
175 UNI_RANGE(5),
176 UNI_RANGE(2.5),
177 UNI_RANGE(1.25)
178 }
179 };
180
181 /* pci-das1001 input ranges */
182 static const struct comedi_lrange cb_pcidas_alt_ranges = {
183 8, {
184 BIP_RANGE(10),
185 BIP_RANGE(1),
186 BIP_RANGE(0.1),
187 BIP_RANGE(0.01),
188 UNI_RANGE(10),
189 UNI_RANGE(1),
190 UNI_RANGE(0.1),
191 UNI_RANGE(0.01)
192 }
193 };
194
195 /* analog output ranges */
196 static const struct comedi_lrange cb_pcidas_ao_ranges = {
197 4, {
198 BIP_RANGE(5),
199 BIP_RANGE(10),
200 UNI_RANGE(5),
201 UNI_RANGE(10)
202 }
203 };
204
205 enum cb_pcidas_boardid {
206 BOARD_PCIDAS1602_16,
207 BOARD_PCIDAS1200,
208 BOARD_PCIDAS1602_12,
209 BOARD_PCIDAS1200_JR,
210 BOARD_PCIDAS1602_16_JR,
211 BOARD_PCIDAS1000,
212 BOARD_PCIDAS1001,
213 BOARD_PCIDAS1002,
214 };
215
216 struct cb_pcidas_board {
217 const char *name;
218 int ai_speed; /* fastest conversion period in ns */
219 int ao_scan_speed; /* analog output scan speed for 1602 series */
220 int fifo_size; /* number of samples fifo can hold */
221 unsigned int is_16bit; /* ai/ao is 1=16-bit; 0=12-bit */
222 unsigned int use_alt_range:1; /* use alternate ai range table */
223 unsigned int has_ao:1; /* has 2 analog output channels */
224 unsigned int has_ao_fifo:1; /* analog output has fifo */
225 unsigned int has_ad8402:1; /* trimpot type 1=AD8402; 0=AD7376 */
226 unsigned int has_dac08:1;
227 unsigned int is_1602:1;
228 };
229
230 static const struct cb_pcidas_board cb_pcidas_boards[] = {
231 [BOARD_PCIDAS1602_16] = {
232 .name = "pci-das1602/16",
233 .ai_speed = 5000,
234 .ao_scan_speed = 10000,
235 .fifo_size = 512,
236 .is_16bit = 1,
237 .has_ao = 1,
238 .has_ao_fifo = 1,
239 .has_ad8402 = 1,
240 .has_dac08 = 1,
241 .is_1602 = 1,
242 },
243 [BOARD_PCIDAS1200] = {
244 .name = "pci-das1200",
245 .ai_speed = 3200,
246 .fifo_size = 1024,
247 .has_ao = 1,
248 },
249 [BOARD_PCIDAS1602_12] = {
250 .name = "pci-das1602/12",
251 .ai_speed = 3200,
252 .ao_scan_speed = 4000,
253 .fifo_size = 1024,
254 .has_ao = 1,
255 .has_ao_fifo = 1,
256 .is_1602 = 1,
257 },
258 [BOARD_PCIDAS1200_JR] = {
259 .name = "pci-das1200/jr",
260 .ai_speed = 3200,
261 .fifo_size = 1024,
262 },
263 [BOARD_PCIDAS1602_16_JR] = {
264 .name = "pci-das1602/16/jr",
265 .ai_speed = 5000,
266 .fifo_size = 512,
267 .is_16bit = 1,
268 .has_ad8402 = 1,
269 .has_dac08 = 1,
270 .is_1602 = 1,
271 },
272 [BOARD_PCIDAS1000] = {
273 .name = "pci-das1000",
274 .ai_speed = 4000,
275 .fifo_size = 1024,
276 },
277 [BOARD_PCIDAS1001] = {
278 .name = "pci-das1001",
279 .ai_speed = 6800,
280 .fifo_size = 1024,
281 .use_alt_range = 1,
282 .has_ao = 1,
283 },
284 [BOARD_PCIDAS1002] = {
285 .name = "pci-das1002",
286 .ai_speed = 6800,
287 .fifo_size = 1024,
288 .has_ao = 1,
289 },
290 };
291
292 struct cb_pcidas_private {
293 struct comedi_8254 *ao_pacer;
294 /* base addresses */
295 unsigned long amcc; /* pcibar0 */
296 unsigned long pcibar1;
297 unsigned long pcibar2;
298 unsigned long pcibar4;
299 /* bits to write to registers */
300 unsigned int ctrl;
301 unsigned int amcc_intcsr;
302 unsigned int ao_ctrl;
303 /* fifo buffers */
304 unsigned short ai_buffer[AI_BUFFER_SIZE];
305 unsigned short ao_buffer[AO_BUFFER_SIZE];
306 unsigned int calib_src;
307 };
308
309 static int cb_pcidas_ai_eoc(struct comedi_device *dev,
310 struct comedi_subdevice *s,
311 struct comedi_insn *insn,
312 unsigned long context)
313 {
314 struct cb_pcidas_private *devpriv = dev->private;
315 unsigned int status;
316
317 status = inw(devpriv->pcibar1 + PCIDAS_AI_REG);
318 if (status & PCIDAS_AI_EOC)
319 return 0;
320 return -EBUSY;
321 }
322
323 static int cb_pcidas_ai_insn_read(struct comedi_device *dev,
324 struct comedi_subdevice *s,
325 struct comedi_insn *insn,
326 unsigned int *data)
327 {
328 struct cb_pcidas_private *devpriv = dev->private;
329 unsigned int chan = CR_CHAN(insn->chanspec);
330 unsigned int range = CR_RANGE(insn->chanspec);
331 unsigned int aref = CR_AREF(insn->chanspec);
332 unsigned int bits;
333 int ret;
334 int n;
335
336 /* enable calibration input if appropriate */
337 if (insn->chanspec & CR_ALT_SOURCE) {
338 outw(PCIDAS_CALIB_EN | PCIDAS_CALIB_SRC(devpriv->calib_src),
339 devpriv->pcibar1 + PCIDAS_CALIB_REG);
340 chan = 0;
341 } else {
342 outw(0, devpriv->pcibar1 + PCIDAS_CALIB_REG);
343 }
344
345 /* set mux limits and gain */
346 bits = PCIDAS_AI_CHAN(chan) | PCIDAS_AI_GAIN(range);
347 /* set unipolar/bipolar */
348 if (comedi_range_is_unipolar(s, range))
349 bits |= PCIDAS_AI_UNIP;
350 /* set single-ended/differential */
351 if (aref != AREF_DIFF)
352 bits |= PCIDAS_AI_SE;
353 outw(bits, devpriv->pcibar1 + PCIDAS_AI_REG);
354
355 /* clear fifo */
356 outw(0, devpriv->pcibar2 + PCIDAS_AI_FIFO_CLR_REG);
357
358 /* convert n samples */
359 for (n = 0; n < insn->n; n++) {
360 /* trigger conversion */
361 outw(0, devpriv->pcibar2 + PCIDAS_AI_DATA_REG);
362
363 /* wait for conversion to end */
364 ret = comedi_timeout(dev, s, insn, cb_pcidas_ai_eoc, 0);
365 if (ret)
366 return ret;
367
368 /* read data */
369 data[n] = inw(devpriv->pcibar2 + PCIDAS_AI_DATA_REG);
370 }
371
372 /* return the number of samples read/written */
373 return n;
374 }
375
376 static int cb_pcidas_ai_insn_config(struct comedi_device *dev,
377 struct comedi_subdevice *s,
378 struct comedi_insn *insn,
379 unsigned int *data)
380 {
381 struct cb_pcidas_private *devpriv = dev->private;
382 int id = data[0];
383 unsigned int source = data[1];
384
385 switch (id) {
386 case INSN_CONFIG_ALT_SOURCE:
387 if (source >= 8) {
388 dev_err(dev->class_dev,
389 "invalid calibration source: %i\n",
390 source);
391 return -EINVAL;
392 }
393 devpriv->calib_src = source;
394 break;
395 default:
396 return -EINVAL;
397 }
398 return insn->n;
399 }
400
401 /* analog output insn for pcidas-1000 and 1200 series */
402 static int cb_pcidas_ao_nofifo_insn_write(struct comedi_device *dev,
403 struct comedi_subdevice *s,
404 struct comedi_insn *insn,
405 unsigned int *data)
406 {
407 struct cb_pcidas_private *devpriv = dev->private;
408 unsigned int chan = CR_CHAN(insn->chanspec);
409 unsigned int range = CR_RANGE(insn->chanspec);
410 unsigned int val = s->readback[chan];
411 unsigned long flags;
412 int i;
413
414 /* set channel and range */
415 spin_lock_irqsave(&dev->spinlock, flags);
416 devpriv->ao_ctrl &= ~(PCIDAS_AO_UPDATE_BOTH |
417 PCIDAS_AO_RANGE_MASK(chan));
418 devpriv->ao_ctrl |= PCIDAS_AO_DACEN | PCIDAS_AO_RANGE(chan, range);
419 outw(devpriv->ao_ctrl, devpriv->pcibar1 + PCIDAS_AO_REG);
420 spin_unlock_irqrestore(&dev->spinlock, flags);
421
422 for (i = 0; i < insn->n; i++) {
423 val = data[i];
424 outw(val, devpriv->pcibar4 + PCIDAS_AO_DATA_REG(chan));
425 }
426
427 s->readback[chan] = val;
428
429 return insn->n;
430 }
431
432 /* analog output insn for pcidas-1602 series */
433 static int cb_pcidas_ao_fifo_insn_write(struct comedi_device *dev,
434 struct comedi_subdevice *s,
435 struct comedi_insn *insn,
436 unsigned int *data)
437 {
438 struct cb_pcidas_private *devpriv = dev->private;
439 unsigned int chan = CR_CHAN(insn->chanspec);
440 unsigned int range = CR_RANGE(insn->chanspec);
441 unsigned int val = s->readback[chan];
442 unsigned long flags;
443 int i;
444
445 /* clear dac fifo */
446 outw(0, devpriv->pcibar4 + PCIDAS_AO_FIFO_CLR_REG);
447
448 /* set channel and range */
449 spin_lock_irqsave(&dev->spinlock, flags);
450 devpriv->ao_ctrl &= ~(PCIDAS_AO_CHAN_MASK | PCIDAS_AO_RANGE_MASK(chan) |
451 PCIDAS_AO_PACER_MASK);
452 devpriv->ao_ctrl |= PCIDAS_AO_DACEN | PCIDAS_AO_RANGE(chan, range) |
453 PCIDAS_AO_CHAN_EN(chan) | PCIDAS_AO_START;
454 outw(devpriv->ao_ctrl, devpriv->pcibar1 + PCIDAS_AO_REG);
455 spin_unlock_irqrestore(&dev->spinlock, flags);
456
457 for (i = 0; i < insn->n; i++) {
458 val = data[i];
459 outw(val, devpriv->pcibar4 + PCIDAS_AO_FIFO_REG);
460 }
461
462 s->readback[chan] = val;
463
464 return insn->n;
465 }
466
467 static int cb_pcidas_eeprom_ready(struct comedi_device *dev,
468 struct comedi_subdevice *s,
469 struct comedi_insn *insn,
470 unsigned long context)
471 {
472 struct cb_pcidas_private *devpriv = dev->private;
473 unsigned int status;
474
475 status = inb(devpriv->amcc + AMCC_OP_REG_MCSR_NVCMD);
476 if ((status & MCSR_NV_BUSY) == 0)
477 return 0;
478 return -EBUSY;
479 }
480
481 static int cb_pcidas_eeprom_insn_read(struct comedi_device *dev,
482 struct comedi_subdevice *s,
483 struct comedi_insn *insn,
484 unsigned int *data)
485 {
486 struct cb_pcidas_private *devpriv = dev->private;
487 unsigned int chan = CR_CHAN(insn->chanspec);
488 int ret;
489 int i;
490
491 for (i = 0; i < insn->n; i++) {
492 /* make sure eeprom is ready */
493 ret = comedi_timeout(dev, s, insn, cb_pcidas_eeprom_ready, 0);
494 if (ret)
495 return ret;
496
497 /* set address (chan) and read operation */
498 outb(MCSR_NV_ENABLE | MCSR_NV_LOAD_LOW_ADDR,
499 devpriv->amcc + AMCC_OP_REG_MCSR_NVCMD);
500 outb(chan & 0xff, devpriv->amcc + AMCC_OP_REG_MCSR_NVDATA);
501 outb(MCSR_NV_ENABLE | MCSR_NV_LOAD_HIGH_ADDR,
502 devpriv->amcc + AMCC_OP_REG_MCSR_NVCMD);
503 outb((chan >> 8) & 0xff,
504 devpriv->amcc + AMCC_OP_REG_MCSR_NVDATA);
505 outb(MCSR_NV_ENABLE | MCSR_NV_READ,
506 devpriv->amcc + AMCC_OP_REG_MCSR_NVCMD);
507
508 /* wait for data to be returned */
509 ret = comedi_timeout(dev, s, insn, cb_pcidas_eeprom_ready, 0);
510 if (ret)
511 return ret;
512
513 data[i] = inb(devpriv->amcc + AMCC_OP_REG_MCSR_NVDATA);
514 }
515
516 return insn->n;
517 }
518
519 static void cb_pcidas_calib_write(struct comedi_device *dev,
520 unsigned int val, unsigned int len,
521 bool trimpot)
522 {
523 struct cb_pcidas_private *devpriv = dev->private;
524 unsigned int calib_bits;
525 unsigned int bit;
526
527 calib_bits = PCIDAS_CALIB_EN | PCIDAS_CALIB_SRC(devpriv->calib_src);
528 if (trimpot) {
529 /* select trimpot */
530 calib_bits |= PCIDAS_CALIB_TRIM_SEL;
531 outw(calib_bits, devpriv->pcibar1 + PCIDAS_CALIB_REG);
532 }
533
534 /* write bitstream to calibration device */
535 for (bit = 1 << (len - 1); bit; bit >>= 1) {
536 if (val & bit)
537 calib_bits |= PCIDAS_CALIB_DATA;
538 else
539 calib_bits &= ~PCIDAS_CALIB_DATA;
540 udelay(1);
541 outw(calib_bits, devpriv->pcibar1 + PCIDAS_CALIB_REG);
542 }
543 udelay(1);
544
545 calib_bits = PCIDAS_CALIB_EN | PCIDAS_CALIB_SRC(devpriv->calib_src);
546
547 if (!trimpot) {
548 /* select caldac */
549 outw(calib_bits | PCIDAS_CALIB_8800_SEL,
550 devpriv->pcibar1 + PCIDAS_CALIB_REG);
551 udelay(1);
552 }
553
554 /* latch value to trimpot/caldac */
555 outw(calib_bits, devpriv->pcibar1 + PCIDAS_CALIB_REG);
556 }
557
558 static int cb_pcidas_caldac_insn_write(struct comedi_device *dev,
559 struct comedi_subdevice *s,
560 struct comedi_insn *insn,
561 unsigned int *data)
562 {
563 unsigned int chan = CR_CHAN(insn->chanspec);
564
565 if (insn->n) {
566 unsigned int val = data[insn->n - 1];
567
568 if (s->readback[chan] != val) {
569 /* write 11-bit channel/value to caldac */
570 cb_pcidas_calib_write(dev, (chan << 8) | val, 11,
571 false);
572 s->readback[chan] = val;
573 }
574 }
575
576 return insn->n;
577 }
578
579 static void cb_pcidas_dac08_write(struct comedi_device *dev, unsigned int val)
580 {
581 struct cb_pcidas_private *devpriv = dev->private;
582
583 val |= PCIDAS_CALIB_EN | PCIDAS_CALIB_SRC(devpriv->calib_src);
584
585 /* latch the new value into the caldac */
586 outw(val, devpriv->pcibar1 + PCIDAS_CALIB_REG);
587 udelay(1);
588 outw(val | PCIDAS_CALIB_DAC08_SEL,
589 devpriv->pcibar1 + PCIDAS_CALIB_REG);
590 udelay(1);
591 outw(val, devpriv->pcibar1 + PCIDAS_CALIB_REG);
592 udelay(1);
593 }
594
595 static int cb_pcidas_dac08_insn_write(struct comedi_device *dev,
596 struct comedi_subdevice *s,
597 struct comedi_insn *insn,
598 unsigned int *data)
599 {
600 unsigned int chan = CR_CHAN(insn->chanspec);
601
602 if (insn->n) {
603 unsigned int val = data[insn->n - 1];
604
605 if (s->readback[chan] != val) {
606 cb_pcidas_dac08_write(dev, val);
607 s->readback[chan] = val;
608 }
609 }
610
611 return insn->n;
612 }
613
614 static void cb_pcidas_trimpot_write(struct comedi_device *dev,
615 unsigned int chan, unsigned int val)
616 {
617 const struct cb_pcidas_board *board = dev->board_ptr;
618
619 if (board->has_ad8402) {
620 /* write 10-bit channel/value to AD8402 trimpot */
621 cb_pcidas_calib_write(dev, (chan << 8) | val, 10, true);
622 } else {
623 /* write 7-bit value to AD7376 trimpot */
624 cb_pcidas_calib_write(dev, val, 7, true);
625 }
626 }
627
628 static int cb_pcidas_trimpot_insn_write(struct comedi_device *dev,
629 struct comedi_subdevice *s,
630 struct comedi_insn *insn,
631 unsigned int *data)
632 {
633 unsigned int chan = CR_CHAN(insn->chanspec);
634
635 if (insn->n) {
636 unsigned int val = data[insn->n - 1];
637
638 if (s->readback[chan] != val) {
639 cb_pcidas_trimpot_write(dev, chan, val);
640 s->readback[chan] = val;
641 }
642 }
643
644 return insn->n;
645 }
646
647 static int cb_pcidas_ai_check_chanlist(struct comedi_device *dev,
648 struct comedi_subdevice *s,
649 struct comedi_cmd *cmd)
650 {
651 unsigned int chan0 = CR_CHAN(cmd->chanlist[0]);
652 unsigned int range0 = CR_RANGE(cmd->chanlist[0]);
653 int i;
654
655 for (i = 1; i < cmd->chanlist_len; i++) {
656 unsigned int chan = CR_CHAN(cmd->chanlist[i]);
657 unsigned int range = CR_RANGE(cmd->chanlist[i]);
658
659 if (chan != (chan0 + i) % s->n_chan) {
660 dev_dbg(dev->class_dev,
661 "entries in chanlist must be consecutive channels, counting upwards\n");
662 return -EINVAL;
663 }
664
665 if (range != range0) {
666 dev_dbg(dev->class_dev,
667 "entries in chanlist must all have the same gain\n");
668 return -EINVAL;
669 }
670 }
671 return 0;
672 }
673
674 static int cb_pcidas_ai_cmdtest(struct comedi_device *dev,
675 struct comedi_subdevice *s,
676 struct comedi_cmd *cmd)
677 {
678 const struct cb_pcidas_board *board = dev->board_ptr;
679 int err = 0;
680 unsigned int arg;
681
682 /* Step 1 : check if triggers are trivially valid */
683
684 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
685 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
686 TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
687 err |= comedi_check_trigger_src(&cmd->convert_src,
688 TRIG_TIMER | TRIG_NOW | TRIG_EXT);
689 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
690 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
691
692 if (err)
693 return 1;
694
695 /* Step 2a : make sure trigger sources are unique */
696
697 err |= comedi_check_trigger_is_unique(cmd->start_src);
698 err |= comedi_check_trigger_is_unique(cmd->scan_begin_src);
699 err |= comedi_check_trigger_is_unique(cmd->convert_src);
700 err |= comedi_check_trigger_is_unique(cmd->stop_src);
701
702 /* Step 2b : and mutually compatible */
703
704 if (cmd->scan_begin_src == TRIG_FOLLOW && cmd->convert_src == TRIG_NOW)
705 err |= -EINVAL;
706 if (cmd->scan_begin_src != TRIG_FOLLOW && cmd->convert_src != TRIG_NOW)
707 err |= -EINVAL;
708 if (cmd->start_src == TRIG_EXT &&
709 (cmd->convert_src == TRIG_EXT || cmd->scan_begin_src == TRIG_EXT))
710 err |= -EINVAL;
711
712 if (err)
713 return 2;
714
715 /* Step 3: check if arguments are trivially valid */
716
717 switch (cmd->start_src) {
718 case TRIG_NOW:
719 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
720 break;
721 case TRIG_EXT:
722 /* External trigger, only CR_EDGE and CR_INVERT flags allowed */
723 if ((cmd->start_arg
724 & (CR_FLAGS_MASK & ~(CR_EDGE | CR_INVERT))) != 0) {
725 cmd->start_arg &= ~(CR_FLAGS_MASK &
726 ~(CR_EDGE | CR_INVERT));
727 err |= -EINVAL;
728 }
729 if (!board->is_1602 && (cmd->start_arg & CR_INVERT)) {
730 cmd->start_arg &= (CR_FLAGS_MASK & ~CR_INVERT);
731 err |= -EINVAL;
732 }
733 break;
734 }
735
736 if (cmd->scan_begin_src == TRIG_TIMER) {
737 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
738 board->ai_speed *
739 cmd->chanlist_len);
740 }
741
742 if (cmd->convert_src == TRIG_TIMER) {
743 err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
744 board->ai_speed);
745 }
746
747 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
748 cmd->chanlist_len);
749
750 if (cmd->stop_src == TRIG_COUNT)
751 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
752 else /* TRIG_NONE */
753 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
754
755 if (err)
756 return 3;
757
758 /* step 4: fix up any arguments */
759
760 if (cmd->scan_begin_src == TRIG_TIMER) {
761 arg = cmd->scan_begin_arg;
762 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
763 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
764 }
765 if (cmd->convert_src == TRIG_TIMER) {
766 arg = cmd->convert_arg;
767 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
768 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
769 }
770
771 if (err)
772 return 4;
773
774 /* Step 5: check channel list if it exists */
775 if (cmd->chanlist && cmd->chanlist_len > 0)
776 err |= cb_pcidas_ai_check_chanlist(dev, s, cmd);
777
778 if (err)
779 return 5;
780
781 return 0;
782 }
783
784 static int cb_pcidas_ai_cmd(struct comedi_device *dev,
785 struct comedi_subdevice *s)
786 {
787 const struct cb_pcidas_board *board = dev->board_ptr;
788 struct cb_pcidas_private *devpriv = dev->private;
789 struct comedi_async *async = s->async;
790 struct comedi_cmd *cmd = &async->cmd;
791 unsigned int range0 = CR_RANGE(cmd->chanlist[0]);
792 unsigned int bits;
793 unsigned long flags;
794
795 /* make sure PCIDAS_CALIB_EN is disabled */
796 outw(0, devpriv->pcibar1 + PCIDAS_CALIB_REG);
797 /* initialize before settings pacer source and count values */
798 outw(PCIDAS_TRIG_SEL_NONE, devpriv->pcibar1 + PCIDAS_TRIG_REG);
799 /* clear fifo */
800 outw(0, devpriv->pcibar2 + PCIDAS_AI_FIFO_CLR_REG);
801
802 /* set mux limits, gain and pacer source */
803 bits = PCIDAS_AI_FIRST(CR_CHAN(cmd->chanlist[0])) |
804 PCIDAS_AI_LAST(CR_CHAN(cmd->chanlist[cmd->chanlist_len - 1])) |
805 PCIDAS_AI_GAIN(range0);
806 /* set unipolar/bipolar */
807 if (comedi_range_is_unipolar(s, range0))
808 bits |= PCIDAS_AI_UNIP;
809 /* set singleended/differential */
810 if (CR_AREF(cmd->chanlist[0]) != AREF_DIFF)
811 bits |= PCIDAS_AI_SE;
812 /* set pacer source */
813 if (cmd->convert_src == TRIG_EXT || cmd->scan_begin_src == TRIG_EXT)
814 bits |= PCIDAS_AI_PACER_EXTP;
815 else
816 bits |= PCIDAS_AI_PACER_INT;
817 outw(bits, devpriv->pcibar1 + PCIDAS_AI_REG);
818
819 /* load counters */
820 if (cmd->scan_begin_src == TRIG_TIMER ||
821 cmd->convert_src == TRIG_TIMER) {
822 comedi_8254_update_divisors(dev->pacer);
823 comedi_8254_pacer_enable(dev->pacer, 1, 2, true);
824 }
825
826 /* enable interrupts */
827 spin_lock_irqsave(&dev->spinlock, flags);
828 devpriv->ctrl |= PCIDAS_CTRL_INTE;
829 devpriv->ctrl &= ~PCIDAS_CTRL_INT_MASK;
830 if (cmd->flags & CMDF_WAKE_EOS) {
831 if (cmd->convert_src == TRIG_NOW && cmd->chanlist_len > 1) {
832 /* interrupt end of burst */
833 devpriv->ctrl |= PCIDAS_CTRL_INT_EOS;
834 } else {
835 /* interrupt fifo not empty */
836 devpriv->ctrl |= PCIDAS_CTRL_INT_FNE;
837 }
838 } else {
839 /* interrupt fifo half full */
840 devpriv->ctrl |= PCIDAS_CTRL_INT_FHF;
841 }
842
843 /* enable (and clear) interrupts */
844 outw(devpriv->ctrl |
845 PCIDAS_CTRL_EOAI | PCIDAS_CTRL_INT_CLR | PCIDAS_CTRL_LADFUL,
846 devpriv->pcibar1 + PCIDAS_CTRL_REG);
847 spin_unlock_irqrestore(&dev->spinlock, flags);
848
849 /* set start trigger and burst mode */
850 bits = 0;
851 if (cmd->start_src == TRIG_NOW) {
852 bits |= PCIDAS_TRIG_SEL_SW;
853 } else { /* TRIG_EXT */
854 bits |= PCIDAS_TRIG_SEL_EXT | PCIDAS_TRIG_EN | PCIDAS_TRIG_CLR;
855 if (board->is_1602) {
856 if (cmd->start_arg & CR_INVERT)
857 bits |= PCIDAS_TRIG_POL;
858 if (cmd->start_arg & CR_EDGE)
859 bits |= PCIDAS_TRIG_MODE;
860 }
861 }
862 if (cmd->convert_src == TRIG_NOW && cmd->chanlist_len > 1)
863 bits |= PCIDAS_TRIG_BURSTE;
864 outw(bits, devpriv->pcibar1 + PCIDAS_TRIG_REG);
865
866 return 0;
867 }
868
869 static int cb_pcidas_ao_check_chanlist(struct comedi_device *dev,
870 struct comedi_subdevice *s,
871 struct comedi_cmd *cmd)
872 {
873 unsigned int chan0 = CR_CHAN(cmd->chanlist[0]);
874
875 if (cmd->chanlist_len > 1) {
876 unsigned int chan1 = CR_CHAN(cmd->chanlist[1]);
877
878 if (chan0 != 0 || chan1 != 1) {
879 dev_dbg(dev->class_dev,
880 "channels must be ordered channel 0, channel 1 in chanlist\n");
881 return -EINVAL;
882 }
883 }
884
885 return 0;
886 }
887
888 static int cb_pcidas_ao_cmdtest(struct comedi_device *dev,
889 struct comedi_subdevice *s,
890 struct comedi_cmd *cmd)
891 {
892 const struct cb_pcidas_board *board = dev->board_ptr;
893 struct cb_pcidas_private *devpriv = dev->private;
894 int err = 0;
895
896 /* Step 1 : check if triggers are trivially valid */
897
898 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_INT);
899 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
900 TRIG_TIMER | TRIG_EXT);
901 err |= comedi_check_trigger_src(&cmd->convert_src, TRIG_NOW);
902 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
903 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
904
905 if (err)
906 return 1;
907
908 /* Step 2a : make sure trigger sources are unique */
909
910 err |= comedi_check_trigger_is_unique(cmd->scan_begin_src);
911 err |= comedi_check_trigger_is_unique(cmd->stop_src);
912
913 /* Step 2b : and mutually compatible */
914
915 if (err)
916 return 2;
917
918 /* Step 3: check if arguments are trivially valid */
919
920 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
921
922 if (cmd->scan_begin_src == TRIG_TIMER) {
923 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
924 board->ao_scan_speed);
925 }
926
927 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
928 cmd->chanlist_len);
929
930 if (cmd->stop_src == TRIG_COUNT)
931 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
932 else /* TRIG_NONE */
933 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
934
935 if (err)
936 return 3;
937
938 /* step 4: fix up any arguments */
939
940 if (cmd->scan_begin_src == TRIG_TIMER) {
941 unsigned int arg = cmd->scan_begin_arg;
942
943 comedi_8254_cascade_ns_to_timer(devpriv->ao_pacer,
944 &arg, cmd->flags);
945 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
946 }
947
948 if (err)
949 return 4;
950
951 /* Step 5: check channel list if it exists */
952 if (cmd->chanlist && cmd->chanlist_len > 0)
953 err |= cb_pcidas_ao_check_chanlist(dev, s, cmd);
954
955 if (err)
956 return 5;
957
958 return 0;
959 }
960
961 static int cb_pcidas_ai_cancel(struct comedi_device *dev,
962 struct comedi_subdevice *s)
963 {
964 struct cb_pcidas_private *devpriv = dev->private;
965 unsigned long flags;
966
967 spin_lock_irqsave(&dev->spinlock, flags);
968 /* disable interrupts */
969 devpriv->ctrl &= ~(PCIDAS_CTRL_INTE | PCIDAS_CTRL_EOAIE);
970 outw(devpriv->ctrl, devpriv->pcibar1 + PCIDAS_CTRL_REG);
971 spin_unlock_irqrestore(&dev->spinlock, flags);
972
973 /* disable start trigger source and burst mode */
974 outw(PCIDAS_TRIG_SEL_NONE, devpriv->pcibar1 + PCIDAS_TRIG_REG);
975 outw(PCIDAS_AI_PACER_SW, devpriv->pcibar1 + PCIDAS_AI_REG);
976
977 return 0;
978 }
979
980 static void cb_pcidas_ao_load_fifo(struct comedi_device *dev,
981 struct comedi_subdevice *s,
982 unsigned int nsamples)
983 {
984 struct cb_pcidas_private *devpriv = dev->private;
985 unsigned int nbytes;
986
987 nsamples = comedi_nsamples_left(s, nsamples);
988 nbytes = comedi_buf_read_samples(s, devpriv->ao_buffer, nsamples);
989
990 nsamples = comedi_bytes_to_samples(s, nbytes);
991 outsw(devpriv->pcibar4 + PCIDAS_AO_FIFO_REG,
992 devpriv->ao_buffer, nsamples);
993 }
994
995 static int cb_pcidas_ao_inttrig(struct comedi_device *dev,
996 struct comedi_subdevice *s,
997 unsigned int trig_num)
998 {
999 const struct cb_pcidas_board *board = dev->board_ptr;
1000 struct cb_pcidas_private *devpriv = dev->private;
1001 struct comedi_async *async = s->async;
1002 struct comedi_cmd *cmd = &async->cmd;
1003 unsigned long flags;
1004
1005 if (trig_num != cmd->start_arg)
1006 return -EINVAL;
1007
1008 cb_pcidas_ao_load_fifo(dev, s, board->fifo_size);
1009
1010 /* enable dac half-full and empty interrupts */
1011 spin_lock_irqsave(&dev->spinlock, flags);
1012 devpriv->ctrl |= PCIDAS_CTRL_DAEMIE | PCIDAS_CTRL_DAHFIE;
1013
1014 /* enable and clear interrupts */
1015 outw(devpriv->ctrl | PCIDAS_CTRL_DAEMI | PCIDAS_CTRL_DAHFI,
1016 devpriv->pcibar1 + PCIDAS_CTRL_REG);
1017
1018 /* start dac */
1019 devpriv->ao_ctrl |= PCIDAS_AO_START | PCIDAS_AO_DACEN | PCIDAS_AO_EMPTY;
1020 outw(devpriv->ao_ctrl, devpriv->pcibar1 + PCIDAS_AO_REG);
1021
1022 spin_unlock_irqrestore(&dev->spinlock, flags);
1023
1024 async->inttrig = NULL;
1025
1026 return 0;
1027 }
1028
1029 static int cb_pcidas_ao_cmd(struct comedi_device *dev,
1030 struct comedi_subdevice *s)
1031 {
1032 struct cb_pcidas_private *devpriv = dev->private;
1033 struct comedi_async *async = s->async;
1034 struct comedi_cmd *cmd = &async->cmd;
1035 unsigned int i;
1036 unsigned long flags;
1037
1038 /* set channel limits, gain */
1039 spin_lock_irqsave(&dev->spinlock, flags);
1040 for (i = 0; i < cmd->chanlist_len; i++) {
1041 unsigned int chan = CR_CHAN(cmd->chanlist[i]);
1042 unsigned int range = CR_RANGE(cmd->chanlist[i]);
1043
1044 /* enable channel */
1045 devpriv->ao_ctrl |= PCIDAS_AO_CHAN_EN(chan);
1046 /* set range */
1047 devpriv->ao_ctrl |= PCIDAS_AO_RANGE(chan, range);
1048 }
1049
1050 /* disable analog out before settings pacer source and count values */
1051 outw(devpriv->ao_ctrl, devpriv->pcibar1 + PCIDAS_AO_REG);
1052 spin_unlock_irqrestore(&dev->spinlock, flags);
1053
1054 /* clear fifo */
1055 outw(0, devpriv->pcibar4 + PCIDAS_AO_FIFO_CLR_REG);
1056
1057 /* load counters */
1058 if (cmd->scan_begin_src == TRIG_TIMER) {
1059 comedi_8254_update_divisors(devpriv->ao_pacer);
1060 comedi_8254_pacer_enable(devpriv->ao_pacer, 1, 2, true);
1061 }
1062
1063 /* set pacer source */
1064 spin_lock_irqsave(&dev->spinlock, flags);
1065 switch (cmd->scan_begin_src) {
1066 case TRIG_TIMER:
1067 devpriv->ao_ctrl |= PCIDAS_AO_PACER_INT;
1068 break;
1069 case TRIG_EXT:
1070 devpriv->ao_ctrl |= PCIDAS_AO_PACER_EXTP;
1071 break;
1072 default:
1073 spin_unlock_irqrestore(&dev->spinlock, flags);
1074 dev_err(dev->class_dev, "error setting dac pacer source\n");
1075 return -1;
1076 }
1077 spin_unlock_irqrestore(&dev->spinlock, flags);
1078
1079 async->inttrig = cb_pcidas_ao_inttrig;
1080
1081 return 0;
1082 }
1083
1084 static int cb_pcidas_ao_cancel(struct comedi_device *dev,
1085 struct comedi_subdevice *s)
1086 {
1087 struct cb_pcidas_private *devpriv = dev->private;
1088 unsigned long flags;
1089
1090 spin_lock_irqsave(&dev->spinlock, flags);
1091 /* disable interrupts */
1092 devpriv->ctrl &= ~(PCIDAS_CTRL_DAHFIE | PCIDAS_CTRL_DAEMIE);
1093 outw(devpriv->ctrl, devpriv->pcibar1 + PCIDAS_CTRL_REG);
1094
1095 /* disable output */
1096 devpriv->ao_ctrl &= ~(PCIDAS_AO_DACEN | PCIDAS_AO_PACER_MASK);
1097 outw(devpriv->ao_ctrl, devpriv->pcibar1 + PCIDAS_AO_REG);
1098 spin_unlock_irqrestore(&dev->spinlock, flags);
1099
1100 return 0;
1101 }
1102
1103 static unsigned int cb_pcidas_ao_interrupt(struct comedi_device *dev,
1104 unsigned int status)
1105 {
1106 const struct cb_pcidas_board *board = dev->board_ptr;
1107 struct cb_pcidas_private *devpriv = dev->private;
1108 struct comedi_subdevice *s = dev->write_subdev;
1109 struct comedi_async *async = s->async;
1110 struct comedi_cmd *cmd = &async->cmd;
1111 unsigned int irq_clr = 0;
1112
1113 if (status & PCIDAS_CTRL_DAEMI) {
1114 irq_clr |= PCIDAS_CTRL_DAEMI;
1115
1116 if (inw(devpriv->pcibar4 + PCIDAS_AO_REG) & PCIDAS_AO_EMPTY) {
1117 if (cmd->stop_src == TRIG_COUNT &&
1118 async->scans_done >= cmd->stop_arg) {
1119 async->events |= COMEDI_CB_EOA;
1120 } else {
1121 dev_err(dev->class_dev, "dac fifo underflow\n");
1122 async->events |= COMEDI_CB_ERROR;
1123 }
1124 }
1125 } else if (status & PCIDAS_CTRL_DAHFI) {
1126 irq_clr |= PCIDAS_CTRL_DAHFI;
1127
1128 cb_pcidas_ao_load_fifo(dev, s, board->fifo_size / 2);
1129 }
1130
1131 comedi_handle_events(dev, s);
1132
1133 return irq_clr;
1134 }
1135
1136 static unsigned int cb_pcidas_ai_interrupt(struct comedi_device *dev,
1137 unsigned int status)
1138 {
1139 const struct cb_pcidas_board *board = dev->board_ptr;
1140 struct cb_pcidas_private *devpriv = dev->private;
1141 struct comedi_subdevice *s = dev->read_subdev;
1142 struct comedi_async *async = s->async;
1143 struct comedi_cmd *cmd = &async->cmd;
1144 unsigned int irq_clr = 0;
1145
1146 if (status & PCIDAS_CTRL_ADHFI) {
1147 unsigned int num_samples;
1148
1149 irq_clr |= PCIDAS_CTRL_INT_CLR;
1150
1151 /* FIFO is half-full - read data */
1152 num_samples = comedi_nsamples_left(s, board->fifo_size / 2);
1153 insw(devpriv->pcibar2 + PCIDAS_AI_DATA_REG,
1154 devpriv->ai_buffer, num_samples);
1155 comedi_buf_write_samples(s, devpriv->ai_buffer, num_samples);
1156
1157 if (cmd->stop_src == TRIG_COUNT &&
1158 async->scans_done >= cmd->stop_arg)
1159 async->events |= COMEDI_CB_EOA;
1160 } else if (status & (PCIDAS_CTRL_ADNEI | PCIDAS_CTRL_EOBI)) {
1161 unsigned int i;
1162
1163 irq_clr |= PCIDAS_CTRL_INT_CLR;
1164
1165 /* FIFO is not empty - read data until empty or timeoout */
1166 for (i = 0; i < 10000; i++) {
1167 unsigned short val;
1168
1169 /* break if fifo is empty */
1170 if ((inw(devpriv->pcibar1 + PCIDAS_CTRL_REG) &
1171 PCIDAS_CTRL_ADNE) == 0)
1172 break;
1173 val = inw(devpriv->pcibar2 + PCIDAS_AI_DATA_REG);
1174 comedi_buf_write_samples(s, &val, 1);
1175
1176 if (cmd->stop_src == TRIG_COUNT &&
1177 async->scans_done >= cmd->stop_arg) {
1178 async->events |= COMEDI_CB_EOA;
1179 break;
1180 }
1181 }
1182 } else if (status & PCIDAS_CTRL_EOAI) {
1183 irq_clr |= PCIDAS_CTRL_EOAI;
1184
1185 dev_err(dev->class_dev,
1186 "bug! encountered end of acquisition interrupt?\n");
1187 }
1188
1189 /* check for fifo overflow */
1190 if (status & PCIDAS_CTRL_LADFUL) {
1191 irq_clr |= PCIDAS_CTRL_LADFUL;
1192
1193 dev_err(dev->class_dev, "fifo overflow\n");
1194 async->events |= COMEDI_CB_ERROR;
1195 }
1196
1197 comedi_handle_events(dev, s);
1198
1199 return irq_clr;
1200 }
1201
1202 static irqreturn_t cb_pcidas_interrupt(int irq, void *d)
1203 {
1204 struct comedi_device *dev = d;
1205 struct cb_pcidas_private *devpriv = dev->private;
1206 unsigned int irq_clr = 0;
1207 unsigned int amcc_status;
1208 unsigned int status;
1209
1210 if (!dev->attached)
1211 return IRQ_NONE;
1212
1213 amcc_status = inl(devpriv->amcc + AMCC_OP_REG_INTCSR);
1214
1215 if ((INTCSR_INTR_ASSERTED & amcc_status) == 0)
1216 return IRQ_NONE;
1217
1218 /* make sure mailbox 4 is empty */
1219 inl_p(devpriv->amcc + AMCC_OP_REG_IMB4);
1220 /* clear interrupt on amcc s5933 */
1221 outl(devpriv->amcc_intcsr | INTCSR_INBOX_INTR_STATUS,
1222 devpriv->amcc + AMCC_OP_REG_INTCSR);
1223
1224 status = inw(devpriv->pcibar1 + PCIDAS_CTRL_REG);
1225
1226 /* handle analog output interrupts */
1227 if (status & PCIDAS_CTRL_AO_INT)
1228 irq_clr |= cb_pcidas_ao_interrupt(dev, status);
1229
1230 /* handle analog input interrupts */
1231 if (status & PCIDAS_CTRL_AI_INT)
1232 irq_clr |= cb_pcidas_ai_interrupt(dev, status);
1233
1234 if (irq_clr) {
1235 unsigned long flags;
1236
1237 spin_lock_irqsave(&dev->spinlock, flags);
1238 outw(devpriv->ctrl | irq_clr,
1239 devpriv->pcibar1 + PCIDAS_CTRL_REG);
1240 spin_unlock_irqrestore(&dev->spinlock, flags);
1241 }
1242
1243 return IRQ_HANDLED;
1244 }
1245
1246 static int cb_pcidas_auto_attach(struct comedi_device *dev,
1247 unsigned long context)
1248 {
1249 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
1250 const struct cb_pcidas_board *board = NULL;
1251 struct cb_pcidas_private *devpriv;
1252 struct comedi_subdevice *s;
1253 int i;
1254 int ret;
1255
1256 if (context < ARRAY_SIZE(cb_pcidas_boards))
1257 board = &cb_pcidas_boards[context];
1258 if (!board)
1259 return -ENODEV;
1260 dev->board_ptr = board;
1261 dev->board_name = board->name;
1262
1263 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1264 if (!devpriv)
1265 return -ENOMEM;
1266
1267 ret = comedi_pci_enable(dev);
1268 if (ret)
1269 return ret;
1270
1271 devpriv->amcc = pci_resource_start(pcidev, 0);
1272 devpriv->pcibar1 = pci_resource_start(pcidev, 1);
1273 devpriv->pcibar2 = pci_resource_start(pcidev, 2);
1274 dev->iobase = pci_resource_start(pcidev, 3);
1275 if (board->has_ao)
1276 devpriv->pcibar4 = pci_resource_start(pcidev, 4);
1277
1278 /* disable and clear interrupts on amcc s5933 */
1279 outl(INTCSR_INBOX_INTR_STATUS,
1280 devpriv->amcc + AMCC_OP_REG_INTCSR);
1281
1282 ret = request_irq(pcidev->irq, cb_pcidas_interrupt, IRQF_SHARED,
1283 "cb_pcidas", dev);
1284 if (ret) {
1285 dev_dbg(dev->class_dev, "unable to allocate irq %d\n",
1286 pcidev->irq);
1287 return ret;
1288 }
1289 dev->irq = pcidev->irq;
1290
1291 dev->pacer = comedi_8254_io_alloc(dev->iobase + PCIDAS_AI_8254_BASE,
1292 I8254_OSC_BASE_10MHZ, I8254_IO8, 0);
1293 if (IS_ERR(dev->pacer))
1294 return PTR_ERR(dev->pacer);
1295
1296 devpriv->ao_pacer =
1297 comedi_8254_io_alloc(dev->iobase + PCIDAS_AO_8254_BASE,
1298 I8254_OSC_BASE_10MHZ, I8254_IO8, 0);
1299 if (IS_ERR(devpriv->ao_pacer))
1300 return PTR_ERR(devpriv->ao_pacer);
1301
1302 ret = comedi_alloc_subdevices(dev, 7);
1303 if (ret)
1304 return ret;
1305
1306 /* Analog Input subdevice */
1307 s = &dev->subdevices[0];
1308 s->type = COMEDI_SUBD_AI;
1309 s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF;
1310 s->n_chan = 16;
1311 s->maxdata = board->is_16bit ? 0xffff : 0x0fff;
1312 s->range_table = board->use_alt_range ? &cb_pcidas_alt_ranges
1313 : &cb_pcidas_ranges;
1314 s->insn_read = cb_pcidas_ai_insn_read;
1315 s->insn_config = cb_pcidas_ai_insn_config;
1316 if (dev->irq) {
1317 dev->read_subdev = s;
1318 s->subdev_flags |= SDF_CMD_READ;
1319 s->len_chanlist = s->n_chan;
1320 s->do_cmd = cb_pcidas_ai_cmd;
1321 s->do_cmdtest = cb_pcidas_ai_cmdtest;
1322 s->cancel = cb_pcidas_ai_cancel;
1323 }
1324
1325 /* Analog Output subdevice */
1326 s = &dev->subdevices[1];
1327 if (board->has_ao) {
1328 s->type = COMEDI_SUBD_AO;
1329 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
1330 s->n_chan = 2;
1331 s->maxdata = board->is_16bit ? 0xffff : 0x0fff;
1332 s->range_table = &cb_pcidas_ao_ranges;
1333 s->insn_write = (board->has_ao_fifo)
1334 ? cb_pcidas_ao_fifo_insn_write
1335 : cb_pcidas_ao_nofifo_insn_write;
1336
1337 ret = comedi_alloc_subdev_readback(s);
1338 if (ret)
1339 return ret;
1340
1341 if (dev->irq && board->has_ao_fifo) {
1342 dev->write_subdev = s;
1343 s->subdev_flags |= SDF_CMD_WRITE;
1344 s->len_chanlist = s->n_chan;
1345 s->do_cmdtest = cb_pcidas_ao_cmdtest;
1346 s->do_cmd = cb_pcidas_ao_cmd;
1347 s->cancel = cb_pcidas_ao_cancel;
1348 }
1349 } else {
1350 s->type = COMEDI_SUBD_UNUSED;
1351 }
1352
1353 /* 8255 */
1354 s = &dev->subdevices[2];
1355 ret = subdev_8255_io_init(dev, s, PCIDAS_8255_BASE);
1356 if (ret)
1357 return ret;
1358
1359 /* Memory subdevice - serial EEPROM */
1360 s = &dev->subdevices[3];
1361 s->type = COMEDI_SUBD_MEMORY;
1362 s->subdev_flags = SDF_READABLE | SDF_INTERNAL;
1363 s->n_chan = 256;
1364 s->maxdata = 0xff;
1365 s->insn_read = cb_pcidas_eeprom_insn_read;
1366
1367 /* Calibration subdevice - 8800 caldac */
1368 s = &dev->subdevices[4];
1369 s->type = COMEDI_SUBD_CALIB;
1370 s->subdev_flags = SDF_WRITABLE | SDF_INTERNAL;
1371 s->n_chan = 8;
1372 s->maxdata = 0xff;
1373 s->insn_write = cb_pcidas_caldac_insn_write;
1374
1375 ret = comedi_alloc_subdev_readback(s);
1376 if (ret)
1377 return ret;
1378
1379 for (i = 0; i < s->n_chan; i++) {
1380 unsigned int val = s->maxdata / 2;
1381
1382 /* write 11-bit channel/value to caldac */
1383 cb_pcidas_calib_write(dev, (i << 8) | val, 11, false);
1384 s->readback[i] = val;
1385 }
1386
1387 /* Calibration subdevice - trim potentiometer */
1388 s = &dev->subdevices[5];
1389 s->type = COMEDI_SUBD_CALIB;
1390 s->subdev_flags = SDF_WRITABLE | SDF_INTERNAL;
1391 if (board->has_ad8402) {
1392 /*
1393 * pci-das1602/16 have an AD8402 trimpot:
1394 * chan 0 : adc gain
1395 * chan 1 : adc postgain offset
1396 */
1397 s->n_chan = 2;
1398 s->maxdata = 0xff;
1399 } else {
1400 /* all other boards have an AD7376 trimpot */
1401 s->n_chan = 1;
1402 s->maxdata = 0x7f;
1403 }
1404 s->insn_write = cb_pcidas_trimpot_insn_write;
1405
1406 ret = comedi_alloc_subdev_readback(s);
1407 if (ret)
1408 return ret;
1409
1410 for (i = 0; i < s->n_chan; i++) {
1411 cb_pcidas_trimpot_write(dev, i, s->maxdata / 2);
1412 s->readback[i] = s->maxdata / 2;
1413 }
1414
1415 /* Calibration subdevice - pci-das1602/16 pregain offset (dac08) */
1416 s = &dev->subdevices[6];
1417 if (board->has_dac08) {
1418 s->type = COMEDI_SUBD_CALIB;
1419 s->subdev_flags = SDF_WRITABLE | SDF_INTERNAL;
1420 s->n_chan = 1;
1421 s->maxdata = 0xff;
1422 s->insn_write = cb_pcidas_dac08_insn_write;
1423
1424 ret = comedi_alloc_subdev_readback(s);
1425 if (ret)
1426 return ret;
1427
1428 for (i = 0; i < s->n_chan; i++) {
1429 cb_pcidas_dac08_write(dev, s->maxdata / 2);
1430 s->readback[i] = s->maxdata / 2;
1431 }
1432 } else {
1433 s->type = COMEDI_SUBD_UNUSED;
1434 }
1435
1436 /* make sure mailbox 4 is empty */
1437 inl(devpriv->amcc + AMCC_OP_REG_IMB4);
1438 /* Set bits to enable incoming mailbox interrupts on amcc s5933. */
1439 devpriv->amcc_intcsr = INTCSR_INBOX_BYTE(3) | INTCSR_INBOX_SELECT(3) |
1440 INTCSR_INBOX_FULL_INT;
1441 /* clear and enable interrupt on amcc s5933 */
1442 outl(devpriv->amcc_intcsr | INTCSR_INBOX_INTR_STATUS,
1443 devpriv->amcc + AMCC_OP_REG_INTCSR);
1444
1445 return 0;
1446 }
1447
1448 static void cb_pcidas_detach(struct comedi_device *dev)
1449 {
1450 struct cb_pcidas_private *devpriv = dev->private;
1451
1452 if (devpriv) {
1453 if (devpriv->amcc)
1454 outl(INTCSR_INBOX_INTR_STATUS,
1455 devpriv->amcc + AMCC_OP_REG_INTCSR);
1456 if (!IS_ERR(devpriv->ao_pacer))
1457 kfree(devpriv->ao_pacer);
1458 }
1459 comedi_pci_detach(dev);
1460 }
1461
1462 static struct comedi_driver cb_pcidas_driver = {
1463 .driver_name = "cb_pcidas",
1464 .module = THIS_MODULE,
1465 .auto_attach = cb_pcidas_auto_attach,
1466 .detach = cb_pcidas_detach,
1467 };
1468
1469 static int cb_pcidas_pci_probe(struct pci_dev *dev,
1470 const struct pci_device_id *id)
1471 {
1472 return comedi_pci_auto_config(dev, &cb_pcidas_driver,
1473 id->driver_data);
1474 }
1475
1476 static const struct pci_device_id cb_pcidas_pci_table[] = {
1477 { PCI_VDEVICE(CB, 0x0001), BOARD_PCIDAS1602_16 },
1478 { PCI_VDEVICE(CB, 0x000f), BOARD_PCIDAS1200 },
1479 { PCI_VDEVICE(CB, 0x0010), BOARD_PCIDAS1602_12 },
1480 { PCI_VDEVICE(CB, 0x0019), BOARD_PCIDAS1200_JR },
1481 { PCI_VDEVICE(CB, 0x001c), BOARD_PCIDAS1602_16_JR },
1482 { PCI_VDEVICE(CB, 0x004c), BOARD_PCIDAS1000 },
1483 { PCI_VDEVICE(CB, 0x001a), BOARD_PCIDAS1001 },
1484 { PCI_VDEVICE(CB, 0x001b), BOARD_PCIDAS1002 },
1485 { 0 }
1486 };
1487 MODULE_DEVICE_TABLE(pci, cb_pcidas_pci_table);
1488
1489 static struct pci_driver cb_pcidas_pci_driver = {
1490 .name = "cb_pcidas",
1491 .id_table = cb_pcidas_pci_table,
1492 .probe = cb_pcidas_pci_probe,
1493 .remove = comedi_pci_auto_unconfig,
1494 };
1495 module_comedi_pci_driver(cb_pcidas_driver, cb_pcidas_pci_driver);
1496
1497 MODULE_AUTHOR("Comedi https://www.comedi.org");
1498 MODULE_DESCRIPTION("Comedi driver for MeasurementComputing PCI-DAS series");
1499 MODULE_LICENSE("GPL");
Kernel DRM miscellaneous fixes and cross-tree changes