comedi/drivers/poc.c

   1 /*
   2     comedi/drivers/poc.c
   3     Mini-drivers for POC (Piece of Crap) boards
   4     Copyright (C) 2000 Frank Mori Hess <fmhess@uiuc.edu>
   5     Copyright (C) 2001 David A. Schleef <ds@schleef.org>
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License, or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; if not, write to the Free Software
  19     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21 /*
  22  * This driver is a kind of miscellaneous driver for very
  23  * simple ISA boards.
  24  */
  25 /*
  26     dac02 - Keithley DAC-02 analog output board driver
  27
  28 The card's ranges are set by the wiring you use.  The driver only
  29 uses the range specified to decide whether or not to take the
  30 complement of the data before sending it to the card (since the
  31 bipolar outputs of the card are inverted.)
  32
  33 */
  34
  35 #include <linux/kernel.h>
  36 #include <linux/module.h>
  37 #include <linux/sched.h>
  38 #include <linux/mm.h>
  39 #include <linux/malloc.h>
  40 #include <linux/errno.h>
  41 #include <linux/ioport.h>
  42 #include <linux/delay.h>
  43 #include <linux/interrupt.h>
  44 #include <linux/timex.h>
  45 #include <linux/timer.h>
  46 #include <asm/io.h>
  47 #include <linux/comedidev.h>
  48
  49 /* DAC-02 registers */
  50 #define DAC02_LSB(a)    (2 * a)
  51 #define DAC02_MSB(a)    (2 * a + 1)
  52
  53 static int poc_attach(comedi_device *dev,comedi_devconfig *it);
  54 static int poc_detach(comedi_device *dev);
  55 static int dac02_ao_winsn(comedi_device *dev,comedi_subdevice *s,comedi_insn *insn,lsampl_t *data);
  56 static int readback_insn(comedi_device *dev,comedi_subdevice *s,comedi_insn *insn,lsampl_t *data);
  57
  58 struct boarddef_struct{
  59         char *name;
  60         int iosize;
  61         int (*setup)(comedi_device *);
  62         int type;
  63         int n_chan;
  64         int n_bits;
  65         int (*winsn)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);
  66         int (*rinsn)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);
  67 };
  68 static struct boarddef_struct boards[]={
  69         {
  70         name:           "dac02",
  71         iosize:         8,
  72         //setup:                dac02_setup,
  73         type:           COMEDI_SUBD_AO,
  74         n_chan:         2,
  75         n_bits:         12,
  76         winsn:          dac02_ao_winsn,
  77         rinsn:          readback_insn,
  78         }
  79 };
  80 #define n_boards (sizeof(boards)/sizeof(boards[0]))
  81 #define this_board ((struct boarddef_struct *)dev->board_ptr)
  82
  83 comedi_driver driver_poc=
  84 {
  85         driver_name:    "poc",
  86         module:         THIS_MODULE,
  87         attach:         poc_attach,
  88         detach:         poc_detach,
  89         board_name:     boards,
  90         num_names:      n_boards,
  91         offset:         sizeof(boards[0]),
  92 };
  93
  94 // analog output ranges
  95 static comedi_lrange range_dac02 = {
  96         4,
  97         {
  98                 RANGE( -5, 5 ),
  99                 RANGE( -10, 10 ),
 100                 RANGE( 0, 5 ),
 101                 RANGE( 0, 10 ),
 102         }
 103 };
 104
 105 static int poc_attach(comedi_device *dev, comedi_devconfig *it)
 106 {
 107         comedi_subdevice *s;
 108         int iosize, iobase;
 109
 110         iobase = it->options[0];
 111         printk("comedi%d: poc: using %s iobase 0x%x\n", dev->minor,
 112                 this_board->name, iobase);
 113
 114         dev->board_name = this_board->name;
 115
 116         if(iobase == 0)
 117         {
 118                 printk("io base address required\n");
 119                 return -EINVAL;
 120         }
 121
 122         iosize = this_board->iosize;
 123         /* check if io addresses are available */
 124         if(check_region(iobase, iosize) < 0)
 125         {
 126                 printk("I/O port conflict: failed to allocate ports 0x%x to 0x%x\n",
 127                         iobase, iobase + iosize - 1);
 128                 return -EIO;
 129         }
 130         request_region(iobase, iosize, "dac02");
 131         dev->iobase = iobase;
 132
 133         dev->n_subdevices = 1;
 134         if(alloc_subdevices(dev) < 0)
 135                 return -ENOMEM;
 136         if(alloc_private(dev,sizeof(lsampl_t)*this_board->n_chan) < 0)
 137                 return -ENOMEM;
 138
 139         /* analog output subdevice */
 140         s=dev->subdevices + 0;
 141         s->type = this_board->type;
 142         s->n_chan = this_board->n_chan;
 143         s->maxdata = (1<<this_board->n_bits)-1;
 144         s->range_table = &range_dac02; // XXX
 145         s->insn_write = this_board->winsn;
 146         s->insn_write = this_board->rinsn;
 147         if(s->type==COMEDI_SUBD_AO || s->type==COMEDI_SUBD_DO){
 148                 s->subdev_flags = SDF_WRITEABLE;
 149         }
 150
 151         return 0;
 152 }
 153
 154 static int poc_detach(comedi_device *dev)
 155 {
 156         /* only free stuff if it has been allocated by _attach */
 157         if(dev->iobase)
 158                 release_region(dev->iobase, this_board->iosize);
 159
 160         printk("comedi%d: dac02: remove\n", dev->minor);
 161
 162         return 0;
 163 }
 164
 165 static int readback_insn(comedi_device *dev,comedi_subdevice *s,comedi_insn *insn,lsampl_t *data)
 166 {
 167         int chan;
 168
 169         chan = CR_CHAN(insn->chanspec);
 170         data[0]=((lsampl_t *)dev->private)[chan];
 171
 172         return 1;
 173 }
 174
 175 static int dac02_ao_winsn(comedi_device *dev,comedi_subdevice *s,comedi_insn *insn,lsampl_t *data)
 176 {
 177         int temp;
 178         int chan;
 179         int output;
 180
 181         chan = CR_CHAN(insn->chanspec);
 182         ((lsampl_t *)dev->private)[chan] = data[0];
 183         output = data[0];
 184 #if wrong
 185         // convert to complementary binary if range is bipolar
 186         if((CR_RANGE(insn->chanspec) & 0x2) == 0)
 187                 output = ~output;
 188 #endif
 189         temp = (output << 4) & 0xf0;
 190         outb(temp, dev->iobase + DAC02_LSB(chan));
 191         temp = (output >> 4) & 0xff;
 192         outb(temp, dev->iobase + DAC02_MSB(chan));
 193
 194         return 1;
 195 }
 196
 197 COMEDI_INITCLEANUP(driver_poc);
 198