blob: 94c6e2aa03d658defb5d30b0f2fbb1f8383cf9d0 [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
92/*
93 * Dynamic device ID manipulation via sysfs is disabled for !CONFIG_HOTPLUG
94 */
95#ifdef CONFIG_HOTPLUG
96/**
97 * store_new_id - sysfs frontend to pci_add_dynid()
Randy Dunlap8f7020d2005-10-23 11:57:38 -070098 * @driver: target device driver
99 * @buf: buffer for scanning device ID data
100 * @count: input size
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 *
Tejun Heo9dba9102009-09-03 15:26:36 +0900102 * Allow PCI IDs to be added to an existing driver via sysfs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 */
Randy Dunlapf8eb1002005-10-28 20:36:51 -0700104static ssize_t
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105store_new_id(struct device_driver *driver, const char *buf, size_t count)
106{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 struct pci_driver *pdrv = to_pci_driver(driver);
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200108 const struct pci_device_id *ids = pdrv->id_table;
Jean Delvare6ba18632007-04-07 17:21:28 +0200109 __u32 vendor, device, subvendor=PCI_ANY_ID,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 subdevice=PCI_ANY_ID, class=0, class_mask=0;
111 unsigned long driver_data=0;
112 int fields=0;
Tejun Heo9dba9102009-09-03 15:26:36 +0900113 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200115 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 &vendor, &device, &subvendor, &subdevice,
117 &class, &class_mask, &driver_data);
Jean Delvare6ba18632007-04-07 17:21:28 +0200118 if (fields < 2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 return -EINVAL;
120
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200121 /* Only accept driver_data values that match an existing id_table
122 entry */
Chris Wright2debb4d2008-11-25 19:36:10 -0800123 if (ids) {
124 retval = -EINVAL;
125 while (ids->vendor || ids->subvendor || ids->class_mask) {
126 if (driver_data == ids->driver_data) {
127 retval = 0;
128 break;
129 }
130 ids++;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200131 }
Chris Wright2debb4d2008-11-25 19:36:10 -0800132 if (retval) /* No match */
133 return retval;
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200134 }
Jean Delvareb41d6cf2008-08-17 21:06:59 +0200135
Tejun Heo9dba9102009-09-03 15:26:36 +0900136 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
137 class, class_mask, driver_data);
Greg Kroah-Hartmanb19441a2006-08-28 11:43:25 -0700138 if (retval)
139 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 return count;
141}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
Chris Wright09943752009-02-23 21:52:23 -0800143/**
144 * store_remove_id - remove a PCI device ID from this driver
145 * @driver: target device driver
146 * @buf: buffer for scanning device ID data
147 * @count: input size
148 *
149 * Removes a dynamic pci device ID to this driver.
150 */
151static ssize_t
152store_remove_id(struct device_driver *driver, const char *buf, size_t count)
153{
154 struct pci_dynid *dynid, *n;
155 struct pci_driver *pdrv = to_pci_driver(driver);
156 __u32 vendor, device, subvendor = PCI_ANY_ID,
157 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
158 int fields = 0;
159 int retval = -ENODEV;
160
161 fields = sscanf(buf, "%x %x %x %x %x %x",
162 &vendor, &device, &subvendor, &subdevice,
163 &class, &class_mask);
164 if (fields < 2)
165 return -EINVAL;
166
167 spin_lock(&pdrv->dynids.lock);
168 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
169 struct pci_device_id *id = &dynid->id;
170 if ((id->vendor == vendor) &&
171 (id->device == device) &&
172 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
173 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
174 !((id->class ^ class) & class_mask)) {
175 list_del(&dynid->node);
176 kfree(dynid);
177 retval = 0;
178 break;
179 }
180 }
181 spin_unlock(&pdrv->dynids.lock);
182
183 if (retval)
184 return retval;
185 return count;
186}
Chris Wright09943752009-02-23 21:52:23 -0800187
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +0400188static struct driver_attribute pci_drv_attrs[] = {
189 __ATTR(new_id, S_IWUSR, NULL, store_new_id),
190 __ATTR(remove_id, S_IWUSR, NULL, store_remove_id),
191 __ATTR_NULL,
192};
Alan Sterned283e92012-01-24 14:35:13 -0500193
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +0400194#else
195#define pci_drv_attrs NULL
196#endif /* CONFIG_HOTPLUG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197
198/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700199 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700201 * @dev: the PCI device structure to match against.
202 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700204 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700206 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200207 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700208 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700210const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
211 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700213 if (ids) {
214 while (ids->vendor || ids->subvendor || ids->class_mask) {
215 if (pci_match_one_device(ids, dev))
216 return ids;
217 ids++;
218 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 }
220 return NULL;
221}
222
223/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800224 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700225 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200226 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700227 *
228 * Used by a driver to check whether a PCI device present in the
229 * system is in its list of supported devices. Returns the matching
230 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200232static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
233 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700234{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700235 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Russell King7461b602006-11-29 21:18:04 +0000237 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700238 spin_lock(&drv->dynids.lock);
239 list_for_each_entry(dynid, &drv->dynids.list, node) {
240 if (pci_match_one_device(&dynid->id, dev)) {
241 spin_unlock(&drv->dynids.lock);
242 return &dynid->id;
243 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700245 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000246
247 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248}
249
Rusty Russell873392c2008-12-31 23:54:56 +1030250struct drv_dev_and_id {
251 struct pci_driver *drv;
252 struct pci_dev *dev;
253 const struct pci_device_id *id;
254};
255
256static long local_pci_probe(void *_ddi)
257{
258 struct drv_dev_and_id *ddi = _ddi;
Alan Sternf3ec4f82010-06-08 15:23:51 -0400259 struct device *dev = &ddi->dev->dev;
Huang Yingea8c88f2012-08-08 09:07:39 +0800260 struct device *parent = dev->parent;
Alan Sternf3ec4f82010-06-08 15:23:51 -0400261 int rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030262
Huang Yingea8c88f2012-08-08 09:07:39 +0800263 /* The parent bridge must be in active state when probing */
264 if (parent)
265 pm_runtime_get_sync(parent);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400266 /* Unbound PCI devices are always set to disabled and suspended.
267 * During probe, the device is set to enabled and active and the
268 * usage count is incremented. If the driver supports runtime PM,
269 * it should call pm_runtime_put_noidle() in its probe routine and
270 * pm_runtime_get_noresume() in its remove routine.
271 */
272 pm_runtime_get_noresume(dev);
273 pm_runtime_set_active(dev);
274 pm_runtime_enable(dev);
275
276 rc = ddi->drv->probe(ddi->dev, ddi->id);
277 if (rc) {
278 pm_runtime_disable(dev);
279 pm_runtime_set_suspended(dev);
280 pm_runtime_put_noidle(dev);
281 }
Huang Yingea8c88f2012-08-08 09:07:39 +0800282 if (parent)
283 pm_runtime_put(parent);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400284 return rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030285}
286
Andi Kleend42c6992005-07-06 19:56:03 +0200287static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
288 const struct pci_device_id *id)
289{
Rusty Russell873392c2008-12-31 23:54:56 +1030290 int error, node;
291 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700292
Rusty Russell873392c2008-12-31 23:54:56 +1030293 /* Execute driver initialization on node where the device's
294 bus is attached to. This way the driver likely allocates
295 its local memory on the right node without any need to
296 change it. */
297 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700298 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030299 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030300
301 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030302 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030303 if (cpu < nr_cpu_ids)
304 error = work_on_cpu(cpu, local_pci_probe, &ddi);
305 else
306 error = local_pci_probe(&ddi);
307 put_online_cpus();
308 } else
309 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200310 return error;
311}
312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313/**
Randy Dunlap23ea3792010-11-18 15:02:31 -0800314 * __pci_device_probe - check if a driver wants to claim a specific PCI device
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700315 * @drv: driver to call to check if it wants the PCI device
316 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700318 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
320 */
321static int
322__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700323{
324 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 int error = 0;
326
327 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700328 error = -ENODEV;
329
330 id = pci_match_device(drv, pci_dev);
331 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200332 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700333 if (error >= 0) {
334 pci_dev->driver = drv;
335 error = 0;
336 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 }
338 return error;
339}
340
341static int pci_device_probe(struct device * dev)
342{
343 int error = 0;
344 struct pci_driver *drv;
345 struct pci_dev *pci_dev;
346
347 drv = to_pci_driver(dev->driver);
348 pci_dev = to_pci_dev(dev);
349 pci_dev_get(pci_dev);
350 error = __pci_device_probe(drv, pci_dev);
351 if (error)
352 pci_dev_put(pci_dev);
353
354 return error;
355}
356
357static int pci_device_remove(struct device * dev)
358{
359 struct pci_dev * pci_dev = to_pci_dev(dev);
360 struct pci_driver * drv = pci_dev->driver;
361
362 if (drv) {
Alan Sternf3ec4f82010-06-08 15:23:51 -0400363 if (drv->remove) {
364 pm_runtime_get_sync(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 drv->remove(pci_dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400366 pm_runtime_put_noidle(dev);
367 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 pci_dev->driver = NULL;
369 }
370
Alan Sternf3ec4f82010-06-08 15:23:51 -0400371 /* Undo the runtime PM settings in local_pci_probe() */
372 pm_runtime_disable(dev);
373 pm_runtime_set_suspended(dev);
374 pm_runtime_put_noidle(dev);
375
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700377 * If the device is still on, set the power state as "unknown",
378 * since it might change by the next time we load the driver.
379 */
380 if (pci_dev->current_state == PCI_D0)
381 pci_dev->current_state = PCI_UNKNOWN;
382
383 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 * We would love to complain here if pci_dev->is_enabled is set, that
385 * the driver should have called pci_disable_device(), but the
386 * unfortunate fact is there are too many odd BIOS and bridge setups
387 * that don't like drivers doing that all of the time.
388 * Oh well, we can dream of sane hardware when we sleep, no matter how
389 * horrible the crap we have to deal with is when we are awake...
390 */
391
392 pci_dev_put(pci_dev);
393 return 0;
394}
395
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200396static void pci_device_shutdown(struct device *dev)
397{
398 struct pci_dev *pci_dev = to_pci_dev(dev);
399 struct pci_driver *drv = pci_dev->driver;
400
401 if (drv && drv->shutdown)
402 drv->shutdown(pci_dev);
403 pci_msi_shutdown(pci_dev);
404 pci_msix_shutdown(pci_dev);
Rafael J. Wysocki5b415f12012-02-07 00:50:35 +0100405
406 /*
Khalid Azizb566a222012-04-27 13:00:33 -0600407 * Turn off Bus Master bit on the device to tell it to not
408 * continue to do DMA
409 */
410 pci_disable_device(pci_dev);
411
412 /*
Rafael J. Wysocki5b415f12012-02-07 00:50:35 +0100413 * Devices may be enabled to wake up by runtime PM, but they need not
414 * be supposed to wake up the system from its "power off" state (e.g.
415 * ACPI S5). Therefore disable wakeup for all devices that aren't
416 * supposed to wake up the system at this point. The state argument
417 * will be ignored by pci_enable_wake().
418 */
419 if (!device_may_wakeup(dev))
420 pci_enable_wake(pci_dev, PCI_UNKNOWN, false);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200421}
422
Rafael J. Wysockiaa338602011-02-11 00:06:54 +0100423#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100424
425/* Auxiliary functions used for system resume and run-time resume. */
426
427/**
428 * pci_restore_standard_config - restore standard config registers of PCI device
429 * @pci_dev: PCI device to handle
430 */
431static int pci_restore_standard_config(struct pci_dev *pci_dev)
432{
433 pci_update_current_state(pci_dev, PCI_UNKNOWN);
434
435 if (pci_dev->current_state != PCI_D0) {
436 int error = pci_set_power_state(pci_dev, PCI_D0);
437 if (error)
438 return error;
439 }
440
Jon Mason1d3c16a2010-11-30 17:43:26 -0600441 pci_restore_state(pci_dev);
442 return 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100443}
444
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100445#endif
446
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200447#ifdef CONFIG_PM_SLEEP
448
Rafael J. Wysockidb288c92012-07-05 15:20:00 -0600449static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
450{
451 pci_power_up(pci_dev);
452 pci_restore_state(pci_dev);
453 pci_fixup_device(pci_fixup_resume_early, pci_dev);
454}
455
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200456/*
457 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100458 * or not even a driver at all (second part).
459 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100460static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200461{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200462 /*
463 * mark its power state as "unknown", since we don't know if
464 * e.g. the BIOS will change its device state when we suspend.
465 */
466 if (pci_dev->current_state == PCI_D0)
467 pci_dev->current_state = PCI_UNKNOWN;
468}
469
470/*
471 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100472 * or not even a driver at all (second part).
473 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100474static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100475{
476 int retval;
477
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200478 /* if the device was enabled before suspend, reenable */
479 retval = pci_reenable_device(pci_dev);
480 /*
481 * if the device was busmaster before the suspend, make it busmaster
482 * again
483 */
484 if (pci_dev->is_busmaster)
485 pci_set_master(pci_dev);
486
487 return retval;
488}
489
490static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
492 struct pci_dev * pci_dev = to_pci_dev(dev);
493 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100494
Andrew Morton02669492006-03-23 01:38:34 -0800495 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100496 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100497 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100498
Frans Pop57ef8022009-03-16 22:39:56 +0100499 error = drv->suspend(pci_dev, state);
500 suspend_report_result(drv->suspend, error);
501 if (error)
502 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100503
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100504 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100505 && pci_dev->current_state != PCI_UNKNOWN) {
506 WARN_ONCE(pci_dev->current_state != prev,
507 "PCI PM: Device state not saved by %pF\n",
508 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100509 }
Andrew Morton02669492006-03-23 01:38:34 -0800510 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100511
512 pci_fixup_device(pci_fixup_suspend, pci_dev);
513
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100514 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515}
516
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200517static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700518{
519 struct pci_dev * pci_dev = to_pci_dev(dev);
520 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700521
522 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100523 pci_power_t prev = pci_dev->current_state;
524 int error;
525
Frans Pop57ef8022009-03-16 22:39:56 +0100526 error = drv->suspend_late(pci_dev, state);
527 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100528 if (error)
529 return error;
530
531 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
532 && pci_dev->current_state != PCI_UNKNOWN) {
533 WARN_ONCE(pci_dev->current_state != prev,
534 "PCI PM: Device state not saved by %pF\n",
535 drv->suspend_late);
536 return 0;
537 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700538 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100539
540 if (!pci_dev->state_saved)
541 pci_save_state(pci_dev);
542
543 pci_pm_set_unknown_state(pci_dev);
544
545 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700546}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100548static int pci_legacy_resume_early(struct device *dev)
549{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100550 struct pci_dev * pci_dev = to_pci_dev(dev);
551 struct pci_driver * drv = pci_dev->driver;
552
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100553 return drv && drv->resume_early ?
554 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100555}
556
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200557static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
559 struct pci_dev * pci_dev = to_pci_dev(dev);
560 struct pci_driver * drv = pci_dev->driver;
561
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100562 pci_fixup_device(pci_fixup_resume, pci_dev);
563
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100564 return drv && drv->resume ?
565 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566}
567
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100568/* Auxiliary functions used by the new power management framework */
569
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100570static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100571{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100572 pci_fixup_device(pci_fixup_resume, pci_dev);
573
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100574 if (!pci_is_bridge(pci_dev))
575 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100576}
577
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100578static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100579{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100580 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100581 if (!pci_is_bridge(pci_dev))
582 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100583}
584
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100585static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
586{
587 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100588 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100589 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100590
591 /*
592 * Legacy PM support is used by default, so warn if the new framework is
593 * supported as well. Drivers are supposed to support either the
594 * former, or the latter, but not both at the same time.
595 */
David Fries82440a82011-11-20 15:29:46 -0600596 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
597 drv->name, pci_dev->vendor, pci_dev->device);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100598
599 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100600}
601
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100602/* New power management framework */
603
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200604static int pci_pm_prepare(struct device *dev)
605{
606 struct device_driver *drv = dev->driver;
607 int error = 0;
608
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100609 /*
610 * PCI devices suspended at run time need to be resumed at this
611 * point, because in general it is necessary to reconfigure them for
612 * system suspend. Namely, if the device is supposed to wake up the
613 * system from the sleep state, we may need to reconfigure it for this
614 * purpose. In turn, if the device is not supposed to wake up the
615 * system from the sleep state, we'll have to prevent it from signaling
616 * wake-up.
617 */
Rafael J. Wysockieea3fc032011-07-06 10:51:40 +0200618 pm_runtime_resume(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100619
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200620 if (drv && drv->pm && drv->pm->prepare)
621 error = drv->pm->prepare(dev);
622
623 return error;
624}
625
626static void pci_pm_complete(struct device *dev)
627{
628 struct device_driver *drv = dev->driver;
629
630 if (drv && drv->pm && drv->pm->complete)
631 drv->pm->complete(dev);
632}
633
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100634#else /* !CONFIG_PM_SLEEP */
635
636#define pci_pm_prepare NULL
637#define pci_pm_complete NULL
638
639#endif /* !CONFIG_PM_SLEEP */
640
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200641#ifdef CONFIG_SUSPEND
642
643static int pci_pm_suspend(struct device *dev)
644{
645 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700646 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200647
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100648 if (pci_has_legacy_pm_support(pci_dev))
649 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100650
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100651 if (!pm) {
652 pci_pm_default_suspend(pci_dev);
653 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200654 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100655
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100656 if (pm->suspend) {
657 pci_power_t prev = pci_dev->current_state;
658 int error;
659
660 error = pm->suspend(dev);
661 suspend_report_result(pm->suspend, error);
662 if (error)
663 return error;
664
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100665 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100666 && pci_dev->current_state != PCI_UNKNOWN) {
667 WARN_ONCE(pci_dev->current_state != prev,
668 "PCI PM: State of device not saved by %pF\n",
669 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100670 }
671 }
672
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100673 Fixup:
674 pci_fixup_device(pci_fixup_suspend, pci_dev);
675
676 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200677}
678
679static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900680{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100681 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700682 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900683
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100684 if (pci_has_legacy_pm_support(pci_dev))
685 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
686
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100687 if (!pm) {
688 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100689 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100690 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100691
692 if (pm->suspend_noirq) {
693 pci_power_t prev = pci_dev->current_state;
694 int error;
695
696 error = pm->suspend_noirq(dev);
697 suspend_report_result(pm->suspend_noirq, error);
698 if (error)
699 return error;
700
701 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
702 && pci_dev->current_state != PCI_UNKNOWN) {
703 WARN_ONCE(pci_dev->current_state != prev,
704 "PCI PM: State of device not saved by %pF\n",
705 pm->suspend_noirq);
706 return 0;
707 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200708 }
709
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100710 if (!pci_dev->state_saved) {
711 pci_save_state(pci_dev);
712 if (!pci_is_bridge(pci_dev))
713 pci_prepare_to_sleep(pci_dev);
714 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100715
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100716 pci_pm_set_unknown_state(pci_dev);
717
Alan Sterndbf0e4c2012-07-09 11:09:21 -0400718 /*
719 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
720 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
721 * hasn't been quiesced and tries to turn it off. If the controller
722 * is already in D3, this can hang or cause memory corruption.
723 *
724 * Since the value of the COMMAND register doesn't matter once the
725 * device has been suspended, we can safely set it to 0 here.
726 */
727 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
728 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
729
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100730 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900731}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200733static int pci_pm_resume_noirq(struct device *dev)
734{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100735 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200736 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200737 int error = 0;
738
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100739 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100740
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100741 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100742 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100743
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100744 if (drv && drv->pm && drv->pm->resume_noirq)
745 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200746
747 return error;
748}
749
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100750static int pci_pm_resume(struct device *dev)
751{
752 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700753 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100754 int error = 0;
755
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100756 /*
757 * This is necessary for the suspend error path in which resume is
758 * called without restoring the standard config registers of the device.
759 */
760 if (pci_dev->state_saved)
761 pci_restore_standard_config(pci_dev);
762
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100763 if (pci_has_legacy_pm_support(pci_dev))
764 return pci_legacy_resume(dev);
765
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100766 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100767
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100768 if (pm) {
769 if (pm->resume)
770 error = pm->resume(dev);
771 } else {
772 pci_pm_reenable_device(pci_dev);
773 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100774
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200775 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100776}
777
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200778#else /* !CONFIG_SUSPEND */
779
780#define pci_pm_suspend NULL
781#define pci_pm_suspend_noirq NULL
782#define pci_pm_resume NULL
783#define pci_pm_resume_noirq NULL
784
785#endif /* !CONFIG_SUSPEND */
786
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200787#ifdef CONFIG_HIBERNATE_CALLBACKS
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200788
789static int pci_pm_freeze(struct device *dev)
790{
791 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700792 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200793
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100794 if (pci_has_legacy_pm_support(pci_dev))
795 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100796
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100797 if (!pm) {
798 pci_pm_default_suspend(pci_dev);
799 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200800 }
801
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100802 if (pm->freeze) {
803 int error;
804
805 error = pm->freeze(dev);
806 suspend_report_result(pm->freeze, error);
807 if (error)
808 return error;
809 }
810
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100811 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200812}
813
814static int pci_pm_freeze_noirq(struct device *dev)
815{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100816 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200817 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200818
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100819 if (pci_has_legacy_pm_support(pci_dev))
820 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
821
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100822 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100823 int error;
824
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100825 error = drv->pm->freeze_noirq(dev);
826 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100827 if (error)
828 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200829 }
830
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100831 if (!pci_dev->state_saved)
832 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100833
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100834 pci_pm_set_unknown_state(pci_dev);
835
836 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200837}
838
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200839static int pci_pm_thaw_noirq(struct device *dev)
840{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100841 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200842 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200843 int error = 0;
844
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100845 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100846 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100847
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100848 pci_update_current_state(pci_dev, PCI_D0);
849
850 if (drv && drv->pm && drv->pm->thaw_noirq)
851 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200852
853 return error;
854}
855
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100856static int pci_pm_thaw(struct device *dev)
857{
858 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700859 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100860 int error = 0;
861
862 if (pci_has_legacy_pm_support(pci_dev))
863 return pci_legacy_resume(dev);
864
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100865 if (pm) {
866 if (pm->thaw)
867 error = pm->thaw(dev);
868 } else {
869 pci_pm_reenable_device(pci_dev);
870 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100871
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200872 pci_dev->state_saved = false;
873
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100874 return error;
875}
876
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200877static int pci_pm_poweroff(struct device *dev)
878{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100879 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700880 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200881
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100882 if (pci_has_legacy_pm_support(pci_dev))
883 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100884
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100885 if (!pm) {
886 pci_pm_default_suspend(pci_dev);
887 goto Fixup;
888 }
889
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100890 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100891 int error;
892
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100893 error = pm->poweroff(dev);
894 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100895 if (error)
896 return error;
897 }
898
899 Fixup:
900 pci_fixup_device(pci_fixup_suspend, pci_dev);
901
902 return 0;
903}
904
905static int pci_pm_poweroff_noirq(struct device *dev)
906{
907 struct pci_dev *pci_dev = to_pci_dev(dev);
908 struct device_driver *drv = dev->driver;
909
910 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
911 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
912
913 if (!drv || !drv->pm)
914 return 0;
915
916 if (drv->pm->poweroff_noirq) {
917 int error;
918
919 error = drv->pm->poweroff_noirq(dev);
920 suspend_report_result(drv->pm->poweroff_noirq, error);
921 if (error)
922 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200923 }
924
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100925 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
926 pci_prepare_to_sleep(pci_dev);
927
Rafael J. Wysocki0b68c8e2012-08-12 23:26:07 +0200928 /*
929 * The reason for doing this here is the same as for the analogous code
930 * in pci_pm_suspend_noirq().
931 */
932 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
933 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
934
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100935 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200936}
937
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200938static int pci_pm_restore_noirq(struct device *dev)
939{
940 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200941 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200942 int error = 0;
943
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100944 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100945
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100946 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100947 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100948
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100949 if (drv && drv->pm && drv->pm->restore_noirq)
950 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200951
952 return error;
953}
954
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100955static int pci_pm_restore(struct device *dev)
956{
957 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700958 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100959 int error = 0;
960
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100961 /*
962 * This is necessary for the hibernation error path in which restore is
963 * called without restoring the standard config registers of the device.
964 */
965 if (pci_dev->state_saved)
966 pci_restore_standard_config(pci_dev);
967
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100968 if (pci_has_legacy_pm_support(pci_dev))
969 return pci_legacy_resume(dev);
970
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100971 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100972
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100973 if (pm) {
974 if (pm->restore)
975 error = pm->restore(dev);
976 } else {
977 pci_pm_reenable_device(pci_dev);
978 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100979
980 return error;
981}
982
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200983#else /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200984
985#define pci_pm_freeze NULL
986#define pci_pm_freeze_noirq NULL
987#define pci_pm_thaw NULL
988#define pci_pm_thaw_noirq NULL
989#define pci_pm_poweroff NULL
990#define pci_pm_poweroff_noirq NULL
991#define pci_pm_restore NULL
992#define pci_pm_restore_noirq NULL
993
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200994#endif /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200995
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100996#ifdef CONFIG_PM_RUNTIME
997
998static int pci_pm_runtime_suspend(struct device *dev)
999{
1000 struct pci_dev *pci_dev = to_pci_dev(dev);
1001 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1002 pci_power_t prev = pci_dev->current_state;
1003 int error;
1004
1005 if (!pm || !pm->runtime_suspend)
1006 return -ENOSYS;
1007
Huang Ying448bd852012-06-23 10:23:51 +08001008 pci_dev->no_d3cold = false;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001009 error = pm->runtime_suspend(dev);
1010 suspend_report_result(pm->runtime_suspend, error);
1011 if (error)
1012 return error;
Huang Ying448bd852012-06-23 10:23:51 +08001013 if (!pci_dev->d3cold_allowed)
1014 pci_dev->no_d3cold = true;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001015
1016 pci_fixup_device(pci_fixup_suspend, pci_dev);
1017
1018 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1019 && pci_dev->current_state != PCI_UNKNOWN) {
1020 WARN_ONCE(pci_dev->current_state != prev,
1021 "PCI PM: State of device not saved by %pF\n",
1022 pm->runtime_suspend);
1023 return 0;
1024 }
1025
1026 if (!pci_dev->state_saved)
1027 pci_save_state(pci_dev);
1028
1029 pci_finish_runtime_suspend(pci_dev);
1030
1031 return 0;
1032}
1033
1034static int pci_pm_runtime_resume(struct device *dev)
1035{
Huang Ying448bd852012-06-23 10:23:51 +08001036 int rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001037 struct pci_dev *pci_dev = to_pci_dev(dev);
1038 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1039
1040 if (!pm || !pm->runtime_resume)
1041 return -ENOSYS;
1042
Rafael J. Wysockidb288c92012-07-05 15:20:00 -06001043 pci_restore_standard_config(pci_dev);
1044 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001045 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1046 pci_fixup_device(pci_fixup_resume, pci_dev);
1047
Huang Ying448bd852012-06-23 10:23:51 +08001048 rc = pm->runtime_resume(dev);
1049
1050 pci_dev->runtime_d3cold = false;
1051
1052 return rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001053}
1054
1055static int pci_pm_runtime_idle(struct device *dev)
1056{
1057 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1058
1059 if (!pm)
1060 return -ENOSYS;
1061
1062 if (pm->runtime_idle) {
1063 int ret = pm->runtime_idle(dev);
1064 if (ret)
1065 return ret;
1066 }
1067
1068 pm_runtime_suspend(dev);
1069
1070 return 0;
1071}
1072
1073#else /* !CONFIG_PM_RUNTIME */
1074
1075#define pci_pm_runtime_suspend NULL
1076#define pci_pm_runtime_resume NULL
1077#define pci_pm_runtime_idle NULL
1078
1079#endif /* !CONFIG_PM_RUNTIME */
1080
Rafael J. Wysockiaa338602011-02-11 00:06:54 +01001081#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001082
Dmitry Torokhov8150f322009-07-24 22:11:32 -07001083const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001084 .prepare = pci_pm_prepare,
1085 .complete = pci_pm_complete,
1086 .suspend = pci_pm_suspend,
1087 .resume = pci_pm_resume,
1088 .freeze = pci_pm_freeze,
1089 .thaw = pci_pm_thaw,
1090 .poweroff = pci_pm_poweroff,
1091 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001092 .suspend_noirq = pci_pm_suspend_noirq,
1093 .resume_noirq = pci_pm_resume_noirq,
1094 .freeze_noirq = pci_pm_freeze_noirq,
1095 .thaw_noirq = pci_pm_thaw_noirq,
1096 .poweroff_noirq = pci_pm_poweroff_noirq,
1097 .restore_noirq = pci_pm_restore_noirq,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001098 .runtime_suspend = pci_pm_runtime_suspend,
1099 .runtime_resume = pci_pm_runtime_resume,
1100 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001101};
1102
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001103#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001104
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001105#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001106
1107#define PCI_PM_OPS_PTR NULL
1108
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001109#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001110
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001112 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001114 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001115 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 *
1117 * Adds the driver structure to the list of registered drivers.
1118 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -06001119 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 * no device was claimed during registration.
1121 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001122int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1123 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 /* initialize common driver fields */
1126 drv->driver.name = drv->name;
1127 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001128 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001129 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001130
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001131 spin_lock_init(&drv->dynids.lock);
1132 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
1134 /* register with core */
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +04001135 return driver_register(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136}
1137
1138/**
1139 * pci_unregister_driver - unregister a pci driver
1140 * @drv: the driver structure to unregister
1141 *
1142 * Deletes the driver structure from the list of registered PCI drivers,
1143 * gives it a chance to clean up by calling its remove() function for
1144 * each device it was responsible for, and marks those devices as
1145 * driverless.
1146 */
1147
1148void
1149pci_unregister_driver(struct pci_driver *drv)
1150{
1151 driver_unregister(&drv->driver);
1152 pci_free_dynids(drv);
1153}
1154
1155static struct pci_driver pci_compat_driver = {
1156 .name = "compat"
1157};
1158
1159/**
1160 * pci_dev_driver - get the pci_driver of a device
1161 * @dev: the device to query
1162 *
1163 * Returns the appropriate pci_driver structure or %NULL if there is no
1164 * registered driver for the device.
1165 */
1166struct pci_driver *
1167pci_dev_driver(const struct pci_dev *dev)
1168{
1169 if (dev->driver)
1170 return dev->driver;
1171 else {
1172 int i;
1173 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1174 if (dev->resource[i].flags & IORESOURCE_BUSY)
1175 return &pci_compat_driver;
1176 }
1177 return NULL;
1178}
1179
1180/**
1181 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001183 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 *
1185 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001186 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 * pci_device_id structure or %NULL if there is no match.
1188 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001189static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001191 struct pci_dev *pci_dev = to_pci_dev(dev);
1192 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 const struct pci_device_id *found_id;
1194
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001195 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 if (found_id)
1197 return 1;
1198
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001199 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200}
1201
1202/**
1203 * pci_dev_get - increments the reference count of the pci device structure
1204 * @dev: the device being referenced
1205 *
1206 * Each live reference to a device should be refcounted.
1207 *
1208 * Drivers for PCI devices should normally record such references in
1209 * their probe() methods, when they bind to a device, and release
1210 * them by calling pci_dev_put(), in their disconnect() methods.
1211 *
1212 * A pointer to the device with the incremented reference counter is returned.
1213 */
1214struct pci_dev *pci_dev_get(struct pci_dev *dev)
1215{
1216 if (dev)
1217 get_device(&dev->dev);
1218 return dev;
1219}
1220
1221/**
1222 * pci_dev_put - release a use of the pci device structure
1223 * @dev: device that's been disconnected
1224 *
1225 * Must be called when a user of a device is finished with it. When the last
1226 * user of the device calls this function, the memory of the device is freed.
1227 */
1228void pci_dev_put(struct pci_dev *dev)
1229{
1230 if (dev)
1231 put_device(&dev->dev);
1232}
1233
1234#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001235int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236{
1237 return -ENODEV;
1238}
1239#endif
1240
1241struct bus_type pci_bus_type = {
1242 .name = "pci",
1243 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001244 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001245 .probe = pci_device_probe,
1246 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001247 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001249 .bus_attrs = pci_bus_attrs,
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +04001250 .drv_attrs = pci_drv_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001251 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252};
1253
1254static int __init pci_driver_init(void)
1255{
1256 return bus_register(&pci_bus_type);
1257}
1258
1259postcore_initcall(pci_driver_init);
1260
Tejun Heo9dba9102009-09-03 15:26:36 +09001261EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001262EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001263EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264EXPORT_SYMBOL(pci_unregister_driver);
1265EXPORT_SYMBOL(pci_dev_driver);
1266EXPORT_SYMBOL(pci_bus_type);
1267EXPORT_SYMBOL(pci_dev_get);
1268EXPORT_SYMBOL(pci_dev_put);