2 comedi/drivers/pcl816.c
4 Author: Juan Grigera <juan@grigera.com.ar>
5 based on pcl818 by Michal Dobes <dobes@tesnet.cz> and bits of pcl812
7 hardware driver for Advantech cards:
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)
17 Updated: Tue, 2 Apr 2002 23:15:21 -0800
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).
22 The driver support AI command mode, other subdevices not written.
24 Analog output and digital input and output are not supported.
26 Configuration Options:
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
35 #include "../comedidev.h"
37 #include <linux/ioport.h>
38 #include <linux/mc146818rtc.h>
39 #include <linux/gfp.h>
40 #include <linux/delay.h>
47 /* boards constants */
49 #define PCLx1x_RANGE 16
51 /* #define outb(x,y) printk("OUTB(%x, 200+%d)\n", x,y-0x200); outb(x,y) */
53 /* INTEL 8254 counters */
57 /* R: counter read-back register W: counter control */
58 #define PCL816_CTRCTL 7
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 */
66 /* R/W: operation control register */
67 #define PCL816_CONTROL 12
69 /* R: return status byte W: set DMA/IRQ */
70 #define PCL816_STATUS 13
71 #define PCL816_STATUS_DRDY_MASK 0x80
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
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
84 #define INT_TYPE_AI1_DMA_RTC 9
85 #define INT_TYPE_AI3_DMA_RTC 10
89 #define RTC_IO_EXTENT 0x10
92 #define MAGIC_DMA_WORD 0x5a5a
94 static const struct comedi_lrange range_pcl816 = { 8, {
106 struct pcl816_board {
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 allowed 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 */
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 */
132 0xffff, /* 16-bit card */
133 0xffff, /* D/A maxdata */
135 1, /* ao chan list */
137 {"pcl814b", 8, 16, 10000, 1, 16, 16, &range_pcl816,
138 &range_pcl816, PCLx1x_RANGE,
141 0x3fff, /* 14 bit card */
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)
152 static int pcl816_attach(struct comedi_device *dev,
153 struct comedi_devconfig *it);
154 static int pcl816_detach(struct comedi_device *dev);
157 static int RTC_lock = 0; /* RTC lock */
158 static int RTC_timer_lock = 0; /* RTC int lock */
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),
171 static int __init driver_pcl816_init_module(void)
173 return comedi_driver_register(&driver_pcl816);
176 static void __exit driver_pcl816_cleanup_module(void)
178 comedi_driver_unregister(&driver_pcl816);
181 module_init(driver_pcl816_init_module);
182 module_exit(driver_pcl816_cleanup_module);
184 struct pcl816_private {
186 unsigned int dma; /* used DMA, 0=don't use DMA */
187 int dma_rtc; /* 1=RTC used with DMA, 0=no RTC alloc */
189 unsigned long rtc_iobase; /* RTC port region */
190 unsigned int rtc_iosize;
191 unsigned int rtc_irq;
193 unsigned long dmabuf[2]; /* pointers to begin of DMA buffers */
194 unsigned int dmapages[2]; /* len of DMA buffers in PAGE_SIZEs */
195 unsigned int hwdmaptr[2]; /* hardware address of DMA buffers */
196 unsigned int hwdmasize[2]; /* len of DMA buffers in Bytes */
197 unsigned int dmasamplsize; /* size in samples hwdmasize[0]/2 */
198 unsigned int last_top_dma; /* DMA pointer in last RTC int */
199 int next_dma_buf; /* which DMA buffer will be used next round */
200 long dma_runs_to_end; /* how many we must permorm DMA transfer to end of record */
201 unsigned long last_dma_run; /* how many bytes we must transfer on last DMA page */
203 unsigned int ai_scans; /* len of scanlist */
204 unsigned char ai_neverending; /* if=1, then we do neverending record (you must use cancel()) */
205 int irq_free; /* 1=have allocated IRQ */
206 int irq_blocked; /* 1=IRQ now uses any subdev */
208 int rtc_irq_blocked; /* 1=we now do AI with DMA&RTC */
210 int irq_was_now_closed; /* when IRQ finish, there's stored int816_mode for last interrupt */
211 int int816_mode; /* who now uses IRQ - 1=AI1 int, 2=AI1 dma, 3=AI3 int, 4AI3 dma */
212 struct comedi_subdevice *last_int_sub; /* ptr to subdevice which now finish */
213 int ai_act_scan; /* how many scans we finished */
214 unsigned int ai_act_chanlist[16]; /* MUX setting for actual AI operations */
215 unsigned int ai_act_chanlist_len; /* how long is actual MUX list */
216 unsigned int ai_act_chanlist_pos; /* actual position in MUX list */
217 unsigned int ai_n_chan; /* how many channels per scan */
218 unsigned int ai_poll_ptr; /* how many sampes transfer poll */
219 struct comedi_subdevice *sub_ai; /* ptr to AI subdevice */
221 struct timer_list rtc_irq_timer; /* timer for RTC sanity check */
222 unsigned long rtc_freq; /* RTC int freq */
227 ==============================================================================
229 static int check_channel_list(struct comedi_device *dev,
230 struct comedi_subdevice *s,
231 unsigned int *chanlist, unsigned int chanlen);
232 static void setup_channel_list(struct comedi_device *dev,
233 struct comedi_subdevice *s,
234 unsigned int *chanlist, unsigned int seglen);
235 static int pcl816_ai_cancel(struct comedi_device *dev,
236 struct comedi_subdevice *s);
237 static void start_pacer(struct comedi_device *dev, int mode,
238 unsigned int divisor1, unsigned int divisor2);
240 static int set_rtc_irq_bit(unsigned char bit);
243 static int pcl816_ai_cmdtest(struct comedi_device *dev,
244 struct comedi_subdevice *s,
245 struct comedi_cmd *cmd);
246 static int pcl816_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s);
249 ==============================================================================
250 ANALOG INPUT MODE0, 816 cards, slow version
252 static int pcl816_ai_insn_read(struct comedi_device *dev,
253 struct comedi_subdevice *s,
254 struct comedi_insn *insn, unsigned int *data)
259 DPRINTK("mode 0 analog input\n");
260 /* software trigger, DMA and INT off */
261 outb(0, dev->iobase + PCL816_CONTROL);
262 /* clear INT (conversion end) flag */
263 outb(0, dev->iobase + PCL816_CLRINT);
265 /* Set the input channel */
266 outb(CR_CHAN(insn->chanspec) & 0xf, dev->iobase + PCL816_MUX);
268 outb(CR_RANGE(insn->chanspec), dev->iobase + PCL816_RANGE);
270 for (n = 0; n < insn->n; n++) {
272 outb(0, dev->iobase + PCL816_AD_LO); /* start conversion */
276 if (!(inb(dev->iobase + PCL816_STATUS) &
277 PCL816_STATUS_DRDY_MASK)) {
278 /* return read value */
281 PCL816_AD_HI) << 8) |
282 (inb(dev->iobase + PCL816_AD_LO)));
283 /* clear INT (conversion end) flag */
284 outb(0, dev->iobase + PCL816_CLRINT);
289 /* Return timeout error */
291 comedi_error(dev, "A/D insn timeout\n");
293 /* clear INT (conversion end) flag */
294 outb(0, dev->iobase + PCL816_CLRINT);
303 ==============================================================================
304 analog input interrupt mode 1 & 3, 818 cards
305 one sample per interrupt version
307 static irqreturn_t interrupt_pcl816_ai_mode13_int(int irq, void *d)
309 struct comedi_device *dev = d;
310 struct comedi_subdevice *s = dev->subdevices + 0;
312 int timeout = 50; /* wait max 50us */
315 if (!(inb(dev->iobase + PCL816_STATUS) &
316 PCL816_STATUS_DRDY_MASK))
320 if (!timeout) { /* timeout, bail error */
321 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
322 comedi_error(dev, "A/D mode1/3 IRQ without DRDY!");
323 pcl816_ai_cancel(dev, s);
324 s->async->events |= COMEDI_CB_EOA | COMEDI_CB_ERROR;
325 comedi_event(dev, s);
331 low = inb(dev->iobase + PCL816_AD_LO);
332 hi = inb(dev->iobase + PCL816_AD_HI);
334 comedi_buf_put(s->async, (hi << 8) | low);
336 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
338 if (++devpriv->ai_act_chanlist_pos >= devpriv->ai_act_chanlist_len)
339 devpriv->ai_act_chanlist_pos = 0;
341 s->async->cur_chan++;
342 if (s->async->cur_chan >= devpriv->ai_n_chan) {
343 s->async->cur_chan = 0;
344 devpriv->ai_act_scan++;
347 if (!devpriv->ai_neverending)
348 /* all data sampled */
349 if (devpriv->ai_act_scan >= devpriv->ai_scans) {
350 /* all data sampled */
351 pcl816_ai_cancel(dev, s);
352 s->async->events |= COMEDI_CB_EOA;
354 comedi_event(dev, s);
359 ==============================================================================
360 analog input dma mode 1 & 3, 816 cards
362 static void transfer_from_dma_buf(struct comedi_device *dev,
363 struct comedi_subdevice *s, short *ptr,
364 unsigned int bufptr, unsigned int len)
368 s->async->events = 0;
370 for (i = 0; i < len; i++) {
372 comedi_buf_put(s->async, ptr[bufptr++]);
374 if (++devpriv->ai_act_chanlist_pos >=
375 devpriv->ai_act_chanlist_len) {
376 devpriv->ai_act_chanlist_pos = 0;
379 s->async->cur_chan++;
380 if (s->async->cur_chan >= devpriv->ai_n_chan) {
381 s->async->cur_chan = 0;
382 devpriv->ai_act_scan++;
385 if (!devpriv->ai_neverending)
386 /* all data sampled */
387 if (devpriv->ai_act_scan >= devpriv->ai_scans) {
388 pcl816_ai_cancel(dev, s);
389 s->async->events |= COMEDI_CB_EOA;
390 s->async->events |= COMEDI_CB_BLOCK;
395 comedi_event(dev, s);
398 static irqreturn_t interrupt_pcl816_ai_mode13_dma(int irq, void *d)
400 struct comedi_device *dev = d;
401 struct comedi_subdevice *s = dev->subdevices + 0;
402 int len, bufptr, this_dma_buf;
403 unsigned long dma_flags;
406 disable_dma(devpriv->dma);
407 this_dma_buf = devpriv->next_dma_buf;
409 /* switch dma bufs */
410 if ((devpriv->dma_runs_to_end > -1) || devpriv->ai_neverending) {
412 devpriv->next_dma_buf = 1 - devpriv->next_dma_buf;
413 set_dma_mode(devpriv->dma, DMA_MODE_READ);
414 dma_flags = claim_dma_lock();
415 /* clear_dma_ff (devpriv->dma); */
416 set_dma_addr(devpriv->dma,
417 devpriv->hwdmaptr[devpriv->next_dma_buf]);
418 if (devpriv->dma_runs_to_end) {
419 set_dma_count(devpriv->dma,
420 devpriv->hwdmasize[devpriv->
423 set_dma_count(devpriv->dma, devpriv->last_dma_run);
425 release_dma_lock(dma_flags);
426 enable_dma(devpriv->dma);
429 devpriv->dma_runs_to_end--;
430 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
432 ptr = (short *)devpriv->dmabuf[this_dma_buf];
434 len = (devpriv->hwdmasize[0] >> 1) - devpriv->ai_poll_ptr;
435 bufptr = devpriv->ai_poll_ptr;
436 devpriv->ai_poll_ptr = 0;
438 transfer_from_dma_buf(dev, s, ptr, bufptr, len);
443 ==============================================================================
446 static irqreturn_t interrupt_pcl816(int irq, void *d)
448 struct comedi_device *dev = d;
451 if (!dev->attached) {
452 comedi_error(dev, "premature interrupt");
456 switch (devpriv->int816_mode) {
457 case INT_TYPE_AI1_DMA:
458 case INT_TYPE_AI3_DMA:
459 return interrupt_pcl816_ai_mode13_dma(irq, d);
460 case INT_TYPE_AI1_INT:
461 case INT_TYPE_AI3_INT:
462 return interrupt_pcl816_ai_mode13_int(irq, d);
465 outb(0, dev->iobase + PCL816_CLRINT); /* clear INT request */
466 if ((!dev->irq) | (!devpriv->irq_free) | (!devpriv->irq_blocked) |
467 (!devpriv->int816_mode)) {
468 if (devpriv->irq_was_now_closed) {
469 devpriv->irq_was_now_closed = 0;
470 /* comedi_error(dev,"last IRQ.."); */
473 comedi_error(dev, "bad IRQ!");
476 comedi_error(dev, "IRQ from unknown source!");
481 ==============================================================================
484 static void pcl816_cmdtest_out(int e, struct comedi_cmd *cmd)
486 printk(KERN_INFO "pcl816 e=%d startsrc=%x scansrc=%x convsrc=%x\n", e,
487 cmd->start_src, cmd->scan_begin_src, cmd->convert_src);
488 printk(KERN_INFO "pcl816 e=%d startarg=%d scanarg=%d convarg=%d\n", e,
489 cmd->start_arg, cmd->scan_begin_arg, cmd->convert_arg);
490 printk(KERN_INFO "pcl816 e=%d stopsrc=%x scanend=%x\n", e,
491 cmd->stop_src, cmd->scan_end_src);
492 printk(KERN_INFO "pcl816 e=%d stoparg=%d scanendarg=%d chanlistlen=%d\n",
493 e, cmd->stop_arg, cmd->scan_end_arg, cmd->chanlist_len);
497 ==============================================================================
499 static int pcl816_ai_cmdtest(struct comedi_device *dev,
500 struct comedi_subdevice *s, struct comedi_cmd *cmd)
503 int tmp, divisor1 = 0, divisor2 = 0;
505 DEBUG(printk(KERN_INFO "pcl816 pcl812_ai_cmdtest\n");
506 pcl816_cmdtest_out(-1, cmd);
509 /* step 1: make sure trigger sources are trivially valid */
510 tmp = cmd->start_src;
511 cmd->start_src &= TRIG_NOW;
512 if (!cmd->start_src || tmp != cmd->start_src)
515 tmp = cmd->scan_begin_src;
516 cmd->scan_begin_src &= TRIG_FOLLOW;
517 if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
520 tmp = cmd->convert_src;
521 cmd->convert_src &= TRIG_EXT | TRIG_TIMER;
522 if (!cmd->convert_src || tmp != cmd->convert_src)
525 tmp = cmd->scan_end_src;
526 cmd->scan_end_src &= TRIG_COUNT;
527 if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
531 cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
532 if (!cmd->stop_src || tmp != cmd->stop_src)
540 * step 2: make sure trigger sources
541 * are unique and mutually compatible
544 if (cmd->start_src != TRIG_NOW) {
545 cmd->start_src = TRIG_NOW;
549 if (cmd->scan_begin_src != TRIG_FOLLOW) {
550 cmd->scan_begin_src = TRIG_FOLLOW;
554 if (cmd->convert_src != TRIG_EXT && cmd->convert_src != TRIG_TIMER) {
555 cmd->convert_src = TRIG_TIMER;
559 if (cmd->scan_end_src != TRIG_COUNT) {
560 cmd->scan_end_src = TRIG_COUNT;
564 if (cmd->stop_src != TRIG_NONE && cmd->stop_src != TRIG_COUNT)
571 /* step 3: make sure arguments are trivially compatible */
572 if (cmd->start_arg != 0) {
577 if (cmd->scan_begin_arg != 0) {
578 cmd->scan_begin_arg = 0;
581 if (cmd->convert_src == TRIG_TIMER) {
582 if (cmd->convert_arg < this_board->ai_ns_min) {
583 cmd->convert_arg = this_board->ai_ns_min;
586 } else { /* TRIG_EXT */
587 if (cmd->convert_arg != 0) {
588 cmd->convert_arg = 0;
593 if (cmd->scan_end_arg != cmd->chanlist_len) {
594 cmd->scan_end_arg = cmd->chanlist_len;
597 if (cmd->stop_src == TRIG_COUNT) {
598 if (!cmd->stop_arg) {
602 } else { /* TRIG_NONE */
603 if (cmd->stop_arg != 0) {
613 /* step 4: fix up any arguments */
614 if (cmd->convert_src == TRIG_TIMER) {
615 tmp = cmd->convert_arg;
616 i8253_cascade_ns_to_timer(this_board->i8254_osc_base,
617 &divisor1, &divisor2,
619 cmd->flags & TRIG_ROUND_MASK);
620 if (cmd->convert_arg < this_board->ai_ns_min)
621 cmd->convert_arg = this_board->ai_ns_min;
622 if (tmp != cmd->convert_arg)
630 /* step 5: complain about special chanlist considerations */
633 if (!check_channel_list(dev, s, cmd->chanlist,
635 return 5; /* incorrect channels list */
641 static int pcl816_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
643 unsigned int divisor1 = 0, divisor2 = 0, dma_flags, bytes, dmairq;
644 struct comedi_cmd *cmd = &s->async->cmd;
647 if (cmd->start_src != TRIG_NOW)
649 if (cmd->scan_begin_src != TRIG_FOLLOW)
651 if (cmd->scan_end_src != TRIG_COUNT)
653 if (cmd->scan_end_arg != cmd->chanlist_len)
655 /* if(cmd->chanlist_len>MAX_CHANLIST_LEN) return -EINVAL; */
656 if (devpriv->irq_blocked)
659 if (cmd->convert_src == TRIG_TIMER) {
660 if (cmd->convert_arg < this_board->ai_ns_min)
661 cmd->convert_arg = this_board->ai_ns_min;
663 i8253_cascade_ns_to_timer(this_board->i8254_osc_base, &divisor1,
664 &divisor2, &cmd->convert_arg,
665 cmd->flags & TRIG_ROUND_MASK);
667 /* PCL816 crash if any divisor is set to 1 */
678 start_pacer(dev, -1, 0, 0); /* stop pacer */
680 seglen = check_channel_list(dev, s, cmd->chanlist, cmd->chanlist_len);
683 setup_channel_list(dev, s, cmd->chanlist, seglen);
686 devpriv->ai_n_chan = cmd->chanlist_len;
687 devpriv->ai_act_scan = 0;
688 s->async->cur_chan = 0;
689 devpriv->irq_blocked = 1;
690 devpriv->ai_poll_ptr = 0;
691 devpriv->irq_was_now_closed = 0;
693 if (cmd->stop_src == TRIG_COUNT) {
694 devpriv->ai_scans = cmd->stop_arg;
695 devpriv->ai_neverending = 0;
697 devpriv->ai_scans = 0;
698 devpriv->ai_neverending = 1;
701 /* don't we want wake up every scan? */
702 if ((cmd->flags & TRIG_WAKE_EOS)) {
704 "pl816: You wankt WAKE_EOS but I dont want handle it");
705 /* devpriv->ai_eos=1; */
706 /* if (devpriv->ai_n_chan==1) */
707 /* devpriv->dma=0; // DMA is useless for this situation */
711 bytes = devpriv->hwdmasize[0];
712 if (!devpriv->ai_neverending) {
714 bytes = s->async->cmd.chanlist_len *
715 s->async->cmd.chanlist_len *
718 /* how many DMA pages we must fill */
719 devpriv->dma_runs_to_end = bytes /
720 devpriv->hwdmasize[0];
722 /* on last dma transfer must be moved */
723 devpriv->last_dma_run = bytes % devpriv->hwdmasize[0];
724 devpriv->dma_runs_to_end--;
725 if (devpriv->dma_runs_to_end >= 0)
726 bytes = devpriv->hwdmasize[0];
728 devpriv->dma_runs_to_end = -1;
730 devpriv->next_dma_buf = 0;
731 set_dma_mode(devpriv->dma, DMA_MODE_READ);
732 dma_flags = claim_dma_lock();
733 clear_dma_ff(devpriv->dma);
734 set_dma_addr(devpriv->dma, devpriv->hwdmaptr[0]);
735 set_dma_count(devpriv->dma, bytes);
736 release_dma_lock(dma_flags);
737 enable_dma(devpriv->dma);
740 start_pacer(dev, 1, divisor1, divisor2);
741 dmairq = ((devpriv->dma & 0x3) << 4) | (dev->irq & 0x7);
743 switch (cmd->convert_src) {
745 devpriv->int816_mode = INT_TYPE_AI1_DMA;
748 outb(0x32, dev->iobase + PCL816_CONTROL);
750 /* write irq and DMA to card */
751 outb(dmairq, dev->iobase + PCL816_STATUS);
755 devpriv->int816_mode = INT_TYPE_AI3_DMA;
757 /* Ext trig+IRQ+DMA */
758 outb(0x34, dev->iobase + PCL816_CONTROL);
760 /* write irq to card */
761 outb(dmairq, dev->iobase + PCL816_STATUS);
765 DPRINTK("pcl816 END: pcl812_ai_cmd()\n");
769 static int pcl816_ai_poll(struct comedi_device *dev, struct comedi_subdevice *s)
772 unsigned int top1, top2, i;
775 return 0; /* poll is valid only for DMA transfer */
777 spin_lock_irqsave(&dev->spinlock, flags);
779 for (i = 0; i < 20; i++) {
780 top1 = get_dma_residue(devpriv->dma); /* where is now DMA */
781 top2 = get_dma_residue(devpriv->dma);
786 spin_unlock_irqrestore(&dev->spinlock, flags);
790 /* where is now DMA in buffer */
791 top1 = devpriv->hwdmasize[0] - top1;
792 top1 >>= 1; /* sample position */
793 top2 = top1 - devpriv->ai_poll_ptr;
794 if (top2 < 1) { /* no new samples */
795 spin_unlock_irqrestore(&dev->spinlock, flags);
799 transfer_from_dma_buf(dev, s,
800 (short *)devpriv->dmabuf[devpriv->next_dma_buf],
801 devpriv->ai_poll_ptr, top2);
803 devpriv->ai_poll_ptr = top1; /* new buffer position */
804 spin_unlock_irqrestore(&dev->spinlock, flags);
806 return s->async->buf_write_count - s->async->buf_read_count;
810 ==============================================================================
811 cancel any mode 1-4 AI
813 static int pcl816_ai_cancel(struct comedi_device *dev,
814 struct comedi_subdevice *s)
816 /* DEBUG(printk("pcl816_ai_cancel()\n");) */
818 if (devpriv->irq_blocked > 0) {
819 switch (devpriv->int816_mode) {
821 case INT_TYPE_AI1_DMA_RTC:
822 case INT_TYPE_AI3_DMA_RTC:
823 set_rtc_irq_bit(0); /* stop RTC */
824 del_timer(&devpriv->rtc_irq_timer);
826 case INT_TYPE_AI1_DMA:
827 case INT_TYPE_AI3_DMA:
828 disable_dma(devpriv->dma);
829 case INT_TYPE_AI1_INT:
830 case INT_TYPE_AI3_INT:
831 outb(inb(dev->iobase + PCL816_CONTROL) & 0x73,
832 dev->iobase + PCL816_CONTROL); /* Stop A/D */
834 outb(0, dev->iobase + PCL816_CONTROL); /* Stop A/D */
837 outb(0xb0, dev->iobase + PCL816_CTRCTL);
838 outb(0x70, dev->iobase + PCL816_CTRCTL);
839 outb(0, dev->iobase + PCL816_AD_LO);
840 inb(dev->iobase + PCL816_AD_LO);
841 inb(dev->iobase + PCL816_AD_HI);
843 /* clear INT request */
844 outb(0, dev->iobase + PCL816_CLRINT);
847 outb(0, dev->iobase + PCL816_CONTROL);
848 devpriv->irq_blocked = 0;
849 devpriv->irq_was_now_closed = devpriv->int816_mode;
850 devpriv->int816_mode = 0;
851 devpriv->last_int_sub = s;
857 DEBUG(printk("comedi: pcl816_ai_cancel() successful\n");)
862 ==============================================================================
865 static int pcl816_check(unsigned long iobase)
867 outb(0x00, iobase + PCL816_MUX);
869 if (inb(iobase + PCL816_MUX) != 0x00)
870 return 1; /* there isn't card */
871 outb(0x55, iobase + PCL816_MUX);
873 if (inb(iobase + PCL816_MUX) != 0x55)
874 return 1; /* there isn't card */
875 outb(0x00, iobase + PCL816_MUX);
877 outb(0x18, iobase + PCL816_CONTROL);
879 if (inb(iobase + PCL816_CONTROL) != 0x18)
880 return 1; /* there isn't card */
881 return 0; /* ok, card exist */
885 ==============================================================================
886 reset whole PCL-816 cards
888 static void pcl816_reset(struct comedi_device *dev)
890 /* outb (0, dev->iobase + PCL818_DA_LO); DAC=0V */
891 /* outb (0, dev->iobase + PCL818_DA_HI); */
893 /* outb (0, dev->iobase + PCL818_DO_HI); DO=$0000 */
894 /* outb (0, dev->iobase + PCL818_DO_LO); */
896 outb(0, dev->iobase + PCL816_CONTROL);
897 outb(0, dev->iobase + PCL816_MUX);
898 outb(0, dev->iobase + PCL816_CLRINT);
899 outb(0xb0, dev->iobase + PCL816_CTRCTL); /* Stop pacer */
900 outb(0x70, dev->iobase + PCL816_CTRCTL);
901 outb(0x30, dev->iobase + PCL816_CTRCTL);
902 outb(0, dev->iobase + PCL816_RANGE);
906 ==============================================================================
907 Start/stop pacer onboard pacer
910 start_pacer(struct comedi_device *dev, int mode, unsigned int divisor1,
911 unsigned int divisor2)
913 outb(0x32, dev->iobase + PCL816_CTRCTL);
914 outb(0xff, dev->iobase + PCL816_CTR0);
915 outb(0x00, dev->iobase + PCL816_CTR0);
918 /* set counter 2 as mode 3 */
919 outb(0xb4, dev->iobase + PCL816_CTRCTL);
920 /* set counter 1 as mode 3 */
921 outb(0x74, dev->iobase + PCL816_CTRCTL);
925 DPRINTK("mode %d, divisor1 %d, divisor2 %d\n", mode, divisor1,
927 outb(divisor2 & 0xff, dev->iobase + PCL816_CTR2);
928 outb((divisor2 >> 8) & 0xff, dev->iobase + PCL816_CTR2);
929 outb(divisor1 & 0xff, dev->iobase + PCL816_CTR1);
930 outb((divisor1 >> 8) & 0xff, dev->iobase + PCL816_CTR1);
933 /* clear pending interrupts (just in case) */
934 /* outb(0, dev->iobase + PCL816_CLRINT); */
938 ==============================================================================
939 Check if channel list from user is builded correctly
940 If it's ok, then return non-zero length of repeated segment of channel list
943 check_channel_list(struct comedi_device *dev,
944 struct comedi_subdevice *s, unsigned int *chanlist,
945 unsigned int chanlen)
947 unsigned int chansegment[16];
948 unsigned int i, nowmustbechan, seglen, segpos;
950 /* correct channel and range number check itself comedi/range.c */
952 comedi_error(dev, "range/channel list is empty!");
957 /* first channel is every time ok */
958 chansegment[0] = chanlist[0];
959 for (i = 1, seglen = 1; i < chanlen; i++, seglen++) {
960 /* build part of chanlist */
961 DEBUG(printk(KERN_INFO "%d. %d %d\n", i,
962 CR_CHAN(chanlist[i]),
963 CR_RANGE(chanlist[i]));)
965 /* we detect loop, this must by finish */
966 if (chanlist[0] == chanlist[i])
969 (CR_CHAN(chansegment[i - 1]) + 1) % chanlen;
970 if (nowmustbechan != CR_CHAN(chanlist[i])) {
971 /* channel list isn't continuous :-( */
973 "comedi%d: pcl816: channel list must "
974 "be continuous! chanlist[%i]=%d but "
975 "must be %d or %d!\n", dev->minor,
976 i, CR_CHAN(chanlist[i]), nowmustbechan,
977 CR_CHAN(chanlist[0]));
980 /* well, this is next correct channel in list */
981 chansegment[i] = chanlist[i];
984 /* check whole chanlist */
985 for (i = 0, segpos = 0; i < chanlen; i++) {
986 DEBUG(printk("%d %d=%d %d\n",
987 CR_CHAN(chansegment[i % seglen]),
988 CR_RANGE(chansegment[i % seglen]),
989 CR_CHAN(chanlist[i]),
990 CR_RANGE(chanlist[i]));)
991 if (chanlist[i] != chansegment[i % seglen]) {
993 "comedi%d: pcl816: bad channel or range"
994 " number! chanlist[%i]=%d,%d,%d and not"
995 " %d,%d,%d!\n", dev->minor, i,
996 CR_CHAN(chansegment[i]),
997 CR_RANGE(chansegment[i]),
998 CR_AREF(chansegment[i]),
999 CR_CHAN(chanlist[i % seglen]),
1000 CR_RANGE(chanlist[i % seglen]),
1001 CR_AREF(chansegment[i % seglen]));
1002 return 0; /* chan/gain list is strange */
1009 return seglen; /* we can serve this with MUX logic */
1013 ==============================================================================
1014 Program scan/gain logic with channel list.
1017 setup_channel_list(struct comedi_device *dev,
1018 struct comedi_subdevice *s, unsigned int *chanlist,
1019 unsigned int seglen)
1023 devpriv->ai_act_chanlist_len = seglen;
1024 devpriv->ai_act_chanlist_pos = 0;
1026 for (i = 0; i < seglen; i++) { /* store range list to card */
1027 devpriv->ai_act_chanlist[i] = CR_CHAN(chanlist[i]);
1028 outb(CR_CHAN(chanlist[0]) & 0xf, dev->iobase + PCL816_MUX);
1030 outb(CR_RANGE(chanlist[0]), dev->iobase + PCL816_RANGE);
1034 /* select channel interval to scan */
1035 outb(devpriv->ai_act_chanlist[0] |
1036 (devpriv->ai_act_chanlist[seglen - 1] << 4),
1037 dev->iobase + PCL816_MUX);
1042 ==============================================================================
1043 Enable(1)/disable(0) periodic interrupts from RTC
1045 static int set_rtc_irq_bit(unsigned char bit)
1048 unsigned long flags;
1052 if (RTC_timer_lock > 1)
1056 if (RTC_timer_lock < 0)
1058 if (RTC_timer_lock > 0)
1064 val = CMOS_READ(RTC_CONTROL);
1070 CMOS_WRITE(val, RTC_CONTROL);
1071 CMOS_READ(RTC_INTR_FLAGS);
1072 restore_flags(flags);
1078 ==============================================================================
1079 Free any resources that we have claimed
1081 static void free_resources(struct comedi_device *dev)
1083 /* printk("free_resource()\n"); */
1085 pcl816_ai_cancel(dev, devpriv->sub_ai);
1088 free_dma(devpriv->dma);
1089 if (devpriv->dmabuf[0])
1090 free_pages(devpriv->dmabuf[0], devpriv->dmapages[0]);
1091 if (devpriv->dmabuf[1])
1092 free_pages(devpriv->dmabuf[1], devpriv->dmapages[1]);
1094 if (devpriv->rtc_irq)
1095 free_irq(devpriv->rtc_irq, dev);
1096 if ((devpriv->dma_rtc) && (RTC_lock == 1)) {
1097 if (devpriv->rtc_iobase)
1098 release_region(devpriv->rtc_iobase,
1099 devpriv->rtc_iosize);
1105 free_irq(dev->irq, dev);
1107 release_region(dev->iobase, this_board->io_range);
1108 /* printk("free_resource() end\n"); */
1112 ==============================================================================
1117 static int pcl816_attach(struct comedi_device *dev, struct comedi_devconfig *it)
1120 unsigned long iobase;
1121 unsigned int irq, dma;
1122 unsigned long pages;
1124 struct comedi_subdevice *s;
1126 /* claim our I/O space */
1127 iobase = it->options[0];
1128 printk("comedi%d: pcl816: board=%s, ioport=0x%03lx", dev->minor,
1129 this_board->name, iobase);
1131 if (!request_region(iobase, this_board->io_range, "pcl816")) {
1132 printk("I/O port conflict\n");
1136 dev->iobase = iobase;
1138 if (pcl816_check(iobase)) {
1139 printk(KERN_ERR ", I cann't detect board. FAIL!\n");
1143 ret = alloc_private(dev, sizeof(struct pcl816_private));
1145 return ret; /* Can't alloc mem */
1147 /* set up some name stuff */
1148 dev->board_name = this_board->name;
1152 if (this_board->IRQbits != 0) { /* board support IRQ */
1153 irq = it->options[1];
1154 if (irq) { /* we want to use IRQ */
1155 if (((1 << irq) & this_board->IRQbits) == 0) {
1157 (", IRQ %u is out of allowed range, "
1158 "DISABLING IT", irq);
1159 irq = 0; /* Bad IRQ */
1162 (irq, interrupt_pcl816, 0, "pcl816", dev)) {
1164 (", unable to allocate IRQ %u, "
1165 "DISABLING IT", irq);
1166 irq = 0; /* Can't use IRQ */
1168 printk(KERN_INFO ", irq=%u", irq);
1175 if (irq) /* 1=we have allocated irq */
1176 devpriv->irq_free = 1;
1178 devpriv->irq_free = 0;
1180 devpriv->irq_blocked = 0; /* number of subdevice which use IRQ */
1181 devpriv->int816_mode = 0; /* mode of irq */
1184 /* grab RTC for DMA operations */
1185 devpriv->dma_rtc = 0;
1186 if (it->options[2] > 0) { /* we want to use DMA */
1187 if (RTC_lock == 0) {
1188 if (!request_region(RTC_PORT(0), RTC_IO_EXTENT,
1192 devpriv->rtc_iobase = RTC_PORT(0);
1193 devpriv->rtc_iosize = RTC_IO_EXTENT;
1195 #ifdef UNTESTED_CODE
1196 if (!request_irq(RTC_IRQ, interrupt_pcl816_ai_mode13_dma_rtc, 0,
1197 "pcl816 DMA (RTC)", dev)) {
1198 devpriv->dma_rtc = 1;
1199 devpriv->rtc_irq = RTC_IRQ;
1200 printk(", dma_irq=%u", devpriv->rtc_irq);
1203 if (RTC_lock == 0) {
1204 if (devpriv->rtc_iobase)
1205 release_region(devpriv->rtc_iobase,
1206 devpriv->rtc_iosize);
1208 devpriv->rtc_iobase = 0;
1209 devpriv->rtc_iosize = 0;
1212 printk("pcl816: RTC code missing");
1222 if ((devpriv->irq_free == 0) && (devpriv->dma_rtc == 0))
1223 goto no_dma; /* if we haven't IRQ, we can't use DMA */
1225 if (this_board->DMAbits != 0) { /* board support DMA */
1226 dma = it->options[2];
1228 goto no_dma; /* DMA disabled */
1230 if (((1 << dma) & this_board->DMAbits) == 0) {
1231 printk(", DMA is out of allowed range, FAIL!\n");
1232 return -EINVAL; /* Bad DMA */
1234 ret = request_dma(dma, "pcl816");
1237 ", unable to allocate DMA %u, FAIL!\n", dma);
1238 return -EBUSY; /* DMA isn't free */
1242 printk(KERN_INFO ", dma=%u", dma);
1243 pages = 2; /* we need 16KB */
1244 devpriv->dmabuf[0] = __get_dma_pages(GFP_KERNEL, pages);
1246 if (!devpriv->dmabuf[0]) {
1247 printk(", unable to allocate DMA buffer, FAIL!\n");
1249 * maybe experiment with try_to_free_pages()
1252 return -EBUSY; /* no buffer :-( */
1254 devpriv->dmapages[0] = pages;
1255 devpriv->hwdmaptr[0] = virt_to_bus((void *)devpriv->dmabuf[0]);
1256 devpriv->hwdmasize[0] = (1 << pages) * PAGE_SIZE;
1257 /* printk("%d %d %ld, ",devpriv->dmapages[0],devpriv->hwdmasize[0],PAGE_SIZE); */
1259 if (devpriv->dma_rtc == 0) { /* we must do duble buff :-( */
1260 devpriv->dmabuf[1] = __get_dma_pages(GFP_KERNEL, pages);
1261 if (!devpriv->dmabuf[1]) {
1263 ", unable to allocate DMA buffer, "
1267 devpriv->dmapages[1] = pages;
1268 devpriv->hwdmaptr[1] =
1269 virt_to_bus((void *)devpriv->dmabuf[1]);
1270 devpriv->hwdmasize[1] = (1 << pages) * PAGE_SIZE;
1276 /* if (this_board->n_aochan > 0)
1277 subdevs[1] = COMEDI_SUBD_AO;
1278 if (this_board->n_dichan > 0)
1279 subdevs[2] = COMEDI_SUBD_DI;
1280 if (this_board->n_dochan > 0)
1281 subdevs[3] = COMEDI_SUBD_DO;
1284 ret = alloc_subdevices(dev, 1);
1288 s = dev->subdevices + 0;
1289 if (this_board->n_aichan > 0) {
1290 s->type = COMEDI_SUBD_AI;
1291 devpriv->sub_ai = s;
1292 dev->read_subdev = s;
1293 s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
1294 s->n_chan = this_board->n_aichan;
1295 s->subdev_flags |= SDF_DIFF;
1296 /* printk (", %dchans DIFF DAC - %d", s->n_chan, i); */
1297 s->maxdata = this_board->ai_maxdata;
1298 s->len_chanlist = this_board->ai_chanlist;
1299 s->range_table = this_board->ai_range_type;
1300 s->cancel = pcl816_ai_cancel;
1301 s->do_cmdtest = pcl816_ai_cmdtest;
1302 s->do_cmd = pcl816_ai_cmd;
1303 s->poll = pcl816_ai_poll;
1304 s->insn_read = pcl816_ai_insn_read;
1306 s->type = COMEDI_SUBD_UNUSED;
1310 case COMEDI_SUBD_AO:
1311 s->subdev_flags = SDF_WRITABLE | SDF_GROUND;
1312 s->n_chan = this_board->n_aochan;
1313 s->maxdata = this_board->ao_maxdata;
1314 s->len_chanlist = this_board->ao_chanlist;
1315 s->range_table = this_board->ao_range_type;
1318 case COMEDI_SUBD_DI:
1319 s->subdev_flags = SDF_READABLE;
1320 s->n_chan = this_board->n_dichan;
1322 s->len_chanlist = this_board->n_dichan;
1323 s->range_table = &range_digital;
1326 case COMEDI_SUBD_DO:
1327 s->subdev_flags = SDF_WRITABLE;
1328 s->n_chan = this_board->n_dochan;
1330 s->len_chanlist = this_board->n_dochan;
1331 s->range_table = &range_digital;
1343 ==============================================================================
1346 static int pcl816_detach(struct comedi_device *dev)
1348 DEBUG(printk(KERN_INFO "comedi%d: pcl816: remove\n", dev->minor);)
1349 free_resources(dev);
1351 if (devpriv->dma_rtc)
1357 MODULE_AUTHOR("Comedi http://www.comedi.org");
1358 MODULE_DESCRIPTION("Comedi low-level driver");
1359 MODULE_LICENSE("GPL");