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>
14 * Registration of PCI drivers and handling of hot-pluggable devices.
18 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
22 struct list_head node;
23 struct pci_device_id id;
31 * Adds a new dynamic pci device ID to this driver,
32 * and causes the driver to probe for all devices again.
35 store_new_id(struct device_driver *driver, const char *buf, size_t count)
37 struct pci_dynid *dynid;
38 struct pci_driver *pdrv = to_pci_driver(driver);
39 __u32 vendor=PCI_ANY_ID, device=PCI_ANY_ID, subvendor=PCI_ANY_ID,
40 subdevice=PCI_ANY_ID, class=0, class_mask=0;
41 unsigned long driver_data=0;
44 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
45 &vendor, &device, &subvendor, &subdevice,
46 &class, &class_mask, &driver_data);
50 dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
54 memset(dynid, 0, sizeof(*dynid));
55 INIT_LIST_HEAD(&dynid->node);
56 dynid->id.vendor = vendor;
57 dynid->id.device = device;
58 dynid->id.subvendor = subvendor;
59 dynid->id.subdevice = subdevice;
60 dynid->id.class = class;
61 dynid->id.class_mask = class_mask;
62 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
65 spin_lock(&pdrv->dynids.lock);
66 list_add_tail(&pdrv->dynids.list, &dynid->node);
67 spin_unlock(&pdrv->dynids.lock);
69 if (get_driver(&pdrv->driver)) {
70 driver_attach(&pdrv->driver);
71 put_driver(&pdrv->driver);
76 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
79 pci_free_dynids(struct pci_driver *drv)
81 struct pci_dynid *dynid, *n;
83 spin_lock(&drv->dynids.lock);
84 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
85 list_del(&dynid->node);
88 spin_unlock(&drv->dynids.lock);
92 pci_create_newid_file(struct pci_driver *drv)
95 if (drv->probe != NULL)
96 error = sysfs_create_file(&drv->driver.kobj,
97 &driver_attr_new_id.attr);
101 #else /* !CONFIG_HOTPLUG */
102 static inline void pci_free_dynids(struct pci_driver *drv) {}
103 static inline int pci_create_newid_file(struct pci_driver *drv)
110 * pci_match_id - See if a pci device matches a given pci_id table
111 * @ids: array of PCI device id structures to search in
112 * @dev: the PCI device structure to match against.
114 * Used by a driver to check whether a PCI device present in the
115 * system is in its list of supported devices. Returns the matching
116 * pci_device_id structure or %NULL if there is no match.
118 * Depreciated, don't use this as it will not catch any dynamic ids
119 * that a driver might want to check for.
121 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
125 while (ids->vendor || ids->subvendor || ids->class_mask) {
126 if (pci_match_one_device(ids, dev))
135 * pci_match_device - Tell if a PCI device structure has a matching
136 * PCI device id structure
137 * @ids: array of PCI device id structures to search in
138 * @dev: the PCI device structure to match against
139 * @drv: the PCI driver to match against
141 * Used by a driver to check whether a PCI device present in the
142 * system is in its list of supported devices. Returns the matching
143 * pci_device_id structure or %NULL if there is no match.
145 const struct pci_device_id *pci_match_device(struct pci_driver *drv,
148 const struct pci_device_id *id;
149 struct pci_dynid *dynid;
151 id = pci_match_id(drv->id_table, dev);
155 /* static ids didn't match, lets look at the dynamic 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);
163 spin_unlock(&drv->dynids.lock);
167 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
168 const struct pci_device_id *id)
172 /* Execute driver initialization on node where the
173 device's bus is attached to. This way the driver likely
174 allocates its local memory on the right node without
175 any need to change it. */
176 struct mempolicy *oldpol;
177 cpumask_t oldmask = current->cpus_allowed;
178 int node = pcibus_to_node(dev->bus);
179 if (node >= 0 && node_online(node))
180 set_cpus_allowed(current, node_to_cpumask(node));
181 /* And set default memory allocation policy */
182 oldpol = current->mempolicy;
183 current->mempolicy = &default_policy;
184 mpol_get(current->mempolicy);
186 error = drv->probe(dev, id);
188 set_cpus_allowed(current, oldmask);
189 mpol_free(current->mempolicy);
190 current->mempolicy = oldpol;
196 * __pci_device_probe()
198 * returns 0 on success, else error.
199 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
202 __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
204 const struct pci_device_id *id;
207 if (!pci_dev->driver && drv->probe) {
210 id = pci_match_device(drv, pci_dev);
212 error = pci_call_probe(drv, pci_dev, id);
214 pci_dev->driver = drv;
221 static int pci_device_probe(struct device * dev)
224 struct pci_driver *drv;
225 struct pci_dev *pci_dev;
227 drv = to_pci_driver(dev->driver);
228 pci_dev = to_pci_dev(dev);
229 pci_dev_get(pci_dev);
230 error = __pci_device_probe(drv, pci_dev);
232 pci_dev_put(pci_dev);
237 static int pci_device_remove(struct device * dev)
239 struct pci_dev * pci_dev = to_pci_dev(dev);
240 struct pci_driver * drv = pci_dev->driver;
244 drv->remove(pci_dev);
245 pci_dev->driver = NULL;
249 * We would love to complain here if pci_dev->is_enabled is set, that
250 * the driver should have called pci_disable_device(), but the
251 * unfortunate fact is there are too many odd BIOS and bridge setups
252 * that don't like drivers doing that all of the time.
253 * Oh well, we can dream of sane hardware when we sleep, no matter how
254 * horrible the crap we have to deal with is when we are awake...
257 pci_dev_put(pci_dev);
261 static int pci_device_suspend(struct device * dev, pm_message_t state)
263 struct pci_dev * pci_dev = to_pci_dev(dev);
264 struct pci_driver * drv = pci_dev->driver;
267 if (drv && drv->suspend)
268 i = drv->suspend(pci_dev, state);
270 pci_save_state(pci_dev);
276 * Default resume method for devices that have no driver provided resume,
277 * or not even a driver at all.
279 static void pci_default_resume(struct pci_dev *pci_dev)
281 /* restore the PCI config space */
282 pci_restore_state(pci_dev);
283 /* if the device was enabled before suspend, reenable */
284 if (pci_dev->is_enabled)
285 pci_enable_device(pci_dev);
286 /* if the device was busmaster before the suspend, make it busmaster again */
287 if (pci_dev->is_busmaster)
288 pci_set_master(pci_dev);
291 static int pci_device_resume(struct device * dev)
293 struct pci_dev * pci_dev = to_pci_dev(dev);
294 struct pci_driver * drv = pci_dev->driver;
296 if (drv && drv->resume)
297 drv->resume(pci_dev);
299 pci_default_resume(pci_dev);
303 static void pci_device_shutdown(struct device *dev)
305 struct pci_dev *pci_dev = to_pci_dev(dev);
306 struct pci_driver *drv = pci_dev->driver;
308 if (drv && drv->shutdown)
309 drv->shutdown(pci_dev);
312 #define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
313 #define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
316 pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
318 struct device_driver *driver = kobj_to_pci_driver(kobj);
319 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
322 if (!get_driver(driver))
325 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
332 pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
333 const char *buf, size_t count)
335 struct device_driver *driver = kobj_to_pci_driver(kobj);
336 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
339 if (!get_driver(driver))
342 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
348 static struct sysfs_ops pci_driver_sysfs_ops = {
349 .show = pci_driver_attr_show,
350 .store = pci_driver_attr_store,
352 static struct kobj_type pci_driver_kobj_type = {
353 .sysfs_ops = &pci_driver_sysfs_ops,
357 * pci_register_driver - register a new pci driver
358 * @drv: the driver structure to register
360 * Adds the driver structure to the list of registered drivers.
361 * Returns a negative value on error, otherwise 0.
362 * If no error occurred, the driver remains registered even if
363 * no device was claimed during registration.
365 int pci_register_driver(struct pci_driver *drv)
369 /* initialize common driver fields */
370 drv->driver.name = drv->name;
371 drv->driver.bus = &pci_bus_type;
372 drv->driver.probe = pci_device_probe;
373 drv->driver.remove = pci_device_remove;
374 /* FIXME, once all of the existing PCI drivers have been fixed to set
375 * the pci shutdown function, this test can go away. */
376 if (!drv->driver.shutdown)
377 drv->driver.shutdown = pci_device_shutdown;
378 drv->driver.owner = drv->owner;
379 drv->driver.kobj.ktype = &pci_driver_kobj_type;
381 spin_lock_init(&drv->dynids.lock);
382 INIT_LIST_HEAD(&drv->dynids.list);
384 /* register with core */
385 error = driver_register(&drv->driver);
388 error = pci_create_newid_file(drv);
394 * pci_unregister_driver - unregister a pci driver
395 * @drv: the driver structure to unregister
397 * Deletes the driver structure from the list of registered PCI drivers,
398 * gives it a chance to clean up by calling its remove() function for
399 * each device it was responsible for, and marks those devices as
404 pci_unregister_driver(struct pci_driver *drv)
406 driver_unregister(&drv->driver);
407 pci_free_dynids(drv);
410 static struct pci_driver pci_compat_driver = {
415 * pci_dev_driver - get the pci_driver of a device
416 * @dev: the device to query
418 * Returns the appropriate pci_driver structure or %NULL if there is no
419 * registered driver for the device.
422 pci_dev_driver(const struct pci_dev *dev)
428 for(i=0; i<=PCI_ROM_RESOURCE; i++)
429 if (dev->resource[i].flags & IORESOURCE_BUSY)
430 return &pci_compat_driver;
436 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
437 * @ids: array of PCI device id structures to search in
438 * @dev: the PCI device structure to match against
440 * Used by a driver to check whether a PCI device present in the
441 * system is in its list of supported devices.Returns the matching
442 * pci_device_id structure or %NULL if there is no match.
444 static int pci_bus_match(struct device *dev, struct device_driver *drv)
446 struct pci_dev *pci_dev = to_pci_dev(dev);
447 struct pci_driver *pci_drv = to_pci_driver(drv);
448 const struct pci_device_id *found_id;
450 found_id = pci_match_device(pci_drv, pci_dev);
458 * pci_dev_get - increments the reference count of the pci device structure
459 * @dev: the device being referenced
461 * Each live reference to a device should be refcounted.
463 * Drivers for PCI devices should normally record such references in
464 * their probe() methods, when they bind to a device, and release
465 * them by calling pci_dev_put(), in their disconnect() methods.
467 * A pointer to the device with the incremented reference counter is returned.
469 struct pci_dev *pci_dev_get(struct pci_dev *dev)
472 get_device(&dev->dev);
477 * pci_dev_put - release a use of the pci device structure
478 * @dev: device that's been disconnected
480 * Must be called when a user of a device is finished with it. When the last
481 * user of the device calls this function, the memory of the device is freed.
483 void pci_dev_put(struct pci_dev *dev)
486 put_device(&dev->dev);
489 #ifndef CONFIG_HOTPLUG
490 int pci_hotplug (struct device *dev, char **envp, int num_envp,
491 char *buffer, int buffer_size)
497 struct bus_type pci_bus_type = {
499 .match = pci_bus_match,
500 .hotplug = pci_hotplug,
501 .suspend = pci_device_suspend,
502 .resume = pci_device_resume,
503 .dev_attrs = pci_dev_attrs,
506 static int __init pci_driver_init(void)
508 return bus_register(&pci_bus_type);
511 postcore_initcall(pci_driver_init);
513 EXPORT_SYMBOL(pci_match_id);
514 EXPORT_SYMBOL(pci_match_device);
515 EXPORT_SYMBOL(pci_register_driver);
516 EXPORT_SYMBOL(pci_unregister_driver);
517 EXPORT_SYMBOL(pci_dev_driver);
518 EXPORT_SYMBOL(pci_bus_type);
519 EXPORT_SYMBOL(pci_dev_get);
520 EXPORT_SYMBOL(pci_dev_put);