release/src-rt-6.x.4708/linux/linux-2.6.36/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_each_pci_dev(pcidev) {
 206                 /*  is it not a computer boards card? */
 207                 if (pcidev->vendor != PCI_VENDOR_ID_CB)
 208                         continue;
 209                 /*  loop through cards supported by this driver */
 210                 for (index = 0; index < ARRAY_SIZE(pcidio_boards); index++) {
 211                         if (pcidio_boards[index].dev_id != pcidev->device)
 212                                 continue;
 213
 214                         /*  was a particular bus/slot requested? */
 215                         if (it->options[0] || it->options[1]) {
 216                                 /*  are we on the wrong bus/slot? */
 217                                 if (pcidev->bus->number != it->options[0] ||
 218                                     PCI_SLOT(pcidev->devfn) != it->options[1]) {
 219                                         continue;
 220                                 }
 221                         }
 222                         dev->board_ptr = pcidio_boards + index;
 223                         goto found;
 224                 }
 225         }
 226
 227         printk("No supported ComputerBoards/MeasurementComputing card found on "
 228                "requested position\n");
 229         return -EIO;
 230
 231 found:
 232
 233 /*
 234  * Initialize dev->board_name.  Note that we can use the "thisboard"
 235  * macro now, since we just initialized it in the last line.
 236  */
 237         dev->board_name = thisboard->name;
 238
 239         devpriv->pci_dev = pcidev;
 240         printk("Found %s on bus %i, slot %i\n", thisboard->name,
 241                devpriv->pci_dev->bus->number,
 242                PCI_SLOT(devpriv->pci_dev->devfn));
 243         if (comedi_pci_enable(pcidev, thisboard->name)) {
 244                 printk
 245                     ("cb_pcidio: failed to enable PCI device and request regions\n");
 246                 return -EIO;
 247         }
 248         devpriv->dio_reg_base
 249             =
 250             pci_resource_start(devpriv->pci_dev,
 251                                pcidio_boards[index].dioregs_badrindex);
 252
 253 /*
 254  * Allocate the subdevice structures.  alloc_subdevice() is a
 255  * convenient macro defined in comedidev.h.
 256  */
 257         if (alloc_subdevices(dev, thisboard->n_8255) < 0)
 258                 return -ENOMEM;
 259
 260         for (i = 0; i < thisboard->n_8255; i++) {
 261                 subdev_8255_init(dev, dev->subdevices + i,
 262                                  NULL, devpriv->dio_reg_base + i * 4);
 263                 printk(" subdev %d: base = 0x%lx\n", i,
 264                        devpriv->dio_reg_base + i * 4);
 265         }
 266
 267         printk("attached\n");
 268         return 1;
 269 }
 270
 271 /*
 272  * _detach is called to deconfigure a device.  It should deallocate
 273  * resources.
 274  * This function is also called when _attach() fails, so it should be
 275  * careful not to release resources that were not necessarily
 276  * allocated by _attach().  dev->private and dev->subdevices are
 277  * deallocated automatically by the core.
 278  */
 279 static int pcidio_detach(struct comedi_device *dev)
 280 {
 281         printk("comedi%d: cb_pcidio: remove\n", dev->minor);
 282         if (devpriv) {
 283                 if (devpriv->pci_dev) {
 284                         if (devpriv->dio_reg_base)
 285                                 comedi_pci_disable(devpriv->pci_dev);
 286                         pci_dev_put(devpriv->pci_dev);
 287                 }
 288         }
 289         if (dev->subdevices) {
 290                 int i;
 291                 for (i = 0; i < thisboard->n_8255; i++)
 292                         subdev_8255_cleanup(dev, dev->subdevices + i);
 293         }
 294         return 0;
 295 }
 296
 297 /*
 298  * A convenient macro that defines init_module() and cleanup_module(),
 299  * as necessary.
 300  */
 301 static int __devinit driver_cb_pcidio_pci_probe(struct pci_dev *dev,
 302                                                 const struct pci_device_id *ent)
 303 {
 304         return comedi_pci_auto_config(dev, driver_cb_pcidio.driver_name);
 305 }
 306
 307 static void __devexit driver_cb_pcidio_pci_remove(struct pci_dev *dev)
 308 {
 309         comedi_pci_auto_unconfig(dev);
 310 }
 311
 312 static struct pci_driver driver_cb_pcidio_pci_driver = {
 313         .id_table = pcidio_pci_table,
 314         .probe = &driver_cb_pcidio_pci_probe,
 315         .remove = __devexit_p(&driver_cb_pcidio_pci_remove)
 316 };
 317
 318 static int __init driver_cb_pcidio_init_module(void)
 319 {
 320         int retval;
 321
 322         retval = comedi_driver_register(&driver_cb_pcidio);
 323         if (retval < 0)
 324                 return retval;
 325
 326         driver_cb_pcidio_pci_driver.name = (char *)driver_cb_pcidio.driver_name;
 327         return pci_register_driver(&driver_cb_pcidio_pci_driver);
 328 }
 329
 330 static void __exit driver_cb_pcidio_cleanup_module(void)
 331 {
 332         pci_unregister_driver(&driver_cb_pcidio_pci_driver);
 333         comedi_driver_unregister(&driver_cb_pcidio);
 334 }
 335
 336 module_init(driver_cb_pcidio_init_module);
 337 module_exit(driver_cb_pcidio_cleanup_module);
 338
 339 MODULE_AUTHOR("Comedi http://www.comedi.org");
 340 MODULE_DESCRIPTION("Comedi low-level driver");
 341 MODULE_LICENSE("GPL");