2 * drivers/pci/pci-driver.c
7 #include <linux/module.h>
8 #include <linux/init.h>
9 #include <linux/device.h>
10 #include <linux/pci-dynids.h>
14 * Registration of PCI drivers and handling of hot-pluggable devices.
18 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
23 * pci_device_probe_dynamic()
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.
29 pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
32 struct list_head *pos;
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);
42 pci_dev->driver = drv;
48 spin_unlock(&drv->dynids.lock);
53 dynid_init(struct dynid *dynid)
55 memset(dynid, 0, sizeof(*dynid));
56 INIT_LIST_HEAD(&dynid->node);
62 * Adds a new dynamic pci device ID to this driver,
63 * and causes the driver to probe for all devices again.
66 store_new_id(struct device_driver *driver, const char *buf, size_t count)
69 struct bus_type * bus;
70 struct pci_driver *pdrv = to_pci_driver(driver);
71 __u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
72 subdevice=PCI_ANY_ID, class=0, class_mask=0;
73 unsigned long driver_data=0;
76 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
77 &vendor, &device, &subvendor, &subdevice,
78 &class, &class_mask, &driver_data);
82 dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
87 dynid->id.vendor = vendor;
88 dynid->id.device = device;
89 dynid->id.subvendor = subvendor;
90 dynid->id.subdevice = subdevice;
91 dynid->id.class = class;
92 dynid->id.class_mask = class_mask;
93 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
96 spin_lock(&pdrv->dynids.lock);
97 list_add_tail(&pdrv->dynids.list, &dynid->node);
98 spin_unlock(&pdrv->dynids.lock);
100 bus = get_bus(pdrv->driver.bus);
102 if (get_driver(&pdrv->driver)) {
103 down_write(&bus->subsys.rwsem);
104 driver_attach(&pdrv->driver);
105 up_write(&bus->subsys.rwsem);
106 put_driver(&pdrv->driver);
114 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
116 pci_init_dynids(struct pci_dynids *dynids)
118 memset(dynids, 0, sizeof(*dynids));
119 spin_lock_init(&dynids->lock);
120 INIT_LIST_HEAD(&dynids->list);
124 pci_free_dynids(struct pci_driver *drv)
126 struct list_head *pos, *n;
129 spin_lock(&drv->dynids.lock);
130 list_for_each_safe(pos, n, &drv->dynids.list) {
131 dynid = list_entry(pos, struct dynid, node);
132 list_del(&dynid->node);
135 spin_unlock(&drv->dynids.lock);
139 pci_create_newid_file(struct pci_driver *drv)
142 if (drv->probe != NULL)
143 error = sysfs_create_file(&drv->driver.kobj,
144 &driver_attr_new_id.attr);
149 pci_bus_match_dynids(const struct pci_dev *pci_dev, struct pci_driver *pci_drv)
151 struct list_head *pos;
154 spin_lock(&pci_drv->dynids.lock);
155 list_for_each(pos, &pci_drv->dynids.list) {
156 dynid = list_entry(pos, struct dynid, node);
157 if (pci_match_one_device(&dynid->id, pci_dev)) {
158 spin_unlock(&pci_drv->dynids.lock);
162 spin_unlock(&pci_drv->dynids.lock);
166 #else /* !CONFIG_HOTPLUG */
167 static inline int pci_device_probe_dynamic(struct pci_driver *drv, struct pci_dev *pci_dev)
171 static inline void dynid_init(struct dynid *dynid) {}
172 static inline void pci_init_dynids(struct pci_dynids *dynids) {}
173 static inline void pci_free_dynids(struct pci_driver *drv) {}
174 static inline int pci_create_newid_file(struct pci_driver *drv)
178 static inline int pci_bus_match_dynids(const struct pci_dev *pci_dev, struct pci_driver *pci_drv)
185 * pci_match_device - Tell if a PCI device structure has a matching
186 * PCI device id structure
187 * @ids: array of PCI device id structures to search in
188 * @dev: the PCI device structure to match against
190 * Used by a driver to check whether a PCI device present in the
191 * system is in its list of supported devices.Returns the matching
192 * pci_device_id structure or %NULL if there is no match.
194 const struct pci_device_id *
195 pci_match_device(const struct pci_device_id *ids, const struct pci_dev *dev)
197 while (ids->vendor || ids->subvendor || ids->class_mask) {
198 if (pci_match_one_device(ids, dev))
206 * pci_device_probe_static()
208 * returns 0 and sets pci_dev->driver when drv claims pci_dev, else error.
211 pci_device_probe_static(struct pci_driver *drv, struct pci_dev *pci_dev)
214 const struct pci_device_id *id;
218 id = pci_match_device(drv->id_table, pci_dev);
220 error = drv->probe(pci_dev, id);
222 pci_dev->driver = drv;
229 * __pci_device_probe()
231 * returns 0 on success, else error.
232 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
235 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
239 if (!pci_dev->driver && drv->probe) {
240 error = pci_device_probe_static(drv, pci_dev);
241 if (error == -ENODEV)
242 error = pci_device_probe_dynamic(drv, pci_dev);
247 static int pci_device_probe(struct device * dev)
250 struct pci_driver *drv;
251 struct pci_dev *pci_dev;
253 drv = to_pci_driver(dev->driver);
254 pci_dev = to_pci_dev(dev);
255 pci_dev_get(pci_dev);
256 error = __pci_device_probe(drv, pci_dev);
258 pci_dev_put(pci_dev);
263 static int pci_device_remove(struct device * dev)
265 struct pci_dev * pci_dev = to_pci_dev(dev);
266 struct pci_driver * drv = pci_dev->driver;
270 drv->remove(pci_dev);
271 pci_dev->driver = NULL;
275 * We would love to complain here if pci_dev->is_enabled is set, that
276 * the driver should have called pci_disable_device(), but the
277 * unfortunate fact is there are too many odd BIOS and bridge setups
278 * that don't like drivers doing that all of the time.
279 * Oh well, we can dream of sane hardware when we sleep, no matter how
280 * horrible the crap we have to deal with is when we are awake...
283 pci_dev_put(pci_dev);
287 static int pci_device_suspend(struct device * dev, u32 state)
289 struct pci_dev * pci_dev = to_pci_dev(dev);
290 struct pci_driver * drv = pci_dev->driver;
294 /* Translate PM_SUSPEND_xx states to PCI device states */
295 static u32 state_conversion[] = {
297 [PM_SUSPEND_STANDBY] = 1,
298 [PM_SUSPEND_MEM] = 3,
299 [PM_SUSPEND_DISK] = 3,
302 if (state >= sizeof(state_conversion) / sizeof(state_conversion[1]))
305 dev_state = state_conversion[state];
306 if (drv && drv->suspend)
307 i = drv->suspend(pci_dev, dev_state);
309 pci_save_state(pci_dev);
315 * Default resume method for devices that have no driver provided resume,
316 * or not even a driver at all.
318 static void pci_default_resume(struct pci_dev *pci_dev)
320 /* restore the PCI config space */
321 pci_restore_state(pci_dev);
322 /* if the device was enabled before suspend, reenable */
323 if (pci_dev->is_enabled)
324 pci_enable_device(pci_dev);
325 /* if the device was busmaster before the suspend, make it busmaster again */
326 if (pci_dev->is_busmaster)
327 pci_set_master(pci_dev);
330 static int pci_device_resume(struct device * dev)
332 struct pci_dev * pci_dev = to_pci_dev(dev);
333 struct pci_driver * drv = pci_dev->driver;
335 if (drv && drv->resume)
336 drv->resume(pci_dev);
338 pci_default_resume(pci_dev);
343 #define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
344 #define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
347 pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
349 struct device_driver *driver = kobj_to_pci_driver(kobj);
350 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
353 if (get_driver(driver)) {
355 ret = dattr->show(driver, buf);
362 pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
363 const char *buf, size_t count)
365 struct device_driver *driver = kobj_to_pci_driver(kobj);
366 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
369 if (get_driver(driver)) {
371 ret = dattr->store(driver, buf, count);
377 static struct sysfs_ops pci_driver_sysfs_ops = {
378 .show = pci_driver_attr_show,
379 .store = pci_driver_attr_store,
381 static struct kobj_type pci_driver_kobj_type = {
382 .sysfs_ops = &pci_driver_sysfs_ops,
386 pci_populate_driver_dir(struct pci_driver *drv)
388 return pci_create_newid_file(drv);
392 * pci_register_driver - register a new pci driver
393 * @drv: the driver structure to register
395 * Adds the driver structure to the list of registered drivers.
396 * Returns a negative value on error, otherwise 0.
397 * If no error occured, the driver remains registered even if
398 * no device was claimed during registration.
400 int pci_register_driver(struct pci_driver *drv)
404 /* initialize common driver fields */
405 drv->driver.name = drv->name;
406 drv->driver.bus = &pci_bus_type;
407 drv->driver.probe = pci_device_probe;
408 drv->driver.remove = pci_device_remove;
409 drv->driver.owner = drv->owner;
410 drv->driver.kobj.ktype = &pci_driver_kobj_type;
411 pci_init_dynids(&drv->dynids);
413 /* register with core */
414 error = driver_register(&drv->driver);
417 pci_populate_driver_dir(drv);
423 * pci_unregister_driver - unregister a pci driver
424 * @drv: the driver structure to unregister
426 * Deletes the driver structure from the list of registered PCI drivers,
427 * gives it a chance to clean up by calling its remove() function for
428 * each device it was responsible for, and marks those devices as
433 pci_unregister_driver(struct pci_driver *drv)
435 driver_unregister(&drv->driver);
436 pci_free_dynids(drv);
439 static struct pci_driver pci_compat_driver = {
444 * pci_dev_driver - get the pci_driver of a device
445 * @dev: the device to query
447 * Returns the appropriate pci_driver structure or %NULL if there is no
448 * registered driver for the device.
451 pci_dev_driver(const struct pci_dev *dev)
457 for(i=0; i<=PCI_ROM_RESOURCE; i++)
458 if (dev->resource[i].flags & IORESOURCE_BUSY)
459 return &pci_compat_driver;
465 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
466 * @ids: array of PCI device id structures to search in
467 * @dev: the PCI device structure to match against
469 * Used by a driver to check whether a PCI device present in the
470 * system is in its list of supported devices.Returns the matching
471 * pci_device_id structure or %NULL if there is no match.
473 static int pci_bus_match(struct device * dev, struct device_driver * drv)
475 const struct pci_dev * pci_dev = to_pci_dev(dev);
476 struct pci_driver * pci_drv = to_pci_driver(drv);
477 const struct pci_device_id * ids = pci_drv->id_table;
478 const struct pci_device_id *found_id;
483 found_id = pci_match_device(ids, pci_dev);
487 return pci_bus_match_dynids(pci_dev, pci_drv);
491 * pci_dev_get - increments the reference count of the pci device structure
492 * @dev: the device being referenced
494 * Each live reference to a device should be refcounted.
496 * Drivers for PCI devices should normally record such references in
497 * their probe() methods, when they bind to a device, and release
498 * them by calling pci_dev_put(), in their disconnect() methods.
500 * A pointer to the device with the incremented reference counter is returned.
502 struct pci_dev *pci_dev_get(struct pci_dev *dev)
505 get_device(&dev->dev);
510 * pci_dev_put - release a use of the pci device structure
511 * @dev: device that's been disconnected
513 * Must be called when a user of a device is finished with it. When the last
514 * user of the device calls this function, the memory of the device is freed.
516 void pci_dev_put(struct pci_dev *dev)
519 put_device(&dev->dev);
522 #ifndef CONFIG_HOTPLUG
523 int pci_hotplug (struct device *dev, char **envp, int num_envp,
524 char *buffer, int buffer_size)
530 struct bus_type pci_bus_type = {
532 .match = pci_bus_match,
533 .hotplug = pci_hotplug,
534 .suspend = pci_device_suspend,
535 .resume = pci_device_resume,
536 .dev_attrs = pci_dev_attrs,
539 static int __init pci_driver_init(void)
541 return bus_register(&pci_bus_type);
544 postcore_initcall(pci_driver_init);
546 EXPORT_SYMBOL(pci_match_device);
547 EXPORT_SYMBOL(pci_register_driver);
548 EXPORT_SYMBOL(pci_unregister_driver);
549 EXPORT_SYMBOL(pci_dev_driver);
550 EXPORT_SYMBOL(pci_bus_type);
551 EXPORT_SYMBOL(pci_dev_get);
552 EXPORT_SYMBOL(pci_dev_put);