2 * drivers/pci/pci-driver.c
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>
17 * Registration of PCI drivers and handling of hot-pluggable devices.
21 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
25 struct list_head node;
26 struct pci_device_id id;
32 * store_new_id - add a new PCI device ID to this driver and re-probe devices
33 * @driver: target device driver
34 * @buf: buffer for scanning device ID data
37 * Adds a new dynamic pci device ID to this driver,
38 * and causes the driver to probe for all devices again.
41 store_new_id(struct device_driver *driver, const char *buf, size_t count)
43 struct pci_dynid *dynid;
44 struct pci_driver *pdrv = to_pci_driver(driver);
45 __u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
46 subdevice=PCI_ANY_ID, class=0, class_mask=0;
47 unsigned long driver_data=0;
50 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
51 &vendor, &device, &subvendor, &subdevice,
52 &class, &class_mask, &driver_data);
56 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
60 INIT_LIST_HEAD(&dynid->node);
61 dynid->id.vendor = vendor;
62 dynid->id.device = device;
63 dynid->id.subvendor = subvendor;
64 dynid->id.subdevice = subdevice;
65 dynid->id.class = class;
66 dynid->id.class_mask = class_mask;
67 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
70 spin_lock(&pdrv->dynids.lock);
71 list_add_tail(&pdrv->dynids.list, &dynid->node);
72 spin_unlock(&pdrv->dynids.lock);
74 if (get_driver(&pdrv->driver)) {
75 driver_attach(&pdrv->driver);
76 put_driver(&pdrv->driver);
81 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
84 pci_free_dynids(struct pci_driver *drv)
86 struct pci_dynid *dynid, *n;
88 spin_lock(&drv->dynids.lock);
89 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
90 list_del(&dynid->node);
93 spin_unlock(&drv->dynids.lock);
97 pci_create_newid_file(struct pci_driver *drv)
100 if (drv->probe != NULL)
101 error = sysfs_create_file(&drv->driver.kobj,
102 &driver_attr_new_id.attr);
106 #else /* !CONFIG_HOTPLUG */
107 static inline void pci_free_dynids(struct pci_driver *drv) {}
108 static inline int pci_create_newid_file(struct pci_driver *drv)
115 * pci_match_id - See if a pci device matches a given pci_id table
116 * @ids: array of PCI device id structures to search in
117 * @dev: the PCI device structure to match against.
119 * Used by a driver to check whether a PCI device present in the
120 * system is in its list of supported devices. Returns the matching
121 * pci_device_id structure or %NULL if there is no match.
123 * Depreciated, don't use this as it will not catch any dynamic ids
124 * that a driver might want to check for.
126 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
130 while (ids->vendor || ids->subvendor || ids->class_mask) {
131 if (pci_match_one_device(ids, dev))
140 * pci_match_device - Tell if a PCI device structure has a matching
141 * PCI device id structure
142 * @drv: the PCI driver to match against
143 * @dev: the PCI device structure to match against
145 * Used by a driver to check whether a PCI device present in the
146 * system is in its list of supported devices. Returns the matching
147 * pci_device_id structure or %NULL if there is no match.
149 const struct pci_device_id *pci_match_device(struct pci_driver *drv,
152 const struct pci_device_id *id;
153 struct pci_dynid *dynid;
155 id = pci_match_id(drv->id_table, dev);
159 /* static ids didn't match, lets look at the dynamic ones */
160 spin_lock(&drv->dynids.lock);
161 list_for_each_entry(dynid, &drv->dynids.list, node) {
162 if (pci_match_one_device(&dynid->id, dev)) {
163 spin_unlock(&drv->dynids.lock);
167 spin_unlock(&drv->dynids.lock);
171 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
172 const struct pci_device_id *id)
176 /* Execute driver initialization on node where the
177 device's bus is attached to. This way the driver likely
178 allocates its local memory on the right node without
179 any need to change it. */
180 struct mempolicy *oldpol;
181 cpumask_t oldmask = current->cpus_allowed;
182 int node = pcibus_to_node(dev->bus);
183 if (node >= 0 && node_online(node))
184 set_cpus_allowed(current, node_to_cpumask(node));
185 /* And set default memory allocation policy */
186 oldpol = current->mempolicy;
187 current->mempolicy = &default_policy;
188 mpol_get(current->mempolicy);
190 error = drv->probe(dev, id);
192 set_cpus_allowed(current, oldmask);
193 mpol_free(current->mempolicy);
194 current->mempolicy = oldpol;
200 * __pci_device_probe()
201 * @drv: driver to call to check if it wants the PCI device
202 * @pci_dev: PCI device being probed
204 * returns 0 on success, else error.
205 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
208 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
210 const struct pci_device_id *id;
213 if (!pci_dev->driver && drv->probe) {
216 id = pci_match_device(drv, pci_dev);
218 error = pci_call_probe(drv, pci_dev, id);
220 pci_dev->driver = drv;
227 static int pci_device_probe(struct device * dev)
230 struct pci_driver *drv;
231 struct pci_dev *pci_dev;
233 drv = to_pci_driver(dev->driver);
234 pci_dev = to_pci_dev(dev);
235 pci_dev_get(pci_dev);
236 error = __pci_device_probe(drv, pci_dev);
238 pci_dev_put(pci_dev);
243 static int pci_device_remove(struct device * dev)
245 struct pci_dev * pci_dev = to_pci_dev(dev);
246 struct pci_driver * drv = pci_dev->driver;
250 drv->remove(pci_dev);
251 pci_dev->driver = NULL;
255 * We would love to complain here if pci_dev->is_enabled is set, that
256 * the driver should have called pci_disable_device(), but the
257 * unfortunate fact is there are too many odd BIOS and bridge setups
258 * that don't like drivers doing that all of the time.
259 * Oh well, we can dream of sane hardware when we sleep, no matter how
260 * horrible the crap we have to deal with is when we are awake...
263 pci_dev_put(pci_dev);
267 static int pci_device_suspend(struct device * dev, pm_message_t state)
269 struct pci_dev * pci_dev = to_pci_dev(dev);
270 struct pci_driver * drv = pci_dev->driver;
273 if (drv && drv->suspend) {
274 i = drv->suspend(pci_dev, state);
275 suspend_report_result(drv->suspend, i);
277 pci_save_state(pci_dev);
282 static int pci_device_suspend_late(struct device * dev, pm_message_t state)
284 struct pci_dev * pci_dev = to_pci_dev(dev);
285 struct pci_driver * drv = pci_dev->driver;
288 if (drv && drv->suspend_late) {
289 i = drv->suspend_late(pci_dev, state);
290 suspend_report_result(drv->suspend_late, i);
296 * Default resume method for devices that have no driver provided resume,
297 * or not even a driver at all.
299 static int pci_default_resume(struct pci_dev *pci_dev)
303 /* restore the PCI config space */
304 pci_restore_state(pci_dev);
305 /* if the device was enabled before suspend, reenable */
306 if (pci_dev->is_enabled)
307 retval = pci_enable_device(pci_dev);
308 /* if the device was busmaster before the suspend, make it busmaster again */
309 if (pci_dev->is_busmaster)
310 pci_set_master(pci_dev);
315 static int pci_device_resume(struct device * dev)
318 struct pci_dev * pci_dev = to_pci_dev(dev);
319 struct pci_driver * drv = pci_dev->driver;
321 if (drv && drv->resume)
322 error = drv->resume(pci_dev);
324 error = pci_default_resume(pci_dev);
328 static int pci_device_resume_early(struct device * dev)
331 struct pci_dev * pci_dev = to_pci_dev(dev);
332 struct pci_driver * drv = pci_dev->driver;
334 if (drv && drv->resume_early)
335 error = drv->resume_early(pci_dev);
339 static void pci_device_shutdown(struct device *dev)
341 struct pci_dev *pci_dev = to_pci_dev(dev);
342 struct pci_driver *drv = pci_dev->driver;
344 if (drv && drv->shutdown)
345 drv->shutdown(pci_dev);
348 #define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
349 #define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
352 pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
354 struct device_driver *driver = kobj_to_pci_driver(kobj);
355 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
358 if (!get_driver(driver))
361 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
368 pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
369 const char *buf, size_t count)
371 struct device_driver *driver = kobj_to_pci_driver(kobj);
372 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
375 if (!get_driver(driver))
378 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
384 static struct sysfs_ops pci_driver_sysfs_ops = {
385 .show = pci_driver_attr_show,
386 .store = pci_driver_attr_store,
388 static struct kobj_type pci_driver_kobj_type = {
389 .sysfs_ops = &pci_driver_sysfs_ops,
393 * __pci_register_driver - register a new pci driver
394 * @drv: the driver structure to register
395 * @owner: owner module of drv
397 * Adds the driver structure to the list of registered drivers.
398 * Returns a negative value on error, otherwise 0.
399 * If no error occurred, the driver remains registered even if
400 * no device was claimed during registration.
402 int __pci_register_driver(struct pci_driver *drv, struct module *owner)
406 /* initialize common driver fields */
407 drv->driver.name = drv->name;
408 drv->driver.bus = &pci_bus_type;
409 drv->driver.owner = owner;
410 drv->driver.kobj.ktype = &pci_driver_kobj_type;
412 spin_lock_init(&drv->dynids.lock);
413 INIT_LIST_HEAD(&drv->dynids.list);
415 /* register with core */
416 error = driver_register(&drv->driver);
419 error = pci_create_newid_file(drv);
425 * pci_unregister_driver - unregister a pci driver
426 * @drv: the driver structure to unregister
428 * Deletes the driver structure from the list of registered PCI drivers,
429 * gives it a chance to clean up by calling its remove() function for
430 * each device it was responsible for, and marks those devices as
435 pci_unregister_driver(struct pci_driver *drv)
437 driver_unregister(&drv->driver);
438 pci_free_dynids(drv);
441 static struct pci_driver pci_compat_driver = {
446 * pci_dev_driver - get the pci_driver of a device
447 * @dev: the device to query
449 * Returns the appropriate pci_driver structure or %NULL if there is no
450 * registered driver for the device.
453 pci_dev_driver(const struct pci_dev *dev)
459 for(i=0; i<=PCI_ROM_RESOURCE; i++)
460 if (dev->resource[i].flags & IORESOURCE_BUSY)
461 return &pci_compat_driver;
467 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
468 * @dev: the PCI device structure to match against
469 * @drv: the device driver to search for matching PCI device id structures
471 * Used by a driver to check whether a PCI device present in the
472 * system is in its list of supported devices. Returns the matching
473 * pci_device_id structure or %NULL if there is no match.
475 static int pci_bus_match(struct device *dev, struct device_driver *drv)
477 struct pci_dev *pci_dev = to_pci_dev(dev);
478 struct pci_driver *pci_drv = to_pci_driver(drv);
479 const struct pci_device_id *found_id;
481 found_id = pci_match_device(pci_drv, pci_dev);
489 * pci_dev_get - increments the reference count of the pci device structure
490 * @dev: the device being referenced
492 * Each live reference to a device should be refcounted.
494 * Drivers for PCI devices should normally record such references in
495 * their probe() methods, when they bind to a device, and release
496 * them by calling pci_dev_put(), in their disconnect() methods.
498 * A pointer to the device with the incremented reference counter is returned.
500 struct pci_dev *pci_dev_get(struct pci_dev *dev)
503 get_device(&dev->dev);
508 * pci_dev_put - release a use of the pci device structure
509 * @dev: device that's been disconnected
511 * Must be called when a user of a device is finished with it. When the last
512 * user of the device calls this function, the memory of the device is freed.
514 void pci_dev_put(struct pci_dev *dev)
517 put_device(&dev->dev);
520 #ifndef CONFIG_HOTPLUG
521 int pci_uevent(struct device *dev, char **envp, int num_envp,
522 char *buffer, int buffer_size)
528 struct bus_type pci_bus_type = {
530 .match = pci_bus_match,
531 .uevent = pci_uevent,
532 .probe = pci_device_probe,
533 .remove = pci_device_remove,
534 .suspend = pci_device_suspend,
535 .suspend_late = pci_device_suspend_late,
536 .resume_early = pci_device_resume_early,
537 .resume = pci_device_resume,
538 .shutdown = pci_device_shutdown,
539 .dev_attrs = pci_dev_attrs,
542 static int __init pci_driver_init(void)
544 return bus_register(&pci_bus_type);
547 postcore_initcall(pci_driver_init);
549 EXPORT_SYMBOL(pci_match_id);
550 EXPORT_SYMBOL(pci_match_device);
551 EXPORT_SYMBOL(__pci_register_driver);
552 EXPORT_SYMBOL(pci_unregister_driver);
553 EXPORT_SYMBOL(pci_dev_driver);
554 EXPORT_SYMBOL(pci_bus_type);
555 EXPORT_SYMBOL(pci_dev_get);
556 EXPORT_SYMBOL(pci_dev_put);