2 comedi/drivers/amplc_pc236.c
3 Driver for Amplicon PC36AT and PCI236 DIO boards.
5 Copyright (C) 2002 MEV Ltd. <http://www.mev.co.uk/>
7 COMEDI - Linux Control and Measurement Device Interface
8 Copyright (C) 2000 David A. Schleef <ds@schleef.org>
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 Description: Amplicon PC36AT, PCI236
28 Author: Ian Abbott <abbotti@mev.co.uk>
29 Devices: [Amplicon] PC36AT (pc36at), PCI236 (pci236 or amplc_pc236)
30 Updated: Wed, 01 Apr 2009 15:41:25 +0100
33 Configuration options - PC36AT:
34 [0] - I/O port base address
37 Configuration options - PCI236:
38 [0] - PCI bus of device (optional)
39 [1] - PCI slot of device (optional)
40 If bus/slot is not specified, the first available PCI device will be
43 The PC36AT ISA board and PCI236 PCI board have a single 8255 appearing
46 Subdevice 1 pretends to be a digital input device, but it always returns
47 0 when read. However, if you run a command with scan_begin_src=TRIG_EXT,
48 a rising edge on port C bit 3 acts as an external trigger, which can be
49 used to wake up tasks. This is like the comedi_parport device, but the
50 only way to physically disable the interrupt on the PC36AT is to remove
51 the IRQ jumper. If no interrupt is connected, then subdevice 1 is
55 #include <linux/pci.h>
56 #include <linux/interrupt.h>
58 #include "../comedidev.h"
60 #include "comedi_fc.h"
64 #define PC236_DRIVER_NAME "amplc_pc236"
66 #define DO_ISA IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_ISA)
67 #define DO_PCI IS_ENABLED(CONFIG_COMEDI_AMPLC_PC236_PCI)
69 /* PCI236 PCI configuration register information */
70 #define PCI_DEVICE_ID_AMPLICON_PCI236 0x0009
71 #define PCI_DEVICE_ID_INVALID 0xffff
73 /* PC36AT / PCI236 registers */
75 #define PC236_IO_SIZE 4
76 #define PC236_LCR_IO_SIZE 128
79 * INTCSR values for PCI236.
81 /* Disable interrupt, also clear any interrupt there */
82 #define PCI236_INTR_DISABLE (PLX9052_INTCSR_LI1ENAB_DISABLED \
83 | PLX9052_INTCSR_LI1POL_HIGH \
84 | PLX9052_INTCSR_LI2POL_HIGH \
85 | PLX9052_INTCSR_PCIENAB_DISABLED \
86 | PLX9052_INTCSR_LI1SEL_EDGE \
87 | PLX9052_INTCSR_LI1CLRINT_ASSERTED)
88 /* Enable interrupt, also clear any interrupt there. */
89 #define PCI236_INTR_ENABLE (PLX9052_INTCSR_LI1ENAB_ENABLED \
90 | PLX9052_INTCSR_LI1POL_HIGH \
91 | PLX9052_INTCSR_LI2POL_HIGH \
92 | PLX9052_INTCSR_PCIENAB_ENABLED \
93 | PLX9052_INTCSR_LI1SEL_EDGE \
94 | PLX9052_INTCSR_LI1CLRINT_ASSERTED)
97 * Board descriptions for Amplicon PC36AT and PCI236.
100 enum pc236_bustype { isa_bustype, pci_bustype };
101 enum pc236_model { pc36at_model, pci236_model, anypci_model };
105 unsigned short devid;
106 enum pc236_bustype bustype;
107 enum pc236_model model;
109 static const struct pc236_board pc236_boards[] = {
113 .bustype = isa_bustype,
114 .model = pc36at_model,
120 .devid = PCI_DEVICE_ID_AMPLICON_PCI236,
121 .bustype = pci_bustype,
122 .model = pci236_model,
125 .name = PC236_DRIVER_NAME,
126 .devid = PCI_DEVICE_ID_INVALID,
127 .bustype = pci_bustype,
128 .model = anypci_model, /* wildcard */
133 /* this structure is for data unique to this hardware driver. If
134 several hardware drivers keep similar information in this structure,
135 feel free to suggest moving the variable to the struct comedi_device struct.
137 struct pc236_private {
138 unsigned long lcr_iobase; /* PLX PCI9052 config registers in PCIBAR1 */
142 /* test if ISA supported and this is an ISA board */
143 static inline bool is_isa_board(const struct pc236_board *board)
145 return DO_ISA && board->bustype == isa_bustype;
148 /* test if PCI supported and this is a PCI board */
149 static inline bool is_pci_board(const struct pc236_board *board)
151 return DO_PCI && board->bustype == pci_bustype;
155 * This function looks for a board matching the supplied PCI device.
157 static const struct pc236_board *pc236_find_pci_board(struct pci_dev *pci_dev)
161 for (i = 0; i < ARRAY_SIZE(pc236_boards); i++)
162 if (is_pci_board(&pc236_boards[i]) &&
163 pci_dev->device == pc236_boards[i].devid)
164 return &pc236_boards[i];
169 * This function looks for a PCI device matching the requested board name,
172 static struct pci_dev *pc236_find_pci_dev(struct comedi_device *dev,
173 struct comedi_devconfig *it)
175 const struct pc236_board *thisboard = comedi_board(dev);
176 struct pci_dev *pci_dev = NULL;
177 int bus = it->options[0];
178 int slot = it->options[1];
180 for_each_pci_dev(pci_dev) {
182 if (bus != pci_dev->bus->number ||
183 slot != PCI_SLOT(pci_dev->devfn))
186 if (pci_dev->vendor != PCI_VENDOR_ID_AMPLICON)
189 if (thisboard->model == anypci_model) {
190 /* Wildcard board matches any supported PCI board. */
191 const struct pc236_board *foundboard;
193 foundboard = pc236_find_pci_board(pci_dev);
194 if (foundboard == NULL)
196 /* Replace wildcard board_ptr. */
197 dev->board_ptr = foundboard;
199 /* Match specific model name. */
200 if (pci_dev->device != thisboard->devid)
205 dev_err(dev->class_dev,
206 "No supported board found! (req. bus %d, slot %d)\n",
212 * This function checks and requests an I/O region, reporting an error
213 * if there is a conflict.
215 static int pc236_request_region(struct comedi_device *dev, unsigned long from,
216 unsigned long extent)
218 if (!from || !request_region(from, extent, PC236_DRIVER_NAME)) {
219 dev_err(dev->class_dev, "I/O port conflict (%#lx,%lu)!\n",
227 * This function is called to mark the interrupt as disabled (no command
228 * configured on subdevice 1) and to physically disable the interrupt
229 * (not possible on the PC36AT, except by removing the IRQ jumper!).
231 static void pc236_intr_disable(struct comedi_device *dev)
233 const struct pc236_board *thisboard = comedi_board(dev);
234 struct pc236_private *devpriv = dev->private;
237 spin_lock_irqsave(&dev->spinlock, flags);
238 devpriv->enable_irq = 0;
239 if (is_pci_board(thisboard))
240 outl(PCI236_INTR_DISABLE, devpriv->lcr_iobase + PLX9052_INTCSR);
241 spin_unlock_irqrestore(&dev->spinlock, flags);
245 * This function is called to mark the interrupt as enabled (a command
246 * configured on subdevice 1) and to physically enable the interrupt
247 * (not possible on the PC36AT, except by (re)connecting the IRQ jumper!).
249 static void pc236_intr_enable(struct comedi_device *dev)
251 const struct pc236_board *thisboard = comedi_board(dev);
252 struct pc236_private *devpriv = dev->private;
255 spin_lock_irqsave(&dev->spinlock, flags);
256 devpriv->enable_irq = 1;
257 if (is_pci_board(thisboard))
258 outl(PCI236_INTR_ENABLE, devpriv->lcr_iobase + PLX9052_INTCSR);
259 spin_unlock_irqrestore(&dev->spinlock, flags);
263 * This function is called when an interrupt occurs to check whether
264 * the interrupt has been marked as enabled and was generated by the
265 * board. If so, the function prepares the hardware for the next
267 * Returns 0 if the interrupt should be ignored.
269 static int pc236_intr_check(struct comedi_device *dev)
271 const struct pc236_board *thisboard = comedi_board(dev);
272 struct pc236_private *devpriv = dev->private;
276 spin_lock_irqsave(&dev->spinlock, flags);
277 if (devpriv->enable_irq) {
279 if (is_pci_board(thisboard)) {
280 if ((inl(devpriv->lcr_iobase + PLX9052_INTCSR)
281 & PLX9052_INTCSR_LI1STAT_MASK)
282 == PLX9052_INTCSR_LI1STAT_INACTIVE) {
285 /* Clear interrupt and keep it enabled. */
286 outl(PCI236_INTR_ENABLE,
287 devpriv->lcr_iobase + PLX9052_INTCSR);
291 spin_unlock_irqrestore(&dev->spinlock, flags);
297 * Input from subdevice 1.
298 * Copied from the comedi_parport driver.
300 static int pc236_intr_insn(struct comedi_device *dev,
301 struct comedi_subdevice *s, struct comedi_insn *insn,
309 * Subdevice 1 command test.
310 * Copied from the comedi_parport driver.
312 static int pc236_intr_cmdtest(struct comedi_device *dev,
313 struct comedi_subdevice *s,
314 struct comedi_cmd *cmd)
318 /* Step 1 : check if triggers are trivially valid */
320 err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
321 err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
322 err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
323 err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
324 err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
329 /* Step 2a : make sure trigger sources are unique */
330 /* Step 2b : and mutually compatible */
335 /* Step 3: check it arguments are trivially valid */
337 err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
338 err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
339 err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
340 err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, 1);
341 err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
346 /* step 4: ignored */
355 * Subdevice 1 command.
357 static int pc236_intr_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
359 pc236_intr_enable(dev);
365 * Subdevice 1 cancel command.
367 static int pc236_intr_cancel(struct comedi_device *dev,
368 struct comedi_subdevice *s)
370 pc236_intr_disable(dev);
376 * Interrupt service routine.
377 * Based on the comedi_parport driver.
379 static irqreturn_t pc236_interrupt(int irq, void *d)
381 struct comedi_device *dev = d;
382 struct comedi_subdevice *s = &dev->subdevices[1];
385 handled = pc236_intr_check(dev);
386 if (dev->attached && handled) {
387 comedi_buf_put(s->async, 0);
388 s->async->events |= COMEDI_CB_BLOCK | COMEDI_CB_EOS;
389 comedi_event(dev, s);
391 return IRQ_RETVAL(handled);
394 static void pc236_report_attach(struct comedi_device *dev, unsigned int irq)
396 const struct pc236_board *thisboard = comedi_board(dev);
397 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
401 if (is_isa_board(thisboard))
402 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
403 "(base %#lx) ", dev->iobase);
404 else if (is_pci_board(thisboard))
405 tmplen = scnprintf(tmpbuf, sizeof(tmpbuf),
406 "(pci %s) ", pci_name(pcidev));
410 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
412 (dev->irq ? "" : " UNAVAILABLE"));
414 tmplen += scnprintf(&tmpbuf[tmplen], sizeof(tmpbuf) - tmplen,
416 dev_info(dev->class_dev, "%s %sattached\n",
417 dev->board_name, tmpbuf);
420 static int pc236_common_attach(struct comedi_device *dev, unsigned long iobase,
421 unsigned int irq, unsigned long req_irq_flags)
423 const struct pc236_board *thisboard = comedi_board(dev);
424 struct comedi_subdevice *s;
427 dev->board_name = thisboard->name;
428 dev->iobase = iobase;
430 ret = comedi_alloc_subdevices(dev, 2);
434 s = &dev->subdevices[0];
435 /* digital i/o subdevice (8255) */
436 ret = subdev_8255_init(dev, s, NULL, iobase);
438 dev_err(dev->class_dev, "error! out of memory!\n");
441 s = &dev->subdevices[1];
442 dev->read_subdev = s;
443 s->type = COMEDI_SUBD_UNUSED;
444 pc236_intr_disable(dev);
446 if (request_irq(irq, pc236_interrupt, req_irq_flags,
447 PC236_DRIVER_NAME, dev) >= 0) {
449 s->type = COMEDI_SUBD_DI;
450 s->subdev_flags = SDF_READABLE | SDF_CMD_READ;
453 s->range_table = &range_digital;
454 s->insn_bits = pc236_intr_insn;
455 s->do_cmdtest = pc236_intr_cmdtest;
456 s->do_cmd = pc236_intr_cmd;
457 s->cancel = pc236_intr_cancel;
460 pc236_report_attach(dev, irq);
464 static int pc236_pci_common_attach(struct comedi_device *dev,
465 struct pci_dev *pci_dev)
467 struct pc236_private *devpriv = dev->private;
468 unsigned long iobase;
471 comedi_set_hw_dev(dev, &pci_dev->dev);
473 ret = comedi_pci_enable(pci_dev, PC236_DRIVER_NAME);
475 dev_err(dev->class_dev,
476 "error! cannot enable PCI device and request regions!\n");
479 devpriv->lcr_iobase = pci_resource_start(pci_dev, 1);
480 iobase = pci_resource_start(pci_dev, 2);
481 return pc236_common_attach(dev, iobase, pci_dev->irq, IRQF_SHARED);
485 * Attach is called by the Comedi core to configure the driver
486 * for a particular board. If you specified a board_name array
487 * in the driver structure, dev->board_ptr contains that
490 static int pc236_attach(struct comedi_device *dev, struct comedi_devconfig *it)
492 const struct pc236_board *thisboard = comedi_board(dev);
493 struct pc236_private *devpriv;
496 dev_info(dev->class_dev, PC236_DRIVER_NAME ": attach\n");
498 devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
501 dev->private = devpriv;
503 /* Process options according to bus type. */
504 if (is_isa_board(thisboard)) {
505 unsigned long iobase = it->options[0];
506 unsigned int irq = it->options[1];
507 ret = pc236_request_region(dev, iobase, PC236_IO_SIZE);
510 return pc236_common_attach(dev, iobase, irq, 0);
511 } else if (is_pci_board(thisboard)) {
512 struct pci_dev *pci_dev;
514 pci_dev = pc236_find_pci_dev(dev, it);
517 return pc236_pci_common_attach(dev, pci_dev);
519 dev_err(dev->class_dev, PC236_DRIVER_NAME
520 ": BUG! cannot determine board type!\n");
526 * The auto_attach hook is called at PCI probe time via
527 * comedi_pci_auto_config(). dev->board_ptr is NULL on entry.
528 * There should be a board entry matching the supplied PCI device.
530 static int pc236_auto_attach(struct comedi_device *dev,
531 unsigned long context_unused)
533 struct pci_dev *pci_dev = comedi_to_pci_dev(dev);
534 struct pc236_private *devpriv;
539 dev_info(dev->class_dev, PC236_DRIVER_NAME ": attach pci %s\n",
542 devpriv = kzalloc(sizeof(*devpriv), GFP_KERNEL);
545 dev->private = devpriv;
547 dev->board_ptr = pc236_find_pci_board(pci_dev);
548 if (dev->board_ptr == NULL) {
549 dev_err(dev->class_dev, "BUG! cannot determine board type!\n");
553 * Need to 'get' the PCI device to match the 'put' in pc236_detach().
554 * TODO: Remove the pci_dev_get() and matching pci_dev_put() once
555 * support for manual attachment of PCI devices via pc236_attach()
558 pci_dev_get(pci_dev);
559 return pc236_pci_common_attach(dev, pci_dev);
562 static void pc236_detach(struct comedi_device *dev)
564 const struct pc236_board *thisboard = comedi_board(dev);
569 pc236_intr_disable(dev);
571 free_irq(dev->irq, dev);
573 subdev_8255_cleanup(dev, &dev->subdevices[0]);
574 if (is_isa_board(thisboard)) {
576 release_region(dev->iobase, PC236_IO_SIZE);
577 } else if (is_pci_board(thisboard)) {
578 struct pci_dev *pcidev = comedi_to_pci_dev(dev);
581 comedi_pci_disable(pcidev);
588 * The struct comedi_driver structure tells the Comedi core module
589 * which functions to call to configure/deconfigure (attach/detach)
590 * the board, and also about the kernel module that contains
593 static struct comedi_driver amplc_pc236_driver = {
594 .driver_name = PC236_DRIVER_NAME,
595 .module = THIS_MODULE,
596 .attach = pc236_attach,
597 .auto_attach = pc236_auto_attach,
598 .detach = pc236_detach,
599 .board_name = &pc236_boards[0].name,
600 .offset = sizeof(struct pc236_board),
601 .num_names = ARRAY_SIZE(pc236_boards),
605 static DEFINE_PCI_DEVICE_TABLE(pc236_pci_table) = {
606 { PCI_DEVICE(PCI_VENDOR_ID_AMPLICON, PCI_DEVICE_ID_AMPLICON_PCI236) },
610 MODULE_DEVICE_TABLE(pci, pc236_pci_table);
612 static int amplc_pc236_pci_probe(struct pci_dev *dev,
613 const struct pci_device_id *ent)
615 return comedi_pci_auto_config(dev, &lc_pc236_driver);
618 static struct pci_driver amplc_pc236_pci_driver = {
619 .name = PC236_DRIVER_NAME,
620 .id_table = pc236_pci_table,
621 .probe = &lc_pc236_pci_probe,
622 .remove = comedi_pci_auto_unconfig,
625 module_comedi_pci_driver(amplc_pc236_driver, amplc_pc236_pci_driver);
627 module_comedi_driver(amplc_pc236_driver);
630 MODULE_AUTHOR("Comedi http://www.comedi.org");
631 MODULE_DESCRIPTION("Comedi low-level driver");
632 MODULE_LICENSE("GPL");