drivers/staging/comedi/drivers/ni_daq_700.c

   1 /*
   2  *     comedi/drivers/ni_daq_700.c
   3  *     Driver for DAQCard-700 DIO/AI
   4  *     copied from 8255
   5  *
   6  *     COMEDI - Linux Control and Measurement Device Interface
   7  *     Copyright (C) 1998 David A. Schleef <ds@schleef.org>
   8  *
   9  *     This program is free software; you can redistribute it and/or modify
  10  *     it under the terms of the GNU General Public License as published by
  11  *     the Free Software Foundation; either version 2 of the License, or
  12  *     (at your option) any later version.
  13  *
  14  *     This program is distributed in the hope that it will be useful,
  15  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *     GNU General Public License for more details.
  18  */
  19
  20 /*
  21 Driver: ni_daq_700
  22 Description: National Instruments PCMCIA DAQCard-700 DIO only
  23 Author: Fred Brooks <nsaspook@nsaspook.com>,
  24   based on ni_daq_dio24 by Daniel Vecino Castel <dvecino@able.es>
  25 Devices: [National Instruments] PCMCIA DAQ-Card-700 (ni_daq_700)
  26 Status: works
  27 Updated: Wed, 19 Sep 2012 12:07:20 +0000
  28
  29 The daqcard-700 appears in Comedi as a  digital I/O subdevice (0) with
  30 16 channels and a analog input subdevice (1) with 16 single-ended channels.
  31
  32 Digital:  The channel 0 corresponds to the daqcard-700's output
  33 port, bit 0; channel 8 corresponds to the input port, bit 0.
  34
  35 Digital direction configuration: channels 0-7 output, 8-15 input (8225 device
  36 emu as port A output, port B input, port C N/A).
  37
  38 Analog: The input  range is 0 to 4095 for -10 to +10 volts
  39 IRQ is assigned but not used.
  40
  41 Version 0.1     Original DIO only driver
  42 Version 0.2     DIO and basic AI analog input support on 16 se channels
  43
  44 Manuals:        Register level: http://www.ni.com/pdf/manuals/340698.pdf
  45                 User Manual:    http://www.ni.com/pdf/manuals/320676d.pdf
  46 */
  47
  48 #include <linux/module.h>
  49 #include <linux/delay.h>
  50 #include <linux/interrupt.h>
  51
  52 #include "../comedidev.h"
  53
  54 #include <pcmcia/cistpl.h>
  55 #include <pcmcia/ds.h>
  56
  57 /* daqcard700 registers */
  58 #define DIO_W           0x04    /* WO 8bit */
  59 #define DIO_R           0x05    /* RO 8bit */
  60 #define CMD_R1          0x00    /* WO 8bit */
  61 #define CMD_R2          0x07    /* RW 8bit */
  62 #define CMD_R3          0x05    /* W0 8bit */
  63 #define STA_R1          0x00    /* RO 8bit */
  64 #define STA_R2          0x01    /* RO 8bit */
  65 #define ADFIFO_R        0x02    /* RO 16bit */
  66 #define ADCLEAR_R       0x01    /* WO 8bit */
  67 #define CDA_R0          0x08    /* RW 8bit */
  68 #define CDA_R1          0x09    /* RW 8bit */
  69 #define CDA_R2          0x0A    /* RW 8bit */
  70 #define CMO_R           0x0B    /* RO 8bit */
  71 #define TIC_R           0x06    /* WO 8bit */
  72
  73 static int daq700_dio_insn_bits(struct comedi_device *dev,
  74                                 struct comedi_subdevice *s,
  75                                 struct comedi_insn *insn,
  76                                 unsigned int *data)
  77 {
  78         unsigned int mask;
  79         unsigned int val;
  80
  81         mask = comedi_dio_update_state(s, data);
  82         if (mask) {
  83                 if (mask & 0xff)
  84                         outb(s->state & 0xff, dev->iobase + DIO_W);
  85         }
  86
  87         val = s->state & 0xff;
  88         val |= inb(dev->iobase + DIO_R) << 8;
  89
  90         data[1] = val;
  91
  92         return insn->n;
  93 }
  94
  95 static int daq700_dio_insn_config(struct comedi_device *dev,
  96                                   struct comedi_subdevice *s,
  97                                   struct comedi_insn *insn,
  98                                   unsigned int *data)
  99 {
 100         int ret;
 101
 102         ret = comedi_dio_insn_config(dev, s, insn, data, 0);
 103         if (ret)
 104                 return ret;
 105
 106         /* The DIO channels are not configurable, fix the io_bits */
 107         s->io_bits = 0x00ff;
 108
 109         return insn->n;
 110 }
 111
 112 static int daq700_ai_rinsn(struct comedi_device *dev,
 113                            struct comedi_subdevice *s,
 114                            struct comedi_insn *insn, unsigned int *data)
 115 {
 116         int n, i, chan;
 117         int d;
 118         unsigned int status;
 119         enum { TIMEOUT = 100 };
 120
 121         chan = CR_CHAN(insn->chanspec);
 122         /* write channel to multiplexer */
 123         /* set mask scan bit high to disable scanning */
 124         outb(chan | 0x80, dev->iobase + CMD_R1);
 125
 126         /* convert n samples */
 127         for (n = 0; n < insn->n; n++) {
 128                 /* trigger conversion with out0 L to H */
 129                 outb(0x00, dev->iobase + CMD_R2); /* enable ADC conversions */
 130                 outb(0x30, dev->iobase + CMO_R); /* mode 0 out0 L, from H */
 131                 /* mode 1 out0 H, L to H, start conversion */
 132                 outb(0x32, dev->iobase + CMO_R);
 133                 /* wait for conversion to end */
 134                 for (i = 0; i < TIMEOUT; i++) {
 135                         status = inb(dev->iobase + STA_R2);
 136                         if ((status & 0x03) != 0) {
 137                                 dev_info(dev->class_dev,
 138                                          "Overflow/run Error\n");
 139                                 return -EOVERFLOW;
 140                         }
 141                         status = inb(dev->iobase + STA_R1);
 142                         if ((status & 0x02) != 0) {
 143                                 dev_info(dev->class_dev, "Data Error\n");
 144                                 return -ENODATA;
 145                         }
 146                         if ((status & 0x11) == 0x01) {
 147                                 /* ADC conversion complete */
 148                                 break;
 149                         }
 150                         udelay(1);
 151                 }
 152                 if (i == TIMEOUT) {
 153                         dev_info(dev->class_dev,
 154                                  "timeout during ADC conversion\n");
 155                         return -ETIMEDOUT;
 156                 }
 157                 /* read data */
 158                 d = inw(dev->iobase + ADFIFO_R);
 159                 /* mangle the data as necessary */
 160                 /* Bipolar Offset Binary: 0 to 4095 for -10 to +10 */
 161                 d &= 0x0fff;
 162                 d ^= 0x0800;
 163                 data[n] = d;
 164         }
 165         return n;
 166 }
 167
 168 /*
 169  * Data acquisition is enabled.
 170  * The counter 0 output is high.
 171  * The I/O connector pin CLK1 drives counter 1 source.
 172  * Multiple-channel scanning is disabled.
 173  * All interrupts are disabled.
 174  * The analog input range is set to +-10 V
 175  * The analog input mode is single-ended.
 176  * The analog input circuitry is initialized to channel 0.
 177  * The A/D FIFO is cleared.
 178  */
 179 static void daq700_ai_config(struct comedi_device *dev,
 180                              struct comedi_subdevice *s)
 181 {
 182         unsigned long iobase = dev->iobase;
 183
 184         outb(0x80, iobase + CMD_R1);    /* disable scanning, ADC to chan 0 */
 185         outb(0x00, iobase + CMD_R2);    /* clear all bits */
 186         outb(0x00, iobase + CMD_R3);    /* set +-10 range */
 187         outb(0x32, iobase + CMO_R);     /* config counter mode1, out0 to H */
 188         outb(0x00, iobase + TIC_R);     /* clear counter interrupt */
 189         outb(0x00, iobase + ADCLEAR_R); /* clear the ADC FIFO */
 190         inw(iobase + ADFIFO_R);         /* read 16bit junk from FIFO to clear */
 191 }
 192
 193 static int daq700_auto_attach(struct comedi_device *dev,
 194                               unsigned long context)
 195 {
 196         struct pcmcia_device *link = comedi_to_pcmcia_dev(dev);
 197         struct comedi_subdevice *s;
 198         int ret;
 199
 200         link->config_flags |= CONF_AUTO_SET_IO;
 201         ret = comedi_pcmcia_enable(dev, NULL);
 202         if (ret)
 203                 return ret;
 204         dev->iobase = link->resource[0]->start;
 205
 206         ret = comedi_alloc_subdevices(dev, 2);
 207         if (ret)
 208                 return ret;
 209
 210         /* DAQCard-700 dio */
 211         s = &dev->subdevices[0];
 212         s->type         = COMEDI_SUBD_DIO;
 213         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 214         s->n_chan       = 16;
 215         s->range_table  = &range_digital;
 216         s->maxdata      = 1;
 217         s->insn_bits    = daq700_dio_insn_bits;
 218         s->insn_config  = daq700_dio_insn_config;
 219         s->io_bits      = 0x00ff;
 220
 221         /* DAQCard-700 ai */
 222         s = &dev->subdevices[1];
 223         s->type = COMEDI_SUBD_AI;
 224         /* we support single-ended (ground)  */
 225         s->subdev_flags = SDF_READABLE | SDF_GROUND;
 226         s->n_chan = 16;
 227         s->maxdata = (1 << 12) - 1;
 228         s->range_table = &range_bipolar10;
 229         s->insn_read = daq700_ai_rinsn;
 230         daq700_ai_config(dev, s);
 231
 232         dev_info(dev->class_dev, "%s: %s, io 0x%lx\n",
 233                 dev->driver->driver_name,
 234                 dev->board_name,
 235                 dev->iobase);
 236
 237         return 0;
 238 }
 239
 240 static struct comedi_driver daq700_driver = {
 241         .driver_name    = "ni_daq_700",
 242         .module         = THIS_MODULE,
 243         .auto_attach    = daq700_auto_attach,
 244         .detach         = comedi_pcmcia_disable,
 245 };
 246
 247 static int daq700_cs_attach(struct pcmcia_device *link)
 248 {
 249         return comedi_pcmcia_auto_config(link, &daq700_driver);
 250 }
 251
 252 static const struct pcmcia_device_id daq700_cs_ids[] = {
 253         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x4743),
 254         PCMCIA_DEVICE_NULL
 255 };
 256 MODULE_DEVICE_TABLE(pcmcia, daq700_cs_ids);
 257
 258 static struct pcmcia_driver daq700_cs_driver = {
 259         .name           = "ni_daq_700",
 260         .owner          = THIS_MODULE,
 261         .id_table       = daq700_cs_ids,
 262         .probe          = daq700_cs_attach,
 263         .remove         = comedi_pcmcia_auto_unconfig,
 264 };
 265 module_comedi_pcmcia_driver(daq700_driver, daq700_cs_driver);
 266
 267 MODULE_AUTHOR("Fred Brooks <nsaspook@nsaspook.com>");
 268 MODULE_DESCRIPTION(
 269         "Comedi driver for National Instruments PCMCIA DAQCard-700 DIO/AI");
 270 MODULE_VERSION("0.2.00");
 271 MODULE_LICENSE("GPL");