blob: ab1d615425a8858248b61efe4a5ed22fcfa764db [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) {
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100358 pci_dev->state_saved = false;
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 i = drv->suspend(pci_dev, state);
Andrew Morton02669492006-03-23 01:38:34 -0800361 suspend_report_result(drv->suspend, i);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100362 if (i)
363 return i;
364
365 if (pci_dev->state_saved)
366 goto Fixup;
367
368 if (WARN_ON_ONCE(pci_dev->current_state != PCI_D0))
369 goto Fixup;
Andrew Morton02669492006-03-23 01:38:34 -0800370 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100371
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100372 pci_save_state(pci_dev);
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100373 pci_dev->state_saved = true;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100374 /*
375 * This is for compatibility with existing code with legacy PM support.
376 */
377 pci_pm_set_unknown_state(pci_dev);
378
379 Fixup:
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100380 pci_fixup_device(pci_fixup_suspend, pci_dev);
381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 return i;
383}
384
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200385static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700386{
387 struct pci_dev * pci_dev = to_pci_dev(dev);
388 struct pci_driver * drv = pci_dev->driver;
389 int i = 0;
390
391 if (drv && drv->suspend_late) {
392 i = drv->suspend_late(pci_dev, state);
393 suspend_report_result(drv->suspend_late, i);
394 }
395 return i;
396}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100398static int pci_legacy_resume_early(struct device *dev)
399{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100400 struct pci_dev * pci_dev = to_pci_dev(dev);
401 struct pci_driver * drv = pci_dev->driver;
402
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100403 return drv && drv->resume_early ?
404 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100405}
406
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200407static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408{
409 struct pci_dev * pci_dev = to_pci_dev(dev);
410 struct pci_driver * drv = pci_dev->driver;
411
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100412 pci_fixup_device(pci_fixup_resume, pci_dev);
413
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100414 return drv && drv->resume ?
415 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416}
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 void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
421{
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100422 pci_restore_standard_config(pci_dev);
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100423 pci_dev->state_saved = false;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100424 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100425}
426
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100427static int pci_pm_default_resume(struct pci_dev *pci_dev)
428{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100429 pci_fixup_device(pci_fixup_resume, pci_dev);
430
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100431 if (!pci_is_bridge(pci_dev))
432 pci_enable_wake(pci_dev, PCI_D0, false);
433
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100434 return pci_pm_reenable_device(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100435}
436
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100437static void pci_pm_default_suspend_generic(struct pci_dev *pci_dev)
438{
439 /* If device is enabled at this point, disable it */
440 pci_disable_enabled_device(pci_dev);
441 /*
442 * Save state with interrupts enabled, because in principle the bus the
443 * device is on may be put into a low power state after this code runs.
444 */
445 pci_save_state(pci_dev);
446}
447
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100448static void pci_pm_default_suspend(struct pci_dev *pci_dev)
449{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100450 pci_pm_default_suspend_generic(pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100451
452 if (!pci_is_bridge(pci_dev))
453 pci_prepare_to_sleep(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100454
455 pci_fixup_device(pci_fixup_suspend, pci_dev);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100456}
457
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100458static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
459{
460 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100461 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100462 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100463
464 /*
465 * Legacy PM support is used by default, so warn if the new framework is
466 * supported as well. Drivers are supposed to support either the
467 * former, or the latter, but not both at the same time.
468 */
469 WARN_ON(ret && drv->driver.pm);
470
471 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100472}
473
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100474/* New power management framework */
475
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200476static int pci_pm_prepare(struct device *dev)
477{
478 struct device_driver *drv = dev->driver;
479 int error = 0;
480
481 if (drv && drv->pm && drv->pm->prepare)
482 error = drv->pm->prepare(dev);
483
484 return error;
485}
486
487static void pci_pm_complete(struct device *dev)
488{
489 struct device_driver *drv = dev->driver;
490
491 if (drv && drv->pm && drv->pm->complete)
492 drv->pm->complete(dev);
493}
494
495#ifdef CONFIG_SUSPEND
496
497static int pci_pm_suspend(struct device *dev)
498{
499 struct pci_dev *pci_dev = to_pci_dev(dev);
500 struct device_driver *drv = dev->driver;
501 int error = 0;
502
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100503 if (pci_has_legacy_pm_support(pci_dev))
504 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100505
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100506 if (drv && drv->pm && drv->pm->suspend) {
507 error = drv->pm->suspend(dev);
508 suspend_report_result(drv->pm->suspend, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200509 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100510
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100511 if (!error)
512 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200513
514 return error;
515}
516
517static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900518{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100519 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200520 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200521 int error = 0;
Greg KHc8958172005-04-08 14:53:31 +0900522
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100523 if (pci_has_legacy_pm_support(pci_dev))
524 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
525
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100526 if (drv && drv->pm && drv->pm->suspend_noirq) {
527 error = drv->pm->suspend_noirq(dev);
528 suspend_report_result(drv->pm->suspend_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200529 }
530
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100531 if (!error)
532 pci_pm_set_unknown_state(pci_dev);
533
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200534 return error;
Greg KHc8958172005-04-08 14:53:31 +0900535}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200537static int pci_pm_resume_noirq(struct device *dev)
538{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100539 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200540 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200541 int error = 0;
542
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100543 pci_pm_default_resume_noirq(pci_dev);
544
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100545 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100546 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100547
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100548 if (drv && drv->pm && drv->pm->resume_noirq)
549 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200550
551 return error;
552}
553
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100554static int pci_pm_resume(struct device *dev)
555{
556 struct pci_dev *pci_dev = to_pci_dev(dev);
557 struct device_driver *drv = dev->driver;
558 int error = 0;
559
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100560 /*
561 * This is necessary for the suspend error path in which resume is
562 * called without restoring the standard config registers of the device.
563 */
564 if (pci_dev->state_saved)
565 pci_restore_standard_config(pci_dev);
566
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100567 if (pci_has_legacy_pm_support(pci_dev))
568 return pci_legacy_resume(dev);
569
570 error = pci_pm_default_resume(pci_dev);
571
572 if (!error && drv && drv->pm && drv->pm->resume)
573 error = drv->pm->resume(dev);
574
575 return error;
576}
577
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200578#else /* !CONFIG_SUSPEND */
579
580#define pci_pm_suspend NULL
581#define pci_pm_suspend_noirq NULL
582#define pci_pm_resume NULL
583#define pci_pm_resume_noirq NULL
584
585#endif /* !CONFIG_SUSPEND */
586
587#ifdef CONFIG_HIBERNATION
588
589static int pci_pm_freeze(struct device *dev)
590{
591 struct pci_dev *pci_dev = to_pci_dev(dev);
592 struct device_driver *drv = dev->driver;
593 int error = 0;
594
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100595 if (pci_has_legacy_pm_support(pci_dev))
596 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100597
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100598 if (drv && drv->pm && drv->pm->freeze) {
599 error = drv->pm->freeze(dev);
600 suspend_report_result(drv->pm->freeze, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200601 }
602
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100603 if (!error)
604 pci_pm_default_suspend_generic(pci_dev);
605
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200606 return error;
607}
608
609static int pci_pm_freeze_noirq(struct device *dev)
610{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100611 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200612 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200613 int error = 0;
614
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100615 if (pci_has_legacy_pm_support(pci_dev))
616 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
617
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100618 if (drv && drv->pm && drv->pm->freeze_noirq) {
619 error = drv->pm->freeze_noirq(dev);
620 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200621 }
622
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100623 if (!error)
624 pci_pm_set_unknown_state(pci_dev);
625
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200626 return error;
627}
628
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200629static int pci_pm_thaw_noirq(struct device *dev)
630{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100631 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200632 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200633 int error = 0;
634
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100635 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100636 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100637
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100638 pci_update_current_state(pci_dev, PCI_D0);
639
640 if (drv && drv->pm && drv->pm->thaw_noirq)
641 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200642
643 return error;
644}
645
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100646static int pci_pm_thaw(struct device *dev)
647{
648 struct pci_dev *pci_dev = to_pci_dev(dev);
649 struct device_driver *drv = dev->driver;
650 int error = 0;
651
652 if (pci_has_legacy_pm_support(pci_dev))
653 return pci_legacy_resume(dev);
654
655 pci_pm_reenable_device(pci_dev);
656
657 if (drv && drv->pm && drv->pm->thaw)
658 error = drv->pm->thaw(dev);
659
660 return error;
661}
662
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200663static int pci_pm_poweroff(struct device *dev)
664{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100665 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200666 struct device_driver *drv = dev->driver;
667 int error = 0;
668
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100669 if (pci_has_legacy_pm_support(pci_dev))
670 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100671
Rafael J. Wysocki545ffd52009-01-22 23:36:56 +0100672 if (!drv || !drv->pm)
673 return 0;
674
675 if (drv->pm->poweroff) {
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100676 error = drv->pm->poweroff(dev);
677 suspend_report_result(drv->pm->poweroff, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200678 }
679
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100680 if (!error)
681 pci_pm_default_suspend(pci_dev);
Rafael J. Wysockic9b99722009-01-07 13:02:36 +0100682
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200683 return error;
684}
685
686static int pci_pm_poweroff_noirq(struct device *dev)
687{
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200688 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200689 int error = 0;
690
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100691 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
692 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
693
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100694 if (drv && drv->pm && drv->pm->poweroff_noirq) {
695 error = drv->pm->poweroff_noirq(dev);
696 suspend_report_result(drv->pm->poweroff_noirq, error);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200697 }
698
699 return error;
700}
701
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200702static int pci_pm_restore_noirq(struct device *dev)
703{
704 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200705 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200706 int error = 0;
707
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100708 pci_pm_default_resume_noirq(pci_dev);
709
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100710 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100711 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100712
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100713 if (drv && drv->pm && drv->pm->restore_noirq)
714 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200715
716 return error;
717}
718
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100719static int pci_pm_restore(struct device *dev)
720{
721 struct pci_dev *pci_dev = to_pci_dev(dev);
722 struct device_driver *drv = dev->driver;
723 int error = 0;
724
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100725 /*
726 * This is necessary for the hibernation error path in which restore is
727 * called without restoring the standard config registers of the device.
728 */
729 if (pci_dev->state_saved)
730 pci_restore_standard_config(pci_dev);
731
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100732 if (pci_has_legacy_pm_support(pci_dev))
733 return pci_legacy_resume(dev);
734
735 error = pci_pm_default_resume(pci_dev);
736
737 if (!error && drv && drv->pm && drv->pm->restore)
738 error = drv->pm->restore(dev);
739
740 return error;
741}
742
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200743#else /* !CONFIG_HIBERNATION */
744
745#define pci_pm_freeze NULL
746#define pci_pm_freeze_noirq NULL
747#define pci_pm_thaw NULL
748#define pci_pm_thaw_noirq NULL
749#define pci_pm_poweroff NULL
750#define pci_pm_poweroff_noirq NULL
751#define pci_pm_restore NULL
752#define pci_pm_restore_noirq NULL
753
754#endif /* !CONFIG_HIBERNATION */
755
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200756struct dev_pm_ops pci_dev_pm_ops = {
757 .prepare = pci_pm_prepare,
758 .complete = pci_pm_complete,
759 .suspend = pci_pm_suspend,
760 .resume = pci_pm_resume,
761 .freeze = pci_pm_freeze,
762 .thaw = pci_pm_thaw,
763 .poweroff = pci_pm_poweroff,
764 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200765 .suspend_noirq = pci_pm_suspend_noirq,
766 .resume_noirq = pci_pm_resume_noirq,
767 .freeze_noirq = pci_pm_freeze_noirq,
768 .thaw_noirq = pci_pm_thaw_noirq,
769 .poweroff_noirq = pci_pm_poweroff_noirq,
770 .restore_noirq = pci_pm_restore_noirq,
771};
772
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200773#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200774
775#else /* !CONFIG_PM_SLEEP */
776
777#define PCI_PM_OPS_PTR NULL
778
779#endif /* !CONFIG_PM_SLEEP */
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781/**
Laurent riffard863b18f2005-10-27 23:12:54 +0200782 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +0200784 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -0800785 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 *
787 * Adds the driver structure to the list of registered drivers.
788 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -0600789 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 * no device was claimed during registration.
791 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800792int __pci_register_driver(struct pci_driver *drv, struct module *owner,
793 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794{
795 int error;
796
797 /* initialize common driver fields */
798 drv->driver.name = drv->name;
799 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +0200800 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -0800801 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +0100802
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700803 spin_lock_init(&drv->dynids.lock);
804 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
806 /* register with core */
807 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800808 if (error)
809 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Akinobu Mita50bf14b2006-11-08 19:53:59 -0800811 error = pci_create_newid_file(drv);
812 if (error)
813 driver_unregister(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
815 return error;
816}
817
818/**
819 * pci_unregister_driver - unregister a pci driver
820 * @drv: the driver structure to unregister
821 *
822 * Deletes the driver structure from the list of registered PCI drivers,
823 * gives it a chance to clean up by calling its remove() function for
824 * each device it was responsible for, and marks those devices as
825 * driverless.
826 */
827
828void
829pci_unregister_driver(struct pci_driver *drv)
830{
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800831 pci_remove_newid_file(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 driver_unregister(&drv->driver);
833 pci_free_dynids(drv);
834}
835
836static struct pci_driver pci_compat_driver = {
837 .name = "compat"
838};
839
840/**
841 * pci_dev_driver - get the pci_driver of a device
842 * @dev: the device to query
843 *
844 * Returns the appropriate pci_driver structure or %NULL if there is no
845 * registered driver for the device.
846 */
847struct pci_driver *
848pci_dev_driver(const struct pci_dev *dev)
849{
850 if (dev->driver)
851 return dev->driver;
852 else {
853 int i;
854 for(i=0; i<=PCI_ROM_RESOURCE; i++)
855 if (dev->resource[i].flags & IORESOURCE_BUSY)
856 return &pci_compat_driver;
857 }
858 return NULL;
859}
860
861/**
862 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700864 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 *
866 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700867 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 * pci_device_id structure or %NULL if there is no match.
869 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700870static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700872 struct pci_dev *pci_dev = to_pci_dev(dev);
873 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 const struct pci_device_id *found_id;
875
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700876 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 if (found_id)
878 return 1;
879
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700880 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881}
882
883/**
884 * pci_dev_get - increments the reference count of the pci device structure
885 * @dev: the device being referenced
886 *
887 * Each live reference to a device should be refcounted.
888 *
889 * Drivers for PCI devices should normally record such references in
890 * their probe() methods, when they bind to a device, and release
891 * them by calling pci_dev_put(), in their disconnect() methods.
892 *
893 * A pointer to the device with the incremented reference counter is returned.
894 */
895struct pci_dev *pci_dev_get(struct pci_dev *dev)
896{
897 if (dev)
898 get_device(&dev->dev);
899 return dev;
900}
901
902/**
903 * pci_dev_put - release a use of the pci device structure
904 * @dev: device that's been disconnected
905 *
906 * Must be called when a user of a device is finished with it. When the last
907 * user of the device calls this function, the memory of the device is freed.
908 */
909void pci_dev_put(struct pci_dev *dev)
910{
911 if (dev)
912 put_device(&dev->dev);
913}
914
915#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200916int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917{
918 return -ENODEV;
919}
920#endif
921
922struct bus_type pci_bus_type = {
923 .name = "pci",
924 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +0100925 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +0000926 .probe = pci_device_probe,
927 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700928 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 .dev_attrs = pci_dev_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200930 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931};
932
933static int __init pci_driver_init(void)
934{
935 return bus_register(&pci_bus_type);
936}
937
938postcore_initcall(pci_driver_init);
939
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700940EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +0200941EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942EXPORT_SYMBOL(pci_unregister_driver);
943EXPORT_SYMBOL(pci_dev_driver);
944EXPORT_SYMBOL(pci_bus_type);
945EXPORT_SYMBOL(pci_dev_get);
946EXPORT_SYMBOL(pci_dev_put);