Quelle  aio_iiro_16.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * aio_iiro_16.c
 * Comedi driver for Access I/O Products 104-IIRO-16 board
 * Copyright (C) 2006 C&C Technologies, Inc.
 */

/*
 * Driver: aio_iiro_16
 * Description: Access I/O Products PC/104 Isolated Input/Relay Output Board
 * Author: Zachary Ware <zach.ware@cctechnol.com>
 * Devices: [Access I/O] 104-IIRO-16 (aio_iiro_16)
 * Status: experimental
 *
 * Configuration Options:
 *   [0] - I/O port base address
 *   [1] - IRQ (optional)
 *
 * The board supports interrupts on change of state of the digital inputs.
 * The sample data returned by the async command indicates which inputs
 * changed state and the current state of the inputs:
 *
 * Bit 23 - IRQ Enable (1) / Disable (0)
 * Bit 17 - Input 8-15 Changed State (1 = Changed, 0 = No Change)
 * Bit 16 - Input 0-7 Changed State (1 = Changed, 0 = No Change)
 * Bit 15 - Digital input 15
 * ...
 * Bit 0  - Digital input 0
 */

#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/comedi/comedidev.h>

#define AIO_IIRO_16_RELAY_0_7  0x00
#define AIO_IIRO_16_INPUT_0_7  0x01
#define AIO_IIRO_16_IRQ   0x02
#define AIO_IIRO_16_RELAY_8_15  0x04
#define AIO_IIRO_16_INPUT_8_15  0x05
#define AIO_IIRO_16_STATUS  0x07
#define AIO_IIRO_16_STATUS_IRQE  BIT(7)
#define AIO_IIRO_16_STATUS_INPUT_8_15 BIT(1)
#define AIO_IIRO_16_STATUS_INPUT_0_7 BIT(0)

static unsigned int aio_iiro_16_read_inputs(struct comedi_device *dev)
{
 unsigned int val;

 val = inb(dev->iobase + AIO_IIRO_16_INPUT_0_7);
 val |= inb(dev->iobase + AIO_IIRO_16_INPUT_8_15) << 8;

 return val;
}

static irqreturn_t aio_iiro_16_cos(int irq, void *d)
{
 struct comedi_device *dev = d;
 struct comedi_subdevice *s = dev->read_subdev;
 unsigned int status;
 unsigned int val;

 status = inb(dev->iobase + AIO_IIRO_16_STATUS);
 if (!(status & AIO_IIRO_16_STATUS_IRQE))
  return IRQ_NONE;

 val = aio_iiro_16_read_inputs(dev);
 val |= (status << 16);

 comedi_buf_write_samples(s, &val, 1);
 comedi_handle_events(dev, s);

 return IRQ_HANDLED;
}

static void aio_iiro_enable_irq(struct comedi_device *dev, bool enable)
{
 if (enable)
  inb(dev->iobase + AIO_IIRO_16_IRQ);
 else
  outb(0, dev->iobase + AIO_IIRO_16_IRQ);
}

static int aio_iiro_16_cos_cancel(struct comedi_device *dev,
      struct comedi_subdevice *s)
{
 aio_iiro_enable_irq(dev, false);

 return 0;
}

static int aio_iiro_16_cos_cmd(struct comedi_device *dev,
          struct comedi_subdevice *s)
{
 aio_iiro_enable_irq(dev, true);

 return 0;
}

static int aio_iiro_16_cos_cmdtest(struct comedi_device *dev,
       struct comedi_subdevice *s,
       struct comedi_cmd *cmd)
{
 int err = 0;

 /* Step 1 : check if triggers are trivially valid */

 err |= comedi_check_trigger_src(&cmd->start_src, TRIG_NOW);
 err |= comedi_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
 err |= comedi_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
 err |= comedi_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 err |= comedi_check_trigger_src(&cmd->stop_src, TRIG_NONE);

 if (err)
  return 1;

 /* Step 2a : make sure trigger sources are unique */
 /* Step 2b : and mutually compatible */

