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