1 /*
2 comedi/drivers/das1800.c
3 Driver for Keitley das1700/das1800 series boards
4 Copyright (C) 2000 Frank Mori Hess <fmhess@users.sourceforge.net>
5
6 COMEDI - Linux Control and Measurement Device Interface
7 Copyright (C) 2000 David A. Schleef <ds@schleef.org>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18 */
19 /*
20 Driver: das1800
21 Description: Keithley Metrabyte DAS1800 (& compatibles)
22 Author: Frank Mori Hess <fmhess@users.sourceforge.net>
23 Devices: [Keithley Metrabyte] DAS-1701ST (das-1701st),
24 DAS-1701ST-DA (das-1701st-da), DAS-1701/AO (das-1701ao),
25 DAS-1702ST (das-1702st), DAS-1702ST-DA (das-1702st-da),
26 DAS-1702HR (das-1702hr), DAS-1702HR-DA (das-1702hr-da),
27 DAS-1702/AO (das-1702ao), DAS-1801ST (das-1801st),
28 DAS-1801ST-DA (das-1801st-da), DAS-1801HC (das-1801hc),
29 DAS-1801AO (das-1801ao), DAS-1802ST (das-1802st),
30 DAS-1802ST-DA (das-1802st-da), DAS-1802HR (das-1802hr),
31 DAS-1802HR-DA (das-1802hr-da), DAS-1802HC (das-1802hc),
32 DAS-1802AO (das-1802ao)
33 Status: works
34
35 The waveform analog output on the 'ao' cards is not supported.
36 If you need it, send me (Frank Hess) an email.
37
38 Configuration options:
39 [0] - I/O port base address
40 [1] - IRQ (optional, required for timed or externally triggered conversions)
41 [2] - DMA0 (optional, requires irq)
42 [3] - DMA1 (optional, requires irq and dma0)
43 */
44 /*
45
46 This driver supports the following Keithley boards:
47
48 das-1701st
49 das-1701st-da
50 das-1701ao
51 das-1702st
52 das-1702st-da
53 das-1702hr
54 das-1702hr-da
55 das-1702ao
56 das-1801st
57 das-1801st-da
58 das-1801hc
59 das-1801ao
60 das-1802st
61 das-1802st-da
62 das-1802hr
63 das-1802hr-da
64 das-1802hc
65 das-1802ao
66
67 Options:
68 [0] - base io address
69 [1] - irq (optional, required for timed or externally triggered conversions)
70 [2] - dma0 (optional, requires irq)
71 [3] - dma1 (optional, requires irq and dma0)
72
73 irq can be omitted, although the cmd interface will not work without it.
74
75 analog input cmd triggers supported:
76 start_src: TRIG_NOW | TRIG_EXT
77 scan_begin_src: TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT
78 scan_end_src: TRIG_COUNT
79 convert_src: TRIG_TIMER | TRIG_EXT (TRIG_EXT requires scan_begin_src == TRIG_FOLLOW)
80 stop_src: TRIG_COUNT | TRIG_EXT | TRIG_NONE
81
82 scan_begin_src triggers TRIG_TIMER and TRIG_EXT use the card's
83 'burst mode' which limits the valid conversion time to 64 microseconds
84 (convert_arg <= 64000). This limitation does not apply if scan_begin_src
85 is TRIG_FOLLOW.
86
87 NOTES:
88 Only the DAS-1801ST has been tested by me.
89 Unipolar and bipolar ranges cannot be mixed in the channel/gain list.
90
91 TODO:
92 Make it automatically allocate irq and dma channels if they are not specified
93 Add support for analog out on 'ao' cards
94 read insn for analog out
95 */
96
97 #include <linux/module.h>
98 #include <linux/interrupt.h>
99 #include <linux/slab.h>
100 #include <linux/io.h>
101
102 #include "../comedidev.h"
103
104 #include "comedi_isadma.h"
105 #include "comedi_8254.h"
106
107 /* misc. defines */
108 #define DAS1800_SIZE 16 /* uses 16 io addresses */
109 #define FIFO_SIZE 1024 /* 1024 sample fifo */
110 #define UNIPOLAR 0x4 /* bit that determines whether input range is uni/bipolar */
111 #define DMA_BUF_SIZE 0x1ff00 /* size in bytes of dma buffers */
112
113 /* Registers for the das1800 */
114 #define DAS1800_FIFO 0x0
115 #define DAS1800_QRAM 0x0
116 #define DAS1800_DAC 0x0
117 #define DAS1800_SELECT 0x2
118 #define ADC 0x0
119 #define QRAM 0x1
120 #define DAC(a) (0x2 + a)
121 #define DAS1800_DIGITAL 0x3
122 #define DAS1800_CONTROL_A 0x4
123 #define FFEN 0x1
124 #define CGEN 0x4
125 #define CGSL 0x8
126 #define TGEN 0x10
127 #define TGSL 0x20
128 #define ATEN 0x80
129 #define DAS1800_CONTROL_B 0x5
130 #define DMA_CH5 0x1
131 #define DMA_CH6 0x2
132 #define DMA_CH7 0x3
133 #define DMA_CH5_CH6 0x5
134 #define DMA_CH6_CH7 0x6
135 #define DMA_CH7_CH5 0x7
136 #define DMA_ENABLED 0x3 /* mask used to determine if dma is enabled */
137 #define DMA_DUAL 0x4
138 #define IRQ3 0x8
139 #define IRQ5 0x10
140 #define IRQ7 0x18
141 #define IRQ10 0x28
142 #define IRQ11 0x30
143 #define IRQ15 0x38
144 #define FIMD 0x40
145 #define DAS1800_CONTROL_C 0X6
146 #define IPCLK 0x1
147 #define XPCLK 0x3
148 #define BMDE 0x4
149 #define CMEN 0x8
150 #define UQEN 0x10
151 #define SD 0x40
152 #define UB 0x80
153 #define DAS1800_STATUS 0x7
154 /* bits that prevent interrupt status bits (and CVEN) from being cleared on write */
155 #define CLEAR_INTR_MASK (CVEN_MASK | 0x1f)
156 #define INT 0x1
157 #define DMATC 0x2
158 #define CT0TC 0x8
159 #define OVF 0x10
160 #define FHF 0x20
161 #define FNE 0x40
162 #define CVEN_MASK 0x40 /* masks CVEN on write */
163 #define CVEN 0x80
164 #define DAS1800_BURST_LENGTH 0x8
165 #define DAS1800_BURST_RATE 0x9
166 #define DAS1800_QRAM_ADDRESS 0xa
167 #define DAS1800_COUNTER 0xc
168
169 #define IOBASE2 0x400 /* offset of additional ioports used on 'ao' cards */
170
171 enum {
172 das1701st, das1701st_da, das1702st, das1702st_da, das1702hr,
173 das1702hr_da,
174 das1701ao, das1702ao, das1801st, das1801st_da, das1802st, das1802st_da,
175 das1802hr, das1802hr_da, das1801hc, das1802hc, das1801ao, das1802ao
176 };
177
178 /* analog input ranges */
179 static const struct comedi_lrange range_ai_das1801 = {
180 8, {
181 BIP_RANGE(5),
182 BIP_RANGE(1),
183 BIP_RANGE(0.1),
184 BIP_RANGE(0.02),
185 UNI_RANGE(5),
186 UNI_RANGE(1),
187 UNI_RANGE(0.1),
188 UNI_RANGE(0.02)
189 }
190 };
191
192 static const struct comedi_lrange range_ai_das1802 = {
193 8, {
194 BIP_RANGE(10),
195 BIP_RANGE(5),
196 BIP_RANGE(2.5),
197 BIP_RANGE(1.25),
198 UNI_RANGE(10),
199 UNI_RANGE(5),
200 UNI_RANGE(2.5),
201 UNI_RANGE(1.25)
202 }
203 };
204
205 struct das1800_board {
206 const char *name;
207 int ai_speed; /* max conversion period in nanoseconds */
208 int resolution; /* bits of ai resolution */
209 int qram_len; /* length of card's channel / gain queue */
210 int common; /* supports AREF_COMMON flag */
211 int do_n_chan; /* number of digital output channels */
212 int ao_ability; /* 0 == no analog out, 1 == basic analog out, 2 == waveform analog out */
213 int ao_n_chan; /* number of analog out channels */
214 const struct comedi_lrange *range_ai; /* available input ranges */
215 };
216
217 /* Warning: the maximum conversion speeds listed below are
218 * not always achievable depending on board setup (see
219 * user manual.)
220 */
221 static const struct das1800_board das1800_boards[] = {
222 {
223 .name = "das-1701st",
224 .ai_speed = 6250,
225 .resolution = 12,
226 .qram_len = 256,
227 .common = 1,
228 .do_n_chan = 4,
229 .ao_ability = 0,
230 .ao_n_chan = 0,
231 .range_ai = &range_ai_das1801,
232 },
233 {
234 .name = "das-1701st-da",
235 .ai_speed = 6250,
236 .resolution = 12,
237 .qram_len = 256,
238 .common = 1,
239 .do_n_chan = 4,
240 .ao_ability = 1,
241 .ao_n_chan = 4,
242 .range_ai = &range_ai_das1801,
243 },
244 {
245 .name = "das-1702st",
246 .ai_speed = 6250,
247 .resolution = 12,
248 .qram_len = 256,
249 .common = 1,
250 .do_n_chan = 4,
251 .ao_ability = 0,
252 .ao_n_chan = 0,
253 .range_ai = &range_ai_das1802,
254 },
255 {
256 .name = "das-1702st-da",
257 .ai_speed = 6250,
258 .resolution = 12,
259 .qram_len = 256,
260 .common = 1,
261 .do_n_chan = 4,
262 .ao_ability = 1,
263 .ao_n_chan = 4,
264 .range_ai = &range_ai_das1802,
265 },
266 {
267 .name = "das-1702hr",
268 .ai_speed = 20000,
269 .resolution = 16,
270 .qram_len = 256,
271 .common = 1,
272 .do_n_chan = 4,
273 .ao_ability = 0,
274 .ao_n_chan = 0,
275 .range_ai = &range_ai_das1802,
276 },
277 {
278 .name = "das-1702hr-da",
279 .ai_speed = 20000,
280 .resolution = 16,
281 .qram_len = 256,
282 .common = 1,
283 .do_n_chan = 4,
284 .ao_ability = 1,
285 .ao_n_chan = 2,
286 .range_ai = &range_ai_das1802,
287 },
288 {
289 .name = "das-1701ao",
290 .ai_speed = 6250,
291 .resolution = 12,
292 .qram_len = 256,
293 .common = 1,
294 .do_n_chan = 4,
295 .ao_ability = 2,
296 .ao_n_chan = 2,
297 .range_ai = &range_ai_das1801,
298 },
299 {
300 .name = "das-1702ao",
301 .ai_speed = 6250,
302 .resolution = 12,
303 .qram_len = 256,
304 .common = 1,
305 .do_n_chan = 4,
306 .ao_ability = 2,
307 .ao_n_chan = 2,
308 .range_ai = &range_ai_das1802,
309 },
310 {
311 .name = "das-1801st",
312 .ai_speed = 3000,
313 .resolution = 12,
314 .qram_len = 256,
315 .common = 1,
316 .do_n_chan = 4,
317 .ao_ability = 0,
318 .ao_n_chan = 0,
319 .range_ai = &range_ai_das1801,
320 },
321 {
322 .name = "das-1801st-da",
323 .ai_speed = 3000,
324 .resolution = 12,
325 .qram_len = 256,
326 .common = 1,
327 .do_n_chan = 4,
328 .ao_ability = 0,
329 .ao_n_chan = 4,
330 .range_ai = &range_ai_das1801,
331 },
332 {
333 .name = "das-1802st",
334 .ai_speed = 3000,
335 .resolution = 12,
336 .qram_len = 256,
337 .common = 1,
338 .do_n_chan = 4,
339 .ao_ability = 0,
340 .ao_n_chan = 0,
341 .range_ai = &range_ai_das1802,
342 },
343 {
344 .name = "das-1802st-da",
345 .ai_speed = 3000,
346 .resolution = 12,
347 .qram_len = 256,
348 .common = 1,
349 .do_n_chan = 4,
350 .ao_ability = 1,
351 .ao_n_chan = 4,
352 .range_ai = &range_ai_das1802,
353 },
354 {
355 .name = "das-1802hr",
356 .ai_speed = 10000,
357 .resolution = 16,
358 .qram_len = 256,
359 .common = 1,
360 .do_n_chan = 4,
361 .ao_ability = 0,
362 .ao_n_chan = 0,
363 .range_ai = &range_ai_das1802,
364 },
365 {
366 .name = "das-1802hr-da",
367 .ai_speed = 10000,
368 .resolution = 16,
369 .qram_len = 256,
370 .common = 1,
371 .do_n_chan = 4,
372 .ao_ability = 1,
373 .ao_n_chan = 2,
374 .range_ai = &range_ai_das1802,
375 },
376 {
377 .name = "das-1801hc",
378 .ai_speed = 3000,
379 .resolution = 12,
380 .qram_len = 64,
381 .common = 0,
382 .do_n_chan = 8,
383 .ao_ability = 1,
384 .ao_n_chan = 2,
385 .range_ai = &range_ai_das1801,
386 },
387 {
388 .name = "das-1802hc",
389 .ai_speed = 3000,
390 .resolution = 12,
391 .qram_len = 64,
392 .common = 0,
393 .do_n_chan = 8,
394 .ao_ability = 1,
395 .ao_n_chan = 2,
396 .range_ai = &range_ai_das1802,
397 },
398 {
399 .name = "das-1801ao",
400 .ai_speed = 3000,
401 .resolution = 12,
402 .qram_len = 256,
403 .common = 1,
404 .do_n_chan = 4,
405 .ao_ability = 2,
406 .ao_n_chan = 2,
407 .range_ai = &range_ai_das1801,
408 },
409 {
410 .name = "das-1802ao",
411 .ai_speed = 3000,
412 .resolution = 12,
413 .qram_len = 256,
414 .common = 1,
415 .do_n_chan = 4,
416 .ao_ability = 2,
417 .ao_n_chan = 2,
418 .range_ai = &range_ai_das1802,
419 },
420 };
421
422 struct das1800_private {
423 struct comedi_isadma *dma;
424 int irq_dma_bits; /* bits for control register b */
425 /* dma bits for control register b, stored so that dma can be
426 * turned on and off */
427 int dma_bits;
428 uint16_t *fifo_buf; /* bounce buffer for analog input FIFO */
429 unsigned long iobase2; /* secondary io address used for analog out on 'ao' boards */
430 unsigned short ao_update_bits; /* remembers the last write to the
431 * 'update' dac */
432 };
433
434 /* analog out range for 'ao' boards */
435 /*
436 static const struct comedi_lrange range_ao_2 = {
437 2, {
438 BIP_RANGE(10),
439 BIP_RANGE(5)
440 }
441 };
442 */
443
munge_bipolar_sample(const struct comedi_device * dev,uint16_t sample)444 static inline uint16_t munge_bipolar_sample(const struct comedi_device *dev,
445 uint16_t sample)
446 {
447 const struct das1800_board *thisboard = dev->board_ptr;
448
449 sample += 1 << (thisboard->resolution - 1);
450 return sample;
451 }
452
munge_data(struct comedi_device * dev,uint16_t * array,unsigned int num_elements)453 static void munge_data(struct comedi_device *dev, uint16_t *array,
454 unsigned int num_elements)
455 {
456 unsigned int i;
457 int unipolar;
458
459 /* see if card is using a unipolar or bipolar range so we can munge data correctly */
460 unipolar = inb(dev->iobase + DAS1800_CONTROL_C) & UB;
461
462 /* convert to unsigned type if we are in a bipolar mode */
463 if (!unipolar) {
464 for (i = 0; i < num_elements; i++)
465 array[i] = munge_bipolar_sample(dev, array[i]);
466 }
467 }
468
das1800_handle_fifo_half_full(struct comedi_device * dev,struct comedi_subdevice * s)469 static void das1800_handle_fifo_half_full(struct comedi_device *dev,
470 struct comedi_subdevice *s)
471 {
472 struct das1800_private *devpriv = dev->private;
473 unsigned int nsamples = comedi_nsamples_left(s, FIFO_SIZE / 2);
474
475 insw(dev->iobase + DAS1800_FIFO, devpriv->fifo_buf, nsamples);
476 munge_data(dev, devpriv->fifo_buf, nsamples);
477 comedi_buf_write_samples(s, devpriv->fifo_buf, nsamples);
478 }
479
das1800_handle_fifo_not_empty(struct comedi_device * dev,struct comedi_subdevice * s)480 static void das1800_handle_fifo_not_empty(struct comedi_device *dev,
481 struct comedi_subdevice *s)
482 {
483 struct comedi_cmd *cmd = &s->async->cmd;
484 unsigned short dpnt;
485 int unipolar;
486
487 unipolar = inb(dev->iobase + DAS1800_CONTROL_C) & UB;
488
489 while (inb(dev->iobase + DAS1800_STATUS) & FNE) {
490 dpnt = inw(dev->iobase + DAS1800_FIFO);
491 /* convert to unsigned type */
492 dpnt = munge_bipolar_sample(dev, dpnt);
493 comedi_buf_write_samples(s, &dpnt, 1);
494
495 if (cmd->stop_src == TRIG_COUNT &&
496 s->async->scans_done >= cmd->stop_arg)
497 break;
498 }
499 }
500
501 /* Utility function used by das1800_flush_dma() and das1800_handle_dma() */
das1800_flush_dma_channel(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_isadma_desc * desc)502 static void das1800_flush_dma_channel(struct comedi_device *dev,
503 struct comedi_subdevice *s,
504 struct comedi_isadma_desc *desc)
505 {
506 unsigned int residue = comedi_isadma_disable(desc->chan);
507 unsigned int nbytes = desc->size - residue;
508 unsigned int nsamples;
509
510 /* figure out how many points to read */
511 nsamples = comedi_bytes_to_samples(s, nbytes);
512 nsamples = comedi_nsamples_left(s, nsamples);
513
514 munge_data(dev, desc->virt_addr, nsamples);
515 comedi_buf_write_samples(s, desc->virt_addr, nsamples);
516 }
517
518 /* flushes remaining data from board when external trigger has stopped acquisition
519 * and we are using dma transfers */
das1800_flush_dma(struct comedi_device * dev,struct comedi_subdevice * s)520 static void das1800_flush_dma(struct comedi_device *dev,
521 struct comedi_subdevice *s)
522 {
523 struct das1800_private *devpriv = dev->private;
524 struct comedi_isadma *dma = devpriv->dma;
525 struct comedi_isadma_desc *desc = &dma->desc[dma->cur_dma];
526 const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
527
528 das1800_flush_dma_channel(dev, s, desc);
529
530 if (dual_dma) {
531 /* switch to other channel and flush it */
532 dma->cur_dma = 1 - dma->cur_dma;
533 desc = &dma->desc[dma->cur_dma];
534 das1800_flush_dma_channel(dev, s, desc);
535 }
536
537 /* get any remaining samples in fifo */
538 das1800_handle_fifo_not_empty(dev, s);
539 }
540
das1800_handle_dma(struct comedi_device * dev,struct comedi_subdevice * s,unsigned int status)541 static void das1800_handle_dma(struct comedi_device *dev,
542 struct comedi_subdevice *s, unsigned int status)
543 {
544 struct das1800_private *devpriv = dev->private;
545 struct comedi_isadma *dma = devpriv->dma;
546 struct comedi_isadma_desc *desc = &dma->desc[dma->cur_dma];
547 const int dual_dma = devpriv->irq_dma_bits & DMA_DUAL;
548
549 das1800_flush_dma_channel(dev, s, desc);
550
551 /* re-enable dma channel */
552 comedi_isadma_program(desc);
553
554 if (status & DMATC) {
555 /* clear DMATC interrupt bit */
556 outb(CLEAR_INTR_MASK & ~DMATC, dev->iobase + DAS1800_STATUS);
557 /* switch dma channels for next time, if appropriate */
558 if (dual_dma)
559 dma->cur_dma = 1 - dma->cur_dma;
560 }
561 }
562
das1800_cancel(struct comedi_device * dev,struct comedi_subdevice * s)563 static int das1800_cancel(struct comedi_device *dev, struct comedi_subdevice *s)
564 {
565 struct das1800_private *devpriv = dev->private;
566 struct comedi_isadma *dma = devpriv->dma;
567 struct comedi_isadma_desc *desc;
568 int i;
569
570 /* disable and stop conversions */
571 outb(0x0, dev->iobase + DAS1800_STATUS);
572 outb(0x0, dev->iobase + DAS1800_CONTROL_B);
573 outb(0x0, dev->iobase + DAS1800_CONTROL_A);
574
575 if (dma) {
576 for (i = 0; i < 2; i++) {
577 desc = &dma->desc[i];
578 if (desc->chan)
579 comedi_isadma_disable(desc->chan);
580 }
581 }
582
583 return 0;
584 }
585
586 /* the guts of the interrupt handler, that is shared with das1800_ai_poll */
das1800_ai_handler(struct comedi_device * dev)587 static void das1800_ai_handler(struct comedi_device *dev)
588 {
589 struct das1800_private *devpriv = dev->private;
590 struct comedi_subdevice *s = dev->read_subdev;
591 struct comedi_async *async = s->async;
592 struct comedi_cmd *cmd = &async->cmd;
593 unsigned int status = inb(dev->iobase + DAS1800_STATUS);
594
595 /* select adc for base address + 0 */
596 outb(ADC, dev->iobase + DAS1800_SELECT);
597 /* dma buffer full */
598 if (devpriv->irq_dma_bits & DMA_ENABLED) {
599 /* look for data from dma transfer even if dma terminal count hasn't happened yet */
600 das1800_handle_dma(dev, s, status);
601 } else if (status & FHF) { /* if fifo half full */
602 das1800_handle_fifo_half_full(dev, s);
603 } else if (status & FNE) { /* if fifo not empty */
604 das1800_handle_fifo_not_empty(dev, s);
605 }
606
607 /* if the card's fifo has overflowed */
608 if (status & OVF) {
609 /* clear OVF interrupt bit */
610 outb(CLEAR_INTR_MASK & ~OVF, dev->iobase + DAS1800_STATUS);
611 dev_err(dev->class_dev, "FIFO overflow\n");
612 async->events |= COMEDI_CB_ERROR;
613 comedi_handle_events(dev, s);
614 return;
615 }
616 /* stop taking data if appropriate */
617 /* stop_src TRIG_EXT */
618 if (status & CT0TC) {
619 /* clear CT0TC interrupt bit */
620 outb(CLEAR_INTR_MASK & ~CT0TC, dev->iobase + DAS1800_STATUS);
621 /* make sure we get all remaining data from board before quitting */
622 if (devpriv->irq_dma_bits & DMA_ENABLED)
623 das1800_flush_dma(dev, s);
624 else
625 das1800_handle_fifo_not_empty(dev, s);
626 async->events |= COMEDI_CB_EOA;
627 } else if (cmd->stop_src == TRIG_COUNT &&
628 async->scans_done >= cmd->stop_arg) {
629 async->events |= COMEDI_CB_EOA;
630 }
631
632 comedi_handle_events(dev, s);
633 }
634
das1800_ai_poll(struct comedi_device * dev,struct comedi_subdevice * s)635 static int das1800_ai_poll(struct comedi_device *dev,
636 struct comedi_subdevice *s)
637 {
638 unsigned long flags;
639
640 /* prevent race with interrupt handler */
641 spin_lock_irqsave(&dev->spinlock, flags);
642 das1800_ai_handler(dev);
643 spin_unlock_irqrestore(&dev->spinlock, flags);
644
645 return comedi_buf_n_bytes_ready(s);
646 }
647
das1800_interrupt(int irq,void * d)648 static irqreturn_t das1800_interrupt(int irq, void *d)
649 {
650 struct comedi_device *dev = d;
651 unsigned int status;
652
653 if (!dev->attached) {
654 dev_err(dev->class_dev, "premature interrupt\n");
655 return IRQ_HANDLED;
656 }
657
658 /* Prevent race with das1800_ai_poll() on multi processor systems.
659 * Also protects indirect addressing in das1800_ai_handler */
660 spin_lock(&dev->spinlock);
661 status = inb(dev->iobase + DAS1800_STATUS);
662
663 /* if interrupt was not caused by das-1800 */
664 if (!(status & INT)) {
665 spin_unlock(&dev->spinlock);
666 return IRQ_NONE;
667 }
668 /* clear the interrupt status bit INT */
669 outb(CLEAR_INTR_MASK & ~INT, dev->iobase + DAS1800_STATUS);
670 /* handle interrupt */
671 das1800_ai_handler(dev);
672
673 spin_unlock(&dev->spinlock);
674 return IRQ_HANDLED;
675 }
676
677 /* converts requested conversion timing to timing compatible with
678 * hardware, used only when card is in 'burst mode'
679 */
burst_convert_arg(unsigned int convert_arg,int flags)680 static unsigned int burst_convert_arg(unsigned int convert_arg, int flags)
681 {
682 unsigned int micro_sec;
683
684 /* in burst mode, the maximum conversion time is 64 microseconds */
685 if (convert_arg > 64000)
686 convert_arg = 64000;
687
688 /* the conversion time must be an integral number of microseconds */
689 switch (flags & CMDF_ROUND_MASK) {
690 case CMDF_ROUND_NEAREST:
691 default:
692 micro_sec = (convert_arg + 500) / 1000;
693 break;
694 case CMDF_ROUND_DOWN:
695 micro_sec = convert_arg / 1000;
696 break;
697 case CMDF_ROUND_UP:
698 micro_sec = (convert_arg - 1) / 1000 + 1;
699 break;
700 }
701
702 /* return number of nanoseconds */
703 return micro_sec * 1000;
704 }
705
das1800_ai_check_chanlist(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_cmd * cmd)706 static int das1800_ai_check_chanlist(struct comedi_device *dev,
707 struct comedi_subdevice *s,
708 struct comedi_cmd *cmd)
709 {
710 unsigned int unipolar0 = CR_RANGE(cmd->chanlist[0]) & UNIPOLAR;
711 int i;
712
713 for (i = 1; i < cmd->chanlist_len; i++) {
714 unsigned int unipolar = CR_RANGE(cmd->chanlist[i]) & UNIPOLAR;
715
716 if (unipolar != unipolar0) {
717 dev_dbg(dev->class_dev,
718 "unipolar and bipolar ranges cannot be mixed in the chanlist\n");
719 return -EINVAL;
720 }
721 }
722
723 return 0;
724 }
725
726 /* test analog input cmd */
das1800_ai_do_cmdtest(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_cmd * cmd)727 static int das1800_ai_do_cmdtest(struct comedi_device *dev,
728 struct comedi_subdevice *s,
729 struct comedi_cmd *cmd)
730 {
731 const struct das1800_board *thisboard = dev->board_ptr;
732 int err = 0;
733 unsigned int arg;
734
735 /* Step 1 : check if triggers are trivially valid */
736
737 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
738 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
739 TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
740 err |= comedi_check_trigger_src(&cmd->convert_src,
741 TRIG_TIMER | TRIG_EXT);
742 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
743 err |= comedi_check_trigger_src(&cmd->stop_src,
744 TRIG_COUNT | TRIG_EXT | TRIG_NONE);
745
746 if (err)
747 return 1;
748
749 /* Step 2a : make sure trigger sources are unique */
750
751 err |= comedi_check_trigger_is_unique(cmd->start_src);
752 err |= comedi_check_trigger_is_unique(cmd->scan_begin_src);
753 err |= comedi_check_trigger_is_unique(cmd->convert_src);
754 err |= comedi_check_trigger_is_unique(cmd->stop_src);
755
756 /* Step 2b : and mutually compatible */
757
758 if (cmd->scan_begin_src != TRIG_FOLLOW &&
759 cmd->convert_src != TRIG_TIMER)
760 err |= -EINVAL;
761
762 if (err)
763 return 2;
764
765 /* Step 3: check if arguments are trivially valid */
766
767 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
768
769 if (cmd->convert_src == TRIG_TIMER) {
770 err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
771 thisboard->ai_speed);
772 }
773
774 err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
775 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
776 cmd->chanlist_len);
777
778 switch (cmd->stop_src) {
779 case TRIG_COUNT:
780 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
781 break;
782 case TRIG_NONE:
783 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
784 break;
785 default:
786 break;
787 }
788
789 if (err)
790 return 3;
791
792 /* step 4: fix up any arguments */
793
794 if (cmd->scan_begin_src == TRIG_FOLLOW &&
795 cmd->convert_src == TRIG_TIMER) {
796 /* we are not in burst mode */
797 arg = cmd->convert_arg;
798 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
799 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
800 } else if (cmd->convert_src == TRIG_TIMER) {
801 /* we are in burst mode */
802 arg = burst_convert_arg(cmd->convert_arg, cmd->flags);
803 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
804
805 if (cmd->scan_begin_src == TRIG_TIMER) {
806 arg = cmd->convert_arg * cmd->chanlist_len;
807 err |= comedi_check_trigger_arg_max(&cmd->
808 scan_begin_arg,
809 arg);
810
811 arg = cmd->scan_begin_arg;
812 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg,
813 cmd->flags);
814 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg,
815 arg);
816 }
817 }
818
819 if (err)
820 return 4;
821
822 /* Step 5: check channel list if it exists */
823 if (cmd->chanlist && cmd->chanlist_len > 0)
824 err |= das1800_ai_check_chanlist(dev, s, cmd);
825
826 if (err)
827 return 5;
828
829 return 0;
830 }
831
832 /* returns appropriate bits for control register a, depending on command */
control_a_bits(const struct comedi_cmd * cmd)833 static int control_a_bits(const struct comedi_cmd *cmd)
834 {
835 int control_a;
836
837 control_a = FFEN; /* enable fifo */
838 if (cmd->stop_src == TRIG_EXT)
839 control_a |= ATEN;
840 switch (cmd->start_src) {
841 case TRIG_EXT:
842 control_a |= TGEN | CGSL;
843 break;
844 case TRIG_NOW:
845 control_a |= CGEN;
846 break;
847 default:
848 break;
849 }
850
851 return control_a;
852 }
853
854 /* returns appropriate bits for control register c, depending on command */
control_c_bits(const struct comedi_cmd * cmd)855 static int control_c_bits(const struct comedi_cmd *cmd)
856 {
857 int control_c;
858 int aref;
859
860 /* set clock source to internal or external, select analog reference,
861 * select unipolar / bipolar
862 */
863 aref = CR_AREF(cmd->chanlist[0]);
864 control_c = UQEN; /* enable upper qram addresses */
865 if (aref != AREF_DIFF)
866 control_c |= SD;
867 if (aref == AREF_COMMON)
868 control_c |= CMEN;
869 /* if a unipolar range was selected */
870 if (CR_RANGE(cmd->chanlist[0]) & UNIPOLAR)
871 control_c |= UB;
872 switch (cmd->scan_begin_src) {
873 case TRIG_FOLLOW: /* not in burst mode */
874 switch (cmd->convert_src) {
875 case TRIG_TIMER:
876 /* trig on cascaded counters */
877 control_c |= IPCLK;
878 break;
879 case TRIG_EXT:
880 /* trig on falling edge of external trigger */
881 control_c |= XPCLK;
882 break;
883 default:
884 break;
885 }
886 break;
887 case TRIG_TIMER:
888 /* burst mode with internal pacer clock */
889 control_c |= BMDE | IPCLK;
890 break;
891 case TRIG_EXT:
892 /* burst mode with external trigger */
893 control_c |= BMDE | XPCLK;
894 break;
895 default:
896 break;
897 }
898
899 return control_c;
900 }
901
das1800_ai_transfer_size(struct comedi_device * dev,struct comedi_subdevice * s,unsigned int maxbytes,unsigned int ns)902 static unsigned int das1800_ai_transfer_size(struct comedi_device *dev,
903 struct comedi_subdevice *s,
904 unsigned int maxbytes,
905 unsigned int ns)
906 {
907 struct comedi_cmd *cmd = &s->async->cmd;
908 unsigned int max_samples = comedi_bytes_to_samples(s, maxbytes);
909 unsigned int samples;
910
911 samples = max_samples;
912
913 /* for timed modes, make dma buffer fill in 'ns' time */
914 switch (cmd->scan_begin_src) {
915 case TRIG_FOLLOW: /* not in burst mode */
916 if (cmd->convert_src == TRIG_TIMER)
917 samples = ns / cmd->convert_arg;
918 break;
919 case TRIG_TIMER:
920 samples = ns / (cmd->scan_begin_arg * cmd->chanlist_len);
921 break;
922 }
923
924 /* limit samples to what is remaining in the command */
925 samples = comedi_nsamples_left(s, samples);
926
927 if (samples > max_samples)
928 samples = max_samples;
929 if (samples < 1)
930 samples = 1;
931
932 return comedi_samples_to_bytes(s, samples);
933 }
934
das1800_ai_setup_dma(struct comedi_device * dev,struct comedi_subdevice * s)935 static void das1800_ai_setup_dma(struct comedi_device *dev,
936 struct comedi_subdevice *s)
937 {
938 struct das1800_private *devpriv = dev->private;
939 struct comedi_isadma *dma = devpriv->dma;
940 struct comedi_isadma_desc *desc;
941 unsigned int bytes;
942
943 if ((devpriv->irq_dma_bits & DMA_ENABLED) == 0)
944 return;
945
946 dma->cur_dma = 0;
947 desc = &dma->desc[0];
948
949 /* determine a dma transfer size to fill buffer in 0.3 sec */
950 bytes = das1800_ai_transfer_size(dev, s, desc->maxsize, 300000000);
951
952 desc->size = bytes;
953 comedi_isadma_program(desc);
954
955 /* set up dual dma if appropriate */
956 if (devpriv->irq_dma_bits & DMA_DUAL) {
957 desc = &dma->desc[1];
958 desc->size = bytes;
959 comedi_isadma_program(desc);
960 }
961 }
962
963 /* programs channel/gain list into card */
program_chanlist(struct comedi_device * dev,const struct comedi_cmd * cmd)964 static void program_chanlist(struct comedi_device *dev,
965 const struct comedi_cmd *cmd)
966 {
967 int i, n, chan_range;
968 unsigned long irq_flags;
969 const int range_mask = 0x3; /* masks unipolar/bipolar bit off range */
970 const int range_bitshift = 8;
971
972 n = cmd->chanlist_len;
973 /* spinlock protects indirect addressing */
974 spin_lock_irqsave(&dev->spinlock, irq_flags);
975 outb(QRAM, dev->iobase + DAS1800_SELECT); /* select QRAM for baseAddress + 0x0 */
976 outb(n - 1, dev->iobase + DAS1800_QRAM_ADDRESS); /*set QRAM address start */
977 /* make channel / gain list */
978 for (i = 0; i < n; i++) {
979 chan_range =
980 CR_CHAN(cmd->chanlist[i]) |
981 ((CR_RANGE(cmd->chanlist[i]) & range_mask) <<
982 range_bitshift);
983 outw(chan_range, dev->iobase + DAS1800_QRAM);
984 }
985 outb(n - 1, dev->iobase + DAS1800_QRAM_ADDRESS); /*finish write to QRAM */
986 spin_unlock_irqrestore(&dev->spinlock, irq_flags);
987 }
988
989 /* analog input do_cmd */
das1800_ai_do_cmd(struct comedi_device * dev,struct comedi_subdevice * s)990 static int das1800_ai_do_cmd(struct comedi_device *dev,
991 struct comedi_subdevice *s)
992 {
993 struct das1800_private *devpriv = dev->private;
994 int control_a, control_c;
995 struct comedi_async *async = s->async;
996 const struct comedi_cmd *cmd = &async->cmd;
997
998 /* disable dma on CMDF_WAKE_EOS, or CMDF_PRIORITY
999 * (because dma in handler is unsafe at hard real-time priority) */
1000 if (cmd->flags & (CMDF_WAKE_EOS | CMDF_PRIORITY))
1001 devpriv->irq_dma_bits &= ~DMA_ENABLED;
1002 else
1003 devpriv->irq_dma_bits |= devpriv->dma_bits;
1004 /* interrupt on end of conversion for CMDF_WAKE_EOS */
1005 if (cmd->flags & CMDF_WAKE_EOS) {
1006 /* interrupt fifo not empty */
1007 devpriv->irq_dma_bits &= ~FIMD;
1008 } else {
1009 /* interrupt fifo half full */
1010 devpriv->irq_dma_bits |= FIMD;
1011 }
1012
1013 das1800_cancel(dev, s);
1014
1015 /* determine proper bits for control registers */
1016 control_a = control_a_bits(cmd);
1017 control_c = control_c_bits(cmd);
1018
1019 /* setup card and start */
1020 program_chanlist(dev, cmd);
1021
1022 /* setup cascaded counters for conversion/scan frequency */
1023 if ((cmd->scan_begin_src == TRIG_FOLLOW ||
1024 cmd->scan_begin_src == TRIG_TIMER) &&
1025 cmd->convert_src == TRIG_TIMER) {
1026 comedi_8254_update_divisors(dev->pacer);
1027 comedi_8254_pacer_enable(dev->pacer, 1, 2, true);
1028 }
1029
1030 /* setup counter 0 for 'about triggering' */
1031 if (cmd->stop_src == TRIG_EXT)
1032 comedi_8254_load(dev->pacer, 0, 1, I8254_MODE0 | I8254_BINARY);
1033
1034 das1800_ai_setup_dma(dev, s);
1035 outb(control_c, dev->iobase + DAS1800_CONTROL_C);
1036 /* set conversion rate and length for burst mode */
1037 if (control_c & BMDE) {
1038 /* program conversion period with number of microseconds minus 1 */
1039 outb(cmd->convert_arg / 1000 - 1,
1040 dev->iobase + DAS1800_BURST_RATE);
1041 outb(cmd->chanlist_len - 1, dev->iobase + DAS1800_BURST_LENGTH);
1042 }
1043 outb(devpriv->irq_dma_bits, dev->iobase + DAS1800_CONTROL_B); /* enable irq/dma */
1044 outb(control_a, dev->iobase + DAS1800_CONTROL_A); /* enable fifo and triggering */
1045 outb(CVEN, dev->iobase + DAS1800_STATUS); /* enable conversions */
1046
1047 return 0;
1048 }
1049
1050 /* read analog input */
das1800_ai_rinsn(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_insn * insn,unsigned int * data)1051 static int das1800_ai_rinsn(struct comedi_device *dev,
1052 struct comedi_subdevice *s,
1053 struct comedi_insn *insn, unsigned int *data)
1054 {
1055 const struct das1800_board *thisboard = dev->board_ptr;
1056 int i, n;
1057 int chan, range, aref, chan_range;
1058 int timeout = 1000;
1059 unsigned short dpnt;
1060 int conv_flags = 0;
1061 unsigned long irq_flags;
1062
1063 /* set up analog reference and unipolar / bipolar mode */
1064 aref = CR_AREF(insn->chanspec);
1065 conv_flags |= UQEN;
1066 if (aref != AREF_DIFF)
1067 conv_flags |= SD;
1068 if (aref == AREF_COMMON)
1069 conv_flags |= CMEN;
1070 /* if a unipolar range was selected */
1071 if (CR_RANGE(insn->chanspec) & UNIPOLAR)
1072 conv_flags |= UB;
1073
1074 outb(conv_flags, dev->iobase + DAS1800_CONTROL_C); /* software conversion enabled */
1075 outb(CVEN, dev->iobase + DAS1800_STATUS); /* enable conversions */
1076 outb(0x0, dev->iobase + DAS1800_CONTROL_A); /* reset fifo */
1077 outb(FFEN, dev->iobase + DAS1800_CONTROL_A);
1078
1079 chan = CR_CHAN(insn->chanspec);
1080 /* mask of unipolar/bipolar bit from range */
1081 range = CR_RANGE(insn->chanspec) & 0x3;
1082 chan_range = chan | (range << 8);
1083 spin_lock_irqsave(&dev->spinlock, irq_flags);
1084 outb(QRAM, dev->iobase + DAS1800_SELECT); /* select QRAM for baseAddress + 0x0 */
1085 outb(0x0, dev->iobase + DAS1800_QRAM_ADDRESS); /* set QRAM address start */
1086 outw(chan_range, dev->iobase + DAS1800_QRAM);
1087 outb(0x0, dev->iobase + DAS1800_QRAM_ADDRESS); /*finish write to QRAM */
1088 outb(ADC, dev->iobase + DAS1800_SELECT); /* select ADC for baseAddress + 0x0 */
1089
1090 for (n = 0; n < insn->n; n++) {
1091 /* trigger conversion */
1092 outb(0, dev->iobase + DAS1800_FIFO);
1093 for (i = 0; i < timeout; i++) {
1094 if (inb(dev->iobase + DAS1800_STATUS) & FNE)
1095 break;
1096 }
1097 if (i == timeout) {
1098 dev_err(dev->class_dev, "timeout\n");
1099 n = -ETIME;
1100 goto exit;
1101 }
1102 dpnt = inw(dev->iobase + DAS1800_FIFO);
1103 /* shift data to offset binary for bipolar ranges */
1104 if ((conv_flags & UB) == 0)
1105 dpnt += 1 << (thisboard->resolution - 1);
1106 data[n] = dpnt;
1107 }
1108 exit:
1109 spin_unlock_irqrestore(&dev->spinlock, irq_flags);
1110
1111 return n;
1112 }
1113
1114 /* writes to an analog output channel */
das1800_ao_winsn(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_insn * insn,unsigned int * data)1115 static int das1800_ao_winsn(struct comedi_device *dev,
1116 struct comedi_subdevice *s,
1117 struct comedi_insn *insn, unsigned int *data)
1118 {
1119 const struct das1800_board *thisboard = dev->board_ptr;
1120 struct das1800_private *devpriv = dev->private;
1121 int chan = CR_CHAN(insn->chanspec);
1122 /* int range = CR_RANGE(insn->chanspec); */
1123 int update_chan = thisboard->ao_n_chan - 1;
1124 unsigned short output;
1125 unsigned long irq_flags;
1126
1127 /* card expects two's complement data */
1128 output = data[0] - (1 << (thisboard->resolution - 1));
1129 /* if the write is to the 'update' channel, we need to remember its value */
1130 if (chan == update_chan)
1131 devpriv->ao_update_bits = output;
1132 /* write to channel */
1133 spin_lock_irqsave(&dev->spinlock, irq_flags);
1134 outb(DAC(chan), dev->iobase + DAS1800_SELECT); /* select dac channel for baseAddress + 0x0 */
1135 outw(output, dev->iobase + DAS1800_DAC);
1136 /* now we need to write to 'update' channel to update all dac channels */
1137 if (chan != update_chan) {
1138 outb(DAC(update_chan), dev->iobase + DAS1800_SELECT); /* select 'update' channel for baseAddress + 0x0 */
1139 outw(devpriv->ao_update_bits, dev->iobase + DAS1800_DAC);
1140 }
1141 spin_unlock_irqrestore(&dev->spinlock, irq_flags);
1142
1143 return 1;
1144 }
1145
1146 /* reads from digital input channels */
das1800_di_rbits(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_insn * insn,unsigned int * data)1147 static int das1800_di_rbits(struct comedi_device *dev,
1148 struct comedi_subdevice *s,
1149 struct comedi_insn *insn, unsigned int *data)
1150 {
1151 data[1] = inb(dev->iobase + DAS1800_DIGITAL) & 0xf;
1152 data[0] = 0;
1153
1154 return insn->n;
1155 }
1156
das1800_do_wbits(struct comedi_device * dev,struct comedi_subdevice * s,struct comedi_insn * insn,unsigned int * data)1157 static int das1800_do_wbits(struct comedi_device *dev,
1158 struct comedi_subdevice *s,
1159 struct comedi_insn *insn,
1160 unsigned int *data)
1161 {
1162 if (comedi_dio_update_state(s, data))
1163 outb(s->state, dev->iobase + DAS1800_DIGITAL);
1164
1165 data[1] = s->state;
1166
1167 return insn->n;
1168 }
1169
das1800_init_dma(struct comedi_device * dev,struct comedi_devconfig * it)1170 static void das1800_init_dma(struct comedi_device *dev,
1171 struct comedi_devconfig *it)
1172 {
1173 struct das1800_private *devpriv = dev->private;
1174 unsigned int *dma_chan;
1175
1176 /*
1177 * it->options[2] is DMA channel 0
1178 * it->options[3] is DMA channel 1
1179 *
1180 * Encode the DMA channels into 2 digit hexadecimal for switch.
1181 */
1182 dma_chan = &it->options[2];
1183
1184 switch ((dma_chan[0] & 0x7) | (dma_chan[1] << 4)) {
1185 case 0x5: /* dma0 == 5 */
1186 devpriv->dma_bits = DMA_CH5;
1187 break;
1188 case 0x6: /* dma0 == 6 */
1189 devpriv->dma_bits = DMA_CH6;
1190 break;
1191 case 0x7: /* dma0 == 7 */
1192 devpriv->dma_bits = DMA_CH7;
1193 break;
1194 case 0x65: /* dma0 == 5, dma1 == 6 */
1195 devpriv->dma_bits = DMA_CH5_CH6;
1196 break;
1197 case 0x76: /* dma0 == 6, dma1 == 7 */
1198 devpriv->dma_bits = DMA_CH6_CH7;
1199 break;
1200 case 0x57: /* dma0 == 7, dma1 == 5 */
1201 devpriv->dma_bits = DMA_CH7_CH5;
1202 break;
1203 default:
1204 return;
1205 }
1206
1207 /* DMA can use 1 or 2 buffers, each with a separate channel */
1208 devpriv->dma = comedi_isadma_alloc(dev, dma_chan[1] ? 2 : 1,
1209 dma_chan[0], dma_chan[1],
1210 DMA_BUF_SIZE, COMEDI_ISADMA_READ);
1211 if (!devpriv->dma)
1212 devpriv->dma_bits = 0;
1213 }
1214
das1800_free_dma(struct comedi_device * dev)1215 static void das1800_free_dma(struct comedi_device *dev)
1216 {
1217 struct das1800_private *devpriv = dev->private;
1218
1219 if (devpriv)
1220 comedi_isadma_free(devpriv->dma);
1221 }
1222
das1800_probe(struct comedi_device * dev)1223 static int das1800_probe(struct comedi_device *dev)
1224 {
1225 const struct das1800_board *board = dev->board_ptr;
1226 int index;
1227 int id;
1228
1229 /* calc the offset to the boardinfo that was found by the core */
1230 index = board - das1800_boards;
1231
1232 /* verify that the board id matches the boardinfo */
1233 id = (inb(dev->iobase + DAS1800_DIGITAL) >> 4) & 0xf;
1234 switch (id) {
1235 case 0x3:
1236 if (index == das1801st_da || index == das1802st_da ||
1237 index == das1701st_da || index == das1702st_da)
1238 return index;
1239 index = das1801st;
1240 break;
1241 case 0x4:
1242 if (index == das1802hr_da || index == das1702hr_da)
1243 return index;
1244 index = das1802hr;
1245 break;
1246 case 0x5:
1247 if (index == das1801ao || index == das1802ao ||
1248 index == das1701ao || index == das1702ao)
1249 return index;
1250 index = das1801ao;
1251 break;
1252 case 0x6:
1253 if (index == das1802hr || index == das1702hr)
1254 return index;
1255 index = das1802hr;
1256 break;
1257 case 0x7:
1258 if (index == das1801st || index == das1802st ||
1259 index == das1701st || index == das1702st)
1260 return index;
1261 index = das1801st;
1262 break;
1263 case 0x8:
1264 if (index == das1801hc || index == das1802hc)
1265 return index;
1266 index = das1801hc;
1267 break;
1268 default:
1269 dev_err(dev->class_dev,
1270 "Board model: probe returned 0x%x (unknown, please report)\n",
1271 id);
1272 break;
1273 }
1274 dev_err(dev->class_dev,
1275 "Board model (probed, not recommended): %s series\n",
1276 das1800_boards[index].name);
1277
1278 return index;
1279 }
1280
das1800_attach(struct comedi_device * dev,struct comedi_devconfig * it)1281 static int das1800_attach(struct comedi_device *dev,
1282 struct comedi_devconfig *it)
1283 {
1284 const struct das1800_board *thisboard;
1285 struct das1800_private *devpriv;
1286 struct comedi_subdevice *s;
1287 unsigned int irq = it->options[1];
1288 int board;
1289 int ret;
1290
1291 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1292 if (!devpriv)
1293 return -ENOMEM;
1294
1295 ret = comedi_request_region(dev, it->options[0], DAS1800_SIZE);
1296 if (ret)
1297 return ret;
1298
1299 board = das1800_probe(dev);
1300 if (board < 0) {
1301 dev_err(dev->class_dev, "unable to determine board type\n");
1302 return -ENODEV;
1303 }
1304
1305 dev->board_ptr = das1800_boards + board;
1306 thisboard = dev->board_ptr;
1307 dev->board_name = thisboard->name;
1308
1309 /* if it is an 'ao' board with fancy analog out then we need extra io ports */
1310 if (thisboard->ao_ability == 2) {
1311 unsigned long iobase2 = dev->iobase + IOBASE2;
1312
1313 ret = __comedi_request_region(dev, iobase2, DAS1800_SIZE);
1314 if (ret)
1315 return ret;
1316 devpriv->iobase2 = iobase2;
1317 }
1318
1319 if (irq == 3 || irq == 5 || irq == 7 || irq == 10 || irq == 11 ||
1320 irq == 15) {
1321 ret = request_irq(irq, das1800_interrupt, 0,
1322 dev->board_name, dev);
1323 if (ret == 0) {
1324 dev->irq = irq;
1325
1326 switch (irq) {
1327 case 3:
1328 devpriv->irq_dma_bits |= 0x8;
1329 break;
1330 case 5:
1331 devpriv->irq_dma_bits |= 0x10;
1332 break;
1333 case 7:
1334 devpriv->irq_dma_bits |= 0x18;
1335 break;
1336 case 10:
1337 devpriv->irq_dma_bits |= 0x28;
1338 break;
1339 case 11:
1340 devpriv->irq_dma_bits |= 0x30;
1341 break;
1342 case 15:
1343 devpriv->irq_dma_bits |= 0x38;
1344 break;
1345 }
1346 }
1347 }
1348
1349 /* an irq and one dma channel is required to use dma */
1350 if (dev->irq & it->options[2])
1351 das1800_init_dma(dev, it);
1352
1353 devpriv->fifo_buf = kmalloc_array(FIFO_SIZE, sizeof(uint16_t), GFP_KERNEL);
1354 if (!devpriv->fifo_buf)
1355 return -ENOMEM;
1356
1357 dev->pacer = comedi_8254_init(dev->iobase + DAS1800_COUNTER,
1358 I8254_OSC_BASE_5MHZ, I8254_IO8, 0);
1359 if (!dev->pacer)
1360 return -ENOMEM;
1361
1362 ret = comedi_alloc_subdevices(dev, 4);
1363 if (ret)
1364 return ret;
1365
1366 /* analog input subdevice */
1367 s = &dev->subdevices[0];
1368 s->type = COMEDI_SUBD_AI;
1369 s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_GROUND;
1370 if (thisboard->common)
1371 s->subdev_flags |= SDF_COMMON;
1372 s->n_chan = thisboard->qram_len;
1373 s->maxdata = (1 << thisboard->resolution) - 1;
1374 s->range_table = thisboard->range_ai;
1375 s->insn_read = das1800_ai_rinsn;
1376 if (dev->irq) {
1377 dev->read_subdev = s;
1378 s->subdev_flags |= SDF_CMD_READ;
1379 s->len_chanlist = s->n_chan;
1380 s->do_cmd = das1800_ai_do_cmd;
1381 s->do_cmdtest = das1800_ai_do_cmdtest;
1382 s->poll = das1800_ai_poll;
1383 s->cancel = das1800_cancel;
1384 }
1385
1386 /* analog out */
1387 s = &dev->subdevices[1];
1388 if (thisboard->ao_ability == 1) {
1389 s->type = COMEDI_SUBD_AO;
1390 s->subdev_flags = SDF_WRITABLE;
1391 s->n_chan = thisboard->ao_n_chan;
1392 s->maxdata = (1 << thisboard->resolution) - 1;
1393 s->range_table = &range_bipolar10;
1394 s->insn_write = das1800_ao_winsn;
1395 } else {
1396 s->type = COMEDI_SUBD_UNUSED;
1397 }
1398
1399 /* di */
1400 s = &dev->subdevices[2];
1401 s->type = COMEDI_SUBD_DI;
1402 s->subdev_flags = SDF_READABLE;
1403 s->n_chan = 4;
1404 s->maxdata = 1;
1405 s->range_table = &range_digital;
1406 s->insn_bits = das1800_di_rbits;
1407
1408 /* do */
1409 s = &dev->subdevices[3];
1410 s->type = COMEDI_SUBD_DO;
1411 s->subdev_flags = SDF_WRITABLE;
1412 s->n_chan = thisboard->do_n_chan;
1413 s->maxdata = 1;
1414 s->range_table = &range_digital;
1415 s->insn_bits = das1800_do_wbits;
1416
1417 das1800_cancel(dev, dev->read_subdev);
1418
1419 /* initialize digital out channels */
1420 outb(0, dev->iobase + DAS1800_DIGITAL);
1421
1422 /* initialize analog out channels */
1423 if (thisboard->ao_ability == 1) {
1424 /* select 'update' dac channel for baseAddress + 0x0 */
1425 outb(DAC(thisboard->ao_n_chan - 1),
1426 dev->iobase + DAS1800_SELECT);
1427 outw(devpriv->ao_update_bits, dev->iobase + DAS1800_DAC);
1428 }
1429
1430 return 0;
1431 };
1432
das1800_detach(struct comedi_device * dev)1433 static void das1800_detach(struct comedi_device *dev)
1434 {
1435 struct das1800_private *devpriv = dev->private;
1436
1437 das1800_free_dma(dev);
1438 if (devpriv) {
1439 kfree(devpriv->fifo_buf);
1440 if (devpriv->iobase2)
1441 release_region(devpriv->iobase2, DAS1800_SIZE);
1442 }
1443 comedi_legacy_detach(dev);
1444 }
1445
1446 static struct comedi_driver das1800_driver = {
1447 .driver_name = "das1800",
1448 .module = THIS_MODULE,
1449 .attach = das1800_attach,
1450 .detach = das1800_detach,
1451 .num_names = ARRAY_SIZE(das1800_boards),
1452 .board_name = &das1800_boards[0].name,
1453 .offset = sizeof(struct das1800_board),
1454 };
1455 module_comedi_driver(das1800_driver);
1456
1457 MODULE_AUTHOR("Comedi http://www.comedi.org");
1458 MODULE_DESCRIPTION("Comedi low-level driver");
1459 MODULE_LICENSE("GPL");
1460