SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/comedi/drivers/cb_pcidio.c

   1 /*
   2     comedi/drivers/cb_pcidio.c
   3     A Comedi driver for PCI-DIO24H & PCI-DIO48H of ComputerBoards (currently MeasurementComputing)
   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_pcidio
  25 Description: ComputerBoards' DIO boards with PCI interface
  26 Devices: [Measurement Computing] PCI-DIO24 (cb_pcidio), PCI-DIO24H, PCI-DIO48H
  27 Author: Yoshiya Matsuzaka
  28 Updated: Mon, 29 Oct 2007 15:40:47 +0000
  29 Status: experimental
  30
  31 This driver has been modified from skel.c of comedi-0.7.70.
  32
  33 Configuration Options:
  34   [0] - PCI bus of device (optional)
  35   [1] - PCI slot of device (optional)
  36   If bus/slot is not specified, the first available PCI device will
  37   be used.
  38
  39 Passing a zero for an option is the same as leaving it unspecified.
  40 */
  41
  42 /*------------------------------ HEADER FILES ---------------------------------*/
  43 #include "../comedidev.h"
  44 #include "comedi_pci.h"
  45 #include "8255.h"
  46
  47 /*-------------------------- MACROS and DATATYPES -----------------------------*/
  48 #define PCI_VENDOR_ID_CB        0x1307
  49
  50 /*
  51  * Board descriptions for two imaginary boards.  Describing the
  52  * boards in this way is optional, and completely driver-dependent.
  53  * Some drivers use arrays such as this, other do not.
  54  */
  55 struct pcidio_board {
  56         const char *name;       /*  name of the board */
  57         int dev_id;
  58         int n_8255;             /*  number of 8255 chips on board */
  59
  60         /*  indices of base address regions */
  61         int pcicontroler_badrindex;
  62         int dioregs_badrindex;
  63 };
  64
  65 static const struct pcidio_board pcidio_boards[] = {
  66         {
  67          .name = "pci-dio24",
  68          .dev_id = 0x0028,
  69          .n_8255 = 1,
  70          .pcicontroler_badrindex = 1,
  71          .dioregs_badrindex = 2,
  72          },
  73         {
  74          .name = "pci-dio24h",
  75          .dev_id = 0x0014,
  76          .n_8255 = 1,
  77          .pcicontroler_badrindex = 1,
  78          .dioregs_badrindex = 2,
  79          },
  80         {
  81          .name = "pci-dio48h",
  82          .dev_id = 0x000b,
  83          .n_8255 = 2,
  84          .pcicontroler_badrindex = 0,
  85          .dioregs_badrindex = 1,
  86          },
  87 };
  88
  89 /* This is used by modprobe to translate PCI IDs to drivers.  Should
  90  * only be used for PCI and ISA-PnP devices */
  91 /* Please add your PCI vendor ID to comedidev.h, and it will be forwarded
  92  * upstream. */
  93 static DEFINE_PCI_DEVICE_TABLE(pcidio_pci_table) = {
  94         {
  95         PCI_VENDOR_ID_CB, 0x0028, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  96         PCI_VENDOR_ID_CB, 0x0014, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  97         PCI_VENDOR_ID_CB, 0x000b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  98         0}
  99 };
 100
 101 MODULE_DEVICE_TABLE(pci, pcidio_pci_table);
 102
 103 /*
 104  * Useful for shorthand access to the particular board structure
 105  */
 106 #define thisboard ((const struct pcidio_board *)dev->board_ptr)
 107
 108 /* this structure is for data unique to this hardware driver.  If
 109    several hardware drivers keep similar information in this structure,
 110    feel free to suggest moving the variable to the struct comedi_device struct.  */
 111 struct pcidio_private {
 112         int data;               /*  currently unused */
 113
 114         /* would be useful for a PCI device */
 115         struct pci_dev *pci_dev;
 116
 117         /* used for DO readback, currently unused */
 118         unsigned int do_readback[4];    /* up to 4 unsigned int suffice to hold 96 bits for PCI-DIO96 */
 119
 120         unsigned long dio_reg_base;     /*  address of port A of the first 8255 chip on board */
 121 };
 122
 123 /*
 124  * most drivers define the following macro to make it easy to
 125  * access the private structure.
 126  */
 127 #define devpriv ((struct pcidio_private *)dev->private)
 128
 129 /*
 130  * The struct comedi_driver structure tells the Comedi core module
 131  * which functions to call to configure/deconfigure (attach/detach)
 132  * the board, and also about the kernel module that contains
 133  * the device code.
 134  */
 135 static int pcidio_attach(struct comedi_device *dev,
 136                          struct comedi_devconfig *it);
 137 static int pcidio_detach(struct comedi_device *dev);
 138 static struct comedi_driver driver_cb_pcidio = {
 139         .driver_name = "cb_pcidio",
 140         .module = THIS_MODULE,
 141         .attach = pcidio_attach,
 142         .detach = pcidio_detach,
 143
 144 /* It is not necessary to implement the following members if you are
 145  * writing a driver for a ISA PnP or PCI card */
 146
 147         /* Most drivers will support multiple types of boards by
 148          * having an array of board structures.  These were defined
 149          * in pcidio_boards[] above.  Note that the element 'name'
 150          * was first in the structure -- Comedi uses this fact to
 151          * extract the name of the board without knowing any details
 152          * about the structure except for its length.
 153          * When a device is attached (by comedi_config), the name
 154          * of the device is given to Comedi, and Comedi tries to
 155          * match it by going through the list of board names.  If
 156          * there is a match, the address of the pointer is put
 157          * into dev->board_ptr and driver->attach() is called.
 158          *
 159          * Note that these are not necessary if you can determine
 160          * the type of board in software.  ISA PnP, PCI, and PCMCIA
 161          * devices are such boards.
 162          */
 163
 164 /* The following fields should NOT be initialized if you are dealing
 165  * with PCI devices
 166  *
 167  *      .board_name = pcidio_boards,
 168  *      .offset = sizeof(struct pcidio_board),
 169  *      .num_names = sizeof(pcidio_boards) / sizeof(structpcidio_board),
 170  */
 171
 172 };
 173
 174 /*------------------------------- FUNCTIONS -----------------------------------*/
 175
 176 /*
 177  * Attach is called by the Comedi core to configure the driver
 178  * for a particular board.  If you specified a board_name array
 179  * in the driver structure, dev->board_ptr contains that
 180  * address.
 181  */
 182 static int pcidio_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 183 {
 184         struct pci_dev *pcidev = NULL;
 185         int index;
 186         int i;
 187
 188         printk("comedi%d: cb_pcidio: \n", dev->minor);
 189
 190 /*
 191  * Allocate the private structure area.  alloc_private() is a
 192  * convenient macro defined in comedidev.h.
 193  */
 194         if (alloc_private(dev, sizeof(struct pcidio_private)) < 0)
 195                 return -ENOMEM;
 196 /*
 197  * If you can probe the device to determine what device in a series
 198  * it is, this is the place to do it.  Otherwise, dev->board_ptr
 199  * should already be initialized.
 200  */
 201 /*
 202  * Probe the device to determine what device in the series it is.
 203  */
 204
 205         for (pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, NULL);
 206              pcidev != NULL;
 207              pcidev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pcidev)) {
 208                 /*  is it not a computer boards card? */
 209                 if (pcidev->vendor != PCI_VENDOR_ID_CB)
 210                         continue;
 211                 /*  loop through cards supported by this driver */
 212                 for (index = 0; index < ARRAY_SIZE(pcidio_boards); index++) {
 213                         if (pcidio_boards[index].dev_id != pcidev->device)
 214                                 continue;
 215
 216                         /*  was a particular bus/slot requested? */
 217                         if (it->options[0] || it->options[1]) {
 218                                 /*  are we on the wrong bus/slot? */
 219                                 if (pcidev->bus->number != it->options[0] ||
 220                                     PCI_SLOT(pcidev->devfn) != it->options[1]) {
 221                                         continue;
 222                                 }
 223                         }
 224                         dev->board_ptr = pcidio_boards + index;
 225                         goto found;
 226                 }
 227         }
 228
 229         printk("No supported ComputerBoards/MeasurementComputing card found on "
 230                "requested position\n");
 231         return -EIO;
 232
 233 found:
 234
 235 /*
 236  * Initialize dev->board_name.  Note that we can use the "thisboard"
 237  * macro now, since we just initialized it in the last line.
 238  */
 239         dev->board_name = thisboard->name;
 240
 241         devpriv->pci_dev = pcidev;
 242         printk("Found %s on bus %i, slot %i\n", thisboard->name,
 243                devpriv->pci_dev->bus->number,
 244                PCI_SLOT(devpriv->pci_dev->devfn));
 245         if (comedi_pci_enable(pcidev, thisboard->name)) {
 246                 printk
 247                     ("cb_pcidio: failed to enable PCI device and request regions\n");
 248                 return -EIO;
 249         }
 250         devpriv->dio_reg_base
 251             =
 252             pci_resource_start(devpriv->pci_dev,
 253                                pcidio_boards[index].dioregs_badrindex);
 254
 255 /*
 256  * Allocate the subdevice structures.  alloc_subdevice() is a
 257  * convenient macro defined in comedidev.h.
 258  */
 259         if (alloc_subdevices(dev, thisboard->n_8255) < 0)
 260                 return -ENOMEM;
 261
 262         for (i = 0; i < thisboard->n_8255; i++) {
 263                 subdev_8255_init(dev, dev->subdevices + i,
 264                                  NULL, devpriv->dio_reg_base + i * 4);
 265                 printk(" subdev %d: base = 0x%lx\n", i,
 266                        devpriv->dio_reg_base + i * 4);
 267         }
 268
 269         printk("attached\n");
 270         return 1;
 271 }
 272
 273 /*
 274  * _detach is called to deconfigure a device.  It should deallocate
 275  * resources.
 276  * This function is also called when _attach() fails, so it should be
 277  * careful not to release resources that were not necessarily
 278  * allocated by _attach().  dev->private and dev->subdevices are
 279  * deallocated automatically by the core.
 280  */
 281 static int pcidio_detach(struct comedi_device *dev)
 282 {
 283         printk("comedi%d: cb_pcidio: remove\n", dev->minor);
 284         if (devpriv) {
 285                 if (devpriv->pci_dev) {
 286                         if (devpriv->dio_reg_base) {
 287                                 comedi_pci_disable(devpriv->pci_dev);
 288                         }
 289                         pci_dev_put(devpriv->pci_dev);
 290                 }
 291         }
 292         if (dev->subdevices) {
 293                 int i;
 294                 for (i = 0; i < thisboard->n_8255; i++) {
 295                         subdev_8255_cleanup(dev, dev->subdevices + i);
 296                 }
 297         }
 298         return 0;
 299 }
 300
 301 /*
 302  * A convenient macro that defines init_module() and cleanup_module(),
 303  * as necessary.
 304  */
 305 COMEDI_PCI_INITCLEANUP(driver_cb_pcidio, pcidio_pci_table);