blob: 94e68c54d27397bf06c56b32d7539c927b8dcf41 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Andi Kleend42c6992005-07-06 19:56:03 +020010#include <linux/mempolicy.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080011#include <linux/string.h>
12#include <linux/slab.h>
Tim Schmielau8c65b4a2005-11-07 00:59:43 -080013#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include "pci.h"
15
16/*
17 * Registration of PCI drivers and handling of hot-pluggable devices.
18 */
19
20/*
21 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
22 */
23
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070024struct pci_dynid {
25 struct list_head node;
26 struct pci_device_id id;
27};
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Greg KH3d3c2ae2005-07-06 09:09:38 -070029#ifdef CONFIG_HOTPLUG
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031/**
Randy Dunlap8f7020d2005-10-23 11:57:38 -070032 * 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
35 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 *
37 * Adds a new dynamic pci device ID to this driver,
38 * and causes the driver to probe for all devices again.
39 */
40static inline ssize_t
41store_new_id(struct device_driver *driver, const char *buf, size_t count)
42{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070043 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 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;
48 int fields=0;
49
50 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
51 &vendor, &device, &subvendor, &subdevice,
52 &class, &class_mask, &driver_data);
53 if (fields < 0)
54 return -EINVAL;
55
56 dynid = kmalloc(sizeof(*dynid), GFP_KERNEL);
57 if (!dynid)
58 return -ENOMEM;
59
60 memset(dynid, 0, sizeof(*dynid));
61 INIT_LIST_HEAD(&dynid->node);
62 dynid->id.vendor = vendor;
63 dynid->id.device = device;
64 dynid->id.subvendor = subvendor;
65 dynid->id.subdevice = subdevice;
66 dynid->id.class = class;
67 dynid->id.class_mask = class_mask;
68 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
69 driver_data : 0UL;
70
71 spin_lock(&pdrv->dynids.lock);
72 list_add_tail(&pdrv->dynids.list, &dynid->node);
73 spin_unlock(&pdrv->dynids.lock);
74
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070075 if (get_driver(&pdrv->driver)) {
76 driver_attach(&pdrv->driver);
77 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 }
79
80 return count;
81}
Linus Torvalds1da177e2005-04-16 15:20:36 -070082static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84static void
85pci_free_dynids(struct pci_driver *drv)
86{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070087 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070090 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 list_del(&dynid->node);
92 kfree(dynid);
93 }
94 spin_unlock(&drv->dynids.lock);
95}
96
97static int
98pci_create_newid_file(struct pci_driver *drv)
99{
100 int error = 0;
101 if (drv->probe != NULL)
102 error = sysfs_create_file(&drv->driver.kobj,
103 &driver_attr_new_id.attr);
104 return error;
105}
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static inline void pci_free_dynids(struct pci_driver *drv) {}
109static inline int pci_create_newid_file(struct pci_driver *drv)
110{
111 return 0;
112}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113#endif
114
115/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700116 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700118 * @dev: the PCI device structure to match against.
119 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700121 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700123 *
124 * Depreciated, don't use this as it will not catch any dynamic ids
125 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700127const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
128 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700130 if (ids) {
131 while (ids->vendor || ids->subvendor || ids->class_mask) {
132 if (pci_match_one_device(ids, dev))
133 return ids;
134 ids++;
135 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137 return NULL;
138}
139
140/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700141 * pci_match_device - Tell if a PCI device structure has a matching
142 * PCI device id structure
143 * @ids: array of PCI device id structures to search in
144 * @dev: the PCI device structure to match against
145 * @drv: the PCI driver to match against
146 *
147 * Used by a driver to check whether a PCI device present in the
148 * system is in its list of supported devices. Returns the matching
149 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700151const struct pci_device_id *pci_match_device(struct pci_driver *drv,
152 struct pci_dev *dev)
153{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 const struct pci_device_id *id;
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700155 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700157 id = pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 if (id)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700159 return id;
160
161 /* static ids didn't match, lets look at the dynamic ones */
162 spin_lock(&drv->dynids.lock);
163 list_for_each_entry(dynid, &drv->dynids.list, node) {
164 if (pci_match_one_device(&dynid->id, dev)) {
165 spin_unlock(&drv->dynids.lock);
166 return &dynid->id;
167 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700169 spin_unlock(&drv->dynids.lock);
170 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Andi Kleend42c6992005-07-06 19:56:03 +0200173static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
174 const struct pci_device_id *id)
175{
176 int error;
177#ifdef CONFIG_NUMA
178 /* Execute driver initialization on node where the
179 device's bus is attached to. This way the driver likely
180 allocates its local memory on the right node without
181 any need to change it. */
182 struct mempolicy *oldpol;
183 cpumask_t oldmask = current->cpus_allowed;
184 int node = pcibus_to_node(dev->bus);
185 if (node >= 0 && node_online(node))
186 set_cpus_allowed(current, node_to_cpumask(node));
187 /* And set default memory allocation policy */
188 oldpol = current->mempolicy;
189 current->mempolicy = &default_policy;
190 mpol_get(current->mempolicy);
191#endif
192 error = drv->probe(dev, id);
193#ifdef CONFIG_NUMA
194 set_cpus_allowed(current, oldmask);
195 mpol_free(current->mempolicy);
196 current->mempolicy = oldpol;
197#endif
198 return error;
199}
200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201/**
202 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700203 * @drv: driver to call to check if it wants the PCI device
204 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700206 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
208 */
209static int
210__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700211{
212 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 int error = 0;
214
215 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700216 error = -ENODEV;
217
218 id = pci_match_device(drv, pci_dev);
219 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200220 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700221 if (error >= 0) {
222 pci_dev->driver = drv;
223 error = 0;
224 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 }
226 return error;
227}
228
229static int pci_device_probe(struct device * dev)
230{
231 int error = 0;
232 struct pci_driver *drv;
233 struct pci_dev *pci_dev;
234
235 drv = to_pci_driver(dev->driver);
236 pci_dev = to_pci_dev(dev);
237 pci_dev_get(pci_dev);
238 error = __pci_device_probe(drv, pci_dev);
239 if (error)
240 pci_dev_put(pci_dev);
241
242 return error;
243}
244
245static int pci_device_remove(struct device * dev)
246{
247 struct pci_dev * pci_dev = to_pci_dev(dev);
248 struct pci_driver * drv = pci_dev->driver;
249
250 if (drv) {
251 if (drv->remove)
252 drv->remove(pci_dev);
253 pci_dev->driver = NULL;
254 }
255
256 /*
257 * We would love to complain here if pci_dev->is_enabled is set, that
258 * the driver should have called pci_disable_device(), but the
259 * unfortunate fact is there are too many odd BIOS and bridge setups
260 * that don't like drivers doing that all of the time.
261 * Oh well, we can dream of sane hardware when we sleep, no matter how
262 * horrible the crap we have to deal with is when we are awake...
263 */
264
265 pci_dev_put(pci_dev);
266 return 0;
267}
268
269static int pci_device_suspend(struct device * dev, pm_message_t state)
270{
271 struct pci_dev * pci_dev = to_pci_dev(dev);
272 struct pci_driver * drv = pci_dev->driver;
273 int i = 0;
274
275 if (drv && drv->suspend)
276 i = drv->suspend(pci_dev, state);
277 else
278 pci_save_state(pci_dev);
279 return i;
280}
281
282
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700283/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 * Default resume method for devices that have no driver provided resume,
285 * or not even a driver at all.
286 */
287static void pci_default_resume(struct pci_dev *pci_dev)
288{
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700289 int retval;
290
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 /* restore the PCI config space */
292 pci_restore_state(pci_dev);
293 /* if the device was enabled before suspend, reenable */
294 if (pci_dev->is_enabled)
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700295 retval = pci_enable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 /* if the device was busmaster before the suspend, make it busmaster again */
297 if (pci_dev->is_busmaster)
298 pci_set_master(pci_dev);
299}
300
301static int pci_device_resume(struct device * dev)
302{
303 struct pci_dev * pci_dev = to_pci_dev(dev);
304 struct pci_driver * drv = pci_dev->driver;
305
306 if (drv && drv->resume)
307 drv->resume(pci_dev);
308 else
309 pci_default_resume(pci_dev);
310 return 0;
311}
312
Greg KHc8958172005-04-08 14:53:31 +0900313static void pci_device_shutdown(struct device *dev)
314{
315 struct pci_dev *pci_dev = to_pci_dev(dev);
316 struct pci_driver *drv = pci_dev->driver;
317
318 if (drv && drv->shutdown)
319 drv->shutdown(pci_dev);
320}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321
322#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
323#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
324
325static ssize_t
326pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
327{
328 struct device_driver *driver = kobj_to_pci_driver(kobj);
329 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500330 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500332 if (!get_driver(driver))
333 return -ENODEV;
334
335 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
336
337 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 return ret;
339}
340
341static ssize_t
342pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
343 const char *buf, size_t count)
344{
345 struct device_driver *driver = kobj_to_pci_driver(kobj);
346 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500347 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500349 if (!get_driver(driver))
350 return -ENODEV;
351
352 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
353
354 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return ret;
356}
357
358static struct sysfs_ops pci_driver_sysfs_ops = {
359 .show = pci_driver_attr_show,
360 .store = pci_driver_attr_store,
361};
362static struct kobj_type pci_driver_kobj_type = {
363 .sysfs_ops = &pci_driver_sysfs_ops,
364};
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366/**
367 * pci_register_driver - register a new pci driver
368 * @drv: the driver structure to register
369 *
370 * Adds the driver structure to the list of registered drivers.
371 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600372 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 * no device was claimed during registration.
374 */
375int pci_register_driver(struct pci_driver *drv)
376{
377 int error;
378
379 /* initialize common driver fields */
380 drv->driver.name = drv->name;
381 drv->driver.bus = &pci_bus_type;
382 drv->driver.probe = pci_device_probe;
383 drv->driver.remove = pci_device_remove;
Christoph Hellwig794f5bf2005-06-17 12:25:25 -0700384 /* FIXME, once all of the existing PCI drivers have been fixed to set
385 * the pci shutdown function, this test can go away. */
386 if (!drv->driver.shutdown)
Mika Kukkonenc83d99452005-06-18 22:49:56 +0300387 drv->driver.shutdown = pci_device_shutdown;
Russell Kinga1720fd2005-10-16 21:31:36 +0100388 else
389 printk(KERN_WARNING "Warning: PCI driver %s has a struct "
390 "device_driver shutdown method, please update!\n",
391 drv->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 drv->driver.owner = drv->owner;
393 drv->driver.kobj.ktype = &pci_driver_kobj_type;
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700394
395 spin_lock_init(&drv->dynids.lock);
396 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398 /* register with core */
399 error = driver_register(&drv->driver);
400
401 if (!error)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700402 error = pci_create_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
404 return error;
405}
406
407/**
408 * pci_unregister_driver - unregister a pci driver
409 * @drv: the driver structure to unregister
410 *
411 * Deletes the driver structure from the list of registered PCI drivers,
412 * gives it a chance to clean up by calling its remove() function for
413 * each device it was responsible for, and marks those devices as
414 * driverless.
415 */
416
417void
418pci_unregister_driver(struct pci_driver *drv)
419{
420 driver_unregister(&drv->driver);
421 pci_free_dynids(drv);
422}
423
424static struct pci_driver pci_compat_driver = {
425 .name = "compat"
426};
427
428/**
429 * pci_dev_driver - get the pci_driver of a device
430 * @dev: the device to query
431 *
432 * Returns the appropriate pci_driver structure or %NULL if there is no
433 * registered driver for the device.
434 */
435struct pci_driver *
436pci_dev_driver(const struct pci_dev *dev)
437{
438 if (dev->driver)
439 return dev->driver;
440 else {
441 int i;
442 for(i=0; i<=PCI_ROM_RESOURCE; i++)
443 if (dev->resource[i].flags & IORESOURCE_BUSY)
444 return &pci_compat_driver;
445 }
446 return NULL;
447}
448
449/**
450 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700452 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 *
454 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700455 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 * pci_device_id structure or %NULL if there is no match.
457 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700458static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700460 struct pci_dev *pci_dev = to_pci_dev(dev);
461 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 const struct pci_device_id *found_id;
463
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700464 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 if (found_id)
466 return 1;
467
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700468 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
470
471/**
472 * pci_dev_get - increments the reference count of the pci device structure
473 * @dev: the device being referenced
474 *
475 * Each live reference to a device should be refcounted.
476 *
477 * Drivers for PCI devices should normally record such references in
478 * their probe() methods, when they bind to a device, and release
479 * them by calling pci_dev_put(), in their disconnect() methods.
480 *
481 * A pointer to the device with the incremented reference counter is returned.
482 */
483struct pci_dev *pci_dev_get(struct pci_dev *dev)
484{
485 if (dev)
486 get_device(&dev->dev);
487 return dev;
488}
489
490/**
491 * pci_dev_put - release a use of the pci device structure
492 * @dev: device that's been disconnected
493 *
494 * Must be called when a user of a device is finished with it. When the last
495 * user of the device calls this function, the memory of the device is freed.
496 */
497void pci_dev_put(struct pci_dev *dev)
498{
499 if (dev)
500 put_device(&dev->dev);
501}
502
503#ifndef CONFIG_HOTPLUG
504int pci_hotplug (struct device *dev, char **envp, int num_envp,
505 char *buffer, int buffer_size)
506{
507 return -ENODEV;
508}
509#endif
510
511struct bus_type pci_bus_type = {
512 .name = "pci",
513 .match = pci_bus_match,
514 .hotplug = pci_hotplug,
515 .suspend = pci_device_suspend,
516 .resume = pci_device_resume,
517 .dev_attrs = pci_dev_attrs,
518};
519
520static int __init pci_driver_init(void)
521{
522 return bus_register(&pci_bus_type);
523}
524
525postcore_initcall(pci_driver_init);
526
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700527EXPORT_SYMBOL(pci_match_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528EXPORT_SYMBOL(pci_match_device);
529EXPORT_SYMBOL(pci_register_driver);
530EXPORT_SYMBOL(pci_unregister_driver);
531EXPORT_SYMBOL(pci_dev_driver);
532EXPORT_SYMBOL(pci_bus_type);
533EXPORT_SYMBOL(pci_dev_get);
534EXPORT_SYMBOL(pci_dev_put);