1 // SPDX-License-Identifier: GPL-2.0+
4 * Comedi driver for PC-LabCard PCL-711 and AdSys ACL-8112 and compatibles
5 * Copyright (C) 1998 David A. Schleef <ds@schleef.org>
6 * Janne Jalkanen <jalkanen@cs.hut.fi>
7 * Eric Bunn <ebu@cs.hut.fi>
9 * COMEDI - Linux Control and Measurement Device Interface
10 * Copyright (C) 1998 David A. Schleef <ds@schleef.org>
15 * Description: Advantech PCL-711 and 711b, ADLink ACL-8112
16 * Devices: [Advantech] PCL-711 (pcl711), PCL-711B (pcl711b),
17 * [ADLink] ACL-8112HG (acl8112hg), ACL-8112DG (acl8112dg)
18 * Author: David A. Schleef <ds@schleef.org>
19 * Janne Jalkanen <jalkanen@cs.hut.fi>
20 * Eric Bunn <ebu@cs.hut.fi>
22 * Status: mostly complete
24 * Configuration Options:
29 #include <linux/module.h>
30 #include <linux/delay.h>
31 #include <linux/interrupt.h>
33 #include "../comedidev.h"
35 #include "comedi_8254.h"
38 * I/O port register map
40 #define PCL711_TIMER_BASE 0x00
41 #define PCL711_AI_LSB_REG 0x04
42 #define PCL711_AI_MSB_REG 0x05
43 #define PCL711_AI_MSB_DRDY BIT(4)
44 #define PCL711_AO_LSB_REG(x) (0x04 + ((x) * 2))
45 #define PCL711_AO_MSB_REG(x) (0x05 + ((x) * 2))
46 #define PCL711_DI_LSB_REG 0x06
47 #define PCL711_DI_MSB_REG 0x07
48 #define PCL711_INT_STAT_REG 0x08
49 #define PCL711_INT_STAT_CLR (0 << 0) /* any value will work */
50 #define PCL711_AI_GAIN_REG 0x09
51 #define PCL711_AI_GAIN(x) (((x) & 0xf) << 0)
52 #define PCL711_MUX_REG 0x0a
53 #define PCL711_MUX_CHAN(x) (((x) & 0xf) << 0)
54 #define PCL711_MUX_CS0 BIT(4)
55 #define PCL711_MUX_CS1 BIT(5)
56 #define PCL711_MUX_DIFF (PCL711_MUX_CS0 | PCL711_MUX_CS1)
57 #define PCL711_MODE_REG 0x0b
58 #define PCL711_MODE(x) (((x) & 0x7) << 0)
59 #define PCL711_MODE_DEFAULT PCL711_MODE(0)
60 #define PCL711_MODE_SOFTTRIG PCL711_MODE(1)
61 #define PCL711_MODE_EXT PCL711_MODE(2)
62 #define PCL711_MODE_EXT_IRQ PCL711_MODE(3)
63 #define PCL711_MODE_PACER PCL711_MODE(4)
64 #define PCL711_MODE_PACER_IRQ PCL711_MODE(6)
65 #define PCL711_MODE_IRQ(x) (((x) & 0x7) << 4)
66 #define PCL711_SOFTTRIG_REG 0x0c
67 #define PCL711_SOFTTRIG (0 << 0) /* any value will work */
68 #define PCL711_DO_LSB_REG 0x0d
69 #define PCL711_DO_MSB_REG 0x0e
71 static const struct comedi_lrange range_pcl711b_ai = {
81 static const struct comedi_lrange range_acl8112hg_ai = {
98 static const struct comedi_lrange range_acl8112dg_ai = {
112 struct pcl711_board {
117 const struct comedi_lrange *ai_range_type;
120 static const struct pcl711_board boardtypes[] = {
125 .ai_range_type = &range_bipolar5,
131 .ai_range_type = &range_pcl711b_ai,
137 .ai_range_type = &range_acl8112hg_ai,
143 .ai_range_type = &range_acl8112dg_ai,
147 static void pcl711_ai_set_mode(struct comedi_device *dev, unsigned int mode)
150 * The pcl711b board uses bits in the mode register to select the
151 * interrupt. The other boards supported by this driver all use
152 * jumpers on the board.
154 * Enables the interrupt when needed on the pcl711b board. These
155 * bits do nothing on the other boards.
157 if (mode == PCL711_MODE_EXT_IRQ || mode == PCL711_MODE_PACER_IRQ)
158 mode |= PCL711_MODE_IRQ(dev->irq);
160 outb(mode, dev->iobase + PCL711_MODE_REG);
163 static unsigned int pcl711_ai_get_sample(struct comedi_device *dev,
164 struct comedi_subdevice *s)
168 val = inb(dev->iobase + PCL711_AI_MSB_REG) << 8;
169 val |= inb(dev->iobase + PCL711_AI_LSB_REG);
171 return val & s->maxdata;
174 static int pcl711_ai_cancel(struct comedi_device *dev,
175 struct comedi_subdevice *s)
177 outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
178 pcl711_ai_set_mode(dev, PCL711_MODE_SOFTTRIG);
182 static irqreturn_t pcl711_interrupt(int irq, void *d)
184 struct comedi_device *dev = d;
185 struct comedi_subdevice *s = dev->read_subdev;
186 struct comedi_cmd *cmd = &s->async->cmd;
189 if (!dev->attached) {
190 dev_err(dev->class_dev, "spurious interrupt\n");
194 data = pcl711_ai_get_sample(dev, s);
196 outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
198 comedi_buf_write_samples(s, &data, 1);
200 if (cmd->stop_src == TRIG_COUNT &&
201 s->async->scans_done >= cmd->stop_arg)
202 s->async->events |= COMEDI_CB_EOA;
204 comedi_handle_events(dev, s);
209 static void pcl711_set_changain(struct comedi_device *dev,
210 struct comedi_subdevice *s,
211 unsigned int chanspec)
213 unsigned int chan = CR_CHAN(chanspec);
214 unsigned int range = CR_RANGE(chanspec);
215 unsigned int aref = CR_AREF(chanspec);
216 unsigned int mux = 0;
218 outb(PCL711_AI_GAIN(range), dev->iobase + PCL711_AI_GAIN_REG);
221 /* Select the correct MPC508A chip */
222 if (aref == AREF_DIFF) {
224 mux |= PCL711_MUX_DIFF;
227 mux |= PCL711_MUX_CS0;
229 mux |= PCL711_MUX_CS1;
232 outb(mux | PCL711_MUX_CHAN(chan), dev->iobase + PCL711_MUX_REG);
235 static int pcl711_ai_eoc(struct comedi_device *dev,
236 struct comedi_subdevice *s,
237 struct comedi_insn *insn,
238 unsigned long context)
242 status = inb(dev->iobase + PCL711_AI_MSB_REG);
243 if ((status & PCL711_AI_MSB_DRDY) == 0)
248 static int pcl711_ai_insn_read(struct comedi_device *dev,
249 struct comedi_subdevice *s,
250 struct comedi_insn *insn,
256 pcl711_set_changain(dev, s, insn->chanspec);
258 pcl711_ai_set_mode(dev, PCL711_MODE_SOFTTRIG);
260 for (i = 0; i < insn->n; i++) {
261 outb(PCL711_SOFTTRIG, dev->iobase + PCL711_SOFTTRIG_REG);
263 ret = comedi_timeout(dev, s, insn, pcl711_ai_eoc, 0);
267 data[i] = pcl711_ai_get_sample(dev, s);
273 static int pcl711_ai_cmdtest(struct comedi_device *dev,
274 struct comedi_subdevice *s, struct comedi_cmd *cmd)
278 /* Step 1 : check if triggers are trivially valid */
280 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW);
281 err |= comedi_check_trigger_src(&cmd->scan_begin_src,
282 TRIG_TIMER | TRIG_EXT);
283 err |= comedi_check_trigger_src(&cmd->convert_src, TRIG_NOW);
284 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
285 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_COUNT | TRIG_NONE);
290 /* Step 2a : make sure trigger sources are unique */
292 err |= comedi_check_trigger_is_unique(cmd->scan_begin_src);
293 err |= comedi_check_trigger_is_unique(cmd->stop_src);
295 /* Step 2b : and mutually compatible */
300 /* Step 3: check if arguments are trivially valid */
302 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
304 if (cmd->scan_begin_src == TRIG_EXT) {
305 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
307 #define MAX_SPEED 1000
308 err |= comedi_check_trigger_arg_min(&cmd->scan_begin_arg,
312 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, 0);
313 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
316 if (cmd->stop_src == TRIG_COUNT)
317 err |= comedi_check_trigger_arg_min(&cmd->stop_arg, 1);
319 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);
326 if (cmd->scan_begin_src == TRIG_TIMER) {
327 unsigned int arg = cmd->scan_begin_arg;
329 comedi_8254_cascade_ns_to_timer(dev->pacer, &arg, cmd->flags);
330 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, arg);
339 static int pcl711_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
341 struct comedi_cmd *cmd = &s->async->cmd;
343 pcl711_set_changain(dev, s, cmd->chanlist[0]);
345 if (cmd->scan_begin_src == TRIG_TIMER) {
346 comedi_8254_update_divisors(dev->pacer);
347 comedi_8254_pacer_enable(dev->pacer, 1, 2, true);
348 outb(PCL711_INT_STAT_CLR, dev->iobase + PCL711_INT_STAT_REG);
349 pcl711_ai_set_mode(dev, PCL711_MODE_PACER_IRQ);
351 pcl711_ai_set_mode(dev, PCL711_MODE_EXT_IRQ);
357 static void pcl711_ao_write(struct comedi_device *dev,
358 unsigned int chan, unsigned int val)
360 outb(val & 0xff, dev->iobase + PCL711_AO_LSB_REG(chan));
361 outb((val >> 8) & 0xff, dev->iobase + PCL711_AO_MSB_REG(chan));
364 static int pcl711_ao_insn_write(struct comedi_device *dev,
365 struct comedi_subdevice *s,
366 struct comedi_insn *insn,
369 unsigned int chan = CR_CHAN(insn->chanspec);
370 unsigned int val = s->readback[chan];
373 for (i = 0; i < insn->n; i++) {
375 pcl711_ao_write(dev, chan, val);
377 s->readback[chan] = val;
382 static int pcl711_di_insn_bits(struct comedi_device *dev,
383 struct comedi_subdevice *s,
384 struct comedi_insn *insn,
389 val = inb(dev->iobase + PCL711_DI_LSB_REG);
390 val |= (inb(dev->iobase + PCL711_DI_MSB_REG) << 8);
397 static int pcl711_do_insn_bits(struct comedi_device *dev,
398 struct comedi_subdevice *s,
399 struct comedi_insn *insn,
404 mask = comedi_dio_update_state(s, data);
407 outb(s->state & 0xff, dev->iobase + PCL711_DO_LSB_REG);
409 outb((s->state >> 8), dev->iobase + PCL711_DO_MSB_REG);
417 static int pcl711_attach(struct comedi_device *dev, struct comedi_devconfig *it)
419 const struct pcl711_board *board = dev->board_ptr;
420 struct comedi_subdevice *s;
423 ret = comedi_request_region(dev, it->options[0], 0x10);
427 if (it->options[1] && it->options[1] <= board->maxirq) {
428 ret = request_irq(it->options[1], pcl711_interrupt, 0,
429 dev->board_name, dev);
431 dev->irq = it->options[1];
434 dev->pacer = comedi_8254_init(dev->iobase + PCL711_TIMER_BASE,
435 I8254_OSC_BASE_2MHZ, I8254_IO8, 0);
439 ret = comedi_alloc_subdevices(dev, 4);
443 /* Analog Input subdevice */
444 s = &dev->subdevices[0];
445 s->type = COMEDI_SUBD_AI;
446 s->subdev_flags = SDF_READABLE | SDF_GROUND;
447 if (board->n_aichan > 8)
448 s->subdev_flags |= SDF_DIFF;
449 s->n_chan = board->n_aichan;
451 s->range_table = board->ai_range_type;
452 s->insn_read = pcl711_ai_insn_read;
454 dev->read_subdev = s;
455 s->subdev_flags |= SDF_CMD_READ;
457 s->do_cmdtest = pcl711_ai_cmdtest;
458 s->do_cmd = pcl711_ai_cmd;
459 s->cancel = pcl711_ai_cancel;
462 /* Analog Output subdevice */
463 s = &dev->subdevices[1];
464 s->type = COMEDI_SUBD_AO;
465 s->subdev_flags = SDF_WRITABLE;
466 s->n_chan = board->n_aochan;
468 s->range_table = &range_bipolar5;
469 s->insn_write = pcl711_ao_insn_write;
471 ret = comedi_alloc_subdev_readback(s);
475 /* Digital Input subdevice */
476 s = &dev->subdevices[2];
477 s->type = COMEDI_SUBD_DI;
478 s->subdev_flags = SDF_READABLE;
481 s->range_table = &range_digital;
482 s->insn_bits = pcl711_di_insn_bits;
484 /* Digital Output subdevice */
485 s = &dev->subdevices[3];
486 s->type = COMEDI_SUBD_DO;
487 s->subdev_flags = SDF_WRITABLE;
490 s->range_table = &range_digital;
491 s->insn_bits = pcl711_do_insn_bits;
494 pcl711_ao_write(dev, 0, 0x0);
495 pcl711_ao_write(dev, 1, 0x0);
500 static struct comedi_driver pcl711_driver = {
501 .driver_name = "pcl711",
502 .module = THIS_MODULE,
503 .attach = pcl711_attach,
504 .detach = comedi_legacy_detach,
505 .board_name = &boardtypes[0].name,
506 .num_names = ARRAY_SIZE(boardtypes),
507 .offset = sizeof(struct pcl711_board),
509 module_comedi_driver(pcl711_driver);
511 MODULE_AUTHOR("Comedi https://www.comedi.org");
512 MODULE_DESCRIPTION("Comedi driver for PCL-711 compatible boards");
513 MODULE_LICENSE("GPL");