blob: 6e2760b6c20a4cc1d1ce08ebb4d64dd87872c2d0 [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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
18 */
19
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070020struct pci_dynid {
21 struct list_head node;
22 struct pci_device_id id;
23};
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Greg KH3d3c2ae2005-07-06 09:09:38 -070025#ifdef CONFIG_HOTPLUG
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027/**
Randy Dunlap8f7020d2005-10-23 11:57:38 -070028 * store_new_id - add a new PCI device ID to this driver and re-probe devices
29 * @driver: target device driver
30 * @buf: buffer for scanning device ID data
31 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 *
33 * Adds a new dynamic pci device ID to this driver,
34 * and causes the driver to probe for all devices again.
35 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -070036static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -070037store_new_id(struct device_driver *driver, const char *buf, size_t count)
38{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070039 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvare6ba18632007-04-07 17:21:28 +020041 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 subdevice=PCI_ANY_ID, class=0, class_mask=0;
43 unsigned long driver_data=0;
44 int fields=0;
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070045 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47 fields = sscanf(buf, "%x %x %x %x %x %x %lux",
48 &vendor, &device, &subvendor, &subdevice,
49 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +020050 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 return -EINVAL;
52
Eric Sesterhennf5afe802006-02-28 15:34:49 +010053 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 if (!dynid)
55 return -ENOMEM;
56
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 dynid->id.vendor = vendor;
58 dynid->id.device = device;
59 dynid->id.subvendor = subvendor;
60 dynid->id.subdevice = subdevice;
61 dynid->id.class = class;
62 dynid->id.class_mask = class_mask;
63 dynid->id.driver_data = pdrv->dynids.use_driver_data ?
64 driver_data : 0UL;
65
66 spin_lock(&pdrv->dynids.lock);
Michael Ellermana56bc692007-09-14 15:33:13 +100067 list_add_tail(&dynid->node, &pdrv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 spin_unlock(&pdrv->dynids.lock);
69
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070070 if (get_driver(&pdrv->driver)) {
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070071 retval = driver_attach(&pdrv->driver);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070072 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 }
74
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070075 if (retval)
76 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 return count;
78}
Linus Torvalds1da177e2005-04-16 15:20:36 -070079static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
81static void
82pci_free_dynids(struct pci_driver *drv)
83{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070084 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
86 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070087 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 list_del(&dynid->node);
89 kfree(dynid);
90 }
91 spin_unlock(&drv->dynids.lock);
92}
93
94static int
95pci_create_newid_file(struct pci_driver *drv)
96{
97 int error = 0;
98 if (drv->probe != NULL)
99 error = sysfs_create_file(&drv->driver.kobj,
100 &driver_attr_new_id.attr);
101 return error;
102}
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static inline void pci_free_dynids(struct pci_driver *drv) {}
106static inline int pci_create_newid_file(struct pci_driver *drv)
107{
108 return 0;
109}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110#endif
111
112/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700113 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700115 * @dev: the PCI device structure to match against.
116 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700118 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700120 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200121 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700122 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700124const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
125 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700127 if (ids) {
128 while (ids->vendor || ids->subvendor || ids->class_mask) {
129 if (pci_match_one_device(ids, dev))
130 return ids;
131 ids++;
132 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 }
134 return NULL;
135}
136
137/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800138 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700139 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200140 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700141 *
142 * Used by a driver to check whether a PCI device present in the
143 * system is in its list of supported devices. Returns the matching
144 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700146const struct pci_device_id *pci_match_device(struct pci_driver *drv,
147 struct pci_dev *dev)
148{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700149 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150
Russell King7461b602006-11-29 21:18:04 +0000151 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700152 spin_lock(&drv->dynids.lock);
153 list_for_each_entry(dynid, &drv->dynids.list, node) {
154 if (pci_match_one_device(&dynid->id, dev)) {
155 spin_unlock(&drv->dynids.lock);
156 return &dynid->id;
157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700159 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000160
161 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
163
Andi Kleend42c6992005-07-06 19:56:03 +0200164static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
165 const struct pci_device_id *id)
166{
167 int error;
168#ifdef CONFIG_NUMA
169 /* Execute driver initialization on node where the
170 device's bus is attached to. This way the driver likely
171 allocates its local memory on the right node without
172 any need to change it. */
173 struct mempolicy *oldpol;
174 cpumask_t oldmask = current->cpus_allowed;
175 int node = pcibus_to_node(dev->bus);
176 if (node >= 0 && node_online(node))
177 set_cpus_allowed(current, node_to_cpumask(node));
178 /* And set default memory allocation policy */
179 oldpol = current->mempolicy;
180 current->mempolicy = &default_policy;
181 mpol_get(current->mempolicy);
182#endif
183 error = drv->probe(dev, id);
184#ifdef CONFIG_NUMA
185 set_cpus_allowed(current, oldmask);
186 mpol_free(current->mempolicy);
187 current->mempolicy = oldpol;
188#endif
189 return error;
190}
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192/**
193 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700194 * @drv: driver to call to check if it wants the PCI device
195 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700197 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
199 */
200static int
201__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700202{
203 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 int error = 0;
205
206 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700207 error = -ENODEV;
208
209 id = pci_match_device(drv, pci_dev);
210 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200211 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700212 if (error >= 0) {
213 pci_dev->driver = drv;
214 error = 0;
215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 }
217 return error;
218}
219
220static int pci_device_probe(struct device * dev)
221{
222 int error = 0;
223 struct pci_driver *drv;
224 struct pci_dev *pci_dev;
225
226 drv = to_pci_driver(dev->driver);
227 pci_dev = to_pci_dev(dev);
228 pci_dev_get(pci_dev);
229 error = __pci_device_probe(drv, pci_dev);
230 if (error)
231 pci_dev_put(pci_dev);
232
233 return error;
234}
235
236static int pci_device_remove(struct device * dev)
237{
238 struct pci_dev * pci_dev = to_pci_dev(dev);
239 struct pci_driver * drv = pci_dev->driver;
240
241 if (drv) {
242 if (drv->remove)
243 drv->remove(pci_dev);
244 pci_dev->driver = NULL;
245 }
246
247 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700248 * If the device is still on, set the power state as "unknown",
249 * since it might change by the next time we load the driver.
250 */
251 if (pci_dev->current_state == PCI_D0)
252 pci_dev->current_state = PCI_UNKNOWN;
253
254 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 * 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...
261 */
262
263 pci_dev_put(pci_dev);
264 return 0;
265}
266
267static int pci_device_suspend(struct device * dev, pm_message_t state)
268{
269 struct pci_dev * pci_dev = to_pci_dev(dev);
270 struct pci_driver * drv = pci_dev->driver;
271 int i = 0;
272
Andrew Morton02669492006-03-23 01:38:34 -0800273 if (drv && drv->suspend) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800275 suspend_report_result(drv->suspend, i);
276 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 pci_save_state(pci_dev);
Shaohua Li2449e062006-10-20 14:45:32 -0700278 /*
279 * mark its power state as "unknown", since we don't know if
280 * e.g. the BIOS will change its device state when we suspend.
281 */
282 if (pci_dev->current_state == PCI_D0)
283 pci_dev->current_state = PCI_UNKNOWN;
Andrew Morton02669492006-03-23 01:38:34 -0800284 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return i;
286}
287
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700288static int pci_device_suspend_late(struct device * dev, pm_message_t state)
289{
290 struct pci_dev * pci_dev = to_pci_dev(dev);
291 struct pci_driver * drv = pci_dev->driver;
292 int i = 0;
293
294 if (drv && drv->suspend_late) {
295 i = drv->suspend_late(pci_dev, state);
296 suspend_report_result(drv->suspend_late, i);
297 }
298 return i;
299}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700301/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 * Default resume method for devices that have no driver provided resume,
303 * or not even a driver at all.
304 */
Jean Delvare8d92bc22006-04-18 14:49:56 +0200305static int pci_default_resume(struct pci_dev *pci_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200307 int retval = 0;
Greg Kroah-Hartman95a62962005-07-28 11:37:33 -0700308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 /* restore the PCI config space */
310 pci_restore_state(pci_dev);
311 /* if the device was enabled before suspend, reenable */
Tejun Heo0b62e132007-07-27 14:43:35 +0900312 retval = pci_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 /* if the device was busmaster before the suspend, make it busmaster again */
314 if (pci_dev->is_busmaster)
315 pci_set_master(pci_dev);
Jean Delvare8d92bc22006-04-18 14:49:56 +0200316
317 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318}
319
320static int pci_device_resume(struct device * dev)
321{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200322 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 struct pci_dev * pci_dev = to_pci_dev(dev);
324 struct pci_driver * drv = pci_dev->driver;
325
326 if (drv && drv->resume)
Jean Delvare8d92bc22006-04-18 14:49:56 +0200327 error = drv->resume(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 else
Jean Delvare8d92bc22006-04-18 14:49:56 +0200329 error = pci_default_resume(pci_dev);
330 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331}
332
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700333static int pci_device_resume_early(struct device * dev)
334{
335 int error = 0;
336 struct pci_dev * pci_dev = to_pci_dev(dev);
337 struct pci_driver * drv = pci_dev->driver;
338
Alan Cox1597cac2006-12-04 15:14:45 -0800339 pci_fixup_device(pci_fixup_resume, pci_dev);
340
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700341 if (drv && drv->resume_early)
342 error = drv->resume_early(pci_dev);
343 return error;
344}
345
Greg KHc8958172005-04-08 14:53:31 +0900346static void pci_device_shutdown(struct device *dev)
347{
348 struct pci_dev *pci_dev = to_pci_dev(dev);
349 struct pci_driver *drv = pci_dev->driver;
350
351 if (drv && drv->shutdown)
352 drv->shutdown(pci_dev);
353}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
355#define kobj_to_pci_driver(obj) container_of(obj, struct device_driver, kobj)
356#define attr_to_driver_attribute(obj) container_of(obj, struct driver_attribute, attr)
357
358static ssize_t
359pci_driver_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
360{
361 struct device_driver *driver = kobj_to_pci_driver(kobj);
362 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500363 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500365 if (!get_driver(driver))
366 return -ENODEV;
367
368 ret = dattr->show ? dattr->show(driver, buf) : -EIO;
369
370 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 return ret;
372}
373
374static ssize_t
375pci_driver_attr_store(struct kobject * kobj, struct attribute *attr,
376 const char *buf, size_t count)
377{
378 struct device_driver *driver = kobj_to_pci_driver(kobj);
379 struct driver_attribute *dattr = attr_to_driver_attribute(attr);
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500380 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Dmitry Torokhovfc7e4822005-04-29 01:26:27 -0500382 if (!get_driver(driver))
383 return -ENODEV;
384
385 ret = dattr->store ? dattr->store(driver, buf, count) : -EIO;
386
387 put_driver(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 return ret;
389}
390
391static struct sysfs_ops pci_driver_sysfs_ops = {
392 .show = pci_driver_attr_show,
393 .store = pci_driver_attr_store,
394};
395static struct kobj_type pci_driver_kobj_type = {
396 .sysfs_ops = &pci_driver_sysfs_ops,
397};
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200400 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200402 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800403 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 *
405 * Adds the driver structure to the list of registered drivers.
406 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600407 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 * no device was claimed during registration.
409 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800410int __pci_register_driver(struct pci_driver *drv, struct module *owner,
411 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
413 int error;
414
415 /* initialize common driver fields */
416 drv->driver.name = drv->name;
417 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200418 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800419 drv->driver.mod_name = mod_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 drv->driver.kobj.ktype = &pci_driver_kobj_type;
Alan Cox50b00752006-08-16 17:42:18 +0100421
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700422 spin_lock_init(&drv->dynids.lock);
423 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
425 /* register with core */
426 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800427 if (error)
428 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800430 error = pci_create_newid_file(drv);
431 if (error)
432 driver_unregister(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 return error;
435}
436
437/**
438 * pci_unregister_driver - unregister a pci driver
439 * @drv: the driver structure to unregister
440 *
441 * Deletes the driver structure from the list of registered PCI drivers,
442 * gives it a chance to clean up by calling its remove() function for
443 * each device it was responsible for, and marks those devices as
444 * driverless.
445 */
446
447void
448pci_unregister_driver(struct pci_driver *drv)
449{
450 driver_unregister(&drv->driver);
451 pci_free_dynids(drv);
452}
453
454static struct pci_driver pci_compat_driver = {
455 .name = "compat"
456};
457
458/**
459 * pci_dev_driver - get the pci_driver of a device
460 * @dev: the device to query
461 *
462 * Returns the appropriate pci_driver structure or %NULL if there is no
463 * registered driver for the device.
464 */
465struct pci_driver *
466pci_dev_driver(const struct pci_dev *dev)
467{
468 if (dev->driver)
469 return dev->driver;
470 else {
471 int i;
472 for(i=0; i<=PCI_ROM_RESOURCE; i++)
473 if (dev->resource[i].flags & IORESOURCE_BUSY)
474 return &pci_compat_driver;
475 }
476 return NULL;
477}
478
479/**
480 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700482 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 *
484 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700485 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 * pci_device_id structure or %NULL if there is no match.
487 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700488static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700490 struct pci_dev *pci_dev = to_pci_dev(dev);
491 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 const struct pci_device_id *found_id;
493
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700494 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (found_id)
496 return 1;
497
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700498 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499}
500
501/**
502 * pci_dev_get - increments the reference count of the pci device structure
503 * @dev: the device being referenced
504 *
505 * Each live reference to a device should be refcounted.
506 *
507 * Drivers for PCI devices should normally record such references in
508 * their probe() methods, when they bind to a device, and release
509 * them by calling pci_dev_put(), in their disconnect() methods.
510 *
511 * A pointer to the device with the incremented reference counter is returned.
512 */
513struct pci_dev *pci_dev_get(struct pci_dev *dev)
514{
515 if (dev)
516 get_device(&dev->dev);
517 return dev;
518}
519
520/**
521 * pci_dev_put - release a use of the pci device structure
522 * @dev: device that's been disconnected
523 *
524 * Must be called when a user of a device is finished with it. When the last
525 * user of the device calls this function, the memory of the device is freed.
526 */
527void pci_dev_put(struct pci_dev *dev)
528{
529 if (dev)
530 put_device(&dev->dev);
531}
532
533#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200534int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
536 return -ENODEV;
537}
538#endif
539
540struct bus_type pci_bus_type = {
541 .name = "pci",
542 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100543 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000544 .probe = pci_device_probe,
545 .remove = pci_device_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 .suspend = pci_device_suspend,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700547 .suspend_late = pci_device_suspend_late,
548 .resume_early = pci_device_resume_early,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 .resume = pci_device_resume,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700550 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 .dev_attrs = pci_dev_attrs,
552};
553
554static int __init pci_driver_init(void)
555{
556 return bus_register(&pci_bus_type);
557}
558
559postcore_initcall(pci_driver_init);
560
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700561EXPORT_SYMBOL(pci_match_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562EXPORT_SYMBOL(pci_match_device);
Laurent riffard863b18f2005-10-27 23:12:54 +0200563EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564EXPORT_SYMBOL(pci_unregister_driver);
565EXPORT_SYMBOL(pci_dev_driver);
566EXPORT_SYMBOL(pci_bus_type);
567EXPORT_SYMBOL(pci_dev_get);
568EXPORT_SYMBOL(pci_dev_put);