kernel/drivers/staging/comedi/drivers/adq12b.c

   1 /*
   2  * adq12b.c
   3  * Driver for MicroAxial ADQ12-B data acquisition and control card
   4  * written by jeremy theler <thelerg@ib.cnea.gov.ar>
   5  *      instituto balseiro
   6  *      commission nacional de energia atomica
   7  *      universidad nacional de cuyo
   8  *      argentina
   9  *
  10  * COMEDI - Linux Control and Measurement Device Interface
  11  * Copyright (C) 2000 David A. Schleef <ds@schleef.org>
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  */
  23
  24 /*
  25  * Driver: adq12b
  26  * Description: Driver for MicroAxial ADQ12-B data acquisition and control card
  27  * Devices: [MicroAxial] ADQ12-B (adq12b)
  28  * Author: jeremy theler <thelerg@ib.cnea.gov.ar>
  29  * Updated: Thu, 21 Feb 2008 02:56:27 -0300
  30  * Status: works
  31  *
  32  * Configuration options:
  33  *   [0] - I/O base address (set with hardware jumpers)
  34  *              address         jumper JADR
  35  *              0x300           1 (factory default)
  36  *              0x320           2
  37  *              0x340           3
  38  *              0x360           4
  39  *              0x380           5
  40  *              0x3A0           6
  41  *   [1] - Analog Input unipolar/bipolar selection
  42  *              selection       option  JUB
  43  *              bipolar         0       2-3 (factory default)
  44  *              unipolar        1       1-2
  45  *   [2] - Analog Input single-ended/differential selection
  46  *              selection       option  JCHA    JCHB
  47  *              single-ended    0       1-2     1-2 (factory default)
  48  *              differential    1       2-3     2-3
  49  *
  50  * Driver for the acquisition card ADQ12-B (without any add-on).
  51  *
  52  * - Analog input is subdevice 0 (16 channels single-ended or 8 differential)
  53  * - Digital input is subdevice 1 (5 channels)
  54  * - Digital output is subdevice 1 (8 channels)
  55  * - The PACER is not supported in this version
  56  */
  57
  58 #include <linux/module.h>
  59 #include <linux/delay.h>
  60
  61 #include "../comedidev.h"
  62
  63 /* address scheme (page 2.17 of the manual) */
  64 #define ADQ12B_CTREG            0x00
  65 #define ADQ12B_CTREG_MSKP       BIT(7)  /* enable pacer interrupt */
  66 #define ADQ12B_CTREG_GTP        BIT(6)  /* enable pacer */
  67 #define ADQ12B_CTREG_RANGE(x)   ((x) << 4)
  68 #define ADQ12B_CTREG_CHAN(x)    ((x) << 0)
  69 #define ADQ12B_STINR            0x00
  70 #define ADQ12B_STINR_OUT2       BIT(7)  /* timer 2 output state */
  71 #define ADQ12B_STINR_OUTP       BIT(6)  /* pacer output state */
  72 #define ADQ12B_STINR_EOC        BIT(5)  /* A/D end-of-conversion */
  73 #define ADQ12B_STINR_IN_MASK    (0x1f << 0)
  74 #define ADQ12B_OUTBR            0x04
  75 #define ADQ12B_ADLOW            0x08
  76 #define ADQ12B_ADHIG            0x09
  77 #define ADQ12B_TIMER_BASE       0x0c
  78
  79 /* available ranges through the PGA gains */
  80 static const struct comedi_lrange range_adq12b_ai_bipolar = {
  81         4, {
  82                 BIP_RANGE(5),
  83                 BIP_RANGE(2),
  84                 BIP_RANGE(1),
  85                 BIP_RANGE(0.5)
  86         }
  87 };
  88
  89 static const struct comedi_lrange range_adq12b_ai_unipolar = {
  90         4, {
  91                 UNI_RANGE(5),
  92                 UNI_RANGE(2),
  93                 UNI_RANGE(1),
  94                 UNI_RANGE(0.5)
  95         }
  96 };
  97
  98 struct adq12b_private {
  99         unsigned int last_ctreg;
 100 };
 101
 102 static int adq12b_ai_eoc(struct comedi_device *dev,
 103                          struct comedi_subdevice *s,
 104                          struct comedi_insn *insn,
 105                          unsigned long context)
 106 {
 107         unsigned char status;
 108
 109         status = inb(dev->iobase + ADQ12B_STINR);
 110         if (status & ADQ12B_STINR_EOC)
 111                 return 0;
 112         return -EBUSY;
 113 }
 114
 115 static int adq12b_ai_insn_read(struct comedi_device *dev,
 116                                struct comedi_subdevice *s,
 117                                struct comedi_insn *insn,
 118                                unsigned int *data)
 119 {
 120         struct adq12b_private *devpriv = dev->private;
 121         unsigned int chan = CR_CHAN(insn->chanspec);
 122         unsigned int range = CR_RANGE(insn->chanspec);
 123         unsigned int val;
 124         int ret;
 125         int i;
 126
 127         /* change channel and range only if it is different from the previous */
 128         val = ADQ12B_CTREG_RANGE(range) | ADQ12B_CTREG_CHAN(chan);
 129         if (val != devpriv->last_ctreg) {
 130                 outb(val, dev->iobase + ADQ12B_CTREG);
 131                 devpriv->last_ctreg = val;
 132                 usleep_range(50, 100);  /* wait for the mux to settle */
 133         }
 134
 135         val = inb(dev->iobase + ADQ12B_ADLOW);  /* trigger A/D */
 136
 137         for (i = 0; i < insn->n; i++) {
 138                 ret = comedi_timeout(dev, s, insn, adq12b_ai_eoc, 0);
 139                 if (ret)
 140                         return ret;
 141
 142                 val = inb(dev->iobase + ADQ12B_ADHIG) << 8;
 143                 val |= inb(dev->iobase + ADQ12B_ADLOW); /* retriggers A/D */
 144
 145                 data[i] = val;
 146         }
 147
 148         return insn->n;
 149 }
 150
 151 static int adq12b_di_insn_bits(struct comedi_device *dev,
 152                                struct comedi_subdevice *s,
 153                                struct comedi_insn *insn, unsigned int *data)
 154 {
 155         /* only bits 0-4 have information about digital inputs */
 156         data[1] = (inb(dev->iobase + ADQ12B_STINR) & ADQ12B_STINR_IN_MASK);
 157
 158         return insn->n;
 159 }
 160
 161 static int adq12b_do_insn_bits(struct comedi_device *dev,
 162                                struct comedi_subdevice *s,
 163                                struct comedi_insn *insn,
 164                                unsigned int *data)
 165 {
 166         unsigned int mask;
 167         unsigned int chan;
 168         unsigned int val;
 169
 170         mask = comedi_dio_update_state(s, data);
 171         if (mask) {
 172                 for (chan = 0; chan < 8; chan++) {
 173                         if ((mask >> chan) & 0x01) {
 174                                 val = (s->state >> chan) & 0x01;
 175                                 outb((val << 3) | chan,
 176                                      dev->iobase + ADQ12B_OUTBR);
 177                         }
 178                 }
 179         }
 180
 181         data[1] = s->state;
 182
 183         return insn->n;
 184 }
 185
 186 static int adq12b_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 187 {
 188         struct adq12b_private *devpriv;
 189         struct comedi_subdevice *s;
 190         int ret;
 191
 192         ret = comedi_request_region(dev, it->options[0], 0x10);
 193         if (ret)
 194                 return ret;
 195
 196         devpriv = comedi_alloc_devpriv(dev, sizeof(*devpriv));
 197         if (!devpriv)
 198                 return -ENOMEM;
 199
 200         devpriv->last_ctreg = -1;       /* force ctreg update */
 201
 202         ret = comedi_alloc_subdevices(dev, 3);
 203         if (ret)
 204                 return ret;
 205
 206         /* Analog Input subdevice */
 207         s = &dev->subdevices[0];
 208         s->type         = COMEDI_SUBD_AI;
 209         if (it->options[2]) {
 210                 s->subdev_flags = SDF_READABLE | SDF_DIFF;
 211                 s->n_chan       = 8;
 212         } else {
 213                 s->subdev_flags = SDF_READABLE | SDF_GROUND;
 214                 s->n_chan       = 16;
 215         }
 216         s->maxdata      = 0xfff;
 217         s->range_table  = it->options[1] ? &range_adq12b_ai_unipolar
 218                                          : &range_adq12b_ai_bipolar;
 219         s->insn_read    = adq12b_ai_insn_read;
 220
 221         /* Digital Input subdevice */
 222         s = &dev->subdevices[1];
 223         s->type         = COMEDI_SUBD_DI;
 224         s->subdev_flags = SDF_READABLE;
 225         s->n_chan       = 5;
 226         s->maxdata      = 1;
 227         s->range_table  = &range_digital;
 228         s->insn_bits    = adq12b_di_insn_bits;
 229
 230         /* Digital Output subdevice */
 231         s = &dev->subdevices[2];
 232         s->type         = COMEDI_SUBD_DO;
 233         s->subdev_flags = SDF_WRITABLE;
 234         s->n_chan       = 8;
 235         s->maxdata      = 1;
 236         s->range_table  = &range_digital;
 237         s->insn_bits    = adq12b_do_insn_bits;
 238
 239         return 0;
 240 }
 241
 242 static struct comedi_driver adq12b_driver = {
 243         .driver_name    = "adq12b",
 244         .module         = THIS_MODULE,
 245         .attach         = adq12b_attach,
 246         .detach         = comedi_legacy_detach,
 247 };
 248 module_comedi_driver(adq12b_driver);
 249
 250 MODULE_AUTHOR("Comedi http://www.comedi.org");
 251 MODULE_DESCRIPTION("Comedi low-level driver");
 252 MODULE_LICENSE("GPL");