blob: 98f7b9b89507e05a331cceacc8defad13e7d9534 [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>
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +010020#include <linux/pm_runtime.h>
Rafael J. Wysockieea3fc032011-07-06 10:51:40 +020021#include <linux/suspend.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "pci.h"
23
Greg Kroah-Hartman75865852005-06-30 02:18:12 -070024struct pci_dynid {
25 struct list_head node;
26 struct pci_device_id id;
27};
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29/**
Tejun Heo9dba9102009-09-03 15:26:36 +090030 * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
31 * @drv: target pci driver
32 * @vendor: PCI vendor ID
33 * @device: PCI device ID
34 * @subvendor: PCI subvendor ID
35 * @subdevice: PCI subdevice ID
36 * @class: PCI class
37 * @class_mask: PCI class mask
38 * @driver_data: private driver data
39 *
40 * Adds a new dynamic pci device ID to this driver and causes the
41 * driver to probe for all devices again. @drv must have been
42 * registered prior to calling this function.
43 *
44 * CONTEXT:
45 * Does GFP_KERNEL allocation.
46 *
47 * RETURNS:
48 * 0 on success, -errno on failure.
49 */
50int pci_add_dynid(struct pci_driver *drv,
51 unsigned int vendor, unsigned int device,
52 unsigned int subvendor, unsigned int subdevice,
53 unsigned int class, unsigned int class_mask,
54 unsigned long driver_data)
55{
56 struct pci_dynid *dynid;
57 int retval;
58
59 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
60 if (!dynid)
61 return -ENOMEM;
62
63 dynid->id.vendor = vendor;
64 dynid->id.device = device;
65 dynid->id.subvendor = subvendor;
66 dynid->id.subdevice = subdevice;
67 dynid->id.class = class;
68 dynid->id.class_mask = class_mask;
69 dynid->id.driver_data = driver_data;
70
71 spin_lock(&drv->dynids.lock);
72 list_add_tail(&dynid->node, &drv->dynids.list);
73 spin_unlock(&drv->dynids.lock);
74
Tejun Heo9dba9102009-09-03 15:26:36 +090075 retval = driver_attach(&drv->driver);
Tejun Heo9dba9102009-09-03 15:26:36 +090076
77 return retval;
78}
79
80static void pci_free_dynids(struct pci_driver *drv)
81{
82 struct pci_dynid *dynid, *n;
83
84 spin_lock(&drv->dynids.lock);
85 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
86 list_del(&dynid->node);
87 kfree(dynid);
88 }
89 spin_unlock(&drv->dynids.lock);
90}
91
Tejun Heo9dba9102009-09-03 15:26:36 +090092/**
93 * store_new_id - sysfs frontend to pci_add_dynid()
Randy Dunlap8f7020d2005-10-23 11:57:38 -070094 * @driver: target device driver
95 * @buf: buffer for scanning device ID data
96 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 *
Tejun Heo9dba9102009-09-03 15:26:36 +090098 * Allow PCI IDs to be added to an existing driver via sysfs.
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -0700100static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101store_new_id(struct device_driver *driver, const char *buf, size_t count)
102{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200104 const struct pci_device_id *ids = pdrv->id_table;
Jean Delvare6ba18632007-04-07 17:21:28 +0200105 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 subdevice=PCI_ANY_ID, class=0, class_mask=0;
107 unsigned long driver_data=0;
108 int fields=0;
Tejun Heo9dba9102009-09-03 15:26:36 +0900109 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200111 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 &vendor, &device, &subvendor, &subdevice,
113 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +0200114 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return -EINVAL;
116
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200117 /* Only accept driver_data values that match an existing id_table
118 entry */
Chris Wright2debb4d2008-11-25 19:36:10 -0800119 if (ids) {
120 retval = -EINVAL;
121 while (ids->vendor || ids->subvendor || ids->class_mask) {
122 if (driver_data == ids->driver_data) {
123 retval = 0;
124 break;
125 }
126 ids++;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200127 }
Chris Wright2debb4d2008-11-25 19:36:10 -0800128 if (retval) /* No match */
129 return retval;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200130 }
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200131
Tejun Heo9dba9102009-09-03 15:26:36 +0900132 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
133 class, class_mask, driver_data);
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700134 if (retval)
135 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 return count;
137}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Chris Wright09943752009-02-23 21:52:23 -0800139/**
140 * store_remove_id - remove a PCI device ID from this driver
141 * @driver: target device driver
142 * @buf: buffer for scanning device ID data
143 * @count: input size
144 *
145 * Removes a dynamic pci device ID to this driver.
146 */
147static ssize_t
148store_remove_id(struct device_driver *driver, const char *buf, size_t count)
149{
150 struct pci_dynid *dynid, *n;
151 struct pci_driver *pdrv = to_pci_driver(driver);
152 __u32 vendor, device, subvendor = PCI_ANY_ID,
153 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
154 int fields = 0;
155 int retval = -ENODEV;
156
157 fields = sscanf(buf, "%x %x %x %x %x %x",
158 &vendor, &device, &subvendor, &subdevice,
159 &class, &class_mask);
160 if (fields < 2)
161 return -EINVAL;
162
163 spin_lock(&pdrv->dynids.lock);
164 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
165 struct pci_device_id *id = &dynid->id;
166 if ((id->vendor == vendor) &&
167 (id->device == device) &&
168 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
169 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
170 !((id->class ^ class) & class_mask)) {
171 list_del(&dynid->node);
172 kfree(dynid);
173 retval = 0;
174 break;
175 }
176 }
177 spin_unlock(&pdrv->dynids.lock);
178
179 if (retval)
180 return retval;
181 return count;
182}
Chris Wright09943752009-02-23 21:52:23 -0800183
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +0400184static struct driver_attribute pci_drv_attrs[] = {
185 __ATTR(new_id, S_IWUSR, NULL, store_new_id),
186 __ATTR(remove_id, S_IWUSR, NULL, store_remove_id),
187 __ATTR_NULL,
188};
Alan Sterned283e92012-01-24 14:35:13 -0500189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700191 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700193 * @dev: the PCI device structure to match against.
194 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700196 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700198 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200199 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700200 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700202const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
203 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700205 if (ids) {
206 while (ids->vendor || ids->subvendor || ids->class_mask) {
207 if (pci_match_one_device(ids, dev))
208 return ids;
209 ids++;
210 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 }
212 return NULL;
213}
214
215/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800216 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700217 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200218 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700219 *
220 * Used by a driver to check whether a PCI device present in the
221 * system is in its list of supported devices. Returns the matching
222 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200224static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
225 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700226{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700227 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Russell King7461b602006-11-29 21:18:04 +0000229 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700230 spin_lock(&drv->dynids.lock);
231 list_for_each_entry(dynid, &drv->dynids.list, node) {
232 if (pci_match_one_device(&dynid->id, dev)) {
233 spin_unlock(&drv->dynids.lock);
234 return &dynid->id;
235 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700237 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000238
239 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240}
241
Rusty Russell873392c2008-12-31 23:54:56 +1030242struct drv_dev_and_id {
243 struct pci_driver *drv;
244 struct pci_dev *dev;
245 const struct pci_device_id *id;
246};
247
248static long local_pci_probe(void *_ddi)
249{
250 struct drv_dev_and_id *ddi = _ddi;
Huang Ying967577b2012-11-20 16:08:22 +0800251 struct pci_dev *pci_dev = ddi->dev;
252 struct pci_driver *pci_drv = ddi->drv;
253 struct device *dev = &pci_dev->dev;
Alan Sternf3ec4f82010-06-08 15:23:51 -0400254 int rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030255
Huang Ying967577b2012-11-20 16:08:22 +0800256 /*
257 * Unbound PCI devices are always put in D0, regardless of
258 * runtime PM status. During probe, the device is set to
259 * active and the usage count is incremented. If the driver
260 * supports runtime PM, it should call pm_runtime_put_noidle()
261 * in its probe routine and pm_runtime_get_noresume() in its
262 * remove routine.
Alan Sternf3ec4f82010-06-08 15:23:51 -0400263 */
Huang Ying967577b2012-11-20 16:08:22 +0800264 pm_runtime_get_sync(dev);
265 pci_dev->driver = pci_drv;
266 rc = pci_drv->probe(pci_dev, ddi->id);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400267 if (rc) {
Huang Ying967577b2012-11-20 16:08:22 +0800268 pci_dev->driver = NULL;
269 pm_runtime_put_sync(dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400270 }
271 return rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030272}
273
Andi Kleend42c6992005-07-06 19:56:03 +0200274static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
275 const struct pci_device_id *id)
276{
Rusty Russell873392c2008-12-31 23:54:56 +1030277 int error, node;
278 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700279
Rusty Russell873392c2008-12-31 23:54:56 +1030280 /* Execute driver initialization on node where the device's
281 bus is attached to. This way the driver likely allocates
282 its local memory on the right node without any need to
283 change it. */
284 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700285 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030286 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030287
288 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030289 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030290 if (cpu < nr_cpu_ids)
291 error = work_on_cpu(cpu, local_pci_probe, &ddi);
292 else
293 error = local_pci_probe(&ddi);
294 put_online_cpus();
295 } else
296 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200297 return error;
298}
299
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300/**
Randy Dunlap23ea3792010-11-18 15:02:31 -0800301 * __pci_device_probe - check if a driver wants to claim a specific PCI device
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700302 * @drv: driver to call to check if it wants the PCI device
303 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700305 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
307 */
308static int
309__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700310{
311 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 int error = 0;
313
314 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700315 error = -ENODEV;
316
317 id = pci_match_device(drv, pci_dev);
318 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200319 error = pci_call_probe(drv, pci_dev, id);
Huang Ying967577b2012-11-20 16:08:22 +0800320 if (error >= 0)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700321 error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 }
323 return error;
324}
325
326static int pci_device_probe(struct device * dev)
327{
328 int error = 0;
329 struct pci_driver *drv;
330 struct pci_dev *pci_dev;
331
332 drv = to_pci_driver(dev->driver);
333 pci_dev = to_pci_dev(dev);
334 pci_dev_get(pci_dev);
335 error = __pci_device_probe(drv, pci_dev);
336 if (error)
337 pci_dev_put(pci_dev);
338
339 return error;
340}
341
342static int pci_device_remove(struct device * dev)
343{
344 struct pci_dev * pci_dev = to_pci_dev(dev);
345 struct pci_driver * drv = pci_dev->driver;
346
347 if (drv) {
Alan Sternf3ec4f82010-06-08 15:23:51 -0400348 if (drv->remove) {
349 pm_runtime_get_sync(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 drv->remove(pci_dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400351 pm_runtime_put_noidle(dev);
352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 pci_dev->driver = NULL;
354 }
355
Alan Sternf3ec4f82010-06-08 15:23:51 -0400356 /* Undo the runtime PM settings in local_pci_probe() */
Huang Ying967577b2012-11-20 16:08:22 +0800357 pm_runtime_put_sync(dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700360 * If the device is still on, set the power state as "unknown",
361 * since it might change by the next time we load the driver.
362 */
363 if (pci_dev->current_state == PCI_D0)
364 pci_dev->current_state = PCI_UNKNOWN;
365
366 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 * We would love to complain here if pci_dev->is_enabled is set, that
368 * the driver should have called pci_disable_device(), but the
369 * unfortunate fact is there are too many odd BIOS and bridge setups
370 * that don't like drivers doing that all of the time.
371 * Oh well, we can dream of sane hardware when we sleep, no matter how
372 * horrible the crap we have to deal with is when we are awake...
373 */
374
375 pci_dev_put(pci_dev);
376 return 0;
377}
378
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200379static void pci_device_shutdown(struct device *dev)
380{
381 struct pci_dev *pci_dev = to_pci_dev(dev);
382 struct pci_driver *drv = pci_dev->driver;
383
Huang Ying3ff2de92012-10-24 14:54:14 +0800384 pm_runtime_resume(dev);
385
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200386 if (drv && drv->shutdown)
387 drv->shutdown(pci_dev);
388 pci_msi_shutdown(pci_dev);
389 pci_msix_shutdown(pci_dev);
Rafael J. Wysocki5b415f12012-02-07 00:50:35 +0100390
391 /*
Khalid Azizb566a222012-04-27 13:00:33 -0600392 * Turn off Bus Master bit on the device to tell it to not
Konstantin Khlebnikov6e0eda32013-03-14 18:49:37 +0400393 * continue to do DMA. Don't touch devices in D3cold or unknown states.
Khalid Azizb566a222012-04-27 13:00:33 -0600394 */
Konstantin Khlebnikov6e0eda32013-03-14 18:49:37 +0400395 if (pci_dev->current_state <= PCI_D3hot)
396 pci_clear_master(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200397}
398
Rafael J. Wysockiaa338602011-02-11 00:06:54 +0100399#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100400
401/* Auxiliary functions used for system resume and run-time resume. */
402
403/**
404 * pci_restore_standard_config - restore standard config registers of PCI device
405 * @pci_dev: PCI device to handle
406 */
407static int pci_restore_standard_config(struct pci_dev *pci_dev)
408{
409 pci_update_current_state(pci_dev, PCI_UNKNOWN);
410
411 if (pci_dev->current_state != PCI_D0) {
412 int error = pci_set_power_state(pci_dev, PCI_D0);
413 if (error)
414 return error;
415 }
416
Jon Mason1d3c16a2010-11-30 17:43:26 -0600417 pci_restore_state(pci_dev);
418 return 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100419}
420
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100421#endif
422
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200423#ifdef CONFIG_PM_SLEEP
424
Rafael J. Wysockidb288c92012-07-05 15:20:00 -0600425static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
426{
427 pci_power_up(pci_dev);
428 pci_restore_state(pci_dev);
429 pci_fixup_device(pci_fixup_resume_early, pci_dev);
430}
431
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200432/*
433 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100434 * or not even a driver at all (second part).
435 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100436static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200437{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200438 /*
439 * mark its power state as "unknown", since we don't know if
440 * e.g. the BIOS will change its device state when we suspend.
441 */
442 if (pci_dev->current_state == PCI_D0)
443 pci_dev->current_state = PCI_UNKNOWN;
444}
445
446/*
447 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100448 * or not even a driver at all (second part).
449 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100450static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100451{
452 int retval;
453
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200454 /* if the device was enabled before suspend, reenable */
455 retval = pci_reenable_device(pci_dev);
456 /*
457 * if the device was busmaster before the suspend, make it busmaster
458 * again
459 */
460 if (pci_dev->is_busmaster)
461 pci_set_master(pci_dev);
462
463 return retval;
464}
465
466static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
468 struct pci_dev * pci_dev = to_pci_dev(dev);
469 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100470
Andrew Morton02669492006-03-23 01:38:34 -0800471 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100472 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100473 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100474
Frans Pop57ef8022009-03-16 22:39:56 +0100475 error = drv->suspend(pci_dev, state);
476 suspend_report_result(drv->suspend, error);
477 if (error)
478 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100479
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100480 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100481 && pci_dev->current_state != PCI_UNKNOWN) {
482 WARN_ONCE(pci_dev->current_state != prev,
483 "PCI PM: Device state not saved by %pF\n",
484 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100485 }
Andrew Morton02669492006-03-23 01:38:34 -0800486 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100487
488 pci_fixup_device(pci_fixup_suspend, pci_dev);
489
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100490 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491}
492
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200493static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700494{
495 struct pci_dev * pci_dev = to_pci_dev(dev);
496 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700497
498 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100499 pci_power_t prev = pci_dev->current_state;
500 int error;
501
Frans Pop57ef8022009-03-16 22:39:56 +0100502 error = drv->suspend_late(pci_dev, state);
503 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100504 if (error)
505 return error;
506
507 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
508 && pci_dev->current_state != PCI_UNKNOWN) {
509 WARN_ONCE(pci_dev->current_state != prev,
510 "PCI PM: Device state not saved by %pF\n",
511 drv->suspend_late);
512 return 0;
513 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700514 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100515
516 if (!pci_dev->state_saved)
517 pci_save_state(pci_dev);
518
519 pci_pm_set_unknown_state(pci_dev);
520
521 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700522}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100524static int pci_legacy_resume_early(struct device *dev)
525{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100526 struct pci_dev * pci_dev = to_pci_dev(dev);
527 struct pci_driver * drv = pci_dev->driver;
528
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100529 return drv && drv->resume_early ?
530 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100531}
532
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200533static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
535 struct pci_dev * pci_dev = to_pci_dev(dev);
536 struct pci_driver * drv = pci_dev->driver;
537
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100538 pci_fixup_device(pci_fixup_resume, pci_dev);
539
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100540 return drv && drv->resume ?
541 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542}
543
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100544/* Auxiliary functions used by the new power management framework */
545
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100546static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100547{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100548 pci_fixup_device(pci_fixup_resume, pci_dev);
549
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100550 if (!pci_is_bridge(pci_dev))
551 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100552}
553
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100554static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100555{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100556 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100557 if (!pci_is_bridge(pci_dev))
558 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100559}
560
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100561static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
562{
563 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100564 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100565 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100566
567 /*
568 * Legacy PM support is used by default, so warn if the new framework is
569 * supported as well. Drivers are supposed to support either the
570 * former, or the latter, but not both at the same time.
571 */
David Fries82440a82011-11-20 15:29:46 -0600572 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
573 drv->name, pci_dev->vendor, pci_dev->device);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100574
575 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100576}
577
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100578/* New power management framework */
579
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200580static int pci_pm_prepare(struct device *dev)
581{
582 struct device_driver *drv = dev->driver;
583 int error = 0;
584
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100585 /*
586 * PCI devices suspended at run time need to be resumed at this
587 * point, because in general it is necessary to reconfigure them for
588 * system suspend. Namely, if the device is supposed to wake up the
589 * system from the sleep state, we may need to reconfigure it for this
590 * purpose. In turn, if the device is not supposed to wake up the
591 * system from the sleep state, we'll have to prevent it from signaling
592 * wake-up.
593 */
Rafael J. Wysockieea3fc032011-07-06 10:51:40 +0200594 pm_runtime_resume(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100595
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200596 if (drv && drv->pm && drv->pm->prepare)
597 error = drv->pm->prepare(dev);
598
599 return error;
600}
601
602static void pci_pm_complete(struct device *dev)
603{
604 struct device_driver *drv = dev->driver;
605
606 if (drv && drv->pm && drv->pm->complete)
607 drv->pm->complete(dev);
608}
609
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100610#else /* !CONFIG_PM_SLEEP */
611
612#define pci_pm_prepare NULL
613#define pci_pm_complete NULL
614
615#endif /* !CONFIG_PM_SLEEP */
616
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200617#ifdef CONFIG_SUSPEND
618
619static int pci_pm_suspend(struct device *dev)
620{
621 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700622 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200623
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100624 if (pci_has_legacy_pm_support(pci_dev))
625 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100626
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100627 if (!pm) {
628 pci_pm_default_suspend(pci_dev);
629 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200630 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100631
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400632 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100633 if (pm->suspend) {
634 pci_power_t prev = pci_dev->current_state;
635 int error;
636
637 error = pm->suspend(dev);
638 suspend_report_result(pm->suspend, error);
639 if (error)
640 return error;
641
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100642 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100643 && pci_dev->current_state != PCI_UNKNOWN) {
644 WARN_ONCE(pci_dev->current_state != prev,
645 "PCI PM: State of device not saved by %pF\n",
646 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100647 }
648 }
649
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100650 Fixup:
651 pci_fixup_device(pci_fixup_suspend, pci_dev);
652
653 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200654}
655
656static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900657{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100658 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700659 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900660
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100661 if (pci_has_legacy_pm_support(pci_dev))
662 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
663
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100664 if (!pm) {
665 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100666 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100667 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100668
669 if (pm->suspend_noirq) {
670 pci_power_t prev = pci_dev->current_state;
671 int error;
672
673 error = pm->suspend_noirq(dev);
674 suspend_report_result(pm->suspend_noirq, error);
675 if (error)
676 return error;
677
678 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
679 && pci_dev->current_state != PCI_UNKNOWN) {
680 WARN_ONCE(pci_dev->current_state != prev,
681 "PCI PM: State of device not saved by %pF\n",
682 pm->suspend_noirq);
683 return 0;
684 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200685 }
686
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100687 if (!pci_dev->state_saved) {
688 pci_save_state(pci_dev);
689 if (!pci_is_bridge(pci_dev))
690 pci_prepare_to_sleep(pci_dev);
691 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100692
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100693 pci_pm_set_unknown_state(pci_dev);
694
Alan Sterndbf0e4c2012-07-09 11:09:21 -0400695 /*
696 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
697 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
698 * hasn't been quiesced and tries to turn it off. If the controller
699 * is already in D3, this can hang or cause memory corruption.
700 *
701 * Since the value of the COMMAND register doesn't matter once the
702 * device has been suspended, we can safely set it to 0 here.
703 */
704 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
705 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
706
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100707 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900708}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200710static int pci_pm_resume_noirq(struct device *dev)
711{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100712 struct pci_dev *pci_dev = to_pci_dev(dev);
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. Wysocki6cbf8212010-02-17 23:44:58 +0100716 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100717
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100718 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100719 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100720
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100721 if (drv && drv->pm && drv->pm->resume_noirq)
722 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200723
724 return error;
725}
726
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100727static int pci_pm_resume(struct device *dev)
728{
729 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700730 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100731 int error = 0;
732
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100733 /*
734 * This is necessary for the suspend error path in which resume is
735 * called without restoring the standard config registers of the device.
736 */
737 if (pci_dev->state_saved)
738 pci_restore_standard_config(pci_dev);
739
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100740 if (pci_has_legacy_pm_support(pci_dev))
741 return pci_legacy_resume(dev);
742
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100743 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100744
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100745 if (pm) {
746 if (pm->resume)
747 error = pm->resume(dev);
748 } else {
749 pci_pm_reenable_device(pci_dev);
750 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100751
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200752 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100753}
754
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200755#else /* !CONFIG_SUSPEND */
756
757#define pci_pm_suspend NULL
758#define pci_pm_suspend_noirq NULL
759#define pci_pm_resume NULL
760#define pci_pm_resume_noirq NULL
761
762#endif /* !CONFIG_SUSPEND */
763
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200764#ifdef CONFIG_HIBERNATE_CALLBACKS
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200765
Sebastian Ott699c1982013-08-20 16:41:02 +0200766
767/*
768 * pcibios_pm_ops - provide arch-specific hooks when a PCI device is doing
769 * a hibernate transition
770 */
771struct dev_pm_ops __weak pcibios_pm_ops;
772
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200773static int pci_pm_freeze(struct device *dev)
774{
775 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700776 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200777
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100778 if (pci_has_legacy_pm_support(pci_dev))
779 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100780
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100781 if (!pm) {
782 pci_pm_default_suspend(pci_dev);
783 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200784 }
785
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400786 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100787 if (pm->freeze) {
788 int error;
789
790 error = pm->freeze(dev);
791 suspend_report_result(pm->freeze, error);
792 if (error)
793 return error;
794 }
795
Sebastian Ott699c1982013-08-20 16:41:02 +0200796 if (pcibios_pm_ops.freeze)
797 return pcibios_pm_ops.freeze(dev);
798
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100799 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200800}
801
802static int pci_pm_freeze_noirq(struct device *dev)
803{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100804 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200805 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200806
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100807 if (pci_has_legacy_pm_support(pci_dev))
808 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
809
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100810 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100811 int error;
812
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100813 error = drv->pm->freeze_noirq(dev);
814 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100815 if (error)
816 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200817 }
818
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100819 if (!pci_dev->state_saved)
820 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100821
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100822 pci_pm_set_unknown_state(pci_dev);
823
Sebastian Ott699c1982013-08-20 16:41:02 +0200824 if (pcibios_pm_ops.freeze_noirq)
825 return pcibios_pm_ops.freeze_noirq(dev);
826
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100827 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200828}
829
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200830static int pci_pm_thaw_noirq(struct device *dev)
831{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100832 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200833 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200834 int error = 0;
835
Sebastian Ott699c1982013-08-20 16:41:02 +0200836 if (pcibios_pm_ops.thaw_noirq) {
837 error = pcibios_pm_ops.thaw_noirq(dev);
838 if (error)
839 return error;
840 }
841
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100842 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100843 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100844
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100845 pci_update_current_state(pci_dev, PCI_D0);
846
847 if (drv && drv->pm && drv->pm->thaw_noirq)
848 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200849
850 return error;
851}
852
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100853static int pci_pm_thaw(struct device *dev)
854{
855 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700856 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100857 int error = 0;
858
Sebastian Ott699c1982013-08-20 16:41:02 +0200859 if (pcibios_pm_ops.thaw) {
860 error = pcibios_pm_ops.thaw(dev);
861 if (error)
862 return error;
863 }
864
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100865 if (pci_has_legacy_pm_support(pci_dev))
866 return pci_legacy_resume(dev);
867
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100868 if (pm) {
869 if (pm->thaw)
870 error = pm->thaw(dev);
871 } else {
872 pci_pm_reenable_device(pci_dev);
873 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100874
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200875 pci_dev->state_saved = false;
876
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100877 return error;
878}
879
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200880static int pci_pm_poweroff(struct device *dev)
881{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100882 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700883 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200884
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100885 if (pci_has_legacy_pm_support(pci_dev))
886 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100887
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100888 if (!pm) {
889 pci_pm_default_suspend(pci_dev);
890 goto Fixup;
891 }
892
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400893 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100894 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100895 int error;
896
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100897 error = pm->poweroff(dev);
898 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100899 if (error)
900 return error;
901 }
902
903 Fixup:
904 pci_fixup_device(pci_fixup_suspend, pci_dev);
905
Sebastian Ott699c1982013-08-20 16:41:02 +0200906 if (pcibios_pm_ops.poweroff)
907 return pcibios_pm_ops.poweroff(dev);
908
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100909 return 0;
910}
911
912static int pci_pm_poweroff_noirq(struct device *dev)
913{
914 struct pci_dev *pci_dev = to_pci_dev(dev);
915 struct device_driver *drv = dev->driver;
916
917 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
918 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
919
920 if (!drv || !drv->pm)
921 return 0;
922
923 if (drv->pm->poweroff_noirq) {
924 int error;
925
926 error = drv->pm->poweroff_noirq(dev);
927 suspend_report_result(drv->pm->poweroff_noirq, error);
928 if (error)
929 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200930 }
931
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100932 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
933 pci_prepare_to_sleep(pci_dev);
934
Rafael J. Wysocki0b68c8e2012-08-12 23:26:07 +0200935 /*
936 * The reason for doing this here is the same as for the analogous code
937 * in pci_pm_suspend_noirq().
938 */
939 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
940 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
941
Sebastian Ott699c1982013-08-20 16:41:02 +0200942 if (pcibios_pm_ops.poweroff_noirq)
943 return pcibios_pm_ops.poweroff_noirq(dev);
944
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100945 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200946}
947
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200948static int pci_pm_restore_noirq(struct device *dev)
949{
950 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200951 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200952 int error = 0;
953
Sebastian Ott699c1982013-08-20 16:41:02 +0200954 if (pcibios_pm_ops.restore_noirq) {
955 error = pcibios_pm_ops.restore_noirq(dev);
956 if (error)
957 return error;
958 }
959
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100960 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100961
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100962 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100963 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100964
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100965 if (drv && drv->pm && drv->pm->restore_noirq)
966 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200967
968 return error;
969}
970
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100971static int pci_pm_restore(struct device *dev)
972{
973 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700974 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100975 int error = 0;
976
Sebastian Ott699c1982013-08-20 16:41:02 +0200977 if (pcibios_pm_ops.restore) {
978 error = pcibios_pm_ops.restore(dev);
979 if (error)
980 return error;
981 }
982
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100983 /*
984 * This is necessary for the hibernation error path in which restore is
985 * called without restoring the standard config registers of the device.
986 */
987 if (pci_dev->state_saved)
988 pci_restore_standard_config(pci_dev);
989
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100990 if (pci_has_legacy_pm_support(pci_dev))
991 return pci_legacy_resume(dev);
992
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100993 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100994
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100995 if (pm) {
996 if (pm->restore)
997 error = pm->restore(dev);
998 } else {
999 pci_pm_reenable_device(pci_dev);
1000 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +01001001
1002 return error;
1003}
1004
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +02001005#else /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001006
1007#define pci_pm_freeze NULL
1008#define pci_pm_freeze_noirq NULL
1009#define pci_pm_thaw NULL
1010#define pci_pm_thaw_noirq NULL
1011#define pci_pm_poweroff NULL
1012#define pci_pm_poweroff_noirq NULL
1013#define pci_pm_restore NULL
1014#define pci_pm_restore_noirq NULL
1015
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +02001016#endif /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001017
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001018#ifdef CONFIG_PM_RUNTIME
1019
1020static int pci_pm_runtime_suspend(struct device *dev)
1021{
1022 struct pci_dev *pci_dev = to_pci_dev(dev);
1023 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1024 pci_power_t prev = pci_dev->current_state;
1025 int error;
1026
Huang Ying967577b2012-11-20 16:08:22 +08001027 /*
1028 * If pci_dev->driver is not set (unbound), the device should
1029 * always remain in D0 regardless of the runtime PM status
1030 */
1031 if (!pci_dev->driver)
1032 return 0;
1033
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001034 if (!pm || !pm->runtime_suspend)
1035 return -ENOSYS;
1036
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +04001037 pci_dev->state_saved = false;
Huang Ying448bd852012-06-23 10:23:51 +08001038 pci_dev->no_d3cold = false;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001039 error = pm->runtime_suspend(dev);
1040 suspend_report_result(pm->runtime_suspend, error);
1041 if (error)
1042 return error;
Huang Ying448bd852012-06-23 10:23:51 +08001043 if (!pci_dev->d3cold_allowed)
1044 pci_dev->no_d3cold = true;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001045
1046 pci_fixup_device(pci_fixup_suspend, pci_dev);
1047
1048 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1049 && pci_dev->current_state != PCI_UNKNOWN) {
1050 WARN_ONCE(pci_dev->current_state != prev,
1051 "PCI PM: State of device not saved by %pF\n",
1052 pm->runtime_suspend);
1053 return 0;
1054 }
1055
Dave Airlie42eca232012-10-29 17:26:54 -06001056 if (!pci_dev->state_saved) {
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001057 pci_save_state(pci_dev);
Dave Airlie42eca232012-10-29 17:26:54 -06001058 pci_finish_runtime_suspend(pci_dev);
1059 }
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001060
1061 return 0;
1062}
1063
1064static int pci_pm_runtime_resume(struct device *dev)
1065{
Huang Ying448bd852012-06-23 10:23:51 +08001066 int rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001067 struct pci_dev *pci_dev = to_pci_dev(dev);
1068 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1069
Huang Ying967577b2012-11-20 16:08:22 +08001070 /*
1071 * If pci_dev->driver is not set (unbound), the device should
1072 * always remain in D0 regardless of the runtime PM status
1073 */
1074 if (!pci_dev->driver)
1075 return 0;
1076
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001077 if (!pm || !pm->runtime_resume)
1078 return -ENOSYS;
1079
Rafael J. Wysockidb288c92012-07-05 15:20:00 -06001080 pci_restore_standard_config(pci_dev);
1081 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001082 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1083 pci_fixup_device(pci_fixup_resume, pci_dev);
1084
Huang Ying448bd852012-06-23 10:23:51 +08001085 rc = pm->runtime_resume(dev);
1086
1087 pci_dev->runtime_d3cold = false;
1088
1089 return rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001090}
1091
1092static int pci_pm_runtime_idle(struct device *dev)
1093{
Huang Ying967577b2012-11-20 16:08:22 +08001094 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001095 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001096 int ret = 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001097
Huang Ying967577b2012-11-20 16:08:22 +08001098 /*
1099 * If pci_dev->driver is not set (unbound), the device should
1100 * always remain in D0 regardless of the runtime PM status
1101 */
1102 if (!pci_dev->driver)
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001103 return 0;
Huang Ying967577b2012-11-20 16:08:22 +08001104
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001105 if (!pm)
1106 return -ENOSYS;
1107
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001108 if (pm->runtime_idle)
1109 ret = pm->runtime_idle(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001110
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001111 return ret;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001112}
1113
1114#else /* !CONFIG_PM_RUNTIME */
1115
1116#define pci_pm_runtime_suspend NULL
1117#define pci_pm_runtime_resume NULL
1118#define pci_pm_runtime_idle NULL
1119
1120#endif /* !CONFIG_PM_RUNTIME */
1121
Rafael J. Wysockiaa338602011-02-11 00:06:54 +01001122#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001123
Dmitry Torokhov8150f322009-07-24 22:11:32 -07001124const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001125 .prepare = pci_pm_prepare,
1126 .complete = pci_pm_complete,
1127 .suspend = pci_pm_suspend,
1128 .resume = pci_pm_resume,
1129 .freeze = pci_pm_freeze,
1130 .thaw = pci_pm_thaw,
1131 .poweroff = pci_pm_poweroff,
1132 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001133 .suspend_noirq = pci_pm_suspend_noirq,
1134 .resume_noirq = pci_pm_resume_noirq,
1135 .freeze_noirq = pci_pm_freeze_noirq,
1136 .thaw_noirq = pci_pm_thaw_noirq,
1137 .poweroff_noirq = pci_pm_poweroff_noirq,
1138 .restore_noirq = pci_pm_restore_noirq,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001139 .runtime_suspend = pci_pm_runtime_suspend,
1140 .runtime_resume = pci_pm_runtime_resume,
1141 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001142};
1143
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001144#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001145
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001146#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001147
1148#define PCI_PM_OPS_PTR NULL
1149
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001150#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001151
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001153 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001155 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001156 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 *
1158 * Adds the driver structure to the list of registered drivers.
1159 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -06001160 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 * no device was claimed during registration.
1162 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001163int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1164 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 /* initialize common driver fields */
1167 drv->driver.name = drv->name;
1168 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001169 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001170 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001171
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001172 spin_lock_init(&drv->dynids.lock);
1173 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174
1175 /* register with core */
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +04001176 return driver_register(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177}
1178
1179/**
1180 * pci_unregister_driver - unregister a pci driver
1181 * @drv: the driver structure to unregister
1182 *
1183 * Deletes the driver structure from the list of registered PCI drivers,
1184 * gives it a chance to clean up by calling its remove() function for
1185 * each device it was responsible for, and marks those devices as
1186 * driverless.
1187 */
1188
1189void
1190pci_unregister_driver(struct pci_driver *drv)
1191{
1192 driver_unregister(&drv->driver);
1193 pci_free_dynids(drv);
1194}
1195
1196static struct pci_driver pci_compat_driver = {
1197 .name = "compat"
1198};
1199
1200/**
1201 * pci_dev_driver - get the pci_driver of a device
1202 * @dev: the device to query
1203 *
1204 * Returns the appropriate pci_driver structure or %NULL if there is no
1205 * registered driver for the device.
1206 */
1207struct pci_driver *
1208pci_dev_driver(const struct pci_dev *dev)
1209{
1210 if (dev->driver)
1211 return dev->driver;
1212 else {
1213 int i;
1214 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1215 if (dev->resource[i].flags & IORESOURCE_BUSY)
1216 return &pci_compat_driver;
1217 }
1218 return NULL;
1219}
1220
1221/**
1222 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001224 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 *
1226 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001227 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 * pci_device_id structure or %NULL if there is no match.
1229 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001230static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001232 struct pci_dev *pci_dev = to_pci_dev(dev);
Yinghai Lu58d9a382013-01-21 13:20:51 -08001233 struct pci_driver *pci_drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 const struct pci_device_id *found_id;
1235
Yinghai Lu58d9a382013-01-21 13:20:51 -08001236 if (!pci_dev->match_driver)
1237 return 0;
1238
1239 pci_drv = to_pci_driver(drv);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001240 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 if (found_id)
1242 return 1;
1243
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001244 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245}
1246
1247/**
1248 * pci_dev_get - increments the reference count of the pci device structure
1249 * @dev: the device being referenced
1250 *
1251 * Each live reference to a device should be refcounted.
1252 *
1253 * Drivers for PCI devices should normally record such references in
1254 * their probe() methods, when they bind to a device, and release
1255 * them by calling pci_dev_put(), in their disconnect() methods.
1256 *
1257 * A pointer to the device with the incremented reference counter is returned.
1258 */
1259struct pci_dev *pci_dev_get(struct pci_dev *dev)
1260{
1261 if (dev)
1262 get_device(&dev->dev);
1263 return dev;
1264}
1265
1266/**
1267 * pci_dev_put - release a use of the pci device structure
1268 * @dev: device that's been disconnected
1269 *
1270 * Must be called when a user of a device is finished with it. When the last
1271 * user of the device calls this function, the memory of the device is freed.
1272 */
1273void pci_dev_put(struct pci_dev *dev)
1274{
1275 if (dev)
1276 put_device(&dev->dev);
1277}
1278
Bill Pemberton8ccc9aa2012-11-21 15:34:58 -05001279static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1280{
1281 struct pci_dev *pdev;
1282
1283 if (!dev)
1284 return -ENODEV;
1285
1286 pdev = to_pci_dev(dev);
1287 if (!pdev)
1288 return -ENODEV;
1289
1290 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1291 return -ENOMEM;
1292
1293 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1294 return -ENOMEM;
1295
1296 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1297 pdev->subsystem_device))
1298 return -ENOMEM;
1299
1300 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1301 return -ENOMEM;
1302
1303 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1304 pdev->vendor, pdev->device,
1305 pdev->subsystem_vendor, pdev->subsystem_device,
1306 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1307 (u8)(pdev->class)))
1308 return -ENOMEM;
1309 return 0;
1310}
1311
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312struct bus_type pci_bus_type = {
1313 .name = "pci",
1314 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001315 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001316 .probe = pci_device_probe,
1317 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001318 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001320 .bus_attrs = pci_bus_attrs,
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +04001321 .drv_attrs = pci_drv_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001322 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323};
1324
1325static int __init pci_driver_init(void)
1326{
1327 return bus_register(&pci_bus_type);
1328}
1329
1330postcore_initcall(pci_driver_init);
1331
Tejun Heo9dba9102009-09-03 15:26:36 +09001332EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001333EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001334EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335EXPORT_SYMBOL(pci_unregister_driver);
1336EXPORT_SYMBOL(pci_dev_driver);
1337EXPORT_SYMBOL(pci_bus_type);
1338EXPORT_SYMBOL(pci_dev_get);
1339EXPORT_SYMBOL(pci_dev_put);