pci-driver.c revision d42c69972b853fd33a26c8c7405624be41a22136
1/* 2 * drivers/pci/pci-driver.c 3 * 4 */ 5 6#include <linux/pci.h> 7#include <linux/module.h> 8#include <linux/init.h> 9#include <linux/device.h> 10#include <linux/mempolicy.h> 11#include "pci.h" 12 13/* 14 * Registration of PCI drivers and handling of hot-pluggable devices. 15 */ 16 17/* 18 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG 19 */ 20 21struct pci_dynid { 22 struct list_head node; 23 struct pci_device_id id; 24}; 25 26#ifdef CONFIG_HOTPLUG 27 28/** 29 * store_new_id 30 * 31 * Adds a new dynamic pci device ID to this driver, 32 * and causes the driver to probe for all devices again. 33 */ 34static inline ssize_t 35store_new_id(struct device_driver *driver, const char *buf, size_t count) 36{ 37 struct pci_dynid *dynid; 38 struct pci_driver *pdrv = to_pci_driver(driver); 39 __u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID, 40 subdevice=PCI_ANY_ID, class=0, class_mask=0; 41 unsigned long driver_data=0; 42 int fields=0; 43 44 fields = sscanf(buf, "%x %x %x %x %x %x %lux", 45 &vendor, &device, &subvendor, &subdevice, 46 &class, &class_mask, &driver_data); 47 if (fields < 0) 48 return -EINVAL; 49 50 dynid = kmalloc(sizeof(*dynid), GFP_KERNEL); 51 if (!dynid) 52 return -ENOMEM; 53 54 memset(dynid, 0, sizeof(*dynid)); 55 INIT_LIST_HEAD(&dynid->node); 56 dynid->id.vendor = vendor; 57 dynid->id.device = device; 58 dynid->id.subvendor = subvendor; 59 dynid->id.subdevice = subdevice; 60 dynid->id.class = class; 61 dynid->id.class_mask = class_mask; 62 dynid->id.driver_data = pdrv->dynids.use_driver_data ? 63 driver_data : 0UL; 64 65 spin_lock(&pdrv->dynids.lock); 66 list_add_tail(&pdrv->dynids.list, &dynid->node); 67 spin_unlock(&pdrv->dynids.lock); 68 69 if (get_driver(&pdrv->driver)) { 70 driver_attach(&pdrv->driver); 71 put_driver(&pdrv->driver); 72 } 73 74 return count; 75} 76static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id); 77 78static void 79pci_free_dynids(struct pci_driver *drv) 80{ 81 struct pci_dynid *dynid, *n; 82 83 spin_lock(&drv->dynids.lock); 84 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) { 85 list_del(&dynid->node); 86 kfree(dynid); 87 } 88 spin_unlock(&drv->dynids.lock); 89} 90 91static int 92pci_create_newid_file(struct pci_driver *drv) 93{ 94 int error = 0; 95 if (drv->probe != NULL) 96 error = sysfs_create_file(&drv->driver.kobj, 97 &driver_attr_new_id.attr); 98 return error; 99} 100 101#else /* !CONFIG_HOTPLUG */ 102static inline void pci_free_dynids(struct pci_driver *drv) {} 103static inline int pci_create_newid_file(struct pci_driver *drv) 104{ 105 return 0; 106} 107#endif 108 109/** 110 * pci_match_id - See if a pci device matches a given pci_id table 111 * @ids: array of PCI device id structures to search in 112 * @dev: the PCI device structure to match against. 113 * 114 * Used by a driver to check whether a PCI device present in the 115 * system is in its list of supported devices. Returns the matching 116 * pci_device_id structure or %NULL if there is no match. 117 * 118 * Depreciated, don't use this as it will not catch any dynamic ids 119 * that a driver might want to check for. 120 */ 121const struct pci_device_id *pci_match_id(const struct pci_device_id *ids, 122 struct pci_dev *dev) 123{ 124 if (ids) { 125 while (ids->vendor || ids->subvendor || ids->class_mask) { 126 if (pci_match_one_device(ids, dev)) 127 return ids; 128 ids++; 129 } 130 } 131 return NULL; 132} 133 134/** 135 * pci_match_device - Tell if a PCI device structure has a matching 136 * PCI device id structure 137 * @ids: array of PCI device id structures to search in 138 * @dev: the PCI device structure to match against 139 * @drv: the PCI driver to match against 140 * 141 * Used by a driver to check whether a PCI device present in the 142 * system is in its list of supported devices. Returns the matching 143 * pci_device_id structure or %NULL if there is no match. 144 */ 145const struct pci_device_id *pci_match_device(struct pci_driver *drv, 146 struct pci_dev *dev) 147{ 148 const struct pci_device_id *id; 149 struct pci_dynid *dynid; 150 151 id = pci_match_id(drv->id_table, dev); 152 if (id) 153 return id; 154 155 /* static ids didn't match, lets look at the dynamic ones */ 156 spin_lock(&drv->dynids.lock); 157 list_for_each_entry(dynid, &drv->dynids.list, node) { 158 if (pci_match_one_device(&dynid->id, dev)) { 159 spin_unlock(&drv->dynids.lock); 160 return &dynid->id; 161 } 162 } 163 spin_unlock(&drv->dynids.lock); 164 return NULL; 165} 166 167static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev, 168 const struct pci_device_id *id) 169{ 170 int error; 171#ifdef CONFIG_NUMA 172 /* Execute driver initialization on node where the 173 device's bus is attached to. This way the driver likely 174 allocates its local memory on the right node without 175 any need to change it. */ 176 struct mempolicy *oldpol; 177 cpumask_t oldmask = current->cpus_allowed; 178 int node = pcibus_to_node(dev->bus); 179 if (node >= 0 && node_online(node)) 180 set_cpus_allowed(current, node_to_cpumask(node)); 181 /* And set default memory allocation policy */ 182 oldpol = current->mempolicy; 183 current->mempolicy = &default_policy; 184 mpol_get(current->mempolicy); 185#endif 186 error = drv->probe(dev, id); 187#ifdef CONFIG_NUMA 188 set_cpus_allowed(current, oldmask); 189 mpol_free(current->mempolicy); 190 current->mempolicy = oldpol; 191#endif 192 return error; 193} 194 195/** 196 * __pci_device_probe() 197 * 198 * returns 0 on success, else error. 199 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev. 200 */ 201static int 202__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev) 203{ 204 const struct pci_device_id *id; 205 int error = 0; 206 207 if (!pci_dev->driver && drv->probe) { 208 error = -ENODEV; 209 210 id = pci_match_device(drv, pci_dev); 211 if (id) 212 error = pci_call_probe(drv, pci_dev, id); 213 if (error >= 0) { 214 pci_dev->driver = drv; 215 error = 0; 216 } 217 } 218 return error; 219} 220 221static int pci_device_probe(struct device * dev) 222{ 223 int error = 0; 224 struct pci_driver *drv; 225 struct pci_dev *pci_dev; 226 227 drv = to_pci_driver(dev->driver); 228 pci_dev = to_pci_dev(dev); 229 pci_dev_get(pci_dev); 230 error = __pci_device_probe(drv, pci_dev); 231 if (error) 232 pci_dev_put(pci_dev); 233 234 return error; 235} 236 237static int pci_device_remove(struct device * dev) 238{ 239 struct pci_dev * pci_dev = to_pci_dev(dev); 240 struct pci_driver * drv = pci_dev->driver; 241 242 if (drv) { 243 if (drv->remove) 244 drv->remove(pci_dev); 245 pci_dev->driver = NULL; 246 } 247 248 /* 249 * We would love to complain here if pci_dev->is_enabled is set, that 250 * the driver should have called pci_disable_device(), but the 251 * unfortunate fact is there are too many odd BIOS and bridge setups 252 * that don't like drivers doing that all of the time. 253 * Oh well, we can dream of sane hardware when we sleep, no matter how 254 * horrible the crap we have to deal with is when we are awake... 255 */ 256 257 pci_dev_put(pci_dev); 258 return 0; 259} 260 261static int pci_device_suspend(struct device * dev, pm_message_t state) 262{ 263 struct pci_dev * pci_dev = to_pci_dev(dev); 264 struct pci_driver * drv = pci_dev->driver; 265 int i = 0; 266 267 if (drv && drv->suspend) 268 i = drv->suspend(pci_dev, state); 269 else 270 pci_save_state(pci_dev); 271 return i; 272} 273 274 275/* 276 * Default resume method for devices that have no driver provided resume, 277 * or not even a driver at all. 278 */ 279static void pci_default_resume(struct pci_dev *pci_dev) 280{ 281 /* restore the PCI config space */ 282 pci_restore_state(pci_dev); 283 /* if the device was enabled before suspend, reenable */ 284 if (pci_dev->is_enabled) 285 pci_enable_device(pci_dev); 286 /* if the device was busmaster before the suspend, make it busmaster again */ 287 if (pci_dev->is_busmaster) 288 pci_set_master(pci_dev); 289} 290 291static int pci_device_resume(struct device * dev) 292{ 293 struct pci_dev * pci_dev = to_pci_dev(dev); 294 struct pci_driver * drv = pci_dev->driver; 295 296 if (drv && drv->resume) 297 drv->resume(pci_dev); 298 else 299 pci_default_resume(pci_dev); 300 return 0; 301} 302 303static void pci_device_shutdown(struct device *dev) 304{ 305 struct pci_dev *pci_dev = to_pci_dev(dev); 306 struct pci_driver *drv = pci_dev->driver; 307 308 if (drv && drv->shutdown) 309 drv->shutdown(pci_dev); 310} 311 312#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj) 313#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr) 314 315static ssize_t 316pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf) 317{ 318 struct device_driver *driver = kobj_to_pci_driver(kobj); 319 struct driver_attribute *dattr = attr_to_driver_attribute(attr); 320 ssize_t ret; 321 322 if (!get_driver(driver)) 323 return -ENODEV; 324 325 ret = dattr->show ? dattr->show(driver, buf) : -EIO; 326 327 put_driver(driver); 328 return ret; 329} 330 331static ssize_t 332pci_driver_attr_store(struct kobject * kobj, struct attribute *attr, 333 const char *buf, size_t count) 334{ 335 struct device_driver *driver = kobj_to_pci_driver(kobj); 336 struct driver_attribute *dattr = attr_to_driver_attribute(attr); 337 ssize_t ret; 338 339 if (!get_driver(driver)) 340 return -ENODEV; 341 342 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO; 343 344 put_driver(driver); 345 return ret; 346} 347 348static struct sysfs_ops pci_driver_sysfs_ops = { 349 .show = pci_driver_attr_show, 350 .store = pci_driver_attr_store, 351}; 352static struct kobj_type pci_driver_kobj_type = { 353 .sysfs_ops = &pci_driver_sysfs_ops, 354}; 355 356/** 357 * pci_register_driver - register a new pci driver 358 * @drv: the driver structure to register 359 * 360 * Adds the driver structure to the list of registered drivers. 361 * Returns a negative value on error, otherwise 0. 362 * If no error occurred, the driver remains registered even if 363 * no device was claimed during registration. 364 */ 365int pci_register_driver(struct pci_driver *drv) 366{ 367 int error; 368 369 /* initialize common driver fields */ 370 drv->driver.name = drv->name; 371 drv->driver.bus = &pci_bus_type; 372 drv->driver.probe = pci_device_probe; 373 drv->driver.remove = pci_device_remove; 374 /* FIXME, once all of the existing PCI drivers have been fixed to set 375 * the pci shutdown function, this test can go away. */ 376 if (!drv->driver.shutdown) 377 drv->driver.shutdown = pci_device_shutdown; 378 drv->driver.owner = drv->owner; 379 drv->driver.kobj.ktype = &pci_driver_kobj_type; 380 381 spin_lock_init(&drv->dynids.lock); 382 INIT_LIST_HEAD(&drv->dynids.list); 383 384 /* register with core */ 385 error = driver_register(&drv->driver); 386 387 if (!error) 388 error = pci_create_newid_file(drv); 389 390 return error; 391} 392 393/** 394 * pci_unregister_driver - unregister a pci driver 395 * @drv: the driver structure to unregister 396 * 397 * Deletes the driver structure from the list of registered PCI drivers, 398 * gives it a chance to clean up by calling its remove() function for 399 * each device it was responsible for, and marks those devices as 400 * driverless. 401 */ 402 403void 404pci_unregister_driver(struct pci_driver *drv) 405{ 406 driver_unregister(&drv->driver); 407 pci_free_dynids(drv); 408} 409 410static struct pci_driver pci_compat_driver = { 411 .name = "compat" 412}; 413 414/** 415 * pci_dev_driver - get the pci_driver of a device 416 * @dev: the device to query 417 * 418 * Returns the appropriate pci_driver structure or %NULL if there is no 419 * registered driver for the device. 420 */ 421struct pci_driver * 422pci_dev_driver(const struct pci_dev *dev) 423{ 424 if (dev->driver) 425 return dev->driver; 426 else { 427 int i; 428 for(i=0; i<=PCI_ROM_RESOURCE; i++) 429 if (dev->resource[i].flags & IORESOURCE_BUSY) 430 return &pci_compat_driver; 431 } 432 return NULL; 433} 434 435/** 436 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure 437 * @ids: array of PCI device id structures to search in 438 * @dev: the PCI device structure to match against 439 * 440 * Used by a driver to check whether a PCI device present in the 441 * system is in its list of supported devices.Returns the matching 442 * pci_device_id structure or %NULL if there is no match. 443 */ 444static int pci_bus_match(struct device *dev, struct device_driver *drv) 445{ 446 struct pci_dev *pci_dev = to_pci_dev(dev); 447 struct pci_driver *pci_drv = to_pci_driver(drv); 448 const struct pci_device_id *found_id; 449 450 found_id = pci_match_device(pci_drv, pci_dev); 451 if (found_id) 452 return 1; 453 454 return 0; 455} 456 457/** 458 * pci_dev_get - increments the reference count of the pci device structure 459 * @dev: the device being referenced 460 * 461 * Each live reference to a device should be refcounted. 462 * 463 * Drivers for PCI devices should normally record such references in 464 * their probe() methods, when they bind to a device, and release 465 * them by calling pci_dev_put(), in their disconnect() methods. 466 * 467 * A pointer to the device with the incremented reference counter is returned. 468 */ 469struct pci_dev *pci_dev_get(struct pci_dev *dev) 470{ 471 if (dev) 472 get_device(&dev->dev); 473 return dev; 474} 475 476/** 477 * pci_dev_put - release a use of the pci device structure 478 * @dev: device that's been disconnected 479 * 480 * Must be called when a user of a device is finished with it. When the last 481 * user of the device calls this function, the memory of the device is freed. 482 */ 483void pci_dev_put(struct pci_dev *dev) 484{ 485 if (dev) 486 put_device(&dev->dev); 487} 488 489#ifndef CONFIG_HOTPLUG 490int pci_hotplug (struct device *dev, char **envp, int num_envp, 491 char *buffer, int buffer_size) 492{ 493 return -ENODEV; 494} 495#endif 496 497struct bus_type pci_bus_type = { 498 .name = "pci", 499 .match = pci_bus_match, 500 .hotplug = pci_hotplug, 501 .suspend = pci_device_suspend, 502 .resume = pci_device_resume, 503 .dev_attrs = pci_dev_attrs, 504}; 505 506static int __init pci_driver_init(void) 507{ 508 return bus_register(&pci_bus_type); 509} 510 511postcore_initcall(pci_driver_init); 512 513EXPORT_SYMBOL(pci_match_id); 514EXPORT_SYMBOL(pci_match_device); 515EXPORT_SYMBOL(pci_register_driver); 516EXPORT_SYMBOL(pci_unregister_driver); 517EXPORT_SYMBOL(pci_dev_driver); 518EXPORT_SYMBOL(pci_bus_type); 519EXPORT_SYMBOL(pci_dev_get); 520EXPORT_SYMBOL(pci_dev_put); 521