1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * comedi_pci.c 4 * Comedi PCI driver specific functions. 5 * 6 * COMEDI - Linux Control and Measurement Device Interface 7 * Copyright (C) 1997-2000 David A. Schleef <ds@schleef.org> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/interrupt.h> 12 13 #include "comedi_pci.h" 14 15 /** 16 * comedi_to_pci_dev() - Return PCI device attached to COMEDI device 17 * @dev: COMEDI device. 18 * 19 * Assuming @dev->hw_dev is non-%NULL, it is assumed to be pointing to a 20 * a &struct device embedded in a &struct pci_dev. 21 * 22 * Return: Attached PCI device if @dev->hw_dev is non-%NULL. 23 * Return %NULL if @dev->hw_dev is %NULL. 24 */ 25 struct pci_dev *comedi_to_pci_dev(struct comedi_device *dev) 26 { 27 return dev->hw_dev ? to_pci_dev(dev->hw_dev) : NULL; 28 } 29 EXPORT_SYMBOL_GPL(comedi_to_pci_dev); 30 31 /** 32 * comedi_pci_enable() - Enable the PCI device and request the regions 33 * @dev: COMEDI device. 34 * 35 * Assuming @dev->hw_dev is non-%NULL, it is assumed to be pointing to a 36 * a &struct device embedded in a &struct pci_dev. Enable the PCI device 37 * and request its regions. Set @dev->ioenabled to %true if successful, 38 * otherwise undo what was done. 39 * 40 * Calls to comedi_pci_enable() and comedi_pci_disable() cannot be nested. 41 * 42 * Return: 43 * 0 on success, 44 * -%ENODEV if @dev->hw_dev is %NULL, 45 * -%EBUSY if regions busy, 46 * or some negative error number if failed to enable PCI device. 47 * 48 */ 49 int comedi_pci_enable(struct comedi_device *dev) 50 { 51 struct pci_dev *pcidev = comedi_to_pci_dev(dev); 52 int rc; 53 54 if (!pcidev) 55 return -ENODEV; 56 57 rc = pci_enable_device(pcidev); 58 if (rc < 0) 59 return rc; 60 61 rc = pci_request_regions(pcidev, dev->board_name); 62 if (rc < 0) 63 pci_disable_device(pcidev); 64 else 65 dev->ioenabled = true; 66 67 return rc; 68 } 69 EXPORT_SYMBOL_GPL(comedi_pci_enable); 70 71 /** 72 * comedi_pci_disable() - Release the regions and disable the PCI device 73 * @dev: COMEDI device. 74 * 75 * Assuming @dev->hw_dev is non-%NULL, it is assumed to be pointing to a 76 * a &struct device embedded in a &struct pci_dev. If the earlier call 77 * to comedi_pci_enable() was successful, release the PCI device's regions 78 * and disable it. Reset @dev->ioenabled back to %false. 79 */ 80 void comedi_pci_disable(struct comedi_device *dev) 81 { 82 struct pci_dev *pcidev = comedi_to_pci_dev(dev); 83 84 if (pcidev && dev->ioenabled) { 85 pci_release_regions(pcidev); 86 pci_disable_device(pcidev); 87 } 88 dev->ioenabled = false; 89 } 90 EXPORT_SYMBOL_GPL(comedi_pci_disable); 91 92 /** 93 * comedi_pci_detach() - A generic "detach" handler for PCI COMEDI drivers 94 * @dev: COMEDI device. 95 * 96 * COMEDI drivers for PCI devices that need no special clean-up of private data 97 * and have no ioremapped regions other than that pointed to by @dev->mmio may 98 * use this function as its "detach" handler called by the COMEDI core when a 99 * COMEDI device is being detached from the low-level driver. It may be also 100 * called from a more specific "detach" handler that does additional clean-up. 101 * 102 * Free the IRQ if @dev->irq is non-zero, iounmap @dev->mmio if it is 103 * non-%NULL, and call comedi_pci_disable() to release the PCI device's regions 104 * and disable it. 105 */ 106 void comedi_pci_detach(struct comedi_device *dev) 107 { 108 struct pci_dev *pcidev = comedi_to_pci_dev(dev); 109 110 if (!pcidev || !dev->ioenabled) 111 return; 112 113 if (dev->irq) { 114 free_irq(dev->irq, dev); 115 dev->irq = 0; 116 } 117 if (dev->mmio) { 118 iounmap(dev->mmio); 119 dev->mmio = NULL; 120 } 121 comedi_pci_disable(dev); 122 } 123 EXPORT_SYMBOL_GPL(comedi_pci_detach); 124 125 /** 126 * comedi_pci_auto_config() - Configure/probe a PCI COMEDI device 127 * @pcidev: PCI device. 128 * @driver: Registered COMEDI driver. 129 * @context: Driver specific data, passed to comedi_auto_config(). 130 * 131 * Typically called from the pci_driver (*probe) function. Auto-configure 132 * a COMEDI device, using the &struct device embedded in *@pcidev as the 133 * hardware device. The @context value gets passed through to @driver's 134 * "auto_attach" handler. The "auto_attach" handler may call 135 * comedi_to_pci_dev() on the passed in COMEDI device to recover @pcidev. 136 * 137 * Return: The result of calling comedi_auto_config() (0 on success, or 138 * a negative error number on failure). 139 */ 140 int comedi_pci_auto_config(struct pci_dev *pcidev, 141 struct comedi_driver *driver, 142 unsigned long context) 143 { 144 return comedi_auto_config(&pcidev->dev, driver, context); 145 } 146 EXPORT_SYMBOL_GPL(comedi_pci_auto_config); 147 148 /** 149 * comedi_pci_auto_unconfig() - Unconfigure/remove a PCI COMEDI device 150 * @pcidev: PCI device. 151 * 152 * Typically called from the pci_driver (*remove) function. Auto-unconfigure 153 * a COMEDI device attached to this PCI device, using a pointer to the 154 * &struct device embedded in *@pcidev as the hardware device. The COMEDI 155 * driver's "detach" handler will be called during unconfiguration of the 156 * COMEDI device. 157 * 158 * Note that the COMEDI device may have already been unconfigured using the 159 * %COMEDI_DEVCONFIG ioctl, in which case this attempt to unconfigure it 160 * again should be ignored. 161 */ 162 void comedi_pci_auto_unconfig(struct pci_dev *pcidev) 163 { 164 comedi_auto_unconfig(&pcidev->dev); 165 } 166 EXPORT_SYMBOL_GPL(comedi_pci_auto_unconfig); 167 168 /** 169 * comedi_pci_driver_register() - Register a PCI COMEDI driver 170 * @comedi_driver: COMEDI driver to be registered. 171 * @pci_driver: PCI driver to be registered. 172 * 173 * This function is called from the module_init() of PCI COMEDI driver modules 174 * to register the COMEDI driver and the PCI driver. Do not call it directly, 175 * use the module_comedi_pci_driver() helper macro instead. 176 * 177 * Return: 0 on success, or a negative error number on failure. 178 */ 179 int comedi_pci_driver_register(struct comedi_driver *comedi_driver, 180 struct pci_driver *pci_driver) 181 { 182 int ret; 183 184 ret = comedi_driver_register(comedi_driver); 185 if (ret < 0) 186 return ret; 187 188 ret = pci_register_driver(pci_driver); 189 if (ret < 0) { 190 comedi_driver_unregister(comedi_driver); 191 return ret; 192 } 193 194 return 0; 195 } 196 EXPORT_SYMBOL_GPL(comedi_pci_driver_register); 197 198 /** 199 * comedi_pci_driver_unregister() - Unregister a PCI COMEDI driver 200 * @comedi_driver: COMEDI driver to be unregistered. 201 * @pci_driver: PCI driver to be unregistered. 202 * 203 * This function is called from the module_exit() of PCI COMEDI driver modules 204 * to unregister the PCI driver and the COMEDI driver. Do not call it 205 * directly, use the module_comedi_pci_driver() helper macro instead. 206 */ 207 void comedi_pci_driver_unregister(struct comedi_driver *comedi_driver, 208 struct pci_driver *pci_driver) 209 { 210 pci_unregister_driver(pci_driver); 211 comedi_driver_unregister(comedi_driver); 212 } 213 EXPORT_SYMBOL_GPL(comedi_pci_driver_unregister); 214 215 static int __init comedi_pci_init(void) 216 { 217 return 0; 218 } 219 module_init(comedi_pci_init); 220 221 static void __exit comedi_pci_exit(void) 222 { 223 } 224 module_exit(comedi_pci_exit); 225 226 MODULE_AUTHOR("https://www.comedi.org"); 227 MODULE_DESCRIPTION("Comedi PCI interface module"); 228 MODULE_LICENSE("GPL"); 229