]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/staging/comedi/drivers/pcl816.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[mirror_ubuntu-bionic-kernel.git] / drivers / staging / comedi / drivers / pcl816.c
1 /*
2 comedi/drivers/pcl816.c
3
4 Author: Juan Grigera <juan@grigera.com.ar>
5 based on pcl818 by Michal Dobes <dobes@tesnet.cz> and bits of pcl812
6
7 hardware driver for Advantech cards:
8 card: PCL-816, PCL814B
9 driver: pcl816
10 */
11 /*
12 Driver: pcl816
13 Description: Advantech PCL-816 cards, PCL-814
14 Author: Juan Grigera <juan@grigera.com.ar>
15 Devices: [Advantech] PCL-816 (pcl816), PCL-814B (pcl814b)
16 Status: works
17 Updated: Tue, 2 Apr 2002 23:15:21 -0800
18
19 PCL 816 and 814B have 16 SE/DIFF ADCs, 16 DACs, 16 DI and 16 DO.
20 Differences are at resolution (16 vs 12 bits).
21
22 The driver support AI command mode, other subdevices not written.
23
24 Analog output and digital input and output are not supported.
25
26 Configuration Options:
27 [0] - IO Base
28 [1] - IRQ (0=disable, 2, 3, 4, 5, 6, 7)
29 [2] - DMA (0=disable, 1, 3)
30 [3] - 0, 10=10MHz clock for 8254
31 1= 1MHz clock for 8254
32
33 */
34
35 #include "../comedidev.h"
36
37 #include <linux/ioport.h>
38 #include <linux/mc146818rtc.h>
39 #include <linux/gfp.h>
40 #include <linux/delay.h>
41 #include <asm/dma.h>
42
43 #include "8253.h"
44
45 #define DEBUG(x) x
46
47 /* boards constants */
48 /* IO space len */
49 #define PCLx1x_RANGE 16
50
51 /* #define outb(x,y) printk("OUTB(%x, 200+%d)\n", x,y-0x200); outb(x,y) */
52
53 /* INTEL 8254 counters */
54 #define PCL816_CTR0 4
55 #define PCL816_CTR1 5
56 #define PCL816_CTR2 6
57 /* R: counter read-back register W: counter control */
58 #define PCL816_CTRCTL 7
59
60 /* R: A/D high byte W: A/D range control */
61 #define PCL816_RANGE 9
62 /* W: clear INT request */
63 #define PCL816_CLRINT 10
64 /* R: next mux scan channel W: mux scan channel & range control pointer */
65 #define PCL816_MUX 11
66 /* R/W: operation control register */
67 #define PCL816_CONTROL 12
68
69 /* R: return status byte W: set DMA/IRQ */
70 #define PCL816_STATUS 13
71 #define PCL816_STATUS_DRDY_MASK 0x80
72
73 /* R: low byte of A/D W: soft A/D trigger */
74 #define PCL816_AD_LO 8
75 /* R: high byte of A/D W: A/D range control */
76 #define PCL816_AD_HI 9
77
78 /* type of interrupt handler */
79 #define INT_TYPE_AI1_INT 1
80 #define INT_TYPE_AI1_DMA 2
81 #define INT_TYPE_AI3_INT 4
82 #define INT_TYPE_AI3_DMA 5
83 #ifdef unused
84 #define INT_TYPE_AI1_DMA_RTC 9
85 #define INT_TYPE_AI3_DMA_RTC 10
86
87 /* RTC stuff... */
88 #define RTC_IRQ 8
89 #define RTC_IO_EXTENT 0x10
90 #endif
91
92 #define MAGIC_DMA_WORD 0x5a5a
93
94 static const struct comedi_lrange range_pcl816 = { 8, {
95 BIP_RANGE(10),
96 BIP_RANGE(5),
97 BIP_RANGE(2.5),
98 BIP_RANGE(1.25),
99 UNI_RANGE(10),
100 UNI_RANGE(5),
101 UNI_RANGE(2.5),
102 UNI_RANGE(1.25),
103 }
104 };
105
106 struct pcl816_board {
107
108 const char *name; /* board name */
109 int n_ranges; /* len of range list */
110 int n_aichan; /* num of A/D chans in diferencial mode */
111 unsigned int ai_ns_min; /* minimal alllowed delay between samples (in ns) */
112 int n_aochan; /* num of D/A chans */
113 int n_dichan; /* num of DI chans */
114 int n_dochan; /* num of DO chans */
115 const struct comedi_lrange *ai_range_type; /* default A/D rangelist */
116 const struct comedi_lrange *ao_range_type; /* default D/A rangelist */
117 unsigned int io_range; /* len of IO space */
118 unsigned int IRQbits; /* allowed interrupts */
119 unsigned int DMAbits; /* allowed DMA chans */
120 int ai_maxdata; /* maxdata for A/D */
121 int ao_maxdata; /* maxdata for D/A */
122 int ai_chanlist; /* allowed len of channel list A/D */
123 int ao_chanlist; /* allowed len of channel list D/A */
124 int i8254_osc_base; /* 1/frequency of on board oscilator in ns */
125 };
126
127 static const struct pcl816_board boardtypes[] = {
128 {"pcl816", 8, 16, 10000, 1, 16, 16, &range_pcl816,
129 &range_pcl816, PCLx1x_RANGE,
130 0x00fc, /* IRQ mask */
131 0x0a, /* DMA mask */
132 0xffff, /* 16-bit card */
133 0xffff, /* D/A maxdata */
134 1024,
135 1, /* ao chan list */
136 100},
137 {"pcl814b", 8, 16, 10000, 1, 16, 16, &range_pcl816,
138 &range_pcl816, PCLx1x_RANGE,
139 0x00fc,
140 0x0a,
141 0x3fff, /* 14 bit card */
142 0x3fff,
143 1024,
144 1,
145 100},
146 };
147
148 #define n_boardtypes (sizeof(boardtypes)/sizeof(struct pcl816_board))
149 #define devpriv ((struct pcl816_private *)dev->private)
150 #define this_board ((const struct pcl816_board *)dev->board_ptr)
151
152 static int pcl816_attach(struct comedi_device *dev,
153 struct comedi_devconfig *it);
154 static int pcl816_detach(struct comedi_device *dev);
155
156 #ifdef unused
157 static int RTC_lock = 0; /* RTC lock */
158 static int RTC_timer_lock = 0; /* RTC int lock */
159 #endif
160
161 static struct comedi_driver driver_pcl816 = {
162 .driver_name = "pcl816",
163 .module = THIS_MODULE,
164 .attach = pcl816_attach,
165 .detach = pcl816_detach,
166 .board_name = &boardtypes[0].name,
167 .num_names = n_boardtypes,
168 .offset = sizeof(struct pcl816_board),
169 };
170
171 COMEDI_INITCLEANUP(driver_pcl816);
172
173 struct pcl816_private {
174
175 unsigned int dma; /* used DMA, 0=don't use DMA */
176 int dma_rtc; /* 1=RTC used with DMA, 0=no RTC alloc */
177 #ifdef unused
178 unsigned long rtc_iobase; /* RTC port region */
179 unsigned int rtc_iosize;
180 unsigned int rtc_irq;
181 #endif
182 unsigned long dmabuf[2]; /* pointers to begin of DMA buffers */
183 unsigned int dmapages[2]; /* len of DMA buffers in PAGE_SIZEs */
184 unsigned int hwdmaptr[2]; /* hardware address of DMA buffers */
185 unsigned int hwdmasize[2]; /* len of DMA buffers in Bytes */
186 unsigned int dmasamplsize; /* size in samples hwdmasize[0]/2 */
187 unsigned int last_top_dma; /* DMA pointer in last RTC int */
188 int next_dma_buf; /* which DMA buffer will be used next round */
189 long dma_runs_to_end; /* how many we must permorm DMA transfer to end of record */
190 unsigned long last_dma_run; /* how many bytes we must transfer on last DMA page */
191
192 unsigned int ai_scans; /* len of scanlist */
193 unsigned char ai_neverending; /* if=1, then we do neverending record (you must use cancel()) */
194 int irq_free; /* 1=have allocated IRQ */
195 int irq_blocked; /* 1=IRQ now uses any subdev */
196 #ifdef unused
197 int rtc_irq_blocked; /* 1=we now do AI with DMA&RTC */
198 #endif
199 int irq_was_now_closed; /* when IRQ finish, there's stored int816_mode for last interrupt */
200 int int816_mode; /* who now uses IRQ - 1=AI1 int, 2=AI1 dma, 3=AI3 int, 4AI3 dma */
201 struct comedi_subdevice *last_int_sub; /* ptr to subdevice which now finish */
202 int ai_act_scan; /* how many scans we finished */
203 unsigned int ai_act_chanlist[16]; /* MUX setting for actual AI operations */
204 unsigned int ai_act_chanlist_len; /* how long is actual MUX list */
205 unsigned int ai_act_chanlist_pos; /* actual position in MUX list */
206 unsigned int ai_n_chan; /* how many channels per scan */
207 unsigned int ai_poll_ptr; /* how many sampes transfer poll */
208 struct comedi_subdevice *sub_ai; /* ptr to AI subdevice */
209 #ifdef unused
210 struct timer_list rtc_irq_timer; /* timer for RTC sanity check */
211 unsigned long rtc_freq; /* RTC int freq */
212 #endif
213 };
214
215 /*
216 ==============================================================================
217 */
218 static int check_channel_list(struct comedi_device *dev,
219 struct comedi_subdevice *s,
220 unsigned int *chanlist, unsigned int chanlen);
221 static void setup_channel_list(struct comedi_device *dev,
222 struct comedi_subdevice *s,
223 unsigned int *chanlist, unsigned int seglen);
224 static int pcl816_ai_cancel(struct comedi_device *dev,
225 struct comedi_subdevice *s);
226 static void start_pacer(struct comedi_device *dev, int mode,
227 unsigned int divisor1, unsigned int divisor2);
228 #ifdef unused
229 static int set_rtc_irq_bit(unsigned char bit);
230 #endif
231
232 static int pcl816_ai_cmdtest(struct comedi_device *dev,
233 struct comedi_subdevice *s,
234 struct comedi_cmd *cmd);
235 static int pcl816_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
236
237 /*
238 ==============================================================================
239 ANALOG INPUT MODE0, 816 cards, slow version
240 */
241 static int pcl816_ai_insn_read(struct comedi_device *dev,
242 struct comedi_subdevice *s,
243 struct comedi_insn *insn, unsigned int *data)
244 {
245 int n;
246 int timeout;
247
248 DPRINTK("mode 0 analog input\n");
249 /* software trigger, DMA and INT off */
250 outb(0, dev->iobase + PCL816_CONTROL);
251 /* clear INT (conversion end) flag */
252 outb(0, dev->iobase + PCL816_CLRINT);
253
254 /* Set the input channel */
255 outb(CR_CHAN(insn->chanspec) & 0xf, dev->iobase + PCL816_MUX);
256 outb(CR_RANGE(insn->chanspec), dev->iobase + PCL816_RANGE); /* select gain */
257
258 for (n = 0; n < insn->n; n++) {
259
260 outb(0, dev->iobase + PCL816_AD_LO); /* start conversion */
261
262 timeout = 100;
263 while (timeout--) {
264 if (!(inb(dev->iobase + PCL816_STATUS) &
265 PCL816_STATUS_DRDY_MASK)) {
266 /* return read value */
267 data[n] =
268 ((inb(dev->iobase +
269 PCL816_AD_HI) << 8) |
270 (inb(dev->iobase + PCL816_AD_LO)));
271
272 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT (conversion end) flag */
273 break;
274 }
275 udelay(1);
276 }
277 /* Return timeout error */
278 if (!timeout) {
279 comedi_error(dev, "A/D insn timeout\n");
280 data[0] = 0;
281 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT (conversion end) flag */
282 return -EIO;
283 }
284
285 }
286 return n;
287 }
288
289 /*
290 ==============================================================================
291 analog input interrupt mode 1 & 3, 818 cards
292 one sample per interrupt version
293 */
294 static irqreturn_t interrupt_pcl816_ai_mode13_int(int irq, void *d)
295 {
296 struct comedi_device *dev = d;
297 struct comedi_subdevice *s = dev->subdevices + 0;
298 int low, hi;
299 int timeout = 50; /* wait max 50us */
300
301 while (timeout--) {
302 if (!(inb(dev->iobase + PCL816_STATUS) &
303 PCL816_STATUS_DRDY_MASK))
304 break;
305 udelay(1);
306 }
307 if (!timeout) { /* timeout, bail error */
308 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
309 comedi_error(dev, "A/D mode1/3 IRQ without DRDY!");
310 pcl816_ai_cancel(dev, s);
311 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
312 comedi_event(dev, s);
313 return IRQ_HANDLED;
314
315 }
316
317 /* get the sample */
318 low = inb(dev->iobase + PCL816_AD_LO);
319 hi = inb(dev->iobase + PCL816_AD_HI);
320
321 comedi_buf_put(s->async, (hi << 8) | low);
322
323 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
324
325 if (++devpriv->ai_act_chanlist_pos >= devpriv->ai_act_chanlist_len)
326 devpriv->ai_act_chanlist_pos = 0;
327
328 s->async->cur_chan++;
329 if (s->async->cur_chan >= devpriv->ai_n_chan) {
330 s->async->cur_chan = 0;
331 devpriv->ai_act_scan++;
332 }
333
334 if (!devpriv->ai_neverending)
335 if (devpriv->ai_act_scan >= devpriv->ai_scans) { /* all data sampled */
336 /* all data sampled */
337 pcl816_ai_cancel(dev, s);
338 s->async->events |= COMEDI_CB_EOA;
339 }
340 comedi_event(dev, s);
341 return IRQ_HANDLED;
342 }
343
344 /*
345 ==============================================================================
346 analog input dma mode 1 & 3, 816 cards
347 */
348 static void transfer_from_dma_buf(struct comedi_device *dev,
349 struct comedi_subdevice *s, short *ptr,
350 unsigned int bufptr, unsigned int len)
351 {
352 int i;
353
354 s->async->events = 0;
355
356 for (i = 0; i < len; i++) {
357
358 comedi_buf_put(s->async, ptr[bufptr++]);
359
360 if (++devpriv->ai_act_chanlist_pos >=
361 devpriv->ai_act_chanlist_len) {
362 devpriv->ai_act_chanlist_pos = 0;
363 }
364
365 s->async->cur_chan++;
366 if (s->async->cur_chan >= devpriv->ai_n_chan) {
367 s->async->cur_chan = 0;
368 devpriv->ai_act_scan++;
369 }
370
371 if (!devpriv->ai_neverending)
372 if (devpriv->ai_act_scan >= devpriv->ai_scans) { /* all data sampled */
373 pcl816_ai_cancel(dev, s);
374 s->async->events |= COMEDI_CB_EOA;
375 s->async->events |= COMEDI_CB_BLOCK;
376 break;
377 }
378 }
379
380 comedi_event(dev, s);
381 }
382
383 static irqreturn_t interrupt_pcl816_ai_mode13_dma(int irq, void *d)
384 {
385 struct comedi_device *dev = d;
386 struct comedi_subdevice *s = dev->subdevices + 0;
387 int len, bufptr, this_dma_buf;
388 unsigned long dma_flags;
389 short *ptr;
390
391 disable_dma(devpriv->dma);
392 this_dma_buf = devpriv->next_dma_buf;
393
394 if ((devpriv->dma_runs_to_end > -1) || devpriv->ai_neverending) { /* switch dma bufs */
395
396 devpriv->next_dma_buf = 1 - devpriv->next_dma_buf;
397 set_dma_mode(devpriv->dma, DMA_MODE_READ);
398 dma_flags = claim_dma_lock();
399 /* clear_dma_ff (devpriv->dma); */
400 set_dma_addr(devpriv->dma,
401 devpriv->hwdmaptr[devpriv->next_dma_buf]);
402 if (devpriv->dma_runs_to_end) {
403 set_dma_count(devpriv->dma,
404 devpriv->hwdmasize[devpriv->
405 next_dma_buf]);
406 } else {
407 set_dma_count(devpriv->dma, devpriv->last_dma_run);
408 }
409 release_dma_lock(dma_flags);
410 enable_dma(devpriv->dma);
411 }
412
413 devpriv->dma_runs_to_end--;
414 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
415
416 ptr = (short *)devpriv->dmabuf[this_dma_buf];
417
418 len = (devpriv->hwdmasize[0] >> 1) - devpriv->ai_poll_ptr;
419 bufptr = devpriv->ai_poll_ptr;
420 devpriv->ai_poll_ptr = 0;
421
422 transfer_from_dma_buf(dev, s, ptr, bufptr, len);
423 return IRQ_HANDLED;
424 }
425
426 /*
427 ==============================================================================
428 INT procedure
429 */
430 static irqreturn_t interrupt_pcl816(int irq, void *d)
431 {
432 struct comedi_device *dev = d;
433 DPRINTK("<I>");
434
435 if (!dev->attached) {
436 comedi_error(dev, "premature interrupt");
437 return IRQ_HANDLED;
438 }
439
440 switch (devpriv->int816_mode) {
441 case INT_TYPE_AI1_DMA:
442 case INT_TYPE_AI3_DMA:
443 return interrupt_pcl816_ai_mode13_dma(irq, d);
444 case INT_TYPE_AI1_INT:
445 case INT_TYPE_AI3_INT:
446 return interrupt_pcl816_ai_mode13_int(irq, d);
447 }
448
449 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
450 if ((!dev->irq) | (!devpriv->irq_free) | (!devpriv->irq_blocked) |
451 (!devpriv->int816_mode)) {
452 if (devpriv->irq_was_now_closed) {
453 devpriv->irq_was_now_closed = 0;
454 /* comedi_error(dev,"last IRQ.."); */
455 return IRQ_HANDLED;
456 }
457 comedi_error(dev, "bad IRQ!");
458 return IRQ_NONE;
459 }
460 comedi_error(dev, "IRQ from unknown source!");
461 return IRQ_NONE;
462 }
463
464 /*
465 ==============================================================================
466 COMMAND MODE
467 */
468 static void pcl816_cmdtest_out(int e, struct comedi_cmd *cmd)
469 {
470 printk("pcl816 e=%d startsrc=%x scansrc=%x convsrc=%x\n", e,
471 cmd->start_src, cmd->scan_begin_src, cmd->convert_src);
472 printk("pcl816 e=%d startarg=%d scanarg=%d convarg=%d\n", e,
473 cmd->start_arg, cmd->scan_begin_arg, cmd->convert_arg);
474 printk("pcl816 e=%d stopsrc=%x scanend=%x\n", e, cmd->stop_src,
475 cmd->scan_end_src);
476 printk("pcl816 e=%d stoparg=%d scanendarg=%d chanlistlen=%d\n", e,
477 cmd->stop_arg, cmd->scan_end_arg, cmd->chanlist_len);
478 }
479
480 /*
481 ==============================================================================
482 */
483 static int pcl816_ai_cmdtest(struct comedi_device *dev,
484 struct comedi_subdevice *s, struct comedi_cmd *cmd)
485 {
486 int err = 0;
487 int tmp, divisor1 = 0, divisor2 = 0;
488
489 DEBUG(printk("pcl816 pcl812_ai_cmdtest\n"); pcl816_cmdtest_out(-1, cmd);
490 );
491
492 /* step 1: make sure trigger sources are trivially valid */
493 tmp = cmd->start_src;
494 cmd->start_src &= TRIG_NOW;
495 if (!cmd->start_src || tmp != cmd->start_src)
496 err++;
497
498 tmp = cmd->scan_begin_src;
499 cmd->scan_begin_src &= TRIG_FOLLOW;
500 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
501 err++;
502
503 tmp = cmd->convert_src;
504 cmd->convert_src &= TRIG_EXT | TRIG_TIMER;
505 if (!cmd->convert_src || tmp != cmd->convert_src)
506 err++;
507
508 tmp = cmd->scan_end_src;
509 cmd->scan_end_src &= TRIG_COUNT;
510 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
511 err++;
512
513 tmp = cmd->stop_src;
514 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
515 if (!cmd->stop_src || tmp != cmd->stop_src)
516 err++;
517
518 if (err) {
519 return 1;
520 }
521
522 /* step 2: make sure trigger sources are unique and mutually compatible */
523
524 if (cmd->start_src != TRIG_NOW) {
525 cmd->start_src = TRIG_NOW;
526 err++;
527 }
528
529 if (cmd->scan_begin_src != TRIG_FOLLOW) {
530 cmd->scan_begin_src = TRIG_FOLLOW;
531 err++;
532 }
533
534 if (cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_TIMER) {
535 cmd->convert_src = TRIG_TIMER;
536 err++;
537 }
538
539 if (cmd->scan_end_src != TRIG_COUNT) {
540 cmd->scan_end_src = TRIG_COUNT;
541 err++;
542 }
543
544 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
545 err++;
546
547 if (err) {
548 return 2;
549 }
550
551 /* step 3: make sure arguments are trivially compatible */
552 if (cmd->start_arg != 0) {
553 cmd->start_arg = 0;
554 err++;
555 }
556
557 if (cmd->scan_begin_arg != 0) {
558 cmd->scan_begin_arg = 0;
559 err++;
560 }
561 if (cmd->convert_src == TRIG_TIMER) {
562 if (cmd->convert_arg < this_board->ai_ns_min) {
563 cmd->convert_arg = this_board->ai_ns_min;
564 err++;
565 }
566 } else { /* TRIG_EXT */
567 if (cmd->convert_arg != 0) {
568 cmd->convert_arg = 0;
569 err++;
570 }
571 }
572
573 if (cmd->scan_end_arg != cmd->chanlist_len) {
574 cmd->scan_end_arg = cmd->chanlist_len;
575 err++;
576 }
577 if (cmd->stop_src == TRIG_COUNT) {
578 if (!cmd->stop_arg) {
579 cmd->stop_arg = 1;
580 err++;
581 }
582 } else { /* TRIG_NONE */
583 if (cmd->stop_arg != 0) {
584 cmd->stop_arg = 0;
585 err++;
586 }
587 }
588
589 if (err) {
590 return 3;
591 }
592
593 /* step 4: fix up any arguments */
594 if (cmd->convert_src == TRIG_TIMER) {
595 tmp = cmd->convert_arg;
596 i8253_cascade_ns_to_timer(this_board->i8254_osc_base,
597 &divisor1, &divisor2,
598 &cmd->convert_arg,
599 cmd->flags & TRIG_ROUND_MASK);
600 if (cmd->convert_arg < this_board->ai_ns_min)
601 cmd->convert_arg = this_board->ai_ns_min;
602 if (tmp != cmd->convert_arg)
603 err++;
604 }
605
606 if (err) {
607 return 4;
608 }
609
610 /* step 5: complain about special chanlist considerations */
611
612 if (cmd->chanlist) {
613 if (!check_channel_list(dev, s, cmd->chanlist,
614 cmd->chanlist_len))
615 return 5; /* incorrect channels list */
616 }
617
618 return 0;
619 }
620
621 static int pcl816_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
622 {
623 unsigned int divisor1 = 0, divisor2 = 0, dma_flags, bytes, dmairq;
624 struct comedi_cmd *cmd = &s->async->cmd;
625 unsigned int seglen;
626
627 if (cmd->start_src != TRIG_NOW)
628 return -EINVAL;
629 if (cmd->scan_begin_src != TRIG_FOLLOW)
630 return -EINVAL;
631 if (cmd->scan_end_src != TRIG_COUNT)
632 return -EINVAL;
633 if (cmd->scan_end_arg != cmd->chanlist_len)
634 return -EINVAL;
635 /* if(cmd->chanlist_len>MAX_CHANLIST_LEN) return -EINVAL; */
636 if (devpriv->irq_blocked)
637 return -EBUSY;
638
639 if (cmd->convert_src == TRIG_TIMER) {
640 if (cmd->convert_arg < this_board->ai_ns_min)
641 cmd->convert_arg = this_board->ai_ns_min;
642
643 i8253_cascade_ns_to_timer(this_board->i8254_osc_base, &divisor1,
644 &divisor2, &cmd->convert_arg,
645 cmd->flags & TRIG_ROUND_MASK);
646 if (divisor1 == 1) { /* PCL816 crash if any divisor is set to 1 */
647 divisor1 = 2;
648 divisor2 /= 2;
649 }
650 if (divisor2 == 1) {
651 divisor2 = 2;
652 divisor1 /= 2;
653 }
654 }
655
656 start_pacer(dev, -1, 0, 0); /* stop pacer */
657
658 seglen = check_channel_list(dev, s, cmd->chanlist, cmd->chanlist_len);
659 if (seglen < 1)
660 return -EINVAL;
661 setup_channel_list(dev, s, cmd->chanlist, seglen);
662 udelay(1);
663
664 devpriv->ai_n_chan = cmd->chanlist_len;
665 devpriv->ai_act_scan = 0;
666 s->async->cur_chan = 0;
667 devpriv->irq_blocked = 1;
668 devpriv->ai_poll_ptr = 0;
669 devpriv->irq_was_now_closed = 0;
670
671 if (cmd->stop_src == TRIG_COUNT) {
672 devpriv->ai_scans = cmd->stop_arg;
673 devpriv->ai_neverending = 0;
674 } else {
675 devpriv->ai_scans = 0;
676 devpriv->ai_neverending = 1;
677 }
678
679 if ((cmd->flags & TRIG_WAKE_EOS)) { /* don't we want wake up every scan? */
680 printk("pl816: You wankt WAKE_EOS but I dont want handle it");
681 /* devpriv->ai_eos=1; */
682 /* if (devpriv->ai_n_chan==1) */
683 /* devpriv->dma=0; // DMA is useless for this situation */
684 }
685
686 if (devpriv->dma) {
687 bytes = devpriv->hwdmasize[0];
688 if (!devpriv->ai_neverending) {
689 bytes = s->async->cmd.chanlist_len * s->async->cmd.chanlist_len * sizeof(short); /* how many */
690 devpriv->dma_runs_to_end = bytes / devpriv->hwdmasize[0]; /* how many DMA pages we must fill */
691 devpriv->last_dma_run = bytes % devpriv->hwdmasize[0]; /* on last dma transfer must be moved */
692 devpriv->dma_runs_to_end--;
693 if (devpriv->dma_runs_to_end >= 0)
694 bytes = devpriv->hwdmasize[0];
695 } else
696 devpriv->dma_runs_to_end = -1;
697
698 devpriv->next_dma_buf = 0;
699 set_dma_mode(devpriv->dma, DMA_MODE_READ);
700 dma_flags = claim_dma_lock();
701 clear_dma_ff(devpriv->dma);
702 set_dma_addr(devpriv->dma, devpriv->hwdmaptr[0]);
703 set_dma_count(devpriv->dma, bytes);
704 release_dma_lock(dma_flags);
705 enable_dma(devpriv->dma);
706 }
707
708 start_pacer(dev, 1, divisor1, divisor2);
709 dmairq = ((devpriv->dma & 0x3) << 4) | (dev->irq & 0x7);
710
711 switch (cmd->convert_src) {
712 case TRIG_TIMER:
713 devpriv->int816_mode = INT_TYPE_AI1_DMA;
714 outb(0x32, dev->iobase + PCL816_CONTROL); /* Pacer+IRQ+DMA */
715 outb(dmairq, dev->iobase + PCL816_STATUS); /* write irq and DMA to card */
716 break;
717
718 default:
719 devpriv->int816_mode = INT_TYPE_AI3_DMA;
720 outb(0x34, dev->iobase + PCL816_CONTROL); /* Ext trig+IRQ+DMA */
721 outb(dmairq, dev->iobase + PCL816_STATUS); /* write irq to card */
722 break;
723 }
724
725 DPRINTK("pcl816 END: pcl812_ai_cmd()\n");
726 return 0;
727 }
728
729 static int pcl816_ai_poll(struct comedi_device *dev, struct comedi_subdevice *s)
730 {
731 unsigned long flags;
732 unsigned int top1, top2, i;
733
734 if (!devpriv->dma)
735 return 0; /* poll is valid only for DMA transfer */
736
737 spin_lock_irqsave(&dev->spinlock, flags);
738
739 for (i = 0; i < 20; i++) {
740 top1 = get_dma_residue(devpriv->dma); /* where is now DMA */
741 top2 = get_dma_residue(devpriv->dma);
742 if (top1 == top2)
743 break;
744 }
745 if (top1 != top2) {
746 spin_unlock_irqrestore(&dev->spinlock, flags);
747 return 0;
748 }
749
750 top1 = devpriv->hwdmasize[0] - top1; /* where is now DMA in buffer */
751 top1 >>= 1; /* sample position */
752 top2 = top1 - devpriv->ai_poll_ptr;
753 if (top2 < 1) { /* no new samples */
754 spin_unlock_irqrestore(&dev->spinlock, flags);
755 return 0;
756 }
757
758 transfer_from_dma_buf(dev, s,
759 (short *)devpriv->dmabuf[devpriv->next_dma_buf],
760 devpriv->ai_poll_ptr, top2);
761
762 devpriv->ai_poll_ptr = top1; /* new buffer position */
763 spin_unlock_irqrestore(&dev->spinlock, flags);
764
765 return s->async->buf_write_count - s->async->buf_read_count;
766 }
767
768 /*
769 ==============================================================================
770 cancel any mode 1-4 AI
771 */
772 static int pcl816_ai_cancel(struct comedi_device *dev,
773 struct comedi_subdevice *s)
774 {
775 /* DEBUG(printk("pcl816_ai_cancel()\n");) */
776
777 if (devpriv->irq_blocked > 0) {
778 switch (devpriv->int816_mode) {
779 #ifdef unused
780 case INT_TYPE_AI1_DMA_RTC:
781 case INT_TYPE_AI3_DMA_RTC:
782 set_rtc_irq_bit(0); /* stop RTC */
783 del_timer(&devpriv->rtc_irq_timer);
784 #endif
785 case INT_TYPE_AI1_DMA:
786 case INT_TYPE_AI3_DMA:
787 disable_dma(devpriv->dma);
788 case INT_TYPE_AI1_INT:
789 case INT_TYPE_AI3_INT:
790 outb(inb(dev->iobase + PCL816_CONTROL) & 0x73, dev->iobase + PCL816_CONTROL); /* Stop A/D */
791 udelay(1);
792 outb(0, dev->iobase + PCL816_CONTROL); /* Stop A/D */
793 outb(0xb0, dev->iobase + PCL816_CTRCTL); /* Stop pacer */
794 outb(0x70, dev->iobase + PCL816_CTRCTL);
795 outb(0, dev->iobase + PCL816_AD_LO);
796 inb(dev->iobase + PCL816_AD_LO);
797 inb(dev->iobase + PCL816_AD_HI);
798 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
799 outb(0, dev->iobase + PCL816_CONTROL); /* Stop A/D */
800 devpriv->irq_blocked = 0;
801 devpriv->irq_was_now_closed = devpriv->int816_mode;
802 devpriv->int816_mode = 0;
803 devpriv->last_int_sub = s;
804 /* s->busy = 0; */
805 break;
806 }
807 }
808
809 DEBUG(printk("comedi: pcl816_ai_cancel() successful\n");)
810 return 0;
811 }
812
813 /*
814 ==============================================================================
815 chech for PCL816
816 */
817 static int pcl816_check(unsigned long iobase)
818 {
819 outb(0x00, iobase + PCL816_MUX);
820 udelay(1);
821 if (inb(iobase + PCL816_MUX) != 0x00)
822 return 1; /* there isn't card */
823 outb(0x55, iobase + PCL816_MUX);
824 udelay(1);
825 if (inb(iobase + PCL816_MUX) != 0x55)
826 return 1; /* there isn't card */
827 outb(0x00, iobase + PCL816_MUX);
828 udelay(1);
829 outb(0x18, iobase + PCL816_CONTROL);
830 udelay(1);
831 if (inb(iobase + PCL816_CONTROL) != 0x18)
832 return 1; /* there isn't card */
833 return 0; /* ok, card exist */
834 }
835
836 /*
837 ==============================================================================
838 reset whole PCL-816 cards
839 */
840 static void pcl816_reset(struct comedi_device *dev)
841 {
842 /* outb (0, dev->iobase + PCL818_DA_LO); DAC=0V */
843 /* outb (0, dev->iobase + PCL818_DA_HI); */
844 /* udelay (1); */
845 /* outb (0, dev->iobase + PCL818_DO_HI); DO=$0000 */
846 /* outb (0, dev->iobase + PCL818_DO_LO); */
847 /* udelay (1); */
848 outb(0, dev->iobase + PCL816_CONTROL);
849 outb(0, dev->iobase + PCL816_MUX);
850 outb(0, dev->iobase + PCL816_CLRINT);
851 outb(0xb0, dev->iobase + PCL816_CTRCTL); /* Stop pacer */
852 outb(0x70, dev->iobase + PCL816_CTRCTL);
853 outb(0x30, dev->iobase + PCL816_CTRCTL);
854 outb(0, dev->iobase + PCL816_RANGE);
855 }
856
857 /*
858 ==============================================================================
859 Start/stop pacer onboard pacer
860 */
861 static void
862 start_pacer(struct comedi_device *dev, int mode, unsigned int divisor1,
863 unsigned int divisor2)
864 {
865 outb(0x32, dev->iobase + PCL816_CTRCTL);
866 outb(0xff, dev->iobase + PCL816_CTR0);
867 outb(0x00, dev->iobase + PCL816_CTR0);
868 udelay(1);
869 outb(0xb4, dev->iobase + PCL816_CTRCTL); /* set counter 2 as mode 3 */
870 outb(0x74, dev->iobase + PCL816_CTRCTL); /* set counter 1 as mode 3 */
871 udelay(1);
872
873 if (mode == 1) {
874 DPRINTK("mode %d, divisor1 %d, divisor2 %d\n", mode, divisor1,
875 divisor2);
876 outb(divisor2 & 0xff, dev->iobase + PCL816_CTR2);
877 outb((divisor2 >> 8) & 0xff, dev->iobase + PCL816_CTR2);
878 outb(divisor1 & 0xff, dev->iobase + PCL816_CTR1);
879 outb((divisor1 >> 8) & 0xff, dev->iobase + PCL816_CTR1);
880 }
881
882 /* clear pending interrupts (just in case) */
883 /* outb(0, dev->iobase + PCL816_CLRINT); */
884 }
885
886 /*
887 ==============================================================================
888 Check if channel list from user is builded correctly
889 If it's ok, then return non-zero length of repeated segment of channel list
890 */
891 static int
892 check_channel_list(struct comedi_device *dev,
893 struct comedi_subdevice *s, unsigned int *chanlist,
894 unsigned int chanlen)
895 {
896 unsigned int chansegment[16];
897 unsigned int i, nowmustbechan, seglen, segpos;
898
899 /* correct channel and range number check itself comedi/range.c */
900 if (chanlen < 1) {
901 comedi_error(dev, "range/channel list is empty!");
902 return 0;
903 }
904
905 if (chanlen > 1) {
906 chansegment[0] = chanlist[0]; /* first channel is everytime ok */
907 for (i = 1, seglen = 1; i < chanlen; i++, seglen++) {
908 /* build part of chanlist */
909 DEBUG(printk("%d. %d %d\n", i, CR_CHAN(chanlist[i]),
910 CR_RANGE(chanlist[i]));)
911 if (chanlist[0] == chanlist[i])
912 break; /* we detect loop, this must by finish */
913 nowmustbechan =
914 (CR_CHAN(chansegment[i - 1]) + 1) % chanlen;
915 if (nowmustbechan != CR_CHAN(chanlist[i])) {
916 /* channel list isn't continous :-( */
917 printk
918 ("comedi%d: pcl816: channel list must be continous! chanlist[%i]=%d but must be %d or %d!\n",
919 dev->minor, i, CR_CHAN(chanlist[i]),
920 nowmustbechan, CR_CHAN(chanlist[0]));
921 return 0;
922 }
923 chansegment[i] = chanlist[i]; /* well, this is next correct channel in list */
924 }
925
926 for (i = 0, segpos = 0; i < chanlen; i++) { /* check whole chanlist */
927 DEBUG(printk("%d %d=%d %d\n",
928 CR_CHAN(chansegment[i % seglen]),
929 CR_RANGE(chansegment[i % seglen]),
930 CR_CHAN(chanlist[i]),
931 CR_RANGE(chanlist[i]));)
932 if (chanlist[i] != chansegment[i % seglen]) {
933 printk
934 ("comedi%d: pcl816: bad channel or range number! chanlist[%i]=%d,%d,%d and not %d,%d,%d!\n",
935 dev->minor, i, CR_CHAN(chansegment[i]),
936 CR_RANGE(chansegment[i]),
937 CR_AREF(chansegment[i]),
938 CR_CHAN(chanlist[i % seglen]),
939 CR_RANGE(chanlist[i % seglen]),
940 CR_AREF(chansegment[i % seglen]));
941 return 0; /* chan/gain list is strange */
942 }
943 }
944 } else {
945 seglen = 1;
946 }
947
948 return seglen; /* we can serve this with MUX logic */
949 }
950
951 /*
952 ==============================================================================
953 Program scan/gain logic with channel list.
954 */
955 static void
956 setup_channel_list(struct comedi_device *dev,
957 struct comedi_subdevice *s, unsigned int *chanlist,
958 unsigned int seglen)
959 {
960 unsigned int i;
961
962 devpriv->ai_act_chanlist_len = seglen;
963 devpriv->ai_act_chanlist_pos = 0;
964
965 for (i = 0; i < seglen; i++) { /* store range list to card */
966 devpriv->ai_act_chanlist[i] = CR_CHAN(chanlist[i]);
967 outb(CR_CHAN(chanlist[0]) & 0xf, dev->iobase + PCL816_MUX);
968 outb(CR_RANGE(chanlist[0]), dev->iobase + PCL816_RANGE); /* select gain */
969 }
970
971 udelay(1);
972
973 outb(devpriv->ai_act_chanlist[0] | (devpriv->ai_act_chanlist[seglen - 1] << 4), dev->iobase + PCL816_MUX); /* select channel interval to scan */
974 }
975
976 #ifdef unused
977 /*
978 ==============================================================================
979 Enable(1)/disable(0) periodic interrupts from RTC
980 */
981 static int set_rtc_irq_bit(unsigned char bit)
982 {
983 unsigned char val;
984 unsigned long flags;
985
986 if (bit == 1) {
987 RTC_timer_lock++;
988 if (RTC_timer_lock > 1)
989 return 0;
990 } else {
991 RTC_timer_lock--;
992 if (RTC_timer_lock < 0)
993 RTC_timer_lock = 0;
994 if (RTC_timer_lock > 0)
995 return 0;
996 }
997
998 save_flags(flags);
999 cli();
1000 val = CMOS_READ(RTC_CONTROL);
1001 if (bit) {
1002 val |= RTC_PIE;
1003 } else {
1004 val &= ~RTC_PIE;
1005 }
1006 CMOS_WRITE(val, RTC_CONTROL);
1007 CMOS_READ(RTC_INTR_FLAGS);
1008 restore_flags(flags);
1009 return 0;
1010 }
1011 #endif
1012
1013 /*
1014 ==============================================================================
1015 Free any resources that we have claimed
1016 */
1017 static void free_resources(struct comedi_device *dev)
1018 {
1019 /* printk("free_resource()\n"); */
1020 if (dev->private) {
1021 pcl816_ai_cancel(dev, devpriv->sub_ai);
1022 pcl816_reset(dev);
1023 if (devpriv->dma)
1024 free_dma(devpriv->dma);
1025 if (devpriv->dmabuf[0])
1026 free_pages(devpriv->dmabuf[0], devpriv->dmapages[0]);
1027 if (devpriv->dmabuf[1])
1028 free_pages(devpriv->dmabuf[1], devpriv->dmapages[1]);
1029 #ifdef unused
1030 if (devpriv->rtc_irq)
1031 free_irq(devpriv->rtc_irq, dev);
1032 if ((devpriv->dma_rtc) && (RTC_lock == 1)) {
1033 if (devpriv->rtc_iobase)
1034 release_region(devpriv->rtc_iobase,
1035 devpriv->rtc_iosize);
1036 }
1037 #endif
1038 }
1039
1040 if (dev->irq)
1041 free_irq(dev->irq, dev);
1042 if (dev->iobase)
1043 release_region(dev->iobase, this_board->io_range);
1044 /* printk("free_resource() end\n"); */
1045 }
1046
1047 /*
1048 ==============================================================================
1049
1050 Initialization
1051
1052 */
1053 static int pcl816_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1054 {
1055 int ret;
1056 unsigned long iobase;
1057 unsigned int irq, dma;
1058 unsigned long pages;
1059 /* int i; */
1060 struct comedi_subdevice *s;
1061
1062 /* claim our I/O space */
1063 iobase = it->options[0];
1064 printk("comedi%d: pcl816: board=%s, ioport=0x%03lx", dev->minor,
1065 this_board->name, iobase);
1066
1067 if (!request_region(iobase, this_board->io_range, "pcl816")) {
1068 printk("I/O port conflict\n");
1069 return -EIO;
1070 }
1071
1072 dev->iobase = iobase;
1073
1074 if (pcl816_check(iobase)) {
1075 printk(", I cann't detect board. FAIL!\n");
1076 return -EIO;
1077 }
1078
1079 ret = alloc_private(dev, sizeof(struct pcl816_private));
1080 if (ret < 0)
1081 return ret; /* Can't alloc mem */
1082
1083 /* set up some name stuff */
1084 dev->board_name = this_board->name;
1085
1086 /* grab our IRQ */
1087 irq = 0;
1088 if (this_board->IRQbits != 0) { /* board support IRQ */
1089 irq = it->options[1];
1090 if (irq) { /* we want to use IRQ */
1091 if (((1 << irq) & this_board->IRQbits) == 0) {
1092 printk
1093 (", IRQ %u is out of allowed range, DISABLING IT",
1094 irq);
1095 irq = 0; /* Bad IRQ */
1096 } else {
1097 if (request_irq
1098 (irq, interrupt_pcl816, 0, "pcl816", dev)) {
1099 printk
1100 (", unable to allocate IRQ %u, DISABLING IT",
1101 irq);
1102 irq = 0; /* Can't use IRQ */
1103 } else {
1104 printk(", irq=%u", irq);
1105 }
1106 }
1107 }
1108 }
1109
1110 dev->irq = irq;
1111 if (irq) {
1112 devpriv->irq_free = 1;
1113 } /* 1=we have allocated irq */
1114 else {
1115 devpriv->irq_free = 0;
1116 }
1117 devpriv->irq_blocked = 0; /* number of subdevice which use IRQ */
1118 devpriv->int816_mode = 0; /* mode of irq */
1119
1120 #ifdef unused
1121 /* grab RTC for DMA operations */
1122 devpriv->dma_rtc = 0;
1123 if (it->options[2] > 0) { /* we want to use DMA */
1124 if (RTC_lock == 0) {
1125 if (!request_region(RTC_PORT(0), RTC_IO_EXTENT,
1126 "pcl816 (RTC)"))
1127 goto no_rtc;
1128 }
1129 devpriv->rtc_iobase = RTC_PORT(0);
1130 devpriv->rtc_iosize = RTC_IO_EXTENT;
1131 RTC_lock++;
1132 #ifdef UNTESTED_CODE
1133 if (!request_irq(RTC_IRQ, interrupt_pcl816_ai_mode13_dma_rtc, 0,
1134 "pcl816 DMA (RTC)", dev)) {
1135 devpriv->dma_rtc = 1;
1136 devpriv->rtc_irq = RTC_IRQ;
1137 printk(", dma_irq=%u", devpriv->rtc_irq);
1138 } else {
1139 RTC_lock--;
1140 if (RTC_lock == 0) {
1141 if (devpriv->rtc_iobase)
1142 release_region(devpriv->rtc_iobase,
1143 devpriv->rtc_iosize);
1144 }
1145 devpriv->rtc_iobase = 0;
1146 devpriv->rtc_iosize = 0;
1147 }
1148 #else
1149 printk("pcl816: RTC code missing");
1150 #endif
1151
1152 }
1153
1154 no_rtc:
1155 #endif
1156 /* grab our DMA */
1157 dma = 0;
1158 devpriv->dma = dma;
1159 if ((devpriv->irq_free == 0) && (devpriv->dma_rtc == 0))
1160 goto no_dma; /* if we haven't IRQ, we can't use DMA */
1161
1162 if (this_board->DMAbits != 0) { /* board support DMA */
1163 dma = it->options[2];
1164 if (dma < 1)
1165 goto no_dma; /* DMA disabled */
1166
1167 if (((1 << dma) & this_board->DMAbits) == 0) {
1168 printk(", DMA is out of allowed range, FAIL!\n");
1169 return -EINVAL; /* Bad DMA */
1170 }
1171 ret = request_dma(dma, "pcl816");
1172 if (ret) {
1173 printk(", unable to allocate DMA %u, FAIL!\n", dma);
1174 return -EBUSY; /* DMA isn't free */
1175 }
1176
1177 devpriv->dma = dma;
1178 printk(", dma=%u", dma);
1179 pages = 2; /* we need 16KB */
1180 devpriv->dmabuf[0] = __get_dma_pages(GFP_KERNEL, pages);
1181
1182 if (!devpriv->dmabuf[0]) {
1183 printk(", unable to allocate DMA buffer, FAIL!\n");
1184 /* maybe experiment with try_to_free_pages() will help .... */
1185 return -EBUSY; /* no buffer :-( */
1186 }
1187 devpriv->dmapages[0] = pages;
1188 devpriv->hwdmaptr[0] = virt_to_bus((void *)devpriv->dmabuf[0]);
1189 devpriv->hwdmasize[0] = (1 << pages) * PAGE_SIZE;
1190 /* printk("%d %d %ld, ",devpriv->dmapages[0],devpriv->hwdmasize[0],PAGE_SIZE); */
1191
1192 if (devpriv->dma_rtc == 0) { /* we must do duble buff :-( */
1193 devpriv->dmabuf[1] = __get_dma_pages(GFP_KERNEL, pages);
1194 if (!devpriv->dmabuf[1]) {
1195 printk
1196 (", unable to allocate DMA buffer, FAIL!\n");
1197 return -EBUSY;
1198 }
1199 devpriv->dmapages[1] = pages;
1200 devpriv->hwdmaptr[1] =
1201 virt_to_bus((void *)devpriv->dmabuf[1]);
1202 devpriv->hwdmasize[1] = (1 << pages) * PAGE_SIZE;
1203 }
1204 }
1205
1206 no_dma:
1207
1208 /* if (this_board->n_aochan > 0)
1209 subdevs[1] = COMEDI_SUBD_AO;
1210 if (this_board->n_dichan > 0)
1211 subdevs[2] = COMEDI_SUBD_DI;
1212 if (this_board->n_dochan > 0)
1213 subdevs[3] = COMEDI_SUBD_DO;
1214 */
1215
1216 ret = alloc_subdevices(dev, 1);
1217 if (ret < 0)
1218 return ret;
1219
1220 s = dev->subdevices + 0;
1221 if (this_board->n_aichan > 0) {
1222 s->type = COMEDI_SUBD_AI;
1223 devpriv->sub_ai = s;
1224 dev->read_subdev = s;
1225 s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
1226 s->n_chan = this_board->n_aichan;
1227 s->subdev_flags |= SDF_DIFF;
1228 /* printk (", %dchans DIFF DAC - %d", s->n_chan, i); */
1229 s->maxdata = this_board->ai_maxdata;
1230 s->len_chanlist = this_board->ai_chanlist;
1231 s->range_table = this_board->ai_range_type;
1232 s->cancel = pcl816_ai_cancel;
1233 s->do_cmdtest = pcl816_ai_cmdtest;
1234 s->do_cmd = pcl816_ai_cmd;
1235 s->poll = pcl816_ai_poll;
1236 s->insn_read = pcl816_ai_insn_read;
1237 } else {
1238 s->type = COMEDI_SUBD_UNUSED;
1239 }
1240
1241 #if 0
1242 case COMEDI_SUBD_AO:
1243 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
1244 s->n_chan = this_board->n_aochan;
1245 s->maxdata = this_board->ao_maxdata;
1246 s->len_chanlist = this_board->ao_chanlist;
1247 s->range_table = this_board->ao_range_type;
1248 break;
1249
1250 case COMEDI_SUBD_DI:
1251 s->subdev_flags = SDF_READABLE;
1252 s->n_chan = this_board->n_dichan;
1253 s->maxdata = 1;
1254 s->len_chanlist = this_board->n_dichan;
1255 s->range_table = &range_digital;
1256 break;
1257
1258 case COMEDI_SUBD_DO:
1259 s->subdev_flags = SDF_WRITABLE;
1260 s->n_chan = this_board->n_dochan;
1261 s->maxdata = 1;
1262 s->len_chanlist = this_board->n_dochan;
1263 s->range_table = &range_digital;
1264 break;
1265 #endif
1266
1267 pcl816_reset(dev);
1268
1269 printk("\n");
1270
1271 return 0;
1272 }
1273
1274 /*
1275 ==============================================================================
1276 Removes device
1277 */
1278 static int pcl816_detach(struct comedi_device *dev)
1279 {
1280 DEBUG(printk("comedi%d: pcl816: remove\n", dev->minor);)
1281 free_resources(dev);
1282 #ifdef unused
1283 if (devpriv->dma_rtc)
1284 RTC_lock--;
1285 #endif
1286 return 0;
1287 }
ubuntu-bionic-kernel mirror