1// SPDX-License-Identifier: GPL-2.0
2/*
3 * pcl816.c
4 * Comedi driver for Advantech PCL-816 cards
5 *
6 * Author: Juan Grigera <juan@grigera.com.ar>
7 * based on pcl818 by Michal Dobes <dobes@tesnet.cz> and bits of pcl812
8 */
9
10/*
11 * Driver: pcl816
12 * Description: Advantech PCL-816 cards, PCL-814
13 * Devices: [Advantech] PCL-816 (pcl816), PCL-814B (pcl814b)
14 * Author: Juan Grigera <juan@grigera.com.ar>
15 * Status: works
16 * Updated: Tue, 2 Apr 2002 23:15:21 -0800
17 *
18 * PCL 816 and 814B have 16 SE/DIFF ADCs, 16 DACs, 16 DI and 16 DO.
19 * Differences are at resolution (16 vs 12 bits).
20 *
21 * The driver support AI command mode, other subdevices not written.
22 *
23 * Analog output and digital input and output are not supported.
24 *
25 * Configuration Options:
26 * [0] - IO Base
27 * [1] - IRQ (0=disable, 2, 3, 4, 5, 6, 7)
28 * [2] - DMA (0=disable, 1, 3)
29 * [3] - 0, 10=10MHz clock for 8254
30 * 1= 1MHz clock for 8254
31 */
32
33#include <linux/module.h>
34#include <linux/gfp.h>
35#include <linux/delay.h>
36#include <linux/io.h>
37#include <linux/interrupt.h>
38#include <linux/comedi/comedidev.h>
39#include <linux/comedi/comedi_8254.h>
40#include <linux/comedi/comedi_isadma.h>
41
42/*
43 * Register I/O map
44 */
45#define PCL816_DO_DI_LSB_REG 0x00
46#define PCL816_DO_DI_MSB_REG 0x01
47#define PCL816_TIMER_BASE 0x04
48#define PCL816_AI_LSB_REG 0x08
49#define PCL816_AI_MSB_REG 0x09
50#define PCL816_RANGE_REG 0x09
51#define PCL816_CLRINT_REG 0x0a
52#define PCL816_MUX_REG 0x0b
53#define PCL816_MUX_SCAN(_first, _last) (((_last) << 4) | (_first))
54#define PCL816_CTRL_REG 0x0c
55#define PCL816_CTRL_SOFT_TRIG BIT(0)
56#define PCL816_CTRL_PACER_TRIG BIT(1)
57#define PCL816_CTRL_EXT_TRIG BIT(2)
58#define PCL816_CTRL_POE BIT(3)
59#define PCL816_CTRL_DMAEN BIT(4)
60#define PCL816_CTRL_INTEN BIT(5)
61#define PCL816_CTRL_DMASRC_SLOT(x) (((x) & 0x3) << 6)
62#define PCL816_STATUS_REG 0x0d
63#define PCL816_STATUS_NEXT_CHAN_MASK (0xf << 0)
64#define PCL816_STATUS_INTSRC_SLOT(x) (((x) & 0x3) << 4)
65#define PCL816_STATUS_INTSRC_DMA PCL816_STATUS_INTSRC_SLOT(3)
66#define PCL816_STATUS_INTSRC_MASK PCL816_STATUS_INTSRC_SLOT(3)
67#define PCL816_STATUS_INTACT BIT(6)
68#define PCL816_STATUS_DRDY BIT(7)
69
70#define MAGIC_DMA_WORD 0x5a5a
71
72static const struct comedi_lrange range_pcl816 = {
73 8, {
74 BIP_RANGE(10),
75 BIP_RANGE(5),
76 BIP_RANGE(2.5),
77 BIP_RANGE(1.25),
78 UNI_RANGE(10),
79 UNI_RANGE(5),
80 UNI_RANGE(2.5),
81 UNI_RANGE(1.25)
82 }
83};
84
85struct pcl816_board {
86 const char *name;
87 int ai_maxdata;
88 int ai_chanlist;
89};
90
91static const struct pcl816_board boardtypes[] = {
92 {
93 .name = "pcl816",
94 .ai_maxdata = 0xffff,
95 .ai_chanlist = 1024,
96 }, {
97 .name = "pcl814b",
98 .ai_maxdata = 0x3fff,
99 .ai_chanlist = 1024,
100 },
101};
102
103struct pcl816_private {
104 struct comedi_isadma *dma;
105 unsigned int ai_poll_ptr; /* how many sampes transfer poll */
106 unsigned int ai_cmd_running:1;
107 unsigned int ai_cmd_canceled:1;
108};
109
110static void pcl816_ai_setup_dma(struct comedi_device *dev,
111 struct comedi_subdevice *s,
112 unsigned int unread_samples)
113{
114 struct pcl816_private *devpriv = dev->private;
115 struct comedi_isadma *dma = devpriv->dma;
116 struct comedi_isadma_desc *desc = &dma->desc[dma->cur_dma];
117 unsigned int max_samples = comedi_bytes_to_samples(s, nbytes: desc->maxsize);
118 unsigned int nsamples;
119
120 comedi_isadma_disable(dma_chan: dma->chan);
121
122 /*
123 * Determine dma size based on the buffer maxsize plus the number of
124 * unread samples and the number of samples remaining in the command.
125 */
126 nsamples = comedi_nsamples_left(s, nsamples: max_samples + unread_samples);
127 if (nsamples > unread_samples) {
128 nsamples -= unread_samples;
129 desc->size = comedi_samples_to_bytes(s, nsamples);
130 comedi_isadma_program(desc);
131 }
132}
133
134static void pcl816_ai_set_chan_range(struct comedi_device *dev,
135 unsigned int chan,
136 unsigned int range)
137{
138 outb(value: chan, port: dev->iobase + PCL816_MUX_REG);
139 outb(value: range, port: dev->iobase + PCL816_RANGE_REG);
140}
141
142static void pcl816_ai_set_chan_scan(struct comedi_device *dev,
143 unsigned int first_chan,
144 unsigned int last_chan)
145{
146 outb(PCL816_MUX_SCAN(first_chan, last_chan),
147 port: dev->iobase + PCL816_MUX_REG);
148}
149
150static void pcl816_ai_setup_chanlist(struct comedi_device *dev,
151 unsigned int *chanlist,
152 unsigned int seglen)
153{
154 unsigned int first_chan = CR_CHAN(chanlist[0]);
155 unsigned int last_chan;
156 unsigned int range;
157 unsigned int i;
158
159 /* store range list to card */
160 for (i = 0; i < seglen; i++) {
161 last_chan = CR_CHAN(chanlist[i]);
162 range = CR_RANGE(chanlist[i]);
163
164 pcl816_ai_set_chan_range(dev, chan: last_chan, range);
165 }
166
167 udelay(1);
168
169 pcl816_ai_set_chan_scan(dev, first_chan, last_chan);
170}
171
172static void pcl816_ai_clear_eoc(struct comedi_device *dev)
173{
174 /* writing any value clears the interrupt request */
175 outb(value: 0, port: dev->iobase + PCL816_CLRINT_REG);
176}
177
178static void pcl816_ai_soft_trig(struct comedi_device *dev)
179{
180 /* writing any value triggers a software conversion */
181 outb(value: 0, port: dev->iobase + PCL816_AI_LSB_REG);
182}
183
184static unsigned int pcl816_ai_get_sample(struct comedi_device *dev,
185 struct comedi_subdevice *s)
186{
187 unsigned int val;
188
189 val = inb(port: dev->iobase + PCL816_AI_MSB_REG) << 8;
190 val |= inb(port: dev->iobase + PCL816_AI_LSB_REG);
191
192 return val & s->maxdata;
193}
194
195static int pcl816_ai_eoc(struct comedi_device *dev,
196 struct comedi_subdevice *s,
197 struct comedi_insn *insn,
198 unsigned long context)
199{
200 unsigned int status;
201
202 status = inb(port: dev->iobase + PCL816_STATUS_REG);
203 if ((status & PCL816_STATUS_DRDY) == 0)
204 return 0;
205 return -EBUSY;
206}
207
208static bool pcl816_ai_next_chan(struct comedi_device *dev,
209 struct comedi_subdevice *s)
210{
211 struct comedi_cmd *cmd = &s->async->cmd;
212
213 if (cmd->stop_src == TRIG_COUNT &&
214 s->async->scans_done >= cmd->stop_arg) {
215 s->async->events |= COMEDI_CB_EOA;
216 return false;
217 }
218
219 return true;
220}
221
222static void transfer_from_dma_buf(struct comedi_device *dev,
223 struct comedi_subdevice *s,
224 unsigned short *ptr,
225 unsigned int bufptr, unsigned int len)
226{
227 unsigned short val;
228 int i;
229
230 for (i = 0; i < len; i++) {
231 val = ptr[bufptr++];
232 comedi_buf_write_samples(s, data: &val, nsamples: 1);
233
234 if (!pcl816_ai_next_chan(dev, s))
235 return;
236 }
237}
238
239static irqreturn_t pcl816_interrupt(int irq, void *d)
240{
241 struct comedi_device *dev = d;
242 struct comedi_subdevice *s = dev->read_subdev;
243 struct pcl816_private *devpriv = dev->private;
244 struct comedi_isadma *dma = devpriv->dma;
245 struct comedi_isadma_desc *desc = &dma->desc[dma->cur_dma];
246 unsigned int nsamples;
247 unsigned int bufptr;
248
249 if (!dev->attached || !devpriv->ai_cmd_running) {
250 pcl816_ai_clear_eoc(dev);
251 return IRQ_HANDLED;
252 }
253
254 if (devpriv->ai_cmd_canceled) {
255 devpriv->ai_cmd_canceled = 0;
256 pcl816_ai_clear_eoc(dev);
257 return IRQ_HANDLED;
258 }
259
260 nsamples = comedi_bytes_to_samples(s, nbytes: desc->size) -
261 devpriv->ai_poll_ptr;
262 bufptr = devpriv->ai_poll_ptr;
263 devpriv->ai_poll_ptr = 0;
264
265 /* restart dma with the next buffer */
266 dma->cur_dma = 1 - dma->cur_dma;
267 pcl816_ai_setup_dma(dev, s, unread_samples: nsamples);
268
269 transfer_from_dma_buf(dev, s, ptr: desc->virt_addr, bufptr, len: nsamples);
270
271 pcl816_ai_clear_eoc(dev);
272
273 comedi_handle_events(dev, s);
274 return IRQ_HANDLED;
275}
276
277static int check_channel_list(struct comedi_device *dev,
278 struct comedi_subdevice *s,
279 unsigned int *chanlist,
280 unsigned int chanlen)
281{
282 unsigned int chansegment[16];
283 unsigned int i, nowmustbechan, seglen;
284
285 /* correct channel and range number check itself comedi/range.c */
286 if (chanlen < 1) {
287 dev_err(dev->class_dev, "range/channel list is empty!\n");
288 return 0;
289 }
290
291 if (chanlen > 1) {
292 /* first channel is every time ok */
293 chansegment[0] = chanlist[0];
294 for (i = 1, seglen = 1; i < chanlen; i++, seglen++) {
295 /* we detect loop, this must by finish */
296 if (chanlist[0] == chanlist[i])
297 break;
298 nowmustbechan =
299 (CR_CHAN(chansegment[i - 1]) + 1) % chanlen;
300 if (nowmustbechan != CR_CHAN(chanlist[i])) {
301 /* channel list isn't continuous :-( */
302 dev_dbg(dev->class_dev,
303 "channel list must be continuous! chanlist[%i]=%d but must be %d or %d!\n",
304 i, CR_CHAN(chanlist[i]), nowmustbechan,
305 CR_CHAN(chanlist[0]));
306 return 0;
307 }
308 /* well, this is next correct channel in list */
309 chansegment[i] = chanlist[i];
310 }
311
312 /* check whole chanlist */
313 for (i = 0; i < chanlen; i++) {
314 if (chanlist[i] != chansegment[i % seglen]) {
315 dev_dbg(dev->class_dev,
316 "bad channel or range number! chanlist[%i]=%d,%d,%d and not %d,%d,%d!\n",
317 i, CR_CHAN(chansegment[i]),
318 CR_RANGE(chansegment[i]),
319 CR_AREF(chansegment[i]),
320 CR_CHAN(chanlist[i % seglen]),
321 CR_RANGE(chanlist[i % seglen]),
322 CR_AREF(chansegment[i % seglen]));
323 return 0; /* chan/gain list is strange */
324 }
325 }
326 } else {
327 seglen = 1;
328 }
329
330 return seglen; /* we can serve this with MUX logic */
331}
332
333static int pcl816_ai_cmdtest(struct comedi_device *dev,
334 struct comedi_subdevice *s, struct comedi_cmd *cmd)
335{
336 int err = 0;
337
338 /* Step 1 : check if triggers are trivially valid */
339
340 err |= comedi_check_trigger_src(src: &cmd->start_src, TRIG_NOW);
341 err |= comedi_check_trigger_src(src: &cmd->scan_begin_src, TRIG_FOLLOW);
342 err |= comedi_check_trigger_src(src: &cmd->convert_src,
343 TRIG_EXT | TRIG_TIMER);
344 err |= comedi_check_trigger_src(src: &cmd->scan_end_src, TRIG_COUNT);
345 err |= comedi_check_trigger_src(src: &cmd->stop_src, TRIG_COUNT | TRIG_NONE);
346
347 if (err)
348 return 1;
349
350 /* Step 2a : make sure trigger sources are unique */
351
352 err |= comedi_check_trigger_is_unique(src: cmd->convert_src);
353 err |= comedi_check_trigger_is_unique(src: cmd->stop_src);
354
355 /* Step 2b : and mutually compatible */
356
357 if (err)
358 return 2;
359
360 /* Step 3: check if arguments are trivially valid */
361
362 err |= comedi_check_trigger_arg_is(arg: &cmd->start_arg, val: 0);
363 err |= comedi_check_trigger_arg_is(arg: &cmd->scan_begin_arg, val: 0);
364
365 if (cmd->convert_src == TRIG_TIMER)
366 err |= comedi_check_trigger_arg_min(arg: &cmd->convert_arg, val: 10000);
367 else /* TRIG_EXT */
368 err |= comedi_check_trigger_arg_is(arg: &cmd->convert_arg, val: 0);
369
370 err |= comedi_check_trigger_arg_is(arg: &cmd->scan_end_arg,
371 val: cmd->chanlist_len);
372
373 if (cmd->stop_src == TRIG_COUNT)
374 err |= comedi_check_trigger_arg_min(arg: &cmd->stop_arg, val: 1);
375 else /* TRIG_NONE */
376 err |= comedi_check_trigger_arg_is(arg: &cmd->stop_arg, val: 0);
377
378 if (err)
379 return 3;
380
381 /* step 4: fix up any arguments */
382 if (cmd->convert_src == TRIG_TIMER) {
383 unsigned int arg = cmd->convert_arg;
384
385 comedi_8254_cascade_ns_to_timer(i8254: dev->pacer, nanosec: &arg, flags: cmd->flags);
386 err |= comedi_check_trigger_arg_is(arg: &cmd->convert_arg, val: arg);
387 }
388
389 if (err)
390 return 4;
391
392 /* step 5: complain about special chanlist considerations */
393
394 if (cmd->chanlist) {
395 if (!check_channel_list(dev, s, chanlist: cmd->chanlist,
396 chanlen: cmd->chanlist_len))
397 return 5; /* incorrect channels list */
398 }
399
400 return 0;
401}
402
403static int pcl816_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
404{
405 struct pcl816_private *devpriv = dev->private;
406 struct comedi_isadma *dma = devpriv->dma;
407 struct comedi_cmd *cmd = &s->async->cmd;
408 unsigned int ctrl;
409 unsigned int seglen;
410
411 if (devpriv->ai_cmd_running)
412 return -EBUSY;
413
414 seglen = check_channel_list(dev, s, chanlist: cmd->chanlist, chanlen: cmd->chanlist_len);
415 if (seglen < 1)
416 return -EINVAL;
417 pcl816_ai_setup_chanlist(dev, chanlist: cmd->chanlist, seglen);
418 udelay(1);
419
420 devpriv->ai_cmd_running = 1;
421 devpriv->ai_poll_ptr = 0;
422 devpriv->ai_cmd_canceled = 0;
423
424 /* setup and enable dma for the first buffer */
425 dma->cur_dma = 0;
426 pcl816_ai_setup_dma(dev, s, unread_samples: 0);
427
428 comedi_8254_set_mode(i8254: dev->pacer, counter: 0, mode: I8254_MODE1 | I8254_BINARY);
429 comedi_8254_write(i8254: dev->pacer, counter: 0, val: 0x0ff);
430 udelay(1);
431 comedi_8254_update_divisors(i8254: dev->pacer);
432 comedi_8254_pacer_enable(i8254: dev->pacer, counter1: 1, counter2: 2, enable: true);
433
434 ctrl = PCL816_CTRL_INTEN | PCL816_CTRL_DMAEN |
435 PCL816_CTRL_DMASRC_SLOT(0);
436 if (cmd->convert_src == TRIG_TIMER)
437 ctrl |= PCL816_CTRL_PACER_TRIG;
438 else /* TRIG_EXT */
439 ctrl |= PCL816_CTRL_EXT_TRIG;
440
441 outb(value: ctrl, port: dev->iobase + PCL816_CTRL_REG);
442 outb(value: (dma->chan << 4) | dev->irq,
443 port: dev->iobase + PCL816_STATUS_REG);
444
445 return 0;
446}
447
448static int pcl816_ai_poll(struct comedi_device *dev, struct comedi_subdevice *s)
449{
450 struct pcl816_private *devpriv = dev->private;
451 struct comedi_isadma *dma = devpriv->dma;
452 struct comedi_isadma_desc *desc;
453 unsigned long flags;
454 unsigned int poll;
455 int ret;
456
457 spin_lock_irqsave(&dev->spinlock, flags);
458
459 poll = comedi_isadma_poll(dma);
460 poll = comedi_bytes_to_samples(s, nbytes: poll);
461 if (poll > devpriv->ai_poll_ptr) {
462 desc = &dma->desc[dma->cur_dma];
463 transfer_from_dma_buf(dev, s, ptr: desc->virt_addr,
464 bufptr: devpriv->ai_poll_ptr,
465 len: poll - devpriv->ai_poll_ptr);
466 /* new buffer position */
467 devpriv->ai_poll_ptr = poll;
468
469 comedi_handle_events(dev, s);
470
471 ret = comedi_buf_n_bytes_ready(s);
472 } else {
473 /* no new samples */
474 ret = 0;
475 }
476 spin_unlock_irqrestore(lock: &dev->spinlock, flags);
477
478 return ret;
479}
480
481static int pcl816_ai_cancel(struct comedi_device *dev,
482 struct comedi_subdevice *s)
483{
484 struct pcl816_private *devpriv = dev->private;
485
486 if (!devpriv->ai_cmd_running)
487 return 0;
488
489 outb(value: 0, port: dev->iobase + PCL816_CTRL_REG);
490 pcl816_ai_clear_eoc(dev);
491
492 comedi_8254_pacer_enable(i8254: dev->pacer, counter1: 1, counter2: 2, enable: false);
493
494 devpriv->ai_cmd_running = 0;
495 devpriv->ai_cmd_canceled = 1;
496
497 return 0;
498}
499
500static int pcl816_ai_insn_read(struct comedi_device *dev,
501 struct comedi_subdevice *s,
502 struct comedi_insn *insn,
503 unsigned int *data)
504{
505 unsigned int chan = CR_CHAN(insn->chanspec);
506 unsigned int range = CR_RANGE(insn->chanspec);
507 int ret = 0;
508 int i;
509
510 outb(PCL816_CTRL_SOFT_TRIG, port: dev->iobase + PCL816_CTRL_REG);
511
512 pcl816_ai_set_chan_range(dev, chan, range);
513 pcl816_ai_set_chan_scan(dev, first_chan: chan, last_chan: chan);
514
515 for (i = 0; i < insn->n; i++) {
516 pcl816_ai_clear_eoc(dev);
517 pcl816_ai_soft_trig(dev);
518
519 ret = comedi_timeout(dev, s, insn, cb: pcl816_ai_eoc, context: 0);
520 if (ret)
521 break;
522
523 data[i] = pcl816_ai_get_sample(dev, s);
524 }
525 outb(value: 0, port: dev->iobase + PCL816_CTRL_REG);
526 pcl816_ai_clear_eoc(dev);
527
528 return ret ? ret : insn->n;
529}
530
531static int pcl816_di_insn_bits(struct comedi_device *dev,
532 struct comedi_subdevice *s,
533 struct comedi_insn *insn,
534 unsigned int *data)
535{
536 data[1] = inb(port: dev->iobase + PCL816_DO_DI_LSB_REG) |
537 (inb(port: dev->iobase + PCL816_DO_DI_MSB_REG) << 8);
538
539 return insn->n;
540}
541
542static int pcl816_do_insn_bits(struct comedi_device *dev,
543 struct comedi_subdevice *s,
544 struct comedi_insn *insn,
545 unsigned int *data)
546{
547 if (comedi_dio_update_state(s, data)) {
548 outb(value: s->state & 0xff, port: dev->iobase + PCL816_DO_DI_LSB_REG);
549 outb(value: (s->state >> 8), port: dev->iobase + PCL816_DO_DI_MSB_REG);
550 }
551
552 data[1] = s->state;
553
554 return insn->n;
555}
556
557static void pcl816_reset(struct comedi_device *dev)
558{
559 outb(value: 0, port: dev->iobase + PCL816_CTRL_REG);
560 pcl816_ai_set_chan_range(dev, chan: 0, range: 0);
561 pcl816_ai_clear_eoc(dev);
562
563 /* set all digital outputs low */
564 outb(value: 0, port: dev->iobase + PCL816_DO_DI_LSB_REG);
565 outb(value: 0, port: dev->iobase + PCL816_DO_DI_MSB_REG);
566}
567
568static void pcl816_alloc_irq_and_dma(struct comedi_device *dev,
569 struct comedi_devconfig *it)
570{
571 struct pcl816_private *devpriv = dev->private;
572 unsigned int irq_num = it->options[1];
573 unsigned int dma_chan = it->options[2];
574
575 /* only IRQs 2-7 and DMA channels 3 and 1 are valid */
576 if (!(irq_num >= 2 && irq_num <= 7) ||
577 !(dma_chan == 3 || dma_chan == 1))
578 return;
579
580 if (request_irq(irq: irq_num, handler: pcl816_interrupt, flags: 0, name: dev->board_name, dev))
581 return;
582
583 /* DMA uses two 16K buffers */
584 devpriv->dma = comedi_isadma_alloc(dev, n_desc: 2, dma_chan1: dma_chan, dma_chan2: dma_chan,
585 PAGE_SIZE * 4, COMEDI_ISADMA_READ);
586 if (!devpriv->dma)
587 free_irq(irq_num, dev);
588 else
589 dev->irq = irq_num;
590}
591
592static void pcl816_free_dma(struct comedi_device *dev)
593{
594 struct pcl816_private *devpriv = dev->private;
595
596 if (devpriv)
597 comedi_isadma_free(dma: devpriv->dma);
598}
599
600static int pcl816_attach(struct comedi_device *dev, struct comedi_devconfig *it)
601{
602 const struct pcl816_board *board = dev->board_ptr;
603 struct pcl816_private *devpriv;
604 struct comedi_subdevice *s;
605 int ret;
606
607 devpriv = comedi_alloc_devpriv(dev, size: sizeof(*devpriv));
608 if (!devpriv)
609 return -ENOMEM;
610
611 ret = comedi_request_region(dev, start: it->options[0], len: 0x10);
612 if (ret)
613 return ret;
614
615 /* an IRQ and DMA are required to support async commands */
616 pcl816_alloc_irq_and_dma(dev, it);
617
618 dev->pacer = comedi_8254_io_alloc(iobase: dev->iobase + PCL816_TIMER_BASE,
619 I8254_OSC_BASE_10MHZ, I8254_IO8, regshift: 0);
620 if (IS_ERR(ptr: dev->pacer))
621 return PTR_ERR(ptr: dev->pacer);
622
623 ret = comedi_alloc_subdevices(dev, num_subdevices: 4);
624 if (ret)
625 return ret;
626
627 s = &dev->subdevices[0];
628 s->type = COMEDI_SUBD_AI;
629 s->subdev_flags = SDF_CMD_READ | SDF_DIFF;
630 s->n_chan = 16;
631 s->maxdata = board->ai_maxdata;
632 s->range_table = &range_pcl816;
633 s->insn_read = pcl816_ai_insn_read;
634 if (dev->irq) {
635 dev->read_subdev = s;
636 s->subdev_flags |= SDF_CMD_READ;
637 s->len_chanlist = board->ai_chanlist;
638 s->do_cmdtest = pcl816_ai_cmdtest;
639 s->do_cmd = pcl816_ai_cmd;
640 s->poll = pcl816_ai_poll;
641 s->cancel = pcl816_ai_cancel;
642 }
643
644 /* Piggyback Slot1 subdevice */
645 s = &dev->subdevices[1];
646 s->type = COMEDI_SUBD_UNUSED;
647
648 /* Digital Input subdevice */
649 s = &dev->subdevices[2];
650 s->type = COMEDI_SUBD_DI;
651 s->subdev_flags = SDF_READABLE;
652 s->n_chan = 16;
653 s->maxdata = 1;
654 s->range_table = &range_digital;
655 s->insn_bits = pcl816_di_insn_bits;
656
657 /* Digital Output subdevice */
658 s = &dev->subdevices[3];
659 s->type = COMEDI_SUBD_DO;
660 s->subdev_flags = SDF_WRITABLE;
661 s->n_chan = 16;
662 s->maxdata = 1;
663 s->range_table = &range_digital;
664 s->insn_bits = pcl816_do_insn_bits;
665
666 pcl816_reset(dev);
667
668 return 0;
669}
670
671static void pcl816_detach(struct comedi_device *dev)
672{
673 if (dev->private) {
674 pcl816_ai_cancel(dev, s: dev->read_subdev);
675 pcl816_reset(dev);
676 }
677 pcl816_free_dma(dev);
678 comedi_legacy_detach(dev);
679}
680
681static struct comedi_driver pcl816_driver = {
682 .driver_name = "pcl816",
683 .module = THIS_MODULE,
684 .attach = pcl816_attach,
685 .detach = pcl816_detach,
686 .board_name = &boardtypes[0].name,
687 .num_names = ARRAY_SIZE(boardtypes),
688 .offset = sizeof(struct pcl816_board),
689};
690module_comedi_driver(pcl816_driver);
691
692MODULE_AUTHOR("Comedi https://www.comedi.org");
693MODULE_DESCRIPTION("Comedi low-level driver");
694MODULE_LICENSE("GPL");
695

source code of linux/drivers/comedi/drivers/pcl816.c