blob: e6515e21afa3d7fdccd9edb1cbe68ea97253255c [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
766static int pci_pm_freeze(struct device *dev)
767{
768 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700769 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200770
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100771 if (pci_has_legacy_pm_support(pci_dev))
772 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100773
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100774 if (!pm) {
775 pci_pm_default_suspend(pci_dev);
776 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200777 }
778
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400779 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100780 if (pm->freeze) {
781 int error;
782
783 error = pm->freeze(dev);
784 suspend_report_result(pm->freeze, error);
785 if (error)
786 return error;
787 }
788
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100789 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200790}
791
792static int pci_pm_freeze_noirq(struct device *dev)
793{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100794 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200795 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200796
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100797 if (pci_has_legacy_pm_support(pci_dev))
798 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
799
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100800 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100801 int error;
802
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100803 error = drv->pm->freeze_noirq(dev);
804 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100805 if (error)
806 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200807 }
808
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100809 if (!pci_dev->state_saved)
810 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100811
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100812 pci_pm_set_unknown_state(pci_dev);
813
814 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200815}
816
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200817static int pci_pm_thaw_noirq(struct device *dev)
818{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100819 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200820 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200821 int error = 0;
822
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100823 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100824 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100825
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100826 pci_update_current_state(pci_dev, PCI_D0);
827
828 if (drv && drv->pm && drv->pm->thaw_noirq)
829 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200830
831 return error;
832}
833
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100834static int pci_pm_thaw(struct device *dev)
835{
836 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700837 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100838 int error = 0;
839
840 if (pci_has_legacy_pm_support(pci_dev))
841 return pci_legacy_resume(dev);
842
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100843 if (pm) {
844 if (pm->thaw)
845 error = pm->thaw(dev);
846 } else {
847 pci_pm_reenable_device(pci_dev);
848 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100849
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200850 pci_dev->state_saved = false;
851
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100852 return error;
853}
854
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200855static int pci_pm_poweroff(struct device *dev)
856{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100857 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700858 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200859
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100860 if (pci_has_legacy_pm_support(pci_dev))
861 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100862
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100863 if (!pm) {
864 pci_pm_default_suspend(pci_dev);
865 goto Fixup;
866 }
867
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400868 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100869 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100870 int error;
871
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100872 error = pm->poweroff(dev);
873 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100874 if (error)
875 return error;
876 }
877
878 Fixup:
879 pci_fixup_device(pci_fixup_suspend, pci_dev);
880
881 return 0;
882}
883
884static int pci_pm_poweroff_noirq(struct device *dev)
885{
886 struct pci_dev *pci_dev = to_pci_dev(dev);
887 struct device_driver *drv = dev->driver;
888
889 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
890 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
891
892 if (!drv || !drv->pm)
893 return 0;
894
895 if (drv->pm->poweroff_noirq) {
896 int error;
897
898 error = drv->pm->poweroff_noirq(dev);
899 suspend_report_result(drv->pm->poweroff_noirq, error);
900 if (error)
901 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200902 }
903
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100904 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
905 pci_prepare_to_sleep(pci_dev);
906
Rafael J. Wysocki0b68c8e2012-08-12 23:26:07 +0200907 /*
908 * The reason for doing this here is the same as for the analogous code
909 * in pci_pm_suspend_noirq().
910 */
911 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
912 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
913
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100914 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200915}
916
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200917static int pci_pm_restore_noirq(struct device *dev)
918{
919 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200920 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200921 int error = 0;
922
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100923 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100924
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100925 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100926 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100927
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100928 if (drv && drv->pm && drv->pm->restore_noirq)
929 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200930
931 return error;
932}
933
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100934static int pci_pm_restore(struct device *dev)
935{
936 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700937 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100938 int error = 0;
939
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100940 /*
941 * This is necessary for the hibernation error path in which restore is
942 * called without restoring the standard config registers of the device.
943 */
944 if (pci_dev->state_saved)
945 pci_restore_standard_config(pci_dev);
946
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100947 if (pci_has_legacy_pm_support(pci_dev))
948 return pci_legacy_resume(dev);
949
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100950 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100951
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100952 if (pm) {
953 if (pm->restore)
954 error = pm->restore(dev);
955 } else {
956 pci_pm_reenable_device(pci_dev);
957 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100958
959 return error;
960}
961
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200962#else /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200963
964#define pci_pm_freeze NULL
965#define pci_pm_freeze_noirq NULL
966#define pci_pm_thaw NULL
967#define pci_pm_thaw_noirq NULL
968#define pci_pm_poweroff NULL
969#define pci_pm_poweroff_noirq NULL
970#define pci_pm_restore NULL
971#define pci_pm_restore_noirq NULL
972
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200973#endif /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200974
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100975#ifdef CONFIG_PM_RUNTIME
976
977static int pci_pm_runtime_suspend(struct device *dev)
978{
979 struct pci_dev *pci_dev = to_pci_dev(dev);
980 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
981 pci_power_t prev = pci_dev->current_state;
982 int error;
983
Huang Ying967577b2012-11-20 16:08:22 +0800984 /*
985 * If pci_dev->driver is not set (unbound), the device should
986 * always remain in D0 regardless of the runtime PM status
987 */
988 if (!pci_dev->driver)
989 return 0;
990
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100991 if (!pm || !pm->runtime_suspend)
992 return -ENOSYS;
993
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400994 pci_dev->state_saved = false;
Huang Ying448bd852012-06-23 10:23:51 +0800995 pci_dev->no_d3cold = false;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100996 error = pm->runtime_suspend(dev);
997 suspend_report_result(pm->runtime_suspend, error);
998 if (error)
999 return error;
Huang Ying448bd852012-06-23 10:23:51 +08001000 if (!pci_dev->d3cold_allowed)
1001 pci_dev->no_d3cold = true;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001002
1003 pci_fixup_device(pci_fixup_suspend, pci_dev);
1004
1005 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1006 && pci_dev->current_state != PCI_UNKNOWN) {
1007 WARN_ONCE(pci_dev->current_state != prev,
1008 "PCI PM: State of device not saved by %pF\n",
1009 pm->runtime_suspend);
1010 return 0;
1011 }
1012
Dave Airlie42eca232012-10-29 17:26:54 -06001013 if (!pci_dev->state_saved) {
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001014 pci_save_state(pci_dev);
Dave Airlie42eca232012-10-29 17:26:54 -06001015 pci_finish_runtime_suspend(pci_dev);
1016 }
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001017
1018 return 0;
1019}
1020
1021static int pci_pm_runtime_resume(struct device *dev)
1022{
Huang Ying448bd852012-06-23 10:23:51 +08001023 int rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001024 struct pci_dev *pci_dev = to_pci_dev(dev);
1025 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
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_resume)
1035 return -ENOSYS;
1036
Rafael J. Wysockidb288c92012-07-05 15:20:00 -06001037 pci_restore_standard_config(pci_dev);
1038 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001039 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1040 pci_fixup_device(pci_fixup_resume, pci_dev);
1041
Huang Ying448bd852012-06-23 10:23:51 +08001042 rc = pm->runtime_resume(dev);
1043
1044 pci_dev->runtime_d3cold = false;
1045
1046 return rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001047}
1048
1049static int pci_pm_runtime_idle(struct device *dev)
1050{
Huang Ying967577b2012-11-20 16:08:22 +08001051 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001052 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001053 int ret = 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001054
Huang Ying967577b2012-11-20 16:08:22 +08001055 /*
1056 * If pci_dev->driver is not set (unbound), the device should
1057 * always remain in D0 regardless of the runtime PM status
1058 */
1059 if (!pci_dev->driver)
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001060 return 0;
Huang Ying967577b2012-11-20 16:08:22 +08001061
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001062 if (!pm)
1063 return -ENOSYS;
1064
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001065 if (pm->runtime_idle)
1066 ret = pm->runtime_idle(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001067
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001068 return ret;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001069}
1070
1071#else /* !CONFIG_PM_RUNTIME */
1072
1073#define pci_pm_runtime_suspend NULL
1074#define pci_pm_runtime_resume NULL
1075#define pci_pm_runtime_idle NULL
1076
1077#endif /* !CONFIG_PM_RUNTIME */
1078
Rafael J. Wysockiaa338602011-02-11 00:06:54 +01001079#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001080
Dmitry Torokhov8150f322009-07-24 22:11:32 -07001081const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001082 .prepare = pci_pm_prepare,
1083 .complete = pci_pm_complete,
1084 .suspend = pci_pm_suspend,
1085 .resume = pci_pm_resume,
1086 .freeze = pci_pm_freeze,
1087 .thaw = pci_pm_thaw,
1088 .poweroff = pci_pm_poweroff,
1089 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001090 .suspend_noirq = pci_pm_suspend_noirq,
1091 .resume_noirq = pci_pm_resume_noirq,
1092 .freeze_noirq = pci_pm_freeze_noirq,
1093 .thaw_noirq = pci_pm_thaw_noirq,
1094 .poweroff_noirq = pci_pm_poweroff_noirq,
1095 .restore_noirq = pci_pm_restore_noirq,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001096 .runtime_suspend = pci_pm_runtime_suspend,
1097 .runtime_resume = pci_pm_runtime_resume,
1098 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001099};
1100
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001101#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001102
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001103#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001104
1105#define PCI_PM_OPS_PTR NULL
1106
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001107#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001110 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001112 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001113 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 *
1115 * Adds the driver structure to the list of registered drivers.
1116 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -06001117 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 * no device was claimed during registration.
1119 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001120int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1121 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 /* initialize common driver fields */
1124 drv->driver.name = drv->name;
1125 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001126 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001127 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001128
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001129 spin_lock_init(&drv->dynids.lock);
1130 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
1132 /* register with core */
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +04001133 return driver_register(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134}
1135
1136/**
1137 * pci_unregister_driver - unregister a pci driver
1138 * @drv: the driver structure to unregister
1139 *
1140 * Deletes the driver structure from the list of registered PCI drivers,
1141 * gives it a chance to clean up by calling its remove() function for
1142 * each device it was responsible for, and marks those devices as
1143 * driverless.
1144 */
1145
1146void
1147pci_unregister_driver(struct pci_driver *drv)
1148{
1149 driver_unregister(&drv->driver);
1150 pci_free_dynids(drv);
1151}
1152
1153static struct pci_driver pci_compat_driver = {
1154 .name = "compat"
1155};
1156
1157/**
1158 * pci_dev_driver - get the pci_driver of a device
1159 * @dev: the device to query
1160 *
1161 * Returns the appropriate pci_driver structure or %NULL if there is no
1162 * registered driver for the device.
1163 */
1164struct pci_driver *
1165pci_dev_driver(const struct pci_dev *dev)
1166{
1167 if (dev->driver)
1168 return dev->driver;
1169 else {
1170 int i;
1171 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1172 if (dev->resource[i].flags & IORESOURCE_BUSY)
1173 return &pci_compat_driver;
1174 }
1175 return NULL;
1176}
1177
1178/**
1179 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001181 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 *
1183 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001184 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 * pci_device_id structure or %NULL if there is no match.
1186 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001187static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001189 struct pci_dev *pci_dev = to_pci_dev(dev);
Yinghai Lu58d9a382013-01-21 13:20:51 -08001190 struct pci_driver *pci_drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 const struct pci_device_id *found_id;
1192
Yinghai Lu58d9a382013-01-21 13:20:51 -08001193 if (!pci_dev->match_driver)
1194 return 0;
1195
1196 pci_drv = to_pci_driver(drv);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001197 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 if (found_id)
1199 return 1;
1200
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001201 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202}
1203
1204/**
1205 * pci_dev_get - increments the reference count of the pci device structure
1206 * @dev: the device being referenced
1207 *
1208 * Each live reference to a device should be refcounted.
1209 *
1210 * Drivers for PCI devices should normally record such references in
1211 * their probe() methods, when they bind to a device, and release
1212 * them by calling pci_dev_put(), in their disconnect() methods.
1213 *
1214 * A pointer to the device with the incremented reference counter is returned.
1215 */
1216struct pci_dev *pci_dev_get(struct pci_dev *dev)
1217{
1218 if (dev)
1219 get_device(&dev->dev);
1220 return dev;
1221}
1222
1223/**
1224 * pci_dev_put - release a use of the pci device structure
1225 * @dev: device that's been disconnected
1226 *
1227 * Must be called when a user of a device is finished with it. When the last
1228 * user of the device calls this function, the memory of the device is freed.
1229 */
1230void pci_dev_put(struct pci_dev *dev)
1231{
1232 if (dev)
1233 put_device(&dev->dev);
1234}
1235
Bill Pemberton8ccc9aa2012-11-21 15:34:58 -05001236static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1237{
1238 struct pci_dev *pdev;
1239
1240 if (!dev)
1241 return -ENODEV;
1242
1243 pdev = to_pci_dev(dev);
1244 if (!pdev)
1245 return -ENODEV;
1246
1247 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1248 return -ENOMEM;
1249
1250 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1251 return -ENOMEM;
1252
1253 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1254 pdev->subsystem_device))
1255 return -ENOMEM;
1256
1257 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1258 return -ENOMEM;
1259
1260 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1261 pdev->vendor, pdev->device,
1262 pdev->subsystem_vendor, pdev->subsystem_device,
1263 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1264 (u8)(pdev->class)))
1265 return -ENOMEM;
1266 return 0;
1267}
1268
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269struct bus_type pci_bus_type = {
1270 .name = "pci",
1271 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001272 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001273 .probe = pci_device_probe,
1274 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001275 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001277 .bus_attrs = pci_bus_attrs,
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +04001278 .drv_attrs = pci_drv_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001279 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280};
1281
1282static int __init pci_driver_init(void)
1283{
1284 return bus_register(&pci_bus_type);
1285}
1286
1287postcore_initcall(pci_driver_init);
1288
Tejun Heo9dba9102009-09-03 15:26:36 +09001289EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001290EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001291EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292EXPORT_SYMBOL(pci_unregister_driver);
1293EXPORT_SYMBOL(pci_dev_driver);
1294EXPORT_SYMBOL(pci_bus_type);
1295EXPORT_SYMBOL(pci_dev_get);
1296EXPORT_SYMBOL(pci_dev_put);