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/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  */
  28 static int
  29 pci_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  */
  58 static inline ssize_t
  59 store_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
 108 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
 109 static inline void
 110 pci_init_dynids(struct pci_dynids *dynids)
 111 {
 112         spin_lock_init(&dynids->lock);
 113         INIT_LIST_HEAD(&dynids->list);
 114 }
 115
 116 static void
 117 pci_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
 131 static int
 132 pci_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
 141 static int
 142 pci_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 */
 160 static inline int pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
 161 {
 162         return -ENODEV;
 163 }
 164 static inline void pci_init_dynids(struct pci_dynids *dynids) {}
 165 static inline void pci_free_dynids(struct pci_driver *drv) {}
 166 static inline int pci_create_newid_file(struct pci_driver *drv)
 167 {
 168         return 0;
 169 }
 170 static 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  */
 186 const struct pci_device_id *
 187 pci_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  */
 202 static int
 203 pci_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  */
 226 static 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
 239 static 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
 255 static 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
 279 static 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  */
 297 static 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
 309 static 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
 321 static 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
 333 static ssize_t
 334 pci_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;
 339
 340         if (!get_driver(driver))
 341                 return -ENODEV;
 342
 343         ret = dattr->show ? dattr->show(driver, buf) : -EIO;
 344
 345         put_driver(driver);
 346         return ret;
 347 }
 348
 349 static ssize_t
 350 pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
 351                       const char *buf, size_t count)
 352 {
 353         struct device_driver *driver = kobj_to_pci_driver(kobj);
 354         struct driver_attribute *dattr = attr_to_driver_attribute(attr);
 355         ssize_t ret;
 356
 357         if (!get_driver(driver))
 358                 return -ENODEV;
 359
 360         ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
 361
 362         put_driver(driver);
 363         return ret;
 364 }
 365
 366 static struct sysfs_ops pci_driver_sysfs_ops = {
 367         .show = pci_driver_attr_show,
 368         .store = pci_driver_attr_store,
 369 };
 370 static struct kobj_type pci_driver_kobj_type = {
 371         .sysfs_ops = &pci_driver_sysfs_ops,
 372 };
 373
 374 static int
 375 pci_populate_driver_dir(struct pci_driver *drv)
 376 {
 377         return pci_create_newid_file(drv);
 378 }
 379
 380 /**
 381  * pci_register_driver - register a new pci driver
 382  * @drv: the driver structure to register
 383  *
 384  * Adds the driver structure to the list of registered drivers.
 385  * Returns a negative value on error, otherwise 0.
 386  * If no error occurred, the driver remains registered even if
 387  * no device was claimed during registration.
 388  */
 389 int pci_register_driver(struct pci_driver *drv)
 390 {
 391         int error;
 392
 393         /* initialize common driver fields */
 394         drv->driver.name = drv->name;
 395         drv->driver.bus = &pci_bus_type;
 396         drv->driver.probe = pci_device_probe;
 397         drv->driver.remove = pci_device_remove;
 398         /* FIXME, once all of the existing PCI drivers have been fixed to set
 399          * the pci shutdown function, this test can go away. */
 400         if (!drv->driver.shutdown)
 401                 drv->driver.shutdown = pci_device_shutdown;
 402         drv->driver.owner = drv->owner;
 403         drv->driver.kobj.ktype = &pci_driver_kobj_type;
 404         pci_init_dynids(&drv->dynids);
 405
 406         /* register with core */
 407         error = driver_register(&drv->driver);
 408
 409         if (!error)
 410                 pci_populate_driver_dir(drv);
 411
 412         return error;
 413 }
 414
 415 /**
 416  * pci_unregister_driver - unregister a pci driver
 417  * @drv: the driver structure to unregister
 418  *
 419  * Deletes the driver structure from the list of registered PCI drivers,
 420  * gives it a chance to clean up by calling its remove() function for
 421  * each device it was responsible for, and marks those devices as
 422  * driverless.
 423  */
 424
 425 void
 426 pci_unregister_driver(struct pci_driver *drv)
 427 {
 428         driver_unregister(&drv->driver);
 429         pci_free_dynids(drv);
 430 }
 431
 432 static struct pci_driver pci_compat_driver = {
 433         .name = "compat"
 434 };
 435
 436 /**
 437  * pci_dev_driver - get the pci_driver of a device
 438  * @dev: the device to query
 439  *
 440  * Returns the appropriate pci_driver structure or %NULL if there is no
 441  * registered driver for the device.
 442  */
 443 struct pci_driver *
 444 pci_dev_driver(const struct pci_dev *dev)
 445 {
 446         if (dev->driver)
 447                 return dev->driver;
 448         else {
 449                 int i;
 450                 for(i=0; i<=PCI_ROM_RESOURCE; i++)
 451                         if (dev->resource[i].flags & IORESOURCE_BUSY)
 452                                 return &pci_compat_driver;
 453         }
 454         return NULL;
 455 }
 456
 457 /**
 458  * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
 459  * @ids: array of PCI device id structures to search in
 460  * @dev: the PCI device structure to match against
 461  *
 462  * Used by a driver to check whether a PCI device present in the
 463  * system is in its list of supported devices.Returns the matching
 464  * pci_device_id structure or %NULL if there is no match.
 465  */
 466 static int pci_bus_match(struct device * dev, struct device_driver * drv)
 467 {
 468         const struct pci_dev * pci_dev = to_pci_dev(dev);
 469         struct pci_driver * pci_drv = to_pci_driver(drv);
 470         const struct pci_device_id * ids = pci_drv->id_table;
 471         const struct pci_device_id *found_id;
 472
 473         if (!ids)
 474                 return 0;
 475
 476         found_id = pci_match_device(ids, pci_dev);
 477         if (found_id)
 478                 return 1;
 479
 480         return pci_bus_match_dynids(pci_dev, pci_drv);
 481 }
 482
 483 /**
 484  * pci_dev_get - increments the reference count of the pci device structure
 485  * @dev: the device being referenced
 486  *
 487  * Each live reference to a device should be refcounted.
 488  *
 489  * Drivers for PCI devices should normally record such references in
 490  * their probe() methods, when they bind to a device, and release
 491  * them by calling pci_dev_put(), in their disconnect() methods.
 492  *
 493  * A pointer to the device with the incremented reference counter is returned.
 494  */
 495 struct pci_dev *pci_dev_get(struct pci_dev *dev)
 496 {
 497         if (dev)
 498                 get_device(&dev->dev);
 499         return dev;
 500 }
 501
 502 /**
 503  * pci_dev_put - release a use of the pci device structure
 504  * @dev: device that's been disconnected
 505  *
 506  * Must be called when a user of a device is finished with it.  When the last
 507  * user of the device calls this function, the memory of the device is freed.
 508  */
 509 void pci_dev_put(struct pci_dev *dev)
 510 {
 511         if (dev)
 512                 put_device(&dev->dev);
 513 }
 514
 515 #ifndef CONFIG_HOTPLUG
 516 int pci_hotplug (struct device *dev, char **envp, int num_envp,
 517                  char *buffer, int buffer_size)
 518 {
 519         return -ENODEV;
 520 }
 521 #endif
 522
 523 struct bus_type pci_bus_type = {
 524         .name           = "pci",
 525         .match          = pci_bus_match,
 526         .hotplug        = pci_hotplug,
 527         .suspend        = pci_device_suspend,
 528         .resume         = pci_device_resume,
 529         .dev_attrs      = pci_dev_attrs,
 530 };
 531
 532 static int __init pci_driver_init(void)
 533 {
 534         return bus_register(&pci_bus_type);
 535 }
 536
 537 postcore_initcall(pci_driver_init);
 538
 539 EXPORT_SYMBOL(pci_match_device);
 540 EXPORT_SYMBOL(pci_register_driver);
 541 EXPORT_SYMBOL(pci_unregister_driver);
 542 EXPORT_SYMBOL(pci_dev_driver);
 543 EXPORT_SYMBOL(pci_bus_type);
 544 EXPORT_SYMBOL(pci_dev_get);
 545 EXPORT_SYMBOL(pci_dev_put);