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