projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
staging: comedi: comedi_test: rename waveform members
[deliverable/linux.git] / drivers / staging / comedi / drivers / das1800.c
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
444 static inline uint16_t munge_bipolar_sample(const struct comedi_device *dev,
445 uint16_t sample)
446 {
447 const struct das1800_board *board = dev->board_ptr;
448
449 sample += 1 << (board->resolution - 1);
450 return sample;
451 }
452
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
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
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() */
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 */
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
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
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 outb(0x0, dev->iobase + DAS1800_STATUS); /* disable conversions */
571 outb(0x0, dev->iobase + DAS1800_CONTROL_B); /* disable interrupts and dma */
572 outb(0x0, dev->iobase + DAS1800_CONTROL_A); /* disable and clear fifo and stop triggering */
573
574 for (i = 0; i < 2; i++) {
575 desc = &dma->desc[i];
576 if (desc->chan)
577 comedi_isadma_disable(desc->chan);
578 }
579
580 return 0;
581 }
582
583 /* the guts of the interrupt handler, that is shared with das1800_ai_poll */
584 static void das1800_ai_handler(struct comedi_device *dev)
585 {
586 struct das1800_private *devpriv = dev->private;
587 struct comedi_subdevice *s = dev->read_subdev;
588 struct comedi_async *async = s->async;
589 struct comedi_cmd *cmd = &async->cmd;
590 unsigned int status = inb(dev->iobase + DAS1800_STATUS);
591
592 /* select adc for base address + 0 */
593 outb(ADC, dev->iobase + DAS1800_SELECT);
594 /* dma buffer full */
595 if (devpriv->irq_dma_bits & DMA_ENABLED) {
596 /* look for data from dma transfer even if dma terminal count hasn't happened yet */
597 das1800_handle_dma(dev, s, status);
598 } else if (status & FHF) { /* if fifo half full */
599 das1800_handle_fifo_half_full(dev, s);
600 } else if (status & FNE) { /* if fifo not empty */
601 das1800_handle_fifo_not_empty(dev, s);
602 }
603
604 /* if the card's fifo has overflowed */
605 if (status & OVF) {
606 /* clear OVF interrupt bit */
607 outb(CLEAR_INTR_MASK & ~OVF, dev->iobase + DAS1800_STATUS);
608 dev_err(dev->class_dev, "FIFO overflow\n");
609 async->events |= COMEDI_CB_ERROR;
610 comedi_handle_events(dev, s);
611 return;
612 }
613 /* stop taking data if appropriate */
614 /* stop_src TRIG_EXT */
615 if (status & CT0TC) {
616 /* clear CT0TC interrupt bit */
617 outb(CLEAR_INTR_MASK & ~CT0TC, dev->iobase + DAS1800_STATUS);
618 /* make sure we get all remaining data from board before quitting */
619 if (devpriv->irq_dma_bits & DMA_ENABLED)
620 das1800_flush_dma(dev, s);
621 else
622 das1800_handle_fifo_not_empty(dev, s);
623 async->events |= COMEDI_CB_EOA;
624 } else if (cmd->stop_src == TRIG_COUNT &&
625 async->scans_done >= cmd->stop_arg) {
626 async->events |= COMEDI_CB_EOA;
627 }
628
629 comedi_handle_events(dev, s);
630 }
631
632 static int das1800_ai_poll(struct comedi_device *dev,
633 struct comedi_subdevice *s)
634 {
635 unsigned long flags;
636
637 /* prevent race with interrupt handler */
638 spin_lock_irqsave(&dev->spinlock, flags);
639 das1800_ai_handler(dev);
640 spin_unlock_irqrestore(&dev->spinlock, flags);
641
642 return comedi_buf_n_bytes_ready(s);
643 }
644
645 static irqreturn_t das1800_interrupt(int irq, void *d)
646 {
647 struct comedi_device *dev = d;
648 unsigned int status;
649
650 if (!dev->attached) {
651 dev_err(dev->class_dev, "premature interrupt\n");
652 return IRQ_HANDLED;
653 }
654
655 /* Prevent race with das1800_ai_poll() on multi processor systems.
656 * Also protects indirect addressing in das1800_ai_handler */
657 spin_lock(&dev->spinlock);
658 status = inb(dev->iobase + DAS1800_STATUS);
659
660 /* if interrupt was not caused by das-1800 */
661 if (!(status & INT)) {
662 spin_unlock(&dev->spinlock);
663 return IRQ_NONE;
664 }
665 /* clear the interrupt status bit INT */
666 outb(CLEAR_INTR_MASK & ~INT, dev->iobase + DAS1800_STATUS);
667 /* handle interrupt */
668 das1800_ai_handler(dev);
669
670 spin_unlock(&dev->spinlock);
671 return IRQ_HANDLED;
672 }
673
674 /* converts requested conversion timing to timing compatible with
675 * hardware, used only when card is in 'burst mode'
676 */
677 static unsigned int burst_convert_arg(unsigned int convert_arg, int flags)
678 {
679 unsigned int micro_sec;
680
681 /* in burst mode, the maximum conversion time is 64 microseconds */
682 if (convert_arg > 64000)
683 convert_arg = 64000;
684
685 /* the conversion time must be an integral number of microseconds */
686 switch (flags & CMDF_ROUND_MASK) {
687 case CMDF_ROUND_NEAREST:
688 default:
689 micro_sec = (convert_arg + 500) / 1000;
690 break;
691 case CMDF_ROUND_DOWN:
692 micro_sec = convert_arg / 1000;
693 break;
694 case CMDF_ROUND_UP:
695 micro_sec = (convert_arg - 1) / 1000 + 1;
696 break;
697 }
698
699 /* return number of nanoseconds */
700 return micro_sec * 1000;
701 }
702
703 static int das1800_ai_check_chanlist(struct comedi_device *dev,
704 struct comedi_subdevice *s,
705 struct comedi_cmd *cmd)
706 {
707 unsigned int unipolar0 = CR_RANGE(cmd->chanlist[0]) & UNIPOLAR;
708 int i;
709
710 for (i = 1; i < cmd->chanlist_len; i++) {
711 unsigned int unipolar = CR_RANGE(cmd->chanlist[i]) & UNIPOLAR;
712
713 if (unipolar != unipolar0) {
714 dev_dbg(dev->class_dev,
715 "unipolar and bipolar ranges cannot be mixed in the chanlist\n");
716 return -EINVAL;
717 }
718 }
719
720 return 0;
721 }
722
723 /* test analog input cmd */
724 static int das1800_ai_do_cmdtest(struct comedi_device *dev,
725 struct comedi_subdevice *s,
726 struct comedi_cmd *cmd)
727 {
728 const struct das1800_board *board = dev->board_ptr;
729 int err = 0;
730 unsigned int arg;
731
732 /* Step 1 : check if triggers are trivially valid */
733
734 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW | TRIG_EXT);
735 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
736 TRIG_FOLLOW | TRIG_TIMER | TRIG_EXT);
737 err |= comedi_check_trigger_src(&cmd->convert_src,
738 TRIG_TIMER | TRIG_EXT);
739 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
740 err |= comedi_check_trigger_src(&cmd->stop_src,
741 TRIG_COUNT | TRIG_EXT | TRIG_NONE);
742
743 if (err)
744 return 1;
745
746 /* Step 2a : make sure trigger sources are unique */
747
748 err |= comedi_check_trigger_is_unique(cmd->start_src);
749 err |= comedi_check_trigger_is_unique(cmd->scan_begin_src);
750 err |= comedi_check_trigger_is_unique(cmd->convert_src);
751 err |= comedi_check_trigger_is_unique(cmd->stop_src);
752
753 /* Step 2b : and mutually compatible */
754
755 if (cmd->scan_begin_src != TRIG_FOLLOW &&
756 cmd->convert_src != TRIG_TIMER)
757 err |= -EINVAL;
758
759 if (err)
760 return 2;
761
762 /* Step 3: check if arguments are trivially valid */
763
764 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
765
766 if (cmd->convert_src == TRIG_TIMER) {
767 err |= comedi_check_trigger_arg_min(&cmd->convert_arg,
768 board->ai_speed);
769 }
770
771 err |= comedi_check_trigger_arg_min(&cmd->chanlist_len, 1);
772 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
773 cmd->chanlist_len);
774
775 switch (cmd->stop_src) {
776 case TRIG_COUNT:
777 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
778 break;
779 case TRIG_NONE:
780 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
781 break;
782 default:
783 break;
784 }
785
786 if (err)
787 return 3;
788
789 /* step 4: fix up any arguments */
790
791 if (cmd->scan_begin_src == TRIG_FOLLOW &&
792 cmd->convert_src == TRIG_TIMER) {
793 /* we are not in burst mode */
794 arg = cmd->convert_arg;
795 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
796 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
797 } else if (cmd->convert_src == TRIG_TIMER) {
798 /* we are in burst mode */
799 arg = burst_convert_arg(cmd->convert_arg, cmd->flags);
800 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, arg);
801
802 if (cmd->scan_begin_src == TRIG_TIMER) {
803 arg = cmd->convert_arg * cmd->chanlist_len;
804 err |= comedi_check_trigger_arg_max(&cmd->
805 scan_begin_arg,
806 arg);
807
808 arg = cmd->scan_begin_arg;
809 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg,
810 cmd->flags);
811 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg,
812 arg);
813 }
814 }
815
816 if (err)
817 return 4;
818
819 /* Step 5: check channel list if it exists */
820 if (cmd->chanlist && cmd->chanlist_len > 0)
821 err |= das1800_ai_check_chanlist(dev, s, cmd);
822
823 if (err)
824 return 5;
825
826 return 0;
827 }
828
829 /* returns appropriate bits for control register a, depending on command */
830 static int control_a_bits(const struct comedi_cmd *cmd)
831 {
832 int control_a;
833
834 control_a = FFEN; /* enable fifo */
835 if (cmd->stop_src == TRIG_EXT)
836 control_a |= ATEN;
837 switch (cmd->start_src) {
838 case TRIG_EXT:
839 control_a |= TGEN | CGSL;
840 break;
841 case TRIG_NOW:
842 control_a |= CGEN;
843 break;
844 default:
845 break;
846 }
847
848 return control_a;
849 }
850
851 /* returns appropriate bits for control register c, depending on command */
852 static int control_c_bits(const struct comedi_cmd *cmd)
853 {
854 int control_c;
855 int aref;
856
857 /* set clock source to internal or external, select analog reference,
858 * select unipolar / bipolar
859 */
860 aref = CR_AREF(cmd->chanlist[0]);
861 control_c = UQEN; /* enable upper qram addresses */
862 if (aref != AREF_DIFF)
863 control_c |= SD;
864 if (aref == AREF_COMMON)
865 control_c |= CMEN;
866 /* if a unipolar range was selected */
867 if (CR_RANGE(cmd->chanlist[0]) & UNIPOLAR)
868 control_c |= UB;
869 switch (cmd->scan_begin_src) {
870 case TRIG_FOLLOW: /* not in burst mode */
871 switch (cmd->convert_src) {
872 case TRIG_TIMER:
873 /* trig on cascaded counters */
874 control_c |= IPCLK;
875 break;
876 case TRIG_EXT:
877 /* trig on falling edge of external trigger */
878 control_c |= XPCLK;
879 break;
880 default:
881 break;
882 }
883 break;
884 case TRIG_TIMER:
885 /* burst mode with internal pacer clock */
886 control_c |= BMDE | IPCLK;
887 break;
888 case TRIG_EXT:
889 /* burst mode with external trigger */
890 control_c |= BMDE | XPCLK;
891 break;
892 default:
893 break;
894 }
895
896 return control_c;
897 }
898
899 static unsigned int das1800_ai_transfer_size(struct comedi_device *dev,
900 struct comedi_subdevice *s,
901 unsigned int maxbytes,
902 unsigned int ns)
903 {
904 struct comedi_cmd *cmd = &s->async->cmd;
905 unsigned int max_samples = comedi_bytes_to_samples(s, maxbytes);
906 unsigned int samples;
907
908 samples = max_samples;
909
910 /* for timed modes, make dma buffer fill in 'ns' time */
911 switch (cmd->scan_begin_src) {
912 case TRIG_FOLLOW: /* not in burst mode */
913 if (cmd->convert_src == TRIG_TIMER)
914 samples = ns / cmd->convert_arg;
915 break;
916 case TRIG_TIMER:
917 samples = ns / (cmd->scan_begin_arg * cmd->chanlist_len);
918 break;
919 }
920
921 /* limit samples to what is remaining in the command */
922 samples = comedi_nsamples_left(s, samples);
923
924 if (samples > max_samples)
925 samples = max_samples;
926 if (samples < 1)
927 samples = 1;
928
929 return comedi_samples_to_bytes(s, samples);
930 }
931
932 static void das1800_ai_setup_dma(struct comedi_device *dev,
933 struct comedi_subdevice *s)
934 {
935 struct das1800_private *devpriv = dev->private;
936 struct comedi_isadma *dma = devpriv->dma;
937 struct comedi_isadma_desc *desc = &dma->desc[0];
938 unsigned int bytes;
939
940 if ((devpriv->irq_dma_bits & DMA_ENABLED) == 0)
941 return;
942
943 dma->cur_dma = 0;
944
945 /* determine a dma transfer size to fill buffer in 0.3 sec */
946 bytes = das1800_ai_transfer_size(dev, s, desc->maxsize, 300000000);
947
948 desc->size = bytes;
949 comedi_isadma_program(desc);
950
951 /* set up dual dma if appropriate */
952 if (devpriv->irq_dma_bits & DMA_DUAL) {
953 desc = &dma->desc[1];
954 desc->size = bytes;
955 comedi_isadma_program(desc);
956 }
957 }
958
959 /* programs channel/gain list into card */
960 static void program_chanlist(struct comedi_device *dev,
961 const struct comedi_cmd *cmd)
962 {
963 int i, n, chan_range;
964 unsigned long irq_flags;
965 const int range_mask = 0x3; /* masks unipolar/bipolar bit off range */
966 const int range_bitshift = 8;
967
968 n = cmd->chanlist_len;
969 /* spinlock protects indirect addressing */
970 spin_lock_irqsave(&dev->spinlock, irq_flags);
971 outb(QRAM, dev->iobase + DAS1800_SELECT); /* select QRAM for baseAddress + 0x0 */
972 outb(n - 1, dev->iobase + DAS1800_QRAM_ADDRESS); /*set QRAM address start */
973 /* make channel / gain list */
974 for (i = 0; i < n; i++) {
975 chan_range =
976 CR_CHAN(cmd->chanlist[i]) |
977 ((CR_RANGE(cmd->chanlist[i]) & range_mask) <<
978 range_bitshift);
979 outw(chan_range, dev->iobase + DAS1800_QRAM);
980 }
981 outb(n - 1, dev->iobase + DAS1800_QRAM_ADDRESS); /*finish write to QRAM */
982 spin_unlock_irqrestore(&dev->spinlock, irq_flags);
983 }
984
985 /* analog input do_cmd */
986 static int das1800_ai_do_cmd(struct comedi_device *dev,
987 struct comedi_subdevice *s)
988 {
989 struct das1800_private *devpriv = dev->private;
990 int control_a, control_c;
991 struct comedi_async *async = s->async;
992 const struct comedi_cmd *cmd = &async->cmd;
993
994 /* disable dma on CMDF_WAKE_EOS, or CMDF_PRIORITY
995 * (because dma in handler is unsafe at hard real-time priority) */
996 if (cmd->flags & (CMDF_WAKE_EOS | CMDF_PRIORITY))
997 devpriv->irq_dma_bits &= ~DMA_ENABLED;
998 else
999 devpriv->irq_dma_bits |= devpriv->dma_bits;
1000 /* interrupt on end of conversion for CMDF_WAKE_EOS */
1001 if (cmd->flags & CMDF_WAKE_EOS) {
1002 /* interrupt fifo not empty */
1003 devpriv->irq_dma_bits &= ~FIMD;
1004 } else {
1005 /* interrupt fifo half full */
1006 devpriv->irq_dma_bits |= FIMD;
1007 }
1008
1009 das1800_cancel(dev, s);
1010
1011 /* determine proper bits for control registers */
1012 control_a = control_a_bits(cmd);
1013 control_c = control_c_bits(cmd);
1014
1015 /* setup card and start */
1016 program_chanlist(dev, cmd);
1017
1018 /* setup cascaded counters for conversion/scan frequency */
1019 if ((cmd->scan_begin_src == TRIG_FOLLOW ||
1020 cmd->scan_begin_src == TRIG_TIMER) &&
1021 cmd->convert_src == TRIG_TIMER) {
1022 comedi_8254_update_divisors(dev->pacer);
1023 comedi_8254_pacer_enable(dev->pacer, 1, 2, true);
1024 }
1025
1026 /* setup counter 0 for 'about triggering' */
1027 if (cmd->stop_src == TRIG_EXT)
1028 comedi_8254_load(dev->pacer, 0, 1, I8254_MODE0 | I8254_BINARY);
1029
1030 das1800_ai_setup_dma(dev, s);
1031 outb(control_c, dev->iobase + DAS1800_CONTROL_C);
1032 /* set conversion rate and length for burst mode */
1033 if (control_c & BMDE) {
1034 /* program conversion period with number of microseconds minus 1 */
1035 outb(cmd->convert_arg / 1000 - 1,
1036 dev->iobase + DAS1800_BURST_RATE);
1037 outb(cmd->chanlist_len - 1, dev->iobase + DAS1800_BURST_LENGTH);
1038 }
1039 outb(devpriv->irq_dma_bits, dev->iobase + DAS1800_CONTROL_B); /* enable irq/dma */
1040 outb(control_a, dev->iobase + DAS1800_CONTROL_A); /* enable fifo and triggering */
1041 outb(CVEN, dev->iobase + DAS1800_STATUS); /* enable conversions */
1042
1043 return 0;
1044 }
1045
1046 /* read analog input */
1047 static int das1800_ai_rinsn(struct comedi_device *dev,
1048 struct comedi_subdevice *s,
1049 struct comedi_insn *insn, unsigned int *data)
1050 {
1051 const struct das1800_board *board = dev->board_ptr;
1052 int i, n;
1053 int chan, range, aref, chan_range;
1054 int timeout = 1000;
1055 unsigned short dpnt;
1056 int conv_flags = 0;
1057 unsigned long irq_flags;
1058
1059 /* set up analog reference and unipolar / bipolar mode */
1060 aref = CR_AREF(insn->chanspec);
1061 conv_flags |= UQEN;
1062 if (aref != AREF_DIFF)
1063 conv_flags |= SD;
1064 if (aref == AREF_COMMON)
1065 conv_flags |= CMEN;
1066 /* if a unipolar range was selected */
1067 if (CR_RANGE(insn->chanspec) & UNIPOLAR)
1068 conv_flags |= UB;
1069
1070 outb(conv_flags, dev->iobase + DAS1800_CONTROL_C); /* software conversion enabled */
1071 outb(CVEN, dev->iobase + DAS1800_STATUS); /* enable conversions */
1072 outb(0x0, dev->iobase + DAS1800_CONTROL_A); /* reset fifo */
1073 outb(FFEN, dev->iobase + DAS1800_CONTROL_A);
1074
1075 chan = CR_CHAN(insn->chanspec);
1076 /* mask of unipolar/bipolar bit from range */
1077 range = CR_RANGE(insn->chanspec) & 0x3;
1078 chan_range = chan | (range << 8);
1079 spin_lock_irqsave(&dev->spinlock, irq_flags);
1080 outb(QRAM, dev->iobase + DAS1800_SELECT); /* select QRAM for baseAddress + 0x0 */
1081 outb(0x0, dev->iobase + DAS1800_QRAM_ADDRESS); /* set QRAM address start */
1082 outw(chan_range, dev->iobase + DAS1800_QRAM);
1083 outb(0x0, dev->iobase + DAS1800_QRAM_ADDRESS); /*finish write to QRAM */
1084 outb(ADC, dev->iobase + DAS1800_SELECT); /* select ADC for baseAddress + 0x0 */
1085
1086 for (n = 0; n < insn->n; n++) {
1087 /* trigger conversion */
1088 outb(0, dev->iobase + DAS1800_FIFO);
1089 for (i = 0; i < timeout; i++) {
1090 if (inb(dev->iobase + DAS1800_STATUS) & FNE)
1091 break;
1092 }
1093 if (i == timeout) {
1094 dev_err(dev->class_dev, "timeout\n");
1095 n = -ETIME;
1096 goto exit;
1097 }
1098 dpnt = inw(dev->iobase + DAS1800_FIFO);
1099 /* shift data to offset binary for bipolar ranges */
1100 if ((conv_flags & UB) == 0)
1101 dpnt += 1 << (board->resolution - 1);
1102 data[n] = dpnt;
1103 }
1104 exit:
1105 spin_unlock_irqrestore(&dev->spinlock, irq_flags);
1106
1107 return n;
1108 }
1109
1110 /* writes to an analog output channel */
1111 static int das1800_ao_winsn(struct comedi_device *dev,
1112 struct comedi_subdevice *s,
1113 struct comedi_insn *insn, unsigned int *data)
1114 {
1115 const struct das1800_board *board = dev->board_ptr;
1116 struct das1800_private *devpriv = dev->private;
1117 int chan = CR_CHAN(insn->chanspec);
1118 /* int range = CR_RANGE(insn->chanspec); */
1119 int update_chan = board->ao_n_chan - 1;
1120 unsigned short output;
1121 unsigned long irq_flags;
1122
1123 /* card expects two's complement data */
1124 output = data[0] - (1 << (board->resolution - 1));
1125 /* if the write is to the 'update' channel, we need to remember its value */
1126 if (chan == update_chan)
1127 devpriv->ao_update_bits = output;
1128 /* write to channel */
1129 spin_lock_irqsave(&dev->spinlock, irq_flags);
1130 outb(DAC(chan), dev->iobase + DAS1800_SELECT); /* select dac channel for baseAddress + 0x0 */
1131 outw(output, dev->iobase + DAS1800_DAC);
1132 /* now we need to write to 'update' channel to update all dac channels */
1133 if (chan != update_chan) {
1134 outb(DAC(update_chan), dev->iobase + DAS1800_SELECT); /* select 'update' channel for baseAddress + 0x0 */
1135 outw(devpriv->ao_update_bits, dev->iobase + DAS1800_DAC);
1136 }
1137 spin_unlock_irqrestore(&dev->spinlock, irq_flags);
1138
1139 return 1;
1140 }
1141
1142 /* reads from digital input channels */
1143 static int das1800_di_rbits(struct comedi_device *dev,
1144 struct comedi_subdevice *s,
1145 struct comedi_insn *insn, unsigned int *data)
1146 {
1147 data[1] = inb(dev->iobase + DAS1800_DIGITAL) & 0xf;
1148 data[0] = 0;
1149
1150 return insn->n;
1151 }
1152
1153 static int das1800_do_wbits(struct comedi_device *dev,
1154 struct comedi_subdevice *s,
1155 struct comedi_insn *insn,
1156 unsigned int *data)
1157 {
1158 if (comedi_dio_update_state(s, data))
1159 outb(s->state, dev->iobase + DAS1800_DIGITAL);
1160
1161 data[1] = s->state;
1162
1163 return insn->n;
1164 }
1165
1166 static void das1800_init_dma(struct comedi_device *dev,
1167 struct comedi_devconfig *it)
1168 {
1169 struct das1800_private *devpriv = dev->private;
1170 unsigned int *dma_chan;
1171
1172 /*
1173 * it->options[2] is DMA channel 0
1174 * it->options[3] is DMA channel 1
1175 *
1176 * Encode the DMA channels into 2 digit hexadecimal for switch.
1177 */
1178 dma_chan = &it->options[2];
1179
1180 switch ((dma_chan[0] & 0x7) | (dma_chan[1] << 4)) {
1181 case 0x5: /* dma0 == 5 */
1182 devpriv->dma_bits = DMA_CH5;
1183 break;
1184 case 0x6: /* dma0 == 6 */
1185 devpriv->dma_bits = DMA_CH6;
1186 break;
1187 case 0x7: /* dma0 == 7 */
1188 devpriv->dma_bits = DMA_CH7;
1189 break;
1190 case 0x65: /* dma0 == 5, dma1 == 6 */
1191 devpriv->dma_bits = DMA_CH5_CH6;
1192 break;
1193 case 0x76: /* dma0 == 6, dma1 == 7 */
1194 devpriv->dma_bits = DMA_CH6_CH7;
1195 break;
1196 case 0x57: /* dma0 == 7, dma1 == 5 */
1197 devpriv->dma_bits = DMA_CH7_CH5;
1198 break;
1199 default:
1200 return;
1201 }
1202
1203 /* DMA can use 1 or 2 buffers, each with a separate channel */
1204 devpriv->dma = comedi_isadma_alloc(dev, dma_chan[1] ? 2 : 1,
1205 dma_chan[0], dma_chan[1],
1206 DMA_BUF_SIZE, COMEDI_ISADMA_READ);
1207 if (!devpriv->dma)
1208 devpriv->dma_bits = 0;
1209 }
1210
1211 static void das1800_free_dma(struct comedi_device *dev)
1212 {
1213 struct das1800_private *devpriv = dev->private;
1214
1215 if (devpriv)
1216 comedi_isadma_free(devpriv->dma);
1217 }
1218
1219 static const struct das1800_board *das1800_probe(struct comedi_device *dev)
1220 {
1221 const struct das1800_board *board = dev->board_ptr;
1222 int index = board ? board - das1800_boards : -EINVAL;
1223 int id;
1224
1225 /*
1226 * The dev->board_ptr will be set by comedi_device_attach() if the
1227 * board name provided by the user matches a board->name in this
1228 * driver. If so, this function sanity checks the id to verify that
1229 * the board is correct.
1230 *
1231 * If the dev->board_ptr is not set, the user is trying to attach
1232 * an unspecified board to this driver. In this case the id is used
1233 * to 'probe' for the correct dev->board_ptr.
1234 */
1235 id = (inb(dev->iobase + DAS1800_DIGITAL) >> 4) & 0xf;
1236 switch (id) {
1237 case 0x3:
1238 if (index == das1801st_da || index == das1802st_da ||
1239 index == das1701st_da || index == das1702st_da)
1240 return board;
1241 index = das1801st;
1242 break;
1243 case 0x4:
1244 if (index == das1802hr_da || index == das1702hr_da)
1245 return board;
1246 index = das1802hr;
1247 break;
1248 case 0x5:
1249 if (index == das1801ao || index == das1802ao ||
1250 index == das1701ao || index == das1702ao)
1251 return board;
1252 index = das1801ao;
1253 break;
1254 case 0x6:
1255 if (index == das1802hr || index == das1702hr)
1256 return board;
1257 index = das1802hr;
1258 break;
1259 case 0x7:
1260 if (index == das1801st || index == das1802st ||
1261 index == das1701st || index == das1702st)
1262 return board;
1263 index = das1801st;
1264 break;
1265 case 0x8:
1266 if (index == das1801hc || index == das1802hc)
1267 return board;
1268 index = das1801hc;
1269 break;
1270 default:
1271 dev_err(dev->class_dev,
1272 "Board model: probe returned 0x%x (unknown, please report)\n",
1273 id);
1274 return NULL;
1275 }
1276 dev_err(dev->class_dev,
1277 "Board model (probed, not recommended): %s series\n",
1278 das1800_boards[index].name);
1279
1280 return &das1800_boards[index];
1281 }
1282
1283 static int das1800_attach(struct comedi_device *dev,
1284 struct comedi_devconfig *it)
1285 {
1286 const struct das1800_board *board;
1287 struct das1800_private *devpriv;
1288 struct comedi_subdevice *s;
1289 unsigned int irq = it->options[1];
1290 int ret;
1291
1292 devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
1293 if (!devpriv)
1294 return -ENOMEM;
1295
1296 ret = comedi_request_region(dev, it->options[0], DAS1800_SIZE);
1297 if (ret)
1298 return ret;
1299
1300 board = das1800_probe(dev);
1301 if (!board) {
1302 dev_err(dev->class_dev, "unable to determine board type\n");
1303 return -ENODEV;
1304 }
1305 dev->board_ptr = board;
1306 dev->board_name = board->name;
1307
1308 /* if it is an 'ao' board with fancy analog out then we need extra io ports */
1309 if (board->ao_ability == 2) {
1310 unsigned long iobase2 = dev->iobase + IOBASE2;
1311
1312 ret = __comedi_request_region(dev, iobase2, DAS1800_SIZE);
1313 if (ret)
1314 return ret;
1315 devpriv->iobase2 = iobase2;
1316 }
1317
1318 if (irq == 3 || irq == 5 || irq == 7 || irq == 10 || irq == 11 ||
1319 irq == 15) {
1320 ret = request_irq(irq, das1800_interrupt, 0,
1321 dev->board_name, dev);
1322 if (ret == 0) {
1323 dev->irq = irq;
1324
1325 switch (irq) {
1326 case 3:
1327 devpriv->irq_dma_bits |= 0x8;
1328 break;
1329 case 5:
1330 devpriv->irq_dma_bits |= 0x10;
1331 break;
1332 case 7:
1333 devpriv->irq_dma_bits |= 0x18;
1334 break;
1335 case 10:
1336 devpriv->irq_dma_bits |= 0x28;
1337 break;
1338 case 11:
1339 devpriv->irq_dma_bits |= 0x30;
1340 break;
1341 case 15:
1342 devpriv->irq_dma_bits |= 0x38;
1343 break;
1344 }
1345 }
1346 }
1347
1348 /* an irq and one dma channel is required to use dma */
1349 if (dev->irq & it->options[2])
1350 das1800_init_dma(dev, it);
1351
1352 devpriv->fifo_buf = kmalloc_array(FIFO_SIZE, sizeof(uint16_t), GFP_KERNEL);
1353 if (!devpriv->fifo_buf)
1354 return -ENOMEM;
1355
1356 dev->pacer = comedi_8254_init(dev->iobase + DAS1800_COUNTER,
1357 I8254_OSC_BASE_5MHZ, I8254_IO8, 0);
1358 if (!dev->pacer)
1359 return -ENOMEM;
1360
1361 ret = comedi_alloc_subdevices(dev, 4);
1362 if (ret)
1363 return ret;
1364
1365 /* analog input subdevice */
1366 s = &dev->subdevices[0];
1367 s->type = COMEDI_SUBD_AI;
1368 s->subdev_flags = SDF_READABLE | SDF_DIFF | SDF_GROUND;
1369 if (board->common)
1370 s->subdev_flags |= SDF_COMMON;
1371 s->n_chan = board->qram_len;
1372 s->maxdata = (1 << board->resolution) - 1;
1373 s->range_table = board->range_ai;
1374 s->insn_read = das1800_ai_rinsn;
1375 if (dev->irq) {
1376 dev->read_subdev = s;
1377 s->subdev_flags |= SDF_CMD_READ;
1378 s->len_chanlist = s->n_chan;
1379 s->do_cmd = das1800_ai_do_cmd;
1380 s->do_cmdtest = das1800_ai_do_cmdtest;
1381 s->poll = das1800_ai_poll;
1382 s->cancel = das1800_cancel;
1383 }
1384
1385 /* analog out */
1386 s = &dev->subdevices[1];
1387 if (board->ao_ability == 1) {
1388 s->type = COMEDI_SUBD_AO;
1389 s->subdev_flags = SDF_WRITABLE;
1390 s->n_chan = board->ao_n_chan;
1391 s->maxdata = (1 << board->resolution) - 1;
1392 s->range_table = &range_bipolar10;
1393 s->insn_write = das1800_ao_winsn;
1394 } else {
1395 s->type = COMEDI_SUBD_UNUSED;
1396 }
1397
1398 /* di */
1399 s = &dev->subdevices[2];
1400 s->type = COMEDI_SUBD_DI;
1401 s->subdev_flags = SDF_READABLE;
1402 s->n_chan = 4;
1403 s->maxdata = 1;
1404 s->range_table = &range_digital;
1405 s->insn_bits = das1800_di_rbits;
1406
1407 /* do */
1408 s = &dev->subdevices[3];
1409 s->type = COMEDI_SUBD_DO;
1410 s->subdev_flags = SDF_WRITABLE;
1411 s->n_chan = board->do_n_chan;
1412 s->maxdata = 1;
1413 s->range_table = &range_digital;
1414 s->insn_bits = das1800_do_wbits;
1415
1416 das1800_cancel(dev, dev->read_subdev);
1417
1418 /* initialize digital out channels */
1419 outb(0, dev->iobase + DAS1800_DIGITAL);
1420
1421 /* initialize analog out channels */
1422 if (board->ao_ability == 1) {
1423 /* select 'update' dac channel for baseAddress + 0x0 */
1424 outb(DAC(board->ao_n_chan - 1),
1425 dev->iobase + DAS1800_SELECT);
1426 outw(devpriv->ao_update_bits, dev->iobase + DAS1800_DAC);
1427 }
1428
1429 return 0;
1430 };
1431
1432 static void das1800_detach(struct comedi_device *dev)
1433 {
1434 struct das1800_private *devpriv = dev->private;
1435
1436 das1800_free_dma(dev);
1437 if (devpriv) {
1438 kfree(devpriv->fifo_buf);
1439 if (devpriv->iobase2)
1440 release_region(devpriv->iobase2, DAS1800_SIZE);
1441 }
1442 comedi_legacy_detach(dev);
1443 }
1444
1445 static struct comedi_driver das1800_driver = {
1446 .driver_name = "das1800",
1447 .module = THIS_MODULE,
1448 .attach = das1800_attach,
1449 .detach = das1800_detach,
1450 .num_names = ARRAY_SIZE(das1800_boards),
1451 .board_name = &das1800_boards[0].name,
1452 .offset = sizeof(struct das1800_board),
1453 };
1454 module_comedi_driver(das1800_driver);
1455
1456 MODULE_AUTHOR("Comedi http://www.comedi.org");
1457 MODULE_DESCRIPTION("Comedi low-level driver");
1458 MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.111527 seconds and 5 git commands to generate.