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 static int poc_recognize(char *name);
  58
  59 struct boarddef_struct{
  60         char *name;
  61         int iosize;
  62         int (*setup)(comedi_device *);
  63         int type;
  64         int n_chan;
  65         int n_bits;
  66         int (*winsn)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);
  67         int (*rinsn)(comedi_device *,comedi_subdevice *,comedi_insn *,lsampl_t *);
  68 };
  69 static struct boarddef_struct boards[]={
  70         {
  71         name:           "dac02",
  72         iosize:         8,
  73         //setup:                dac02_setup,
  74         type:           COMEDI_SUBD_AO,
  75         n_chan:         2,
  76         n_bits:         12,
  77         winsn:          dac02_ao_winsn,
  78         rinsn:          readback_insn,
  79         }
  80 };
  81 #define n_boards (sizeof(boards)/sizeof(boards[0]))
  82
  83 comedi_driver driver_poc=
  84 {
  85         driver_name:    "poc",
  86         module:         THIS_MODULE,
  87         attach:         poc_attach,
  88         detach:         poc_detach,
  89         recognize:      poc_recognize,
  90 };
  91
  92 // analog output ranges
  93 static comedi_lrange range_dac02 = {
  94         4,
  95         {
  96                 RANGE( -5, 5 ),
  97                 RANGE( -10, 10 ),
  98                 RANGE( 0, 5 ),
  99                 RANGE( 0, 10 ),
 100         }
 101 };
 102
 103 static int poc_recognize(char *name)
 104 {
 105         int i;
 106
 107         for(i=0;i<n_boards;i++){
 108                 if(!strcmp(boards[i].name,name))
 109                         return i;
 110         }
 111
 112         return -1;
 113 }
 114
 115 static int poc_attach(comedi_device *dev, comedi_devconfig *it)
 116 {
 117         comedi_subdevice *s;
 118         int iosize, iobase;
 119
 120         iobase = it->options[0];
 121         printk("comedi%d: poc: using %s iobase 0x%x\n", dev->minor,
 122                 boards[dev->board].name, iobase);
 123
 124         dev->board_name = boards[dev->board].name;
 125
 126         if(iobase == 0)
 127         {
 128                 printk("io base address required\n");
 129                 return -EINVAL;
 130         }
 131
 132         iosize = boards[dev->board].iosize;
 133         /* check if io addresses are available */
 134         if(check_region(iobase, iosize) < 0)
 135         {
 136                 printk("I/O port conflict: failed to allocate ports 0x%x to 0x%x\n",
 137                         iobase, iobase + iosize - 1);
 138                 return -EIO;
 139         }
 140         request_region(iobase, iosize, "dac02");
 141         dev->iobase = iobase;
 142         dev->iosize = iosize;
 143
 144         dev->n_subdevices = 1;
 145         if(alloc_subdevices(dev) < 0)
 146                 return -ENOMEM;
 147         if(alloc_private(dev,sizeof(lsampl_t)*boards[dev->board].n_chan) < 0)
 148                 return -ENOMEM;
 149
 150         /* analog output subdevice */
 151         s=dev->subdevices + 0;
 152         s->type = boards[dev->board].type;
 153         s->n_chan = boards[dev->board].n_chan;
 154         s->maxdata = (1<<boards[dev->board].n_bits)-1;
 155         s->range_table = &range_dac02; // XXX
 156         s->insn_write = boards[dev->board].winsn;
 157         s->insn_write = boards[dev->board].rinsn;
 158         if(s->type==COMEDI_SUBD_AO || s->type==COMEDI_SUBD_DO){
 159                 s->subdev_flags = SDF_WRITEABLE;
 160         }
 161
 162         return 0;
 163 }
 164
 165 static int poc_detach(comedi_device *dev)
 166 {
 167         /* only free stuff if it has been allocated by _attach */
 168         if(dev->iobase)
 169                 release_region(dev->iobase, dev->iosize);
 170
 171         printk("comedi%d: dac02: remove\n", dev->minor);
 172
 173         return 0;
 174 }
 175
 176 static int readback_insn(comedi_device *dev,comedi_subdevice *s,comedi_insn *insn,lsampl_t *data)
 177 {
 178         int chan;
 179
 180         chan = CR_CHAN(insn->chanspec);
 181         data[0]=((lsampl_t *)dev->private)[chan];
 182
 183         return 1;
 184 }
 185
 186 static int dac02_ao_winsn(comedi_device *dev,comedi_subdevice *s,comedi_insn *insn,lsampl_t *data)
 187 {
 188         int temp;
 189         int chan;
 190         int output;
 191
 192         chan = CR_CHAN(insn->chanspec);
 193         ((lsampl_t *)dev->private)[chan] = data[0];
 194         output = data[0];
 195 #if wrong
 196         // convert to complementary binary if range is bipolar
 197         if((CR_RANGE(insn->chanspec) & 0x2) == 0)
 198                 output = ~output;
 199 #endif
 200         temp = (output << 4) & 0xf0;
 201         outb(temp, dev->iobase + DAC02_LSB(chan));
 202         temp = (output >> 4) & 0xff;
 203         outb(temp, dev->iobase + DAC02_MSB(chan));
 204
 205         return 1;
 206 }
 207
 208 COMEDI_INITCLEANUP(driver_poc);
 209