blob: 2e76945a1cd880f05023e162ba485b0e2e7b35c1 [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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 return i;
369}
370
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200371static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700372{
373 struct pci_dev * pci_dev = to_pci_dev(dev);
374 struct pci_driver * drv = pci_dev->driver;
375 int i = 0;
376
377 if (drv && drv->suspend_late) {
378 i = drv->suspend_late(pci_dev, state);
379 suspend_report_result(drv->suspend_late, i);
380 }
381 return i;
382}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200384static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385{
Jean Delvare8d92bc22006-04-18 14:49:56 +0200386 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 struct pci_dev * pci_dev = to_pci_dev(dev);
388 struct pci_driver * drv = pci_dev->driver;
389
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100390 if (drv && drv->resume) {
Jean Delvare8d92bc22006-04-18 14:49:56 +0200391 error = drv->resume(pci_dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100392 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100393 /* restore the PCI config space */
394 pci_restore_state(pci_dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100395 error = pci_pm_reenable_device(pci_dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100396 }
Jean Delvare8d92bc22006-04-18 14:49:56 +0200397 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398}
399
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200400static int pci_legacy_resume_early(struct device *dev)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700401{
402 int error = 0;
403 struct pci_dev * pci_dev = to_pci_dev(dev);
404 struct pci_driver * drv = pci_dev->driver;
405
406 if (drv && drv->resume_early)
407 error = drv->resume_early(pci_dev);
408 return error;
409}
410
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100411/* Auxiliary functions used by the new power management framework */
412
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100413static int pci_restore_standard_config(struct pci_dev *pci_dev)
414{
415 struct pci_dev *parent = pci_dev->bus->self;
416 int error = 0;
417
418 /* Check if the device's bus is operational */
419 if (!parent || parent->current_state == PCI_D0) {
420 pci_restore_state(pci_dev);
421 pci_update_current_state(pci_dev, PCI_D0);
422 } else {
423 dev_warn(&pci_dev->dev, "unable to restore config, "
424 "bridge %s in low power state D%d\n", pci_name(parent),
425 parent->current_state);
426 pci_dev->current_state = PCI_UNKNOWN;
427 error = -EAGAIN;
428 }
429
430 return error;
431}
432
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100433static bool pci_is_bridge(struct pci_dev *pci_dev)
434{
435 return !!(pci_dev->subordinate);
436}
437
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100438static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
439{
440 if (pci_restore_standard_config(pci_dev))
441 pci_fixup_device(pci_fixup_resume_early, pci_dev);
442}
443
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100444static int pci_pm_default_resume(struct pci_dev *pci_dev)
445{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100446 /*
447 * pci_restore_standard_config() should have been called once already,
448 * but it would have failed if the device's parent bridge had not been
449 * in power state D0 at that time. Check it and try again if necessary.
450 */
451 if (pci_dev->current_state == PCI_UNKNOWN) {
452 int error = pci_restore_standard_config(pci_dev);
453 if (error)
454 return error;
455 }
456
457 pci_fixup_device(pci_fixup_resume, pci_dev);
458
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100459 if (!pci_is_bridge(pci_dev))
460 pci_enable_wake(pci_dev, PCI_D0, false);
461
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100462 return pci_pm_reenable_device(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100463}
464
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100465static void pci_pm_default_suspend_generic(struct pci_dev *pci_dev)
466{
467 /* If device is enabled at this point, disable it */
468 pci_disable_enabled_device(pci_dev);
469 /*
470 * Save state with interrupts enabled, because in principle the bus the
471 * device is on may be put into a low power state after this code runs.
472 */
473 pci_save_state(pci_dev);
474}
475
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100476static void pci_pm_default_suspend(struct pci_dev *pci_dev)
477{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100478 pci_pm_default_suspend_generic(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100479
480 if (!pci_is_bridge(pci_dev))
481 pci_prepare_to_sleep(pci_dev);
482}
483
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100484static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
485{
486 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100487 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100488 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100489
490 /*
491 * Legacy PM support is used by default, so warn if the new framework is
492 * supported as well. Drivers are supposed to support either the
493 * former, or the latter, but not both at the same time.
494 */
495 WARN_ON(ret && drv->driver.pm);
496
497 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100498}
499
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100500/* New power management framework */
501
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200502static int pci_pm_prepare(struct device *dev)
503{
504 struct device_driver *drv = dev->driver;
505 int error = 0;
506
507 if (drv && drv->pm && drv->pm->prepare)
508 error = drv->pm->prepare(dev);
509
510 return error;
511}
512
513static void pci_pm_complete(struct device *dev)
514{
515 struct device_driver *drv = dev->driver;
516
517 if (drv && drv->pm && drv->pm->complete)
518 drv->pm->complete(dev);
519}
520
521#ifdef CONFIG_SUSPEND
522
523static int pci_pm_suspend(struct device *dev)
524{
525 struct pci_dev *pci_dev = to_pci_dev(dev);
526 struct device_driver *drv = dev->driver;
527 int error = 0;
528
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100529 if (pci_has_legacy_pm_support(pci_dev)) {
530 error = pci_legacy_suspend(dev, PMSG_SUSPEND);
531 goto Exit;
532 }
533
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200534 if (drv && drv->pm) {
535 if (drv->pm->suspend) {
536 error = drv->pm->suspend(dev);
537 suspend_report_result(drv->pm->suspend, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200538 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100539 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100540 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200541 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100542
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100543 Exit:
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200544 pci_fixup_device(pci_fixup_suspend, pci_dev);
545
546 return error;
547}
548
549static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900550{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100551 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200552 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200553 int error = 0;
Greg KHc8958172005-04-08 14:53:31 +0900554
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100555 if (pci_has_legacy_pm_support(pci_dev))
556 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
557
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200558 if (drv && drv->pm) {
559 if (drv->pm->suspend_noirq) {
560 error = drv->pm->suspend_noirq(dev);
561 suspend_report_result(drv->pm->suspend_noirq, error);
562 }
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100563 } else {
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100564 pci_pm_set_unknown_state(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200565 }
566
567 return error;
Greg KHc8958172005-04-08 14:53:31 +0900568}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200570static int pci_pm_resume(struct device *dev)
571{
572 struct pci_dev *pci_dev = to_pci_dev(dev);
573 struct device_driver *drv = dev->driver;
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100574 int error = 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200575
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100576 if (pci_has_legacy_pm_support(pci_dev)) {
577 pci_fixup_device(pci_fixup_resume, pci_dev);
578 return pci_legacy_resume(dev);
579 }
580
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200581 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100582 pci_fixup_device(pci_fixup_resume, pci_dev);
583
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100584 if (drv->pm->resume)
585 error = drv->pm->resume(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100586 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100587 error = pci_pm_default_resume(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200588 }
589
590 return error;
591}
592
593static int pci_pm_resume_noirq(struct device *dev)
594{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100595 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200596 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200597 int error = 0;
598
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100599 if (pci_has_legacy_pm_support(pci_dev)) {
600 pci_fixup_device(pci_fixup_resume_early, pci_dev);
601 return pci_legacy_resume_early(dev);
602 }
603
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200604 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100605 pci_fixup_device(pci_fixup_resume_early, pci_dev);
606
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200607 if (drv->pm->resume_noirq)
608 error = drv->pm->resume_noirq(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100609 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100610 pci_pm_default_resume_noirq(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200611 }
612
613 return error;
614}
615
616#else /* !CONFIG_SUSPEND */
617
618#define pci_pm_suspend NULL
619#define pci_pm_suspend_noirq NULL
620#define pci_pm_resume NULL
621#define pci_pm_resume_noirq NULL
622
623#endif /* !CONFIG_SUSPEND */
624
625#ifdef CONFIG_HIBERNATION
626
627static int pci_pm_freeze(struct device *dev)
628{
629 struct pci_dev *pci_dev = to_pci_dev(dev);
630 struct device_driver *drv = dev->driver;
631 int error = 0;
632
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100633 if (pci_has_legacy_pm_support(pci_dev)) {
634 error = pci_legacy_suspend(dev, PMSG_FREEZE);
635 pci_fixup_device(pci_fixup_suspend, pci_dev);
636 return error;
637 }
638
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200639 if (drv && drv->pm) {
640 if (drv->pm->freeze) {
641 error = drv->pm->freeze(dev);
642 suspend_report_result(drv->pm->freeze, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200643 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100644 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100645 pci_pm_default_suspend_generic(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200646 }
647
648 return error;
649}
650
651static int pci_pm_freeze_noirq(struct device *dev)
652{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100653 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200654 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200655 int error = 0;
656
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100657 if (pci_has_legacy_pm_support(pci_dev))
658 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
659
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200660 if (drv && drv->pm) {
661 if (drv->pm->freeze_noirq) {
662 error = drv->pm->freeze_noirq(dev);
663 suspend_report_result(drv->pm->freeze_noirq, error);
664 }
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100665 } else {
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100666 pci_pm_set_unknown_state(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200667 }
668
669 return error;
670}
671
672static int pci_pm_thaw(struct device *dev)
673{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100674 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200675 struct device_driver *drv = dev->driver;
676 int error = 0;
677
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100678 if (pci_has_legacy_pm_support(pci_dev)) {
679 pci_fixup_device(pci_fixup_resume, pci_dev);
680 return pci_legacy_resume(dev);
681 }
682
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200683 if (drv && drv->pm) {
684 if (drv->pm->thaw)
685 error = drv->pm->thaw(dev);
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100686 } else {
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100687 pci_pm_reenable_device(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200688 }
689
690 return error;
691}
692
693static int pci_pm_thaw_noirq(struct device *dev)
694{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100695 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200696 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200697 int error = 0;
698
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100699 if (pci_has_legacy_pm_support(pci_dev)) {
700 pci_fixup_device(pci_fixup_resume_early, to_pci_dev(dev));
701 return pci_legacy_resume_early(dev);
702 }
703
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200704 if (drv && drv->pm) {
705 if (drv->pm->thaw_noirq)
706 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100707 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100708 pci_update_current_state(pci_dev, PCI_D0);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200709 }
710
711 return error;
712}
713
714static int pci_pm_poweroff(struct device *dev)
715{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100716 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200717 struct device_driver *drv = dev->driver;
718 int error = 0;
719
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100720 if (pci_has_legacy_pm_support(pci_dev)) {
721 error = pci_legacy_suspend(dev, PMSG_HIBERNATE);
722 goto Exit;
723 }
724
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200725 if (drv && drv->pm) {
726 if (drv->pm->poweroff) {
727 error = drv->pm->poweroff(dev);
728 suspend_report_result(drv->pm->poweroff, error);
729 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100730 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100731 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200732 }
733
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100734 Exit:
Rafael J. Wysockic9b99722009-01-07 13:02:36 +0100735 pci_fixup_device(pci_fixup_suspend, pci_dev);
736
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200737 return error;
738}
739
740static int pci_pm_poweroff_noirq(struct device *dev)
741{
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200742 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200743 int error = 0;
744
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100745 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
746 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
747
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200748 if (drv && drv->pm) {
749 if (drv->pm->poweroff_noirq) {
750 error = drv->pm->poweroff_noirq(dev);
751 suspend_report_result(drv->pm->poweroff_noirq, error);
752 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200753 }
754
755 return error;
756}
757
758static int pci_pm_restore(struct device *dev)
759{
760 struct pci_dev *pci_dev = to_pci_dev(dev);
761 struct device_driver *drv = dev->driver;
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100762 int error = 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200763
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100764 if (pci_has_legacy_pm_support(pci_dev)) {
765 pci_fixup_device(pci_fixup_resume, pci_dev);
766 return pci_legacy_resume(dev);
767 }
768
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200769 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100770 pci_fixup_device(pci_fixup_resume, pci_dev);
771
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100772 if (drv->pm->restore)
773 error = drv->pm->restore(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100774 } else {
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100775 error = pci_pm_default_resume(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200776 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200777
778 return error;
779}
780
781static int pci_pm_restore_noirq(struct device *dev)
782{
783 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200784 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200785 int error = 0;
786
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100787 if (pci_has_legacy_pm_support(pci_dev)) {
788 pci_fixup_device(pci_fixup_resume_early, pci_dev);
789 return pci_legacy_resume_early(dev);
790 }
791
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200792 if (drv && drv->pm) {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100793 pci_fixup_device(pci_fixup_resume_early, pci_dev);
794
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200795 if (drv->pm->restore_noirq)
796 error = drv->pm->restore_noirq(dev);
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100797 } else {
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100798 pci_pm_default_resume_noirq(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200799 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200800
801 return error;
802}
803
804#else /* !CONFIG_HIBERNATION */
805
806#define pci_pm_freeze NULL
807#define pci_pm_freeze_noirq NULL
808#define pci_pm_thaw NULL
809#define pci_pm_thaw_noirq NULL
810#define pci_pm_poweroff NULL
811#define pci_pm_poweroff_noirq NULL
812#define pci_pm_restore NULL
813#define pci_pm_restore_noirq NULL
814
815#endif /* !CONFIG_HIBERNATION */
816
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200817struct dev_pm_ops pci_dev_pm_ops = {
818 .prepare = pci_pm_prepare,
819 .complete = pci_pm_complete,
820 .suspend = pci_pm_suspend,
821 .resume = pci_pm_resume,
822 .freeze = pci_pm_freeze,
823 .thaw = pci_pm_thaw,
824 .poweroff = pci_pm_poweroff,
825 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200826 .suspend_noirq = pci_pm_suspend_noirq,
827 .resume_noirq = pci_pm_resume_noirq,
828 .freeze_noirq = pci_pm_freeze_noirq,
829 .thaw_noirq = pci_pm_thaw_noirq,
830 .poweroff_noirq = pci_pm_poweroff_noirq,
831 .restore_noirq = pci_pm_restore_noirq,
832};
833
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200834#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200835
836#else /* !CONFIG_PM_SLEEP */
837
838#define PCI_PM_OPS_PTR NULL
839
840#endif /* !CONFIG_PM_SLEEP */
841
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200843 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200845 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800846 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 *
848 * Adds the driver structure to the list of registered drivers.
849 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600850 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 * no device was claimed during registration.
852 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800853int __pci_register_driver(struct pci_driver *drv, struct module *owner,
854 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855{
856 int error;
857
858 /* initialize common driver fields */
859 drv->driver.name = drv->name;
860 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200861 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800862 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100863
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700864 spin_lock_init(&drv->dynids.lock);
865 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
867 /* register with core */
868 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800869 if (error)
870 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800872 error = pci_create_newid_file(drv);
873 if (error)
874 driver_unregister(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875
876 return error;
877}
878
879/**
880 * pci_unregister_driver - unregister a pci driver
881 * @drv: the driver structure to unregister
882 *
883 * Deletes the driver structure from the list of registered PCI drivers,
884 * gives it a chance to clean up by calling its remove() function for
885 * each device it was responsible for, and marks those devices as
886 * driverless.
887 */
888
889void
890pci_unregister_driver(struct pci_driver *drv)
891{
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800892 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 driver_unregister(&drv->driver);
894 pci_free_dynids(drv);
895}
896
897static struct pci_driver pci_compat_driver = {
898 .name = "compat"
899};
900
901/**
902 * pci_dev_driver - get the pci_driver of a device
903 * @dev: the device to query
904 *
905 * Returns the appropriate pci_driver structure or %NULL if there is no
906 * registered driver for the device.
907 */
908struct pci_driver *
909pci_dev_driver(const struct pci_dev *dev)
910{
911 if (dev->driver)
912 return dev->driver;
913 else {
914 int i;
915 for(i=0; i<=PCI_ROM_RESOURCE; i++)
916 if (dev->resource[i].flags & IORESOURCE_BUSY)
917 return &pci_compat_driver;
918 }
919 return NULL;
920}
921
922/**
923 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700925 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 *
927 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700928 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 * pci_device_id structure or %NULL if there is no match.
930 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700931static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700933 struct pci_dev *pci_dev = to_pci_dev(dev);
934 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 const struct pci_device_id *found_id;
936
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700937 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 if (found_id)
939 return 1;
940
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700941 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942}
943
944/**
945 * pci_dev_get - increments the reference count of the pci device structure
946 * @dev: the device being referenced
947 *
948 * Each live reference to a device should be refcounted.
949 *
950 * Drivers for PCI devices should normally record such references in
951 * their probe() methods, when they bind to a device, and release
952 * them by calling pci_dev_put(), in their disconnect() methods.
953 *
954 * A pointer to the device with the incremented reference counter is returned.
955 */
956struct pci_dev *pci_dev_get(struct pci_dev *dev)
957{
958 if (dev)
959 get_device(&dev->dev);
960 return dev;
961}
962
963/**
964 * pci_dev_put - release a use of the pci device structure
965 * @dev: device that's been disconnected
966 *
967 * Must be called when a user of a device is finished with it. When the last
968 * user of the device calls this function, the memory of the device is freed.
969 */
970void pci_dev_put(struct pci_dev *dev)
971{
972 if (dev)
973 put_device(&dev->dev);
974}
975
976#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200977int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978{
979 return -ENODEV;
980}
981#endif
982
983struct bus_type pci_bus_type = {
984 .name = "pci",
985 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100986 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000987 .probe = pci_device_probe,
988 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700989 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 .dev_attrs = pci_dev_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200991 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992};
993
994static int __init pci_driver_init(void)
995{
996 return bus_register(&pci_bus_type);
997}
998
999postcore_initcall(pci_driver_init);
1000
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001001EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001002EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003EXPORT_SYMBOL(pci_unregister_driver);
1004EXPORT_SYMBOL(pci_dev_driver);
1005EXPORT_SYMBOL(pci_bus_type);
1006EXPORT_SYMBOL(pci_dev_get);
1007EXPORT_SYMBOL(pci_dev_put);