blob: b7e67c2f40b97c8fa43cae14cdddc1ae39a331c7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * drivers/pci/pci-driver.c
3 *
Greg Kroah-Hartman2b937302007-11-28 12:23:18 -08004 * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com>
5 * (C) Copyright 2007 Novell Inc.
6 *
7 * Released under the GPL v2 only.
8 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 */
10
11#include <linux/pci.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/device.h>
Andi Kleend42c6992005-07-06 19:56:03 +020015#include <linux/mempolicy.h>
Tim Schmielau4e57b682005-10-30 15:03:48 -080016#include <linux/string.h>
17#include <linux/slab.h>
Tim Schmielau8c65b4a2005-11-07 00:59:43 -080018#include <linux/sched.h>
Rusty Russell873392c2008-12-31 23:54:56 +103019#include <linux/cpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "pci.h"
21
22/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 * Dynamic device IDs are disabled for !CONFIG_HOTPLUG
24 */
25
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070026struct pci_dynid {
27 struct list_head node;
28 struct pci_device_id id;
29};
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Greg KH3d3c2ae2005-07-06 09:09:38 -070031#ifdef CONFIG_HOTPLUG
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033/**
Randy Dunlap8f7020d2005-10-23 11:57:38 -070034 * store_new_id - add a new PCI device ID to this driver and re-probe devices
35 * @driver: target device driver
36 * @buf: buffer for scanning device ID data
37 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 *
39 * Adds a new dynamic pci device ID to this driver,
40 * and causes the driver to probe for all devices again.
41 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -070042static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -070043store_new_id(struct device_driver *driver, const char *buf, size_t count)
44{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070045 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvareb41d6cf2008-08-17 21:06:59 +020047 const struct pci_device_id *ids = pdrv->id_table;
Jean Delvare6ba18632007-04-07 17:21:28 +020048 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 subdevice=PCI_ANY_ID, class=0, class_mask=0;
50 unsigned long driver_data=0;
51 int fields=0;
Chris Wright2debb4d2008-11-25 19:36:10 -080052 int retval=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Jean Delvareb41d6cf2008-08-17 21:06:59 +020054 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 &vendor, &device, &subvendor, &subdevice,
56 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +020057 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 return -EINVAL;
59
Jean Delvareb41d6cf2008-08-17 21:06:59 +020060 /* Only accept driver_data values that match an existing id_table
61 entry */
Chris Wright2debb4d2008-11-25 19:36:10 -080062 if (ids) {
63 retval = -EINVAL;
64 while (ids->vendor || ids->subvendor || ids->class_mask) {
65 if (driver_data == ids->driver_data) {
66 retval = 0;
67 break;
68 }
69 ids++;
Jean Delvareb41d6cf2008-08-17 21:06:59 +020070 }
Chris Wright2debb4d2008-11-25 19:36:10 -080071 if (retval) /* No match */
72 return retval;
Jean Delvareb41d6cf2008-08-17 21:06:59 +020073 }
Jean Delvareb41d6cf2008-08-17 21:06:59 +020074
Eric Sesterhennf5afe802006-02-28 15:34:49 +010075 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 if (!dynid)
77 return -ENOMEM;
78
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 dynid->id.vendor = vendor;
80 dynid->id.device = device;
81 dynid->id.subvendor = subvendor;
82 dynid->id.subdevice = subdevice;
83 dynid->id.class = class;
84 dynid->id.class_mask = class_mask;
Milton Milleredbc25c2008-07-10 16:29:37 -050085 dynid->id.driver_data = driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87 spin_lock(&pdrv->dynids.lock);
Michael Ellermana56bc692007-09-14 15:33:13 +100088 list_add_tail(&dynid->node, &pdrv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 spin_unlock(&pdrv->dynids.lock);
90
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070091 if (get_driver(&pdrv->driver)) {
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070092 retval = driver_attach(&pdrv->driver);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070093 put_driver(&pdrv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 }
95
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -070096 if (retval)
97 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 return count;
99}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101
102static void
103pci_free_dynids(struct pci_driver *drv)
104{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700105 struct pci_dynid *dynid, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106
107 spin_lock(&drv->dynids.lock);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700108 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 list_del(&dynid->node);
110 kfree(dynid);
111 }
112 spin_unlock(&drv->dynids.lock);
113}
114
115static int
116pci_create_newid_file(struct pci_driver *drv)
117{
118 int error = 0;
119 if (drv->probe != NULL)
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800120 error = driver_create_file(&drv->driver, &driver_attr_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 return error;
122}
123
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800124static void pci_remove_newid_file(struct pci_driver *drv)
125{
126 driver_remove_file(&drv->driver, &driver_attr_new_id);
127}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128#else /* !CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129static inline void pci_free_dynids(struct pci_driver *drv) {}
130static inline int pci_create_newid_file(struct pci_driver *drv)
131{
132 return 0;
133}
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800134static inline void pci_remove_newid_file(struct pci_driver *drv) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135#endif
136
137/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700138 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700140 * @dev: the PCI device structure to match against.
141 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700143 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700145 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200146 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700147 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700149const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
150 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700152 if (ids) {
153 while (ids->vendor || ids->subvendor || ids->class_mask) {
154 if (pci_match_one_device(ids, dev))
155 return ids;
156 ids++;
157 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 }
159 return NULL;
160}
161
162/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800163 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700164 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200165 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700166 *
167 * Used by a driver to check whether a PCI device present in the
168 * system is in its list of supported devices. Returns the matching
169 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200171static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
172 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700173{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700174 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Russell King7461b602006-11-29 21:18:04 +0000176 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700177 spin_lock(&drv->dynids.lock);
178 list_for_each_entry(dynid, &drv->dynids.list, node) {
179 if (pci_match_one_device(&dynid->id, dev)) {
180 spin_unlock(&drv->dynids.lock);
181 return &dynid->id;
182 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700184 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000185
186 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187}
188
Rusty Russell873392c2008-12-31 23:54:56 +1030189struct drv_dev_and_id {
190 struct pci_driver *drv;
191 struct pci_dev *dev;
192 const struct pci_device_id *id;
193};
194
195static long local_pci_probe(void *_ddi)
196{
197 struct drv_dev_and_id *ddi = _ddi;
198
199 return ddi->drv->probe(ddi->dev, ddi->id);
200}
201
Andi Kleend42c6992005-07-06 19:56:03 +0200202static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
203 const struct pci_device_id *id)
204{
Rusty Russell873392c2008-12-31 23:54:56 +1030205 int error, node;
206 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700207
Rusty Russell873392c2008-12-31 23:54:56 +1030208 /* Execute driver initialization on node where the device's
209 bus is attached to. This way the driver likely allocates
210 its local memory on the right node without any need to
211 change it. */
212 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700213 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030214 int cpu;
Mike Travisf70316d2008-04-04 18:11:06 -0700215 node_to_cpumask_ptr(nodecpumask, node);
Rusty Russell873392c2008-12-31 23:54:56 +1030216
217 get_online_cpus();
218 cpu = cpumask_any_and(nodecpumask, cpu_online_mask);
219 if (cpu < nr_cpu_ids)
220 error = work_on_cpu(cpu, local_pci_probe, &ddi);
221 else
222 error = local_pci_probe(&ddi);
223 put_online_cpus();
224 } else
225 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200226 return error;
227}
228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229/**
230 * __pci_device_probe()
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700231 * @drv: driver to call to check if it wants the PCI device
232 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700234 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
236 */
237static int
238__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700239{
240 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 int error = 0;
242
243 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700244 error = -ENODEV;
245
246 id = pci_match_device(drv, pci_dev);
247 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200248 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700249 if (error >= 0) {
250 pci_dev->driver = drv;
251 error = 0;
252 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 }
254 return error;
255}
256
257static int pci_device_probe(struct device * dev)
258{
259 int error = 0;
260 struct pci_driver *drv;
261 struct pci_dev *pci_dev;
262
263 drv = to_pci_driver(dev->driver);
264 pci_dev = to_pci_dev(dev);
265 pci_dev_get(pci_dev);
266 error = __pci_device_probe(drv, pci_dev);
267 if (error)
268 pci_dev_put(pci_dev);
269
270 return error;
271}
272
273static int pci_device_remove(struct device * dev)
274{
275 struct pci_dev * pci_dev = to_pci_dev(dev);
276 struct pci_driver * drv = pci_dev->driver;
277
278 if (drv) {
279 if (drv->remove)
280 drv->remove(pci_dev);
281 pci_dev->driver = NULL;
282 }
283
284 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700285 * If the device is still on, set the power state as "unknown",
286 * since it might change by the next time we load the driver.
287 */
288 if (pci_dev->current_state == PCI_D0)
289 pci_dev->current_state = PCI_UNKNOWN;
290
291 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 * We would love to complain here if pci_dev->is_enabled is set, that
293 * the driver should have called pci_disable_device(), but the
294 * unfortunate fact is there are too many odd BIOS and bridge setups
295 * that don't like drivers doing that all of the time.
296 * Oh well, we can dream of sane hardware when we sleep, no matter how
297 * horrible the crap we have to deal with is when we are awake...
298 */
299
300 pci_dev_put(pci_dev);
301 return 0;
302}
303
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200304static void pci_device_shutdown(struct device *dev)
305{
306 struct pci_dev *pci_dev = to_pci_dev(dev);
307 struct pci_driver *drv = pci_dev->driver;
308
309 if (drv && drv->shutdown)
310 drv->shutdown(pci_dev);
311 pci_msi_shutdown(pci_dev);
312 pci_msix_shutdown(pci_dev);
313}
314
315#ifdef CONFIG_PM_SLEEP
316
317/*
318 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100319 * or not even a driver at all (second part).
320 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100321static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200322{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200323 /*
324 * mark its power state as "unknown", since we don't know if
325 * e.g. the BIOS will change its device state when we suspend.
326 */
327 if (pci_dev->current_state == PCI_D0)
328 pci_dev->current_state = PCI_UNKNOWN;
329}
330
331/*
332 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100333 * or not even a driver at all (second part).
334 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100335static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100336{
337 int retval;
338
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200339 /* if the device was enabled before suspend, reenable */
340 retval = pci_reenable_device(pci_dev);
341 /*
342 * if the device was busmaster before the suspend, make it busmaster
343 * again
344 */
345 if (pci_dev->is_busmaster)
346 pci_set_master(pci_dev);
347
348 return retval;
349}
350
351static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
353 struct pci_dev * pci_dev = to_pci_dev(dev);
354 struct pci_driver * drv = pci_dev->driver;
355 int i = 0;
356
Andrew Morton02669492006-03-23 01:38:34 -0800357 if (drv && drv->suspend) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800359 suspend_report_result(drv->suspend, i);
360 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100361 pci_save_state(pci_dev);
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100362 /*
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100363 * This is for compatibility with existing code with legacy PM
364 * support.
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100365 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100366 pci_pm_set_unknown_state(pci_dev);
Andrew Morton02669492006-03-23 01:38:34 -0800367 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100368
369 pci_fixup_device(pci_fixup_suspend, pci_dev);
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 return i;
372}
373
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200374static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700375{
376 struct pci_dev * pci_dev = to_pci_dev(dev);
377 struct pci_driver * drv = pci_dev->driver;
378 int i = 0;
379
380 if (drv && drv->suspend_late) {
381 i = drv->suspend_late(pci_dev, state);
382 suspend_report_result(drv->suspend_late, i);
383 }
384 return i;
385}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200387static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200389 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 struct pci_dev * pci_dev = to_pci_dev(dev);
391 struct pci_driver * drv = pci_dev->driver;
392
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100393 pci_fixup_device(pci_fixup_resume, pci_dev);
394
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100395 if (drv && drv->resume) {
Jean Delvare8d92bc22006-04-18 14:49:56 +0200396 error = drv->resume(pci_dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100397 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100398 /* restore the PCI config space */
399 pci_restore_state(pci_dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100400 error = pci_pm_reenable_device(pci_dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100401 }
Jean Delvare8d92bc22006-04-18 14:49:56 +0200402 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403}
404
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200405static int pci_legacy_resume_early(struct device *dev)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700406{
407 int error = 0;
408 struct pci_dev * pci_dev = to_pci_dev(dev);
409 struct pci_driver * drv = pci_dev->driver;
410
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100411 pci_fixup_device(pci_fixup_resume_early, pci_dev);
412
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700413 if (drv && drv->resume_early)
414 error = drv->resume_early(pci_dev);
415 return error;
416}
417
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100418/* Auxiliary functions used by the new power management framework */
419
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100420static int pci_restore_standard_config(struct pci_dev *pci_dev)
421{
422 struct pci_dev *parent = pci_dev->bus->self;
423 int error = 0;
424
425 /* Check if the device's bus is operational */
426 if (!parent || parent->current_state == PCI_D0) {
427 pci_restore_state(pci_dev);
428 pci_update_current_state(pci_dev, PCI_D0);
429 } else {
430 dev_warn(&pci_dev->dev, "unable to restore config, "
431 "bridge %s in low power state D%d\n", pci_name(parent),
432 parent->current_state);
433 pci_dev->current_state = PCI_UNKNOWN;
434 error = -EAGAIN;
435 }
436
437 return error;
438}
439
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100440static bool pci_is_bridge(struct pci_dev *pci_dev)
441{
442 return !!(pci_dev->subordinate);
443}
444
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100445static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
446{
447 if (pci_restore_standard_config(pci_dev))
448 pci_fixup_device(pci_fixup_resume_early, pci_dev);
449}
450
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100451static int pci_pm_default_resume(struct pci_dev *pci_dev)
452{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100453 /*
454 * pci_restore_standard_config() should have been called once already,
455 * but it would have failed if the device's parent bridge had not been
456 * in power state D0 at that time. Check it and try again if necessary.
457 */
458 if (pci_dev->current_state == PCI_UNKNOWN) {
459 int error = pci_restore_standard_config(pci_dev);
460 if (error)
461 return error;
462 }
463
464 pci_fixup_device(pci_fixup_resume, pci_dev);
465
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100466 if (!pci_is_bridge(pci_dev))
467 pci_enable_wake(pci_dev, PCI_D0, false);
468
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100469 return pci_pm_reenable_device(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100470}
471
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100472static void pci_pm_default_suspend_generic(struct pci_dev *pci_dev)
473{
474 /* If device is enabled at this point, disable it */
475 pci_disable_enabled_device(pci_dev);
476 /*
477 * Save state with interrupts enabled, because in principle the bus the
478 * device is on may be put into a low power state after this code runs.
479 */
480 pci_save_state(pci_dev);
481}
482
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100483static void pci_pm_default_suspend(struct pci_dev *pci_dev)
484{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100485 pci_pm_default_suspend_generic(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100486
487 if (!pci_is_bridge(pci_dev))
488 pci_prepare_to_sleep(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100489
490 pci_fixup_device(pci_fixup_suspend, pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100491}
492
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100493static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
494{
495 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100496 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100497 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100498
499 /*
500 * Legacy PM support is used by default, so warn if the new framework is
501 * supported as well. Drivers are supposed to support either the
502 * former, or the latter, but not both at the same time.
503 */
504 WARN_ON(ret && drv->driver.pm);
505
506 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100507}
508
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100509/* New power management framework */
510
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200511static int pci_pm_prepare(struct device *dev)
512{
513 struct device_driver *drv = dev->driver;
514 int error = 0;
515
516 if (drv && drv->pm && drv->pm->prepare)
517 error = drv->pm->prepare(dev);
518
519 return error;
520}
521
522static void pci_pm_complete(struct device *dev)
523{
524 struct device_driver *drv = dev->driver;
525
526 if (drv && drv->pm && drv->pm->complete)
527 drv->pm->complete(dev);
528}
529
530#ifdef CONFIG_SUSPEND
531
532static int pci_pm_suspend(struct device *dev)
533{
534 struct pci_dev *pci_dev = to_pci_dev(dev);
535 struct device_driver *drv = dev->driver;
536 int error = 0;
537
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100538 if (pci_has_legacy_pm_support(pci_dev))
539 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100540
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100541 if (drv && drv->pm && drv->pm->suspend) {
542 error = drv->pm->suspend(dev);
543 suspend_report_result(drv->pm->suspend, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200544 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100545
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100546 if (!error)
547 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200548
549 return error;
550}
551
552static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900553{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100554 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200555 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200556 int error = 0;
Greg KHc8958172005-04-08 14:53:31 +0900557
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100558 if (pci_has_legacy_pm_support(pci_dev))
559 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
560
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100561 if (drv && drv->pm && drv->pm->suspend_noirq) {
562 error = drv->pm->suspend_noirq(dev);
563 suspend_report_result(drv->pm->suspend_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200564 }
565
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100566 if (!error)
567 pci_pm_set_unknown_state(pci_dev);
568
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200569 return error;
Greg KHc8958172005-04-08 14:53:31 +0900570}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200572static int pci_pm_resume(struct device *dev)
573{
574 struct pci_dev *pci_dev = to_pci_dev(dev);
575 struct device_driver *drv = dev->driver;
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100576 int error = 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200577
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100578 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100579 return pci_legacy_resume(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100580
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100581 error = pci_pm_default_resume(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100582
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100583 if (!error && drv && drv->pm && drv->pm->resume)
584 error = drv->pm->resume(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200585
586 return error;
587}
588
589static int pci_pm_resume_noirq(struct device *dev)
590{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100591 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200592 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200593 int error = 0;
594
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100595 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100596 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100597
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100598 pci_pm_default_resume_noirq(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100599
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100600 if (drv && drv->pm && drv->pm->resume_noirq)
601 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200602
603 return error;
604}
605
606#else /* !CONFIG_SUSPEND */
607
608#define pci_pm_suspend NULL
609#define pci_pm_suspend_noirq NULL
610#define pci_pm_resume NULL
611#define pci_pm_resume_noirq NULL
612
613#endif /* !CONFIG_SUSPEND */
614
615#ifdef CONFIG_HIBERNATION
616
617static int pci_pm_freeze(struct device *dev)
618{
619 struct pci_dev *pci_dev = to_pci_dev(dev);
620 struct device_driver *drv = dev->driver;
621 int error = 0;
622
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100623 if (pci_has_legacy_pm_support(pci_dev))
624 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100625
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100626 if (drv && drv->pm && drv->pm->freeze) {
627 error = drv->pm->freeze(dev);
628 suspend_report_result(drv->pm->freeze, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200629 }
630
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100631 if (!error)
632 pci_pm_default_suspend_generic(pci_dev);
633
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200634 return error;
635}
636
637static int pci_pm_freeze_noirq(struct device *dev)
638{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100639 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200640 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200641 int error = 0;
642
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100643 if (pci_has_legacy_pm_support(pci_dev))
644 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
645
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100646 if (drv && drv->pm && drv->pm->freeze_noirq) {
647 error = drv->pm->freeze_noirq(dev);
648 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200649 }
650
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100651 if (!error)
652 pci_pm_set_unknown_state(pci_dev);
653
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200654 return error;
655}
656
657static int pci_pm_thaw(struct device *dev)
658{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100659 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200660 struct device_driver *drv = dev->driver;
661 int error = 0;
662
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100663 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100664 return pci_legacy_resume(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100665
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100666 pci_pm_reenable_device(pci_dev);
667
668 if (drv && drv->pm && drv->pm->thaw)
669 error = drv->pm->thaw(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200670
671 return error;
672}
673
674static int pci_pm_thaw_noirq(struct device *dev)
675{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100676 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200677 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200678 int error = 0;
679
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100680 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100681 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100682
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100683 pci_update_current_state(pci_dev, PCI_D0);
684
685 if (drv && drv->pm && drv->pm->thaw_noirq)
686 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200687
688 return error;
689}
690
691static int pci_pm_poweroff(struct device *dev)
692{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100693 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200694 struct device_driver *drv = dev->driver;
695 int error = 0;
696
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100697 if (pci_has_legacy_pm_support(pci_dev))
698 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100699
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100700 if (drv && drv->pm && drv->pm->poweroff) {
701 error = drv->pm->poweroff(dev);
702 suspend_report_result(drv->pm->poweroff, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200703 }
704
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100705 if (!error)
706 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockic9b99722009-01-07 13:02:36 +0100707
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200708 return error;
709}
710
711static int pci_pm_poweroff_noirq(struct device *dev)
712{
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200713 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200714 int error = 0;
715
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100716 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
717 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
718
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100719 if (drv && drv->pm && drv->pm->poweroff_noirq) {
720 error = drv->pm->poweroff_noirq(dev);
721 suspend_report_result(drv->pm->poweroff_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200722 }
723
724 return error;
725}
726
727static int pci_pm_restore(struct device *dev)
728{
729 struct pci_dev *pci_dev = to_pci_dev(dev);
730 struct device_driver *drv = dev->driver;
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100731 int error = 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200732
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100733 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100734 return pci_legacy_resume(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100735
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100736 error = pci_pm_default_resume(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100737
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100738 if (!error && drv && drv->pm && drv->pm->restore)
739 error = drv->pm->restore(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200740
741 return error;
742}
743
744static int pci_pm_restore_noirq(struct device *dev)
745{
746 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200747 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200748 int error = 0;
749
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100750 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100751 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100752
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100753 pci_pm_default_resume_noirq(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100754
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100755 if (drv && drv->pm && drv->pm->restore_noirq)
756 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200757
758 return error;
759}
760
761#else /* !CONFIG_HIBERNATION */
762
763#define pci_pm_freeze NULL
764#define pci_pm_freeze_noirq NULL
765#define pci_pm_thaw NULL
766#define pci_pm_thaw_noirq NULL
767#define pci_pm_poweroff NULL
768#define pci_pm_poweroff_noirq NULL
769#define pci_pm_restore NULL
770#define pci_pm_restore_noirq NULL
771
772#endif /* !CONFIG_HIBERNATION */
773
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200774struct dev_pm_ops pci_dev_pm_ops = {
775 .prepare = pci_pm_prepare,
776 .complete = pci_pm_complete,
777 .suspend = pci_pm_suspend,
778 .resume = pci_pm_resume,
779 .freeze = pci_pm_freeze,
780 .thaw = pci_pm_thaw,
781 .poweroff = pci_pm_poweroff,
782 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200783 .suspend_noirq = pci_pm_suspend_noirq,
784 .resume_noirq = pci_pm_resume_noirq,
785 .freeze_noirq = pci_pm_freeze_noirq,
786 .thaw_noirq = pci_pm_thaw_noirq,
787 .poweroff_noirq = pci_pm_poweroff_noirq,
788 .restore_noirq = pci_pm_restore_noirq,
789};
790
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200791#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200792
793#else /* !CONFIG_PM_SLEEP */
794
795#define PCI_PM_OPS_PTR NULL
796
797#endif /* !CONFIG_PM_SLEEP */
798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200800 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200802 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800803 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 *
805 * Adds the driver structure to the list of registered drivers.
806 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600807 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 * no device was claimed during registration.
809 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800810int __pci_register_driver(struct pci_driver *drv, struct module *owner,
811 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
813 int error;
814
815 /* initialize common driver fields */
816 drv->driver.name = drv->name;
817 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200818 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800819 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100820
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700821 spin_lock_init(&drv->dynids.lock);
822 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823
824 /* register with core */
825 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800826 if (error)
827 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800829 error = pci_create_newid_file(drv);
830 if (error)
831 driver_unregister(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 return error;
834}
835
836/**
837 * pci_unregister_driver - unregister a pci driver
838 * @drv: the driver structure to unregister
839 *
840 * Deletes the driver structure from the list of registered PCI drivers,
841 * gives it a chance to clean up by calling its remove() function for
842 * each device it was responsible for, and marks those devices as
843 * driverless.
844 */
845
846void
847pci_unregister_driver(struct pci_driver *drv)
848{
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800849 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 driver_unregister(&drv->driver);
851 pci_free_dynids(drv);
852}
853
854static struct pci_driver pci_compat_driver = {
855 .name = "compat"
856};
857
858/**
859 * pci_dev_driver - get the pci_driver of a device
860 * @dev: the device to query
861 *
862 * Returns the appropriate pci_driver structure or %NULL if there is no
863 * registered driver for the device.
864 */
865struct pci_driver *
866pci_dev_driver(const struct pci_dev *dev)
867{
868 if (dev->driver)
869 return dev->driver;
870 else {
871 int i;
872 for(i=0; i<=PCI_ROM_RESOURCE; i++)
873 if (dev->resource[i].flags & IORESOURCE_BUSY)
874 return &pci_compat_driver;
875 }
876 return NULL;
877}
878
879/**
880 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700882 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 *
884 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700885 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 * pci_device_id structure or %NULL if there is no match.
887 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700888static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700890 struct pci_dev *pci_dev = to_pci_dev(dev);
891 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 const struct pci_device_id *found_id;
893
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700894 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if (found_id)
896 return 1;
897
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700898 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899}
900
901/**
902 * pci_dev_get - increments the reference count of the pci device structure
903 * @dev: the device being referenced
904 *
905 * Each live reference to a device should be refcounted.
906 *
907 * Drivers for PCI devices should normally record such references in
908 * their probe() methods, when they bind to a device, and release
909 * them by calling pci_dev_put(), in their disconnect() methods.
910 *
911 * A pointer to the device with the incremented reference counter is returned.
912 */
913struct pci_dev *pci_dev_get(struct pci_dev *dev)
914{
915 if (dev)
916 get_device(&dev->dev);
917 return dev;
918}
919
920/**
921 * pci_dev_put - release a use of the pci device structure
922 * @dev: device that's been disconnected
923 *
924 * Must be called when a user of a device is finished with it. When the last
925 * user of the device calls this function, the memory of the device is freed.
926 */
927void pci_dev_put(struct pci_dev *dev)
928{
929 if (dev)
930 put_device(&dev->dev);
931}
932
933#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200934int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935{
936 return -ENODEV;
937}
938#endif
939
940struct bus_type pci_bus_type = {
941 .name = "pci",
942 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100943 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000944 .probe = pci_device_probe,
945 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700946 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 .dev_attrs = pci_dev_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200948 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949};
950
951static int __init pci_driver_init(void)
952{
953 return bus_register(&pci_bus_type);
954}
955
956postcore_initcall(pci_driver_init);
957
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700958EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +0200959EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960EXPORT_SYMBOL(pci_unregister_driver);
961EXPORT_SYMBOL(pci_dev_driver);
962EXPORT_SYMBOL(pci_bus_type);
963EXPORT_SYMBOL(pci_dev_get);
964EXPORT_SYMBOL(pci_dev_put);