 /* Step 3: check if arguments are trivially valid */

 err |= comedi_check_trigger_arg_is(&cmd->start_arg, 0);
 err |= comedi_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 err |= comedi_check_trigger_arg_is(&cmd->convert_arg, 0);
 err |= comedi_check_trigger_arg_is(&cmd->scan_end_arg,
        cmd->chanlist_len);
 err |= comedi_check_trigger_arg_is(&cmd->stop_arg, 0);

 if (err)
  return 3;

 /* Step 4: fix up any arguments */

 /* Step 5: check channel list if it exists */

 return 0;
}

static int aio_iiro_16_do_insn_bits(struct comedi_device *dev,
        struct comedi_subdevice *s,
        struct comedi_insn *insn,
        unsigned int *data)
{
 if (comedi_dio_update_state(s, data)) {
  outb(s->state & 0xff, dev->iobase + AIO_IIRO_16_RELAY_0_7);
  outb((s->state >> 8) & 0xff,
       dev->iobase + AIO_IIRO_16_RELAY_8_15);
 }

 data[1] = s->state;

 return insn->n;
}

static int aio_iiro_16_di_insn_bits(struct comedi_device *dev,
        struct comedi_subdevice *s,
        struct comedi_insn *insn,
        unsigned int *data)
{
 data[1] = aio_iiro_16_read_inputs(dev);

 return insn->n;
}

static int aio_iiro_16_attach(struct comedi_device *dev,
         struct comedi_devconfig *it)
{
 struct comedi_subdevice *s;
 int ret;

 ret = comedi_request_region(dev, it->options[0], 0x8);
 if (ret)
  return ret;

 aio_iiro_enable_irq(dev, false);

 /*
 * Digital input change of state interrupts are optionally supported
 * using IRQ 2-7, 10-12, 14, or 15.
 */
 if (it->options[1] > 0 && it->options[1] < 16 &&
     (1 << it->options[1]) & 0xdcfc) {
  ret = request_irq(it->options[1], aio_iiro_16_cos, 0,
      dev->board_name, dev);
  if (ret == 0)
   dev->irq = it->options[1];
 }

 ret = comedi_alloc_subdevices(dev, 2);
 if (ret)
  return ret;

 /* Digital Output subdevice */
 s = &dev->subdevices[0];
 s->type  = COMEDI_SUBD_DO;
 s->subdev_flags = SDF_WRITABLE;
 s->n_chan = 16;
 s->maxdata = 1;
 s->range_table = &range_digital;
 s->insn_bits = aio_iiro_16_do_insn_bits;

 /* get the initial state of the relays */
 s->state = inb(dev->iobase + AIO_IIRO_16_RELAY_0_7) |
     (inb(dev->iobase + AIO_IIRO_16_RELAY_8_15) << 8);

 /* Digital Input subdevice */
 s = &dev->subdevices[1];
 s->type  = COMEDI_SUBD_DI;
 s->subdev_flags = SDF_READABLE;
 s->n_chan = 16;
 s->maxdata = 1;
 s->range_table = &range_digital;
 s->insn_bits = aio_iiro_16_di_insn_bits;
 if (dev->irq) {
  dev->read_subdev = s;
  s->subdev_flags |= SDF_CMD_READ | SDF_LSAMPL;
  s->len_chanlist = 1;
  s->do_cmdtest = aio_iiro_16_cos_cmdtest;
  s->do_cmd = aio_iiro_16_cos_cmd;
  s->cancel = aio_iiro_16_cos_cancel;
 }

 return 0;
}

static struct comedi_driver aio_iiro_16_driver = {
 .driver_name = "aio_iiro_16",
 .module  = THIS_MODULE,
 .attach  = aio_iiro_16_attach,
 .detach  = comedi_legacy_detach,
};
module_comedi_driver(aio_iiro_16_driver);

MODULE_AUTHOR("Comedi https://www.comedi.org");
MODULE_DESCRIPTION("Comedi driver for Access I/O Products 104-IIRO-16 board");
MODULE_LICENSE("GPL");