drivers/staging/comedi/drivers/cb_pcimdas.c

   1 /*
   2     comedi/drivers/cb_pcimdas.c
   3     Comedi driver for Computer Boards PCIM-DAS1602/16
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22 */
  23 /*
  24 Driver: cb_pcimdas
  25 Description: Measurement Computing PCI Migration series boards
  26 Devices: [ComputerBoards] PCIM-DAS1602/16 (cb_pcimdas)
  27 Author: Richard Bytheway
  28 Updated: Wed, 13 Nov 2002 12:34:56 +0000
  29 Status: experimental
  30
  31 Written to support the PCIM-DAS1602/16 on a 2.4 series kernel.
  32
  33 Configuration Options:
  34     [0] - PCI bus number
  35     [1] - PCI slot number
  36
  37 Developed from cb_pcidas and skel by Richard Bytheway (mocelet@sucs.org).
  38 Only supports DIO, AO and simple AI in it's present form.
  39 No interrupts, multi channel or FIFO AI, although the card looks like it could support this.
  40 See http://www.measurementcomputing.com/PDFManuals/pcim-das1602_16.pdf for more details.
  41 */
  42
  43 #include "../comedidev.h"
  44
  45 #include <linux/delay.h>
  46 #include <linux/interrupt.h>
  47
  48 #include "comedi_pci.h"
  49 #include "plx9052.h"
  50 #include "8255.h"
  51
  52 /* #define CBPCIMDAS_DEBUG */
  53 #undef CBPCIMDAS_DEBUG
  54
  55 /* Registers for the PCIM-DAS1602/16 */
  56
  57 /* sizes of io regions (bytes) */
  58 #define BADR0_SIZE 2            /* ?? */
  59 #define BADR1_SIZE 4
  60 #define BADR2_SIZE 6
  61 #define BADR3_SIZE 16
  62 #define BADR4_SIZE 4
  63
  64 /* DAC Offsets */
  65 #define ADC_TRIG 0
  66 #define DAC0_OFFSET 2
  67 #define DAC1_OFFSET 4
  68
  69 /* AI and Counter Constants */
  70 #define MUX_LIMITS 0
  71 #define MAIN_CONN_DIO 1
  72 #define ADC_STAT 2
  73 #define ADC_CONV_STAT 3
  74 #define ADC_INT 4
  75 #define ADC_PACER 5
  76 #define BURST_MODE 6
  77 #define PROG_GAIN 7
  78 #define CLK8254_1_DATA 8
  79 #define CLK8254_2_DATA 9
  80 #define CLK8254_3_DATA 10
  81 #define CLK8254_CONTROL 11
  82 #define USER_COUNTER 12
  83 #define RESID_COUNT_H 13
  84 #define RESID_COUNT_L 14
  85
  86 /* Board description */
  87 struct cb_pcimdas_board {
  88         const char *name;
  89         unsigned short device_id;
  90         int ai_se_chans;        /*  Inputs in single-ended mode */
  91         int ai_diff_chans;      /*  Inputs in differential mode */
  92         int ai_bits;            /*  analog input resolution */
  93         int ai_speed;           /*  fastest conversion period in ns */
  94         int ao_nchan;           /*  number of analog out channels */
  95         int ao_bits;            /*  analogue output resolution */
  96         int has_ao_fifo;        /*  analog output has fifo */
  97         int ao_scan_speed;      /*  analog output speed for 1602 series (for a scan, not conversion) */
  98         int fifo_size;          /*  number of samples fifo can hold */
  99         int dio_bits;           /*  number of dio bits */
 100         int has_dio;            /*  has DIO */
 101         const struct comedi_lrange *ranges;
 102 };
 103
 104 static const struct cb_pcimdas_board cb_pcimdas_boards[] = {
 105         {
 106          .name = "PCIM-DAS1602/16",
 107          .device_id = 0x56,
 108          .ai_se_chans = 16,
 109          .ai_diff_chans = 8,
 110          .ai_bits = 16,
 111          .ai_speed = 10000,     /* ?? */
 112          .ao_nchan = 2,
 113          .ao_bits = 12,
 114          .has_ao_fifo = 0,      /* ?? */
 115          .ao_scan_speed = 10000,
 116          /* ?? */
 117          .fifo_size = 1024,
 118          .dio_bits = 24,
 119          .has_dio = 1,
 120 /*      .ranges = &cb_pcimdas_ranges, */
 121          },
 122 };
 123
 124 /* This is used by modprobe to translate PCI IDs to drivers.  Should
 125  * only be used for PCI and ISA-PnP devices */
 126 static DEFINE_PCI_DEVICE_TABLE(cb_pcimdas_pci_table) = {
 127         {
 128         PCI_VENDOR_ID_COMPUTERBOARDS, 0x0056, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 129         {
 130         0}
 131 };
 132
 133 MODULE_DEVICE_TABLE(pci, cb_pcimdas_pci_table);
 134
 135 #define N_BOARDS 1              /*  Max number of boards supported */
 136
 137 /*
 138  * Useful for shorthand access to the particular board structure
 139  */
 140 #define thisboard ((const struct cb_pcimdas_board *)dev->board_ptr)
 141
 142 /* this structure is for data unique to this hardware driver.  If
 143    several hardware drivers keep similar information in this structure,
 144    feel free to suggest moving the variable to the struct comedi_device struct.  */
 145 struct cb_pcimdas_private {
 146         int data;
 147
 148         /*  would be useful for a PCI device */
 149         struct pci_dev *pci_dev;
 150
 151         /* base addresses */
 152         unsigned long BADR0;
 153         unsigned long BADR1;
 154         unsigned long BADR2;
 155         unsigned long BADR3;
 156         unsigned long BADR4;
 157
 158         /* Used for AO readback */
 159         unsigned int ao_readback[2];
 160
 161         /*  Used for DIO */
 162         unsigned short int port_a;      /*  copy of BADR4+0 */
 163         unsigned short int port_b;      /*  copy of BADR4+1 */
 164         unsigned short int port_c;      /*  copy of BADR4+2 */
 165         unsigned short int dio_mode;    /*  copy of BADR4+3 */
 166
 167 };
 168
 169 /*
 170  * most drivers define the following macro to make it easy to
 171  * access the private structure.
 172  */
 173 #define devpriv ((struct cb_pcimdas_private *)dev->private)
 174
 175 /*
 176  * The struct comedi_driver structure tells the Comedi core module
 177  * which functions to call to configure/deconfigure (attach/detach)
 178  * the board, and also about the kernel module that contains
 179  * the device code.
 180  */
 181 static int cb_pcimdas_attach(struct comedi_device *dev,
 182                              struct comedi_devconfig *it);
 183 static int cb_pcimdas_detach(struct comedi_device *dev);
 184 static struct comedi_driver driver_cb_pcimdas = {
 185         .driver_name = "cb_pcimdas",
 186         .module = THIS_MODULE,
 187         .attach = cb_pcimdas_attach,
 188         .detach = cb_pcimdas_detach,
 189 };
 190
 191 static int cb_pcimdas_ai_rinsn(struct comedi_device *dev,
 192                                struct comedi_subdevice *s,
 193                                struct comedi_insn *insn, unsigned int *data);
 194 static int cb_pcimdas_ao_winsn(struct comedi_device *dev,
 195                                struct comedi_subdevice *s,
 196                                struct comedi_insn *insn, unsigned int *data);
 197 static int cb_pcimdas_ao_rinsn(struct comedi_device *dev,
 198                                struct comedi_subdevice *s,
 199                                struct comedi_insn *insn, unsigned int *data);
 200
 201 /*
 202  * Attach is called by the Comedi core to configure the driver
 203  * for a particular board.  If you specified a board_name array
 204  * in the driver structure, dev->board_ptr contains that
 205  * address.
 206  */
 207 static int cb_pcimdas_attach(struct comedi_device *dev,
 208                              struct comedi_devconfig *it)
 209 {
 210         struct comedi_subdevice *s;
 211         struct pci_dev *pcidev;
 212         int index;
 213         /* int i; */
 214
 215         printk("comedi%d: cb_pcimdas: ", dev->minor);
 216
 217 /*
 218  * Allocate the private structure area.
 219  */
 220         if (alloc_private(dev, sizeof(struct cb_pcimdas_private)) < 0)
 221                 return -ENOMEM;
 222
 223 /*
 224  * Probe the device to determine what device in the series it is.
 225  */
 226         printk("\n");
 227
 228         for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
 229              pcidev != NULL;
 230              pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
 231                 /*  is it not a computer boards card? */
 232                 if (pcidev->vendor != PCI_VENDOR_ID_COMPUTERBOARDS)
 233                         continue;
 234                 /*  loop through cards supported by this driver */
 235                 for (index = 0; index < N_BOARDS; index++) {
 236                         if (cb_pcimdas_boards[index].device_id !=
 237                             pcidev->device)
 238                                 continue;
 239                         /*  was a particular bus/slot requested? */
 240                         if (it->options[0] || it->options[1]) {
 241                                 /*  are we on the wrong bus/slot? */
 242                                 if (pcidev->bus->number != it->options[0] ||
 243                                     PCI_SLOT(pcidev->devfn) != it->options[1]) {
 244                                         continue;
 245                                 }
 246                         }
 247                         devpriv->pci_dev = pcidev;
 248                         dev->board_ptr = cb_pcimdas_boards + index;
 249                         goto found;
 250                 }
 251         }
 252
 253         printk("No supported ComputerBoards/MeasurementComputing card found on "
 254                "requested position\n");
 255         return -EIO;
 256
 257 found:
 258
 259         printk("Found %s on bus %i, slot %i\n", cb_pcimdas_boards[index].name,
 260                pcidev->bus->number, PCI_SLOT(pcidev->devfn));
 261
 262         /*  Warn about non-tested features */
 263         switch (thisboard->device_id) {
 264         case 0x56:
 265                 break;
 266         default:
 267                 printk("THIS CARD IS UNSUPPORTED.\n"
 268                        "PLEASE REPORT USAGE TO <mocelet@sucs.org>\n");
 269         };
 270
 271         if (comedi_pci_enable(pcidev, "cb_pcimdas")) {
 272                 printk(" Failed to enable PCI device and request regions\n");
 273                 return -EIO;
 274         }
 275
 276         devpriv->BADR0 = pci_resource_start(devpriv->pci_dev, 0);
 277         devpriv->BADR1 = pci_resource_start(devpriv->pci_dev, 1);
 278         devpriv->BADR2 = pci_resource_start(devpriv->pci_dev, 2);
 279         devpriv->BADR3 = pci_resource_start(devpriv->pci_dev, 3);
 280         devpriv->BADR4 = pci_resource_start(devpriv->pci_dev, 4);
 281
 282 #ifdef CBPCIMDAS_DEBUG
 283         printk("devpriv->BADR0 = 0x%lx\n", devpriv->BADR0);
 284         printk("devpriv->BADR1 = 0x%lx\n", devpriv->BADR1);
 285         printk("devpriv->BADR2 = 0x%lx\n", devpriv->BADR2);
 286         printk("devpriv->BADR3 = 0x%lx\n", devpriv->BADR3);
 287         printk("devpriv->BADR4 = 0x%lx\n", devpriv->BADR4);
 288 #endif
 289
 290 /* Dont support IRQ yet */
 291 /*  get irq */
 292 /* if(request_irq(devpriv->pci_dev->irq, cb_pcimdas_interrupt, IRQF_SHARED, "cb_pcimdas", dev )) */
 293 /* { */
 294 /* printk(" unable to allocate irq %u\n", devpriv->pci_dev->irq); */
 295 /* return -EINVAL; */
 296 /* } */
 297 /* dev->irq = devpriv->pci_dev->irq; */
 298
 299         /* Initialize dev->board_name */
 300         dev->board_name = thisboard->name;
 301
 302 /*
 303  * Allocate the subdevice structures.  alloc_subdevice() is a
 304  * convenient macro defined in comedidev.h.
 305  */
 306         if (alloc_subdevices(dev, 3) < 0)
 307                 return -ENOMEM;
 308
 309         s = dev->subdevices + 0;
 310         /* dev->read_subdev=s; */
 311         /*  analog input subdevice */
 312         s->type = COMEDI_SUBD_AI;
 313         s->subdev_flags = SDF_READABLE | SDF_GROUND;
 314         s->n_chan = thisboard->ai_se_chans;
 315         s->maxdata = (1 << thisboard->ai_bits) - 1;
 316         s->range_table = &range_unknown;
 317         s->len_chanlist = 1;    /*  This is the maximum chanlist length that */
 318         /*  the board can handle */
 319         s->insn_read = cb_pcimdas_ai_rinsn;
 320
 321         s = dev->subdevices + 1;
 322         /*  analog output subdevice */
 323         s->type = COMEDI_SUBD_AO;
 324         s->subdev_flags = SDF_WRITABLE;
 325         s->n_chan = thisboard->ao_nchan;
 326         s->maxdata = 1 << thisboard->ao_bits;
 327         s->range_table = &range_unknown;        /* ranges are hardware settable, but not software readable. */
 328         s->insn_write = &cb_pcimdas_ao_winsn;
 329         s->insn_read = &cb_pcimdas_ao_rinsn;
 330
 331         s = dev->subdevices + 2;
 332         /* digital i/o subdevice */
 333         if (thisboard->has_dio)
 334                 subdev_8255_init(dev, s, NULL, devpriv->BADR4);
 335         else
 336                 s->type = COMEDI_SUBD_UNUSED;
 337
 338         printk("attached\n");
 339
 340         return 1;
 341 }
 342
 343 /*
 344  * _detach is called to deconfigure a device.  It should deallocate
 345  * resources.
 346  * This function is also called when _attach() fails, so it should be
 347  * careful not to release resources that were not necessarily
 348  * allocated by _attach().  dev->private and dev->subdevices are
 349  * deallocated automatically by the core.
 350  */
 351 static int cb_pcimdas_detach(struct comedi_device *dev)
 352 {
 353 #ifdef CBPCIMDAS_DEBUG
 354         if (devpriv) {
 355                 printk("devpriv->BADR0 = 0x%lx\n", devpriv->BADR0);
 356                 printk("devpriv->BADR1 = 0x%lx\n", devpriv->BADR1);
 357                 printk("devpriv->BADR2 = 0x%lx\n", devpriv->BADR2);
 358                 printk("devpriv->BADR3 = 0x%lx\n", devpriv->BADR3);
 359                 printk("devpriv->BADR4 = 0x%lx\n", devpriv->BADR4);
 360         }
 361 #endif
 362         printk("comedi%d: cb_pcimdas: remove\n", dev->minor);
 363         if (dev->irq)
 364                 free_irq(dev->irq, dev);
 365         if (devpriv) {
 366                 if (devpriv->pci_dev) {
 367                         if (devpriv->BADR0)
 368                                 comedi_pci_disable(devpriv->pci_dev);
 369                         pci_dev_put(devpriv->pci_dev);
 370                 }
 371         }
 372
 373         return 0;
 374 }
 375
 376 /*
 377  * "instructions" read/write data in "one-shot" or "software-triggered"
 378  * mode.
 379  */
 380 static int cb_pcimdas_ai_rinsn(struct comedi_device *dev,
 381                                struct comedi_subdevice *s,
 382                                struct comedi_insn *insn, unsigned int *data)
 383 {
 384         int n, i;
 385         unsigned int d;
 386         unsigned int busy;
 387         int chan = CR_CHAN(insn->chanspec);
 388         unsigned short chanlims;
 389         int maxchans;
 390
 391         /*  only support sw initiated reads from a single channel */
 392
 393         /* check channel number */
 394         if ((inb(devpriv->BADR3 + 2) & 0x20) == 0)      /* differential mode */
 395                 maxchans = thisboard->ai_diff_chans;
 396         else
 397                 maxchans = thisboard->ai_se_chans;
 398
 399         if (chan > (maxchans - 1))
 400                 return -ETIMEDOUT;      /* *** Wrong error code. Fixme. */
 401
 402         /* configure for sw initiated read */
 403         d = inb(devpriv->BADR3 + 5);
 404         if ((d & 0x03) > 0) {   /* only reset if needed. */
 405                 d = d & 0xfd;
 406                 outb(d, devpriv->BADR3 + 5);
 407         }
 408         outb(0x01, devpriv->BADR3 + 6); /* set bursting off, conversions on */
 409         outb(0x00, devpriv->BADR3 + 7); /* set range to 10V. UP/BP is controlled by a switch on the board */
 410
 411         /*  write channel limits to multiplexer, set Low (bits 0-3) and High (bits 4-7) channels to chan. */
 412         chanlims = chan | (chan << 4);
 413         outb(chanlims, devpriv->BADR3 + 0);
 414
 415         /* convert n samples */
 416         for (n = 0; n < insn->n; n++) {
 417                 /* trigger conversion */
 418                 outw(0, devpriv->BADR2 + 0);
 419
 420 #define TIMEOUT 1000            /* typically takes 5 loops on a lightly loaded Pentium 100MHz, */
 421                 /* this is likely to be 100 loops on a 2GHz machine, so set 1000 as the limit. */
 422
 423                 /* wait for conversion to end */
 424                 for (i = 0; i < TIMEOUT; i++) {
 425                         busy = inb(devpriv->BADR3 + 2) & 0x80;
 426                         if (!busy)
 427                                 break;
 428                 }
 429                 if (i == TIMEOUT) {
 430                         printk("timeout\n");
 431                         return -ETIMEDOUT;
 432                 }
 433                 /* read data */
 434                 d = inw(devpriv->BADR2 + 0);
 435
 436                 /* mangle the data as necessary */
 437                 /* d ^= 1<<(thisboard->ai_bits-1); // 16 bit data from ADC, so no mangle needed. */
 438
 439                 data[n] = d;
 440         }
 441
 442         /* return the number of samples read/written */
 443         return n;
 444 }
 445
 446 static int cb_pcimdas_ao_winsn(struct comedi_device *dev,
 447                                struct comedi_subdevice *s,
 448                                struct comedi_insn *insn, unsigned int *data)
 449 {
 450         int i;
 451         int chan = CR_CHAN(insn->chanspec);
 452
 453         /* Writing a list of values to an AO channel is probably not
 454          * very useful, but that's how the interface is defined. */
 455         for (i = 0; i < insn->n; i++) {
 456                 switch (chan) {
 457                 case 0:
 458                         outw(data[i] & 0x0FFF, devpriv->BADR2 + DAC0_OFFSET);
 459                         break;
 460                 case 1:
 461                         outw(data[i] & 0x0FFF, devpriv->BADR2 + DAC1_OFFSET);
 462                         break;
 463                 default:
 464                         return -1;
 465                 }
 466                 devpriv->ao_readback[chan] = data[i];
 467         }
 468
 469         /* return the number of samples read/written */
 470         return i;
 471 }
 472
 473 /* AO subdevices should have a read insn as well as a write insn.
 474  * Usually this means copying a value stored in devpriv. */
 475 static int cb_pcimdas_ao_rinsn(struct comedi_device *dev,
 476                                struct comedi_subdevice *s,
 477                                struct comedi_insn *insn, unsigned int *data)
 478 {
 479         int i;
 480         int chan = CR_CHAN(insn->chanspec);
 481
 482         for (i = 0; i < insn->n; i++)
 483                 data[i] = devpriv->ao_readback[chan];
 484
 485         return i;
 486 }
 487
 488 /*
 489  * A convenient macro that defines init_module() and cleanup_module(),
 490  * as necessary.
 491  */
 492 COMEDI_PCI_INITCLEANUP(driver_cb_pcimdas, cb_pcimdas_pci_table);