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