drivers/pci/pci-driver.c

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