blob: bf0cee629b60f8bb763b4407f631e7ba7e778aa8 [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 -0700142static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Chris Wright09943752009-02-23 21:52:23 -0800144/**
145 * store_remove_id - remove a PCI device ID from this driver
146 * @driver: target device driver
147 * @buf: buffer for scanning device ID data
148 * @count: input size
149 *
150 * Removes a dynamic pci device ID to this driver.
151 */
152static ssize_t
153store_remove_id(struct device_driver *driver, const char *buf, size_t count)
154{
155 struct pci_dynid *dynid, *n;
156 struct pci_driver *pdrv = to_pci_driver(driver);
157 __u32 vendor, device, subvendor = PCI_ANY_ID,
158 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
159 int fields = 0;
160 int retval = -ENODEV;
161
162 fields = sscanf(buf, "%x %x %x %x %x %x",
163 &vendor, &device, &subvendor, &subdevice,
164 &class, &class_mask);
165 if (fields < 2)
166 return -EINVAL;
167
168 spin_lock(&pdrv->dynids.lock);
169 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
170 struct pci_device_id *id = &dynid->id;
171 if ((id->vendor == vendor) &&
172 (id->device == device) &&
173 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
174 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
175 !((id->class ^ class) & class_mask)) {
176 list_del(&dynid->node);
177 kfree(dynid);
178 retval = 0;
179 break;
180 }
181 }
182 spin_unlock(&pdrv->dynids.lock);
183
184 if (retval)
185 return retval;
186 return count;
187}
188static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190static int
Alan Sterned283e92012-01-24 14:35:13 -0500191pci_create_newid_files(struct pci_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192{
193 int error = 0;
Alan Sterned283e92012-01-24 14:35:13 -0500194
195 if (drv->probe != NULL) {
Greg Kroah-Hartman03d43b12007-11-28 12:23:18 -0800196 error = driver_create_file(&drv->driver, &driver_attr_new_id);
Alan Sterned283e92012-01-24 14:35:13 -0500197 if (error == 0) {
198 error = driver_create_file(&drv->driver,
199 &driver_attr_remove_id);
200 if (error)
201 driver_remove_file(&drv->driver,
202 &driver_attr_new_id);
203 }
204 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 return error;
206}
207
Alan Sterned283e92012-01-24 14:35:13 -0500208static void pci_remove_newid_files(struct pci_driver *drv)
Chris Wright09943752009-02-23 21:52:23 -0800209{
210 driver_remove_file(&drv->driver, &driver_attr_remove_id);
Alan Sterned283e92012-01-24 14:35:13 -0500211 driver_remove_file(&drv->driver, &driver_attr_new_id);
Chris Wright09943752009-02-23 21:52:23 -0800212}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213#else /* !CONFIG_HOTPLUG */
Alan Sterned283e92012-01-24 14:35:13 -0500214static inline int pci_create_newid_files(struct pci_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
216 return 0;
217}
Alan Sterned283e92012-01-24 14:35:13 -0500218static inline void pci_remove_newid_files(struct pci_driver *drv) {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219#endif
220
221/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700222 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700224 * @dev: the PCI device structure to match against.
225 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700227 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700229 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200230 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700231 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700233const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
234 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700236 if (ids) {
237 while (ids->vendor || ids->subvendor || ids->class_mask) {
238 if (pci_match_one_device(ids, dev))
239 return ids;
240 ids++;
241 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 }
243 return NULL;
244}
245
246/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800247 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700248 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200249 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700250 *
251 * Used by a driver to check whether a PCI device present in the
252 * system is in its list of supported devices. Returns the matching
253 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200255static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
256 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700257{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700258 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
Russell King7461b602006-11-29 21:18:04 +0000260 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700261 spin_lock(&drv->dynids.lock);
262 list_for_each_entry(dynid, &drv->dynids.list, node) {
263 if (pci_match_one_device(&dynid->id, dev)) {
264 spin_unlock(&drv->dynids.lock);
265 return &dynid->id;
266 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700268 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000269
270 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
272
Rusty Russell873392c2008-12-31 23:54:56 +1030273struct drv_dev_and_id {
274 struct pci_driver *drv;
275 struct pci_dev *dev;
276 const struct pci_device_id *id;
277};
278
279static long local_pci_probe(void *_ddi)
280{
281 struct drv_dev_and_id *ddi = _ddi;
Alan Sternf3ec4f82010-06-08 15:23:51 -0400282 struct device *dev = &ddi->dev->dev;
283 int rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030284
Alan Sternf3ec4f82010-06-08 15:23:51 -0400285 /* Unbound PCI devices are always set to disabled and suspended.
286 * During probe, the device is set to enabled and active and the
287 * usage count is incremented. If the driver supports runtime PM,
288 * it should call pm_runtime_put_noidle() in its probe routine and
289 * pm_runtime_get_noresume() in its remove routine.
290 */
291 pm_runtime_get_noresume(dev);
292 pm_runtime_set_active(dev);
293 pm_runtime_enable(dev);
294
295 rc = ddi->drv->probe(ddi->dev, ddi->id);
296 if (rc) {
297 pm_runtime_disable(dev);
298 pm_runtime_set_suspended(dev);
299 pm_runtime_put_noidle(dev);
300 }
301 return rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030302}
303
Andi Kleend42c6992005-07-06 19:56:03 +0200304static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
305 const struct pci_device_id *id)
306{
Rusty Russell873392c2008-12-31 23:54:56 +1030307 int error, node;
308 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700309
Rusty Russell873392c2008-12-31 23:54:56 +1030310 /* Execute driver initialization on node where the device's
311 bus is attached to. This way the driver likely allocates
312 its local memory on the right node without any need to
313 change it. */
314 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700315 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030316 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030317
318 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030319 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030320 if (cpu < nr_cpu_ids)
321 error = work_on_cpu(cpu, local_pci_probe, &ddi);
322 else
323 error = local_pci_probe(&ddi);
324 put_online_cpus();
325 } else
326 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200327 return error;
328}
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330/**
Randy Dunlap23ea3792010-11-18 15:02:31 -0800331 * __pci_device_probe - check if a driver wants to claim a specific PCI device
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700332 * @drv: driver to call to check if it wants the PCI device
333 * @pci_dev: PCI device being probed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700335 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
337 */
338static int
339__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700340{
341 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 int error = 0;
343
344 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700345 error = -ENODEV;
346
347 id = pci_match_device(drv, pci_dev);
348 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200349 error = pci_call_probe(drv, pci_dev, id);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700350 if (error >= 0) {
351 pci_dev->driver = drv;
352 error = 0;
353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
355 return error;
356}
357
358static int pci_device_probe(struct device * dev)
359{
360 int error = 0;
361 struct pci_driver *drv;
362 struct pci_dev *pci_dev;
363
364 drv = to_pci_driver(dev->driver);
365 pci_dev = to_pci_dev(dev);
366 pci_dev_get(pci_dev);
367 error = __pci_device_probe(drv, pci_dev);
368 if (error)
369 pci_dev_put(pci_dev);
370
371 return error;
372}
373
374static int pci_device_remove(struct device * dev)
375{
376 struct pci_dev * pci_dev = to_pci_dev(dev);
377 struct pci_driver * drv = pci_dev->driver;
378
379 if (drv) {
Alan Sternf3ec4f82010-06-08 15:23:51 -0400380 if (drv->remove) {
381 pm_runtime_get_sync(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 drv->remove(pci_dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400383 pm_runtime_put_noidle(dev);
384 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 pci_dev->driver = NULL;
386 }
387
Alan Sternf3ec4f82010-06-08 15:23:51 -0400388 /* Undo the runtime PM settings in local_pci_probe() */
389 pm_runtime_disable(dev);
390 pm_runtime_set_suspended(dev);
391 pm_runtime_put_noidle(dev);
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700394 * If the device is still on, set the power state as "unknown",
395 * since it might change by the next time we load the driver.
396 */
397 if (pci_dev->current_state == PCI_D0)
398 pci_dev->current_state = PCI_UNKNOWN;
399
400 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 * We would love to complain here if pci_dev->is_enabled is set, that
402 * the driver should have called pci_disable_device(), but the
403 * unfortunate fact is there are too many odd BIOS and bridge setups
404 * that don't like drivers doing that all of the time.
405 * Oh well, we can dream of sane hardware when we sleep, no matter how
406 * horrible the crap we have to deal with is when we are awake...
407 */
408
409 pci_dev_put(pci_dev);
410 return 0;
411}
412
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200413static void pci_device_shutdown(struct device *dev)
414{
415 struct pci_dev *pci_dev = to_pci_dev(dev);
416 struct pci_driver *drv = pci_dev->driver;
417
418 if (drv && drv->shutdown)
419 drv->shutdown(pci_dev);
420 pci_msi_shutdown(pci_dev);
421 pci_msix_shutdown(pci_dev);
Rafael J. Wysocki5b415f12012-02-07 00:50:35 +0100422
423 /*
Khalid Azizb566a222012-04-27 13:00:33 -0600424 * Turn off Bus Master bit on the device to tell it to not
425 * continue to do DMA
426 */
427 pci_disable_device(pci_dev);
428
429 /*
Rafael J. Wysocki5b415f12012-02-07 00:50:35 +0100430 * Devices may be enabled to wake up by runtime PM, but they need not
431 * be supposed to wake up the system from its "power off" state (e.g.
432 * ACPI S5). Therefore disable wakeup for all devices that aren't
433 * supposed to wake up the system at this point. The state argument
434 * will be ignored by pci_enable_wake().
435 */
436 if (!device_may_wakeup(dev))
437 pci_enable_wake(pci_dev, PCI_UNKNOWN, false);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200438}
439
Rafael J. Wysockiaa338602011-02-11 00:06:54 +0100440#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100441
442/* Auxiliary functions used for system resume and run-time resume. */
443
444/**
445 * pci_restore_standard_config - restore standard config registers of PCI device
446 * @pci_dev: PCI device to handle
447 */
448static int pci_restore_standard_config(struct pci_dev *pci_dev)
449{
450 pci_update_current_state(pci_dev, PCI_UNKNOWN);
451
452 if (pci_dev->current_state != PCI_D0) {
453 int error = pci_set_power_state(pci_dev, PCI_D0);
454 if (error)
455 return error;
456 }
457
Jon Mason1d3c16a2010-11-30 17:43:26 -0600458 pci_restore_state(pci_dev);
459 return 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100460}
461
462static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
463{
464 pci_restore_standard_config(pci_dev);
465 pci_fixup_device(pci_fixup_resume_early, pci_dev);
466}
467
468#endif
469
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200470#ifdef CONFIG_PM_SLEEP
471
472/*
473 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100474 * or not even a driver at all (second part).
475 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100476static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200477{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200478 /*
479 * mark its power state as "unknown", since we don't know if
480 * e.g. the BIOS will change its device state when we suspend.
481 */
482 if (pci_dev->current_state == PCI_D0)
483 pci_dev->current_state = PCI_UNKNOWN;
484}
485
486/*
487 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100488 * or not even a driver at all (second part).
489 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100490static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100491{
492 int retval;
493
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200494 /* if the device was enabled before suspend, reenable */
495 retval = pci_reenable_device(pci_dev);
496 /*
497 * if the device was busmaster before the suspend, make it busmaster
498 * again
499 */
500 if (pci_dev->is_busmaster)
501 pci_set_master(pci_dev);
502
503 return retval;
504}
505
506static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507{
508 struct pci_dev * pci_dev = to_pci_dev(dev);
509 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100510
Andrew Morton02669492006-03-23 01:38:34 -0800511 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100512 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100513 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100514
Frans Pop57ef8022009-03-16 22:39:56 +0100515 error = drv->suspend(pci_dev, state);
516 suspend_report_result(drv->suspend, error);
517 if (error)
518 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100519
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100520 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100521 && pci_dev->current_state != PCI_UNKNOWN) {
522 WARN_ONCE(pci_dev->current_state != prev,
523 "PCI PM: Device state not saved by %pF\n",
524 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100525 }
Andrew Morton02669492006-03-23 01:38:34 -0800526 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100527
528 pci_fixup_device(pci_fixup_suspend, pci_dev);
529
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100530 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531}
532
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200533static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700534{
535 struct pci_dev * pci_dev = to_pci_dev(dev);
536 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700537
538 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100539 pci_power_t prev = pci_dev->current_state;
540 int error;
541
Frans Pop57ef8022009-03-16 22:39:56 +0100542 error = drv->suspend_late(pci_dev, state);
543 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100544 if (error)
545 return error;
546
547 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
548 && pci_dev->current_state != PCI_UNKNOWN) {
549 WARN_ONCE(pci_dev->current_state != prev,
550 "PCI PM: Device state not saved by %pF\n",
551 drv->suspend_late);
552 return 0;
553 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700554 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100555
556 if (!pci_dev->state_saved)
557 pci_save_state(pci_dev);
558
559 pci_pm_set_unknown_state(pci_dev);
560
561 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700562}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100564static int pci_legacy_resume_early(struct device *dev)
565{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100566 struct pci_dev * pci_dev = to_pci_dev(dev);
567 struct pci_driver * drv = pci_dev->driver;
568
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100569 return drv && drv->resume_early ?
570 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100571}
572
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200573static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574{
575 struct pci_dev * pci_dev = to_pci_dev(dev);
576 struct pci_driver * drv = pci_dev->driver;
577
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100578 pci_fixup_device(pci_fixup_resume, pci_dev);
579
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100580 return drv && drv->resume ?
581 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100584/* Auxiliary functions used by the new power management framework */
585
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100586static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100587{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100588 pci_fixup_device(pci_fixup_resume, pci_dev);
589
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100590 if (!pci_is_bridge(pci_dev))
591 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100592}
593
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100594static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100595{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100596 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100597 if (!pci_is_bridge(pci_dev))
598 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100599}
600
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100601static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
602{
603 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100604 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100605 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100606
607 /*
608 * Legacy PM support is used by default, so warn if the new framework is
609 * supported as well. Drivers are supposed to support either the
610 * former, or the latter, but not both at the same time.
611 */
David Fries82440a82011-11-20 15:29:46 -0600612 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
613 drv->name, pci_dev->vendor, pci_dev->device);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100614
615 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100616}
617
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100618/* New power management framework */
619
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200620static int pci_pm_prepare(struct device *dev)
621{
622 struct device_driver *drv = dev->driver;
623 int error = 0;
624
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100625 /*
Rafael J. Wysockieea3fc032011-07-06 10:51:40 +0200626 * If a PCI device configured to wake up the system from sleep states
627 * has been suspended at run time and there's a resume request pending
628 * for it, this is equivalent to the device signaling wakeup, so the
629 * system suspend operation should be aborted.
630 */
631 pm_runtime_get_noresume(dev);
632 if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
633 pm_wakeup_event(dev, 0);
634
635 if (pm_wakeup_pending()) {
636 pm_runtime_put_sync(dev);
637 return -EBUSY;
638 }
639
640 /*
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100641 * PCI devices suspended at run time need to be resumed at this
642 * point, because in general it is necessary to reconfigure them for
643 * system suspend. Namely, if the device is supposed to wake up the
644 * system from the sleep state, we may need to reconfigure it for this
645 * purpose. In turn, if the device is not supposed to wake up the
646 * system from the sleep state, we'll have to prevent it from signaling
647 * wake-up.
648 */
Rafael J. Wysockieea3fc032011-07-06 10:51:40 +0200649 pm_runtime_resume(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100650
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200651 if (drv && drv->pm && drv->pm->prepare)
652 error = drv->pm->prepare(dev);
653
654 return error;
655}
656
657static void pci_pm_complete(struct device *dev)
658{
659 struct device_driver *drv = dev->driver;
660
661 if (drv && drv->pm && drv->pm->complete)
662 drv->pm->complete(dev);
Rafael J. Wysockia5f76d52011-06-21 23:47:15 +0200663
664 pm_runtime_put_sync(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200665}
666
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100667#else /* !CONFIG_PM_SLEEP */
668
669#define pci_pm_prepare NULL
670#define pci_pm_complete NULL
671
672#endif /* !CONFIG_PM_SLEEP */
673
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200674#ifdef CONFIG_SUSPEND
675
676static int pci_pm_suspend(struct device *dev)
677{
678 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700679 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200680
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100681 if (pci_has_legacy_pm_support(pci_dev))
682 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100683
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100684 if (!pm) {
685 pci_pm_default_suspend(pci_dev);
686 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200687 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100688
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100689 if (pm->suspend) {
690 pci_power_t prev = pci_dev->current_state;
691 int error;
692
693 error = pm->suspend(dev);
694 suspend_report_result(pm->suspend, error);
695 if (error)
696 return error;
697
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100698 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100699 && pci_dev->current_state != PCI_UNKNOWN) {
700 WARN_ONCE(pci_dev->current_state != prev,
701 "PCI PM: State of device not saved by %pF\n",
702 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100703 }
704 }
705
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100706 Fixup:
707 pci_fixup_device(pci_fixup_suspend, pci_dev);
708
709 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200710}
711
712static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900713{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100714 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700715 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900716
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100717 if (pci_has_legacy_pm_support(pci_dev))
718 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
719
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100720 if (!pm) {
721 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100722 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100723 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100724
725 if (pm->suspend_noirq) {
726 pci_power_t prev = pci_dev->current_state;
727 int error;
728
729 error = pm->suspend_noirq(dev);
730 suspend_report_result(pm->suspend_noirq, error);
731 if (error)
732 return error;
733
734 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
735 && pci_dev->current_state != PCI_UNKNOWN) {
736 WARN_ONCE(pci_dev->current_state != prev,
737 "PCI PM: State of device not saved by %pF\n",
738 pm->suspend_noirq);
739 return 0;
740 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200741 }
742
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100743 if (!pci_dev->state_saved) {
744 pci_save_state(pci_dev);
745 if (!pci_is_bridge(pci_dev))
746 pci_prepare_to_sleep(pci_dev);
747 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100748
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100749 pci_pm_set_unknown_state(pci_dev);
750
751 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900752}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200754static int pci_pm_resume_noirq(struct device *dev)
755{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100756 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200757 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200758 int error = 0;
759
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100760 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100761
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100762 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100763 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100764
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100765 if (drv && drv->pm && drv->pm->resume_noirq)
766 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200767
768 return error;
769}
770
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100771static int pci_pm_resume(struct device *dev)
772{
773 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700774 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100775 int error = 0;
776
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100777 /*
778 * This is necessary for the suspend error path in which resume is
779 * called without restoring the standard config registers of the device.
780 */
781 if (pci_dev->state_saved)
782 pci_restore_standard_config(pci_dev);
783
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100784 if (pci_has_legacy_pm_support(pci_dev))
785 return pci_legacy_resume(dev);
786
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100787 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100788
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100789 if (pm) {
790 if (pm->resume)
791 error = pm->resume(dev);
792 } else {
793 pci_pm_reenable_device(pci_dev);
794 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100795
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200796 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100797}
798
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200799#else /* !CONFIG_SUSPEND */
800
801#define pci_pm_suspend NULL
802#define pci_pm_suspend_noirq NULL
803#define pci_pm_resume NULL
804#define pci_pm_resume_noirq NULL
805
806#endif /* !CONFIG_SUSPEND */
807
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200808#ifdef CONFIG_HIBERNATE_CALLBACKS
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200809
810static int pci_pm_freeze(struct device *dev)
811{
812 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700813 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200814
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100815 if (pci_has_legacy_pm_support(pci_dev))
816 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100817
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100818 if (!pm) {
819 pci_pm_default_suspend(pci_dev);
820 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200821 }
822
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100823 if (pm->freeze) {
824 int error;
825
826 error = pm->freeze(dev);
827 suspend_report_result(pm->freeze, error);
828 if (error)
829 return error;
830 }
831
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100832 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200833}
834
835static int pci_pm_freeze_noirq(struct device *dev)
836{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100837 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200838 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200839
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100840 if (pci_has_legacy_pm_support(pci_dev))
841 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
842
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100843 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100844 int error;
845
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100846 error = drv->pm->freeze_noirq(dev);
847 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100848 if (error)
849 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200850 }
851
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100852 if (!pci_dev->state_saved)
853 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100854
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100855 pci_pm_set_unknown_state(pci_dev);
856
857 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200858}
859
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200860static int pci_pm_thaw_noirq(struct device *dev)
861{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100862 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200863 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200864 int error = 0;
865
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100866 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100867 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100868
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100869 pci_update_current_state(pci_dev, PCI_D0);
870
871 if (drv && drv->pm && drv->pm->thaw_noirq)
872 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200873
874 return error;
875}
876
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100877static int pci_pm_thaw(struct device *dev)
878{
879 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. Wysockif6dc1e52009-01-07 13:12:22 +0100881 int error = 0;
882
883 if (pci_has_legacy_pm_support(pci_dev))
884 return pci_legacy_resume(dev);
885
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100886 if (pm) {
887 if (pm->thaw)
888 error = pm->thaw(dev);
889 } else {
890 pci_pm_reenable_device(pci_dev);
891 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100892
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200893 pci_dev->state_saved = false;
894
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100895 return error;
896}
897
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200898static int pci_pm_poweroff(struct device *dev)
899{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100900 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700901 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200902
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100903 if (pci_has_legacy_pm_support(pci_dev))
904 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100905
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100906 if (!pm) {
907 pci_pm_default_suspend(pci_dev);
908 goto Fixup;
909 }
910
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100911 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100912 int error;
913
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100914 error = pm->poweroff(dev);
915 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100916 if (error)
917 return error;
918 }
919
920 Fixup:
921 pci_fixup_device(pci_fixup_suspend, pci_dev);
922
923 return 0;
924}
925
926static int pci_pm_poweroff_noirq(struct device *dev)
927{
928 struct pci_dev *pci_dev = to_pci_dev(dev);
929 struct device_driver *drv = dev->driver;
930
931 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
932 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
933
934 if (!drv || !drv->pm)
935 return 0;
936
937 if (drv->pm->poweroff_noirq) {
938 int error;
939
940 error = drv->pm->poweroff_noirq(dev);
941 suspend_report_result(drv->pm->poweroff_noirq, error);
942 if (error)
943 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200944 }
945
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100946 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
947 pci_prepare_to_sleep(pci_dev);
948
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100949 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200950}
951
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200952static int pci_pm_restore_noirq(struct device *dev)
953{
954 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200955 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200956 int error = 0;
957
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100958 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100959
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100960 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100961 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100962
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100963 if (drv && drv->pm && drv->pm->restore_noirq)
964 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200965
966 return error;
967}
968
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100969static int pci_pm_restore(struct device *dev)
970{
971 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700972 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100973 int error = 0;
974
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100975 /*
976 * This is necessary for the hibernation error path in which restore is
977 * called without restoring the standard config registers of the device.
978 */
979 if (pci_dev->state_saved)
980 pci_restore_standard_config(pci_dev);
981
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100982 if (pci_has_legacy_pm_support(pci_dev))
983 return pci_legacy_resume(dev);
984
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100985 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100986
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100987 if (pm) {
988 if (pm->restore)
989 error = pm->restore(dev);
990 } else {
991 pci_pm_reenable_device(pci_dev);
992 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100993
994 return error;
995}
996
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200997#else /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200998
999#define pci_pm_freeze NULL
1000#define pci_pm_freeze_noirq NULL
1001#define pci_pm_thaw NULL
1002#define pci_pm_thaw_noirq NULL
1003#define pci_pm_poweroff NULL
1004#define pci_pm_poweroff_noirq NULL
1005#define pci_pm_restore NULL
1006#define pci_pm_restore_noirq NULL
1007
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +02001008#endif /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001009
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001010#ifdef CONFIG_PM_RUNTIME
1011
1012static int pci_pm_runtime_suspend(struct device *dev)
1013{
1014 struct pci_dev *pci_dev = to_pci_dev(dev);
1015 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1016 pci_power_t prev = pci_dev->current_state;
1017 int error;
1018
1019 if (!pm || !pm->runtime_suspend)
1020 return -ENOSYS;
1021
1022 error = pm->runtime_suspend(dev);
1023 suspend_report_result(pm->runtime_suspend, error);
1024 if (error)
1025 return error;
1026
1027 pci_fixup_device(pci_fixup_suspend, pci_dev);
1028
1029 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1030 && pci_dev->current_state != PCI_UNKNOWN) {
1031 WARN_ONCE(pci_dev->current_state != prev,
1032 "PCI PM: State of device not saved by %pF\n",
1033 pm->runtime_suspend);
1034 return 0;
1035 }
1036
1037 if (!pci_dev->state_saved)
1038 pci_save_state(pci_dev);
1039
1040 pci_finish_runtime_suspend(pci_dev);
1041
1042 return 0;
1043}
1044
1045static int pci_pm_runtime_resume(struct device *dev)
1046{
1047 struct pci_dev *pci_dev = to_pci_dev(dev);
1048 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1049
1050 if (!pm || !pm->runtime_resume)
1051 return -ENOSYS;
1052
1053 pci_pm_default_resume_early(pci_dev);
1054 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1055 pci_fixup_device(pci_fixup_resume, pci_dev);
1056
1057 return pm->runtime_resume(dev);
1058}
1059
1060static int pci_pm_runtime_idle(struct device *dev)
1061{
1062 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1063
1064 if (!pm)
1065 return -ENOSYS;
1066
1067 if (pm->runtime_idle) {
1068 int ret = pm->runtime_idle(dev);
1069 if (ret)
1070 return ret;
1071 }
1072
1073 pm_runtime_suspend(dev);
1074
1075 return 0;
1076}
1077
1078#else /* !CONFIG_PM_RUNTIME */
1079
1080#define pci_pm_runtime_suspend NULL
1081#define pci_pm_runtime_resume NULL
1082#define pci_pm_runtime_idle NULL
1083
1084#endif /* !CONFIG_PM_RUNTIME */
1085
Rafael J. Wysockiaa338602011-02-11 00:06:54 +01001086#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001087
Dmitry Torokhov8150f322009-07-24 22:11:32 -07001088const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001089 .prepare = pci_pm_prepare,
1090 .complete = pci_pm_complete,
1091 .suspend = pci_pm_suspend,
1092 .resume = pci_pm_resume,
1093 .freeze = pci_pm_freeze,
1094 .thaw = pci_pm_thaw,
1095 .poweroff = pci_pm_poweroff,
1096 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001097 .suspend_noirq = pci_pm_suspend_noirq,
1098 .resume_noirq = pci_pm_resume_noirq,
1099 .freeze_noirq = pci_pm_freeze_noirq,
1100 .thaw_noirq = pci_pm_thaw_noirq,
1101 .poweroff_noirq = pci_pm_poweroff_noirq,
1102 .restore_noirq = pci_pm_restore_noirq,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001103 .runtime_suspend = pci_pm_runtime_suspend,
1104 .runtime_resume = pci_pm_runtime_resume,
1105 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001106};
1107
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001108#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001109
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001110#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001111
1112#define PCI_PM_OPS_PTR NULL
1113
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001114#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001115
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001117 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001119 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001120 * @mod_name: module name string
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 *
1122 * Adds the driver structure to the list of registered drivers.
1123 * Returns a negative value on error, otherwise 0.
Steven Coleeaae4b32005-05-03 18:38:30 -06001124 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 * no device was claimed during registration.
1126 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001127int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1128 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129{
1130 int error;
1131
1132 /* initialize common driver fields */
1133 drv->driver.name = drv->name;
1134 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001135 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001136 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001137
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001138 spin_lock_init(&drv->dynids.lock);
1139 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
1141 /* register with core */
1142 error = driver_register(&drv->driver);
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001143 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001144 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
Alan Sterned283e92012-01-24 14:35:13 -05001146 error = pci_create_newid_files(drv);
Akinobu Mita50bf14b2006-11-08 19:53:59 -08001147 if (error)
Chris Wright09943752009-02-23 21:52:23 -08001148 goto out_newid;
Chris Wright09943752009-02-23 21:52:23 -08001149out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 return error;
Chris Wright09943752009-02-23 21:52:23 -08001151
Chris Wright09943752009-02-23 21:52:23 -08001152out_newid:
1153 driver_unregister(&drv->driver);
1154 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155}
1156
1157/**
1158 * pci_unregister_driver - unregister a pci driver
1159 * @drv: the driver structure to unregister
1160 *
1161 * Deletes the driver structure from the list of registered PCI drivers,
1162 * gives it a chance to clean up by calling its remove() function for
1163 * each device it was responsible for, and marks those devices as
1164 * driverless.
1165 */
1166
1167void
1168pci_unregister_driver(struct pci_driver *drv)
1169{
Alan Sterned283e92012-01-24 14:35:13 -05001170 pci_remove_newid_files(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 driver_unregister(&drv->driver);
1172 pci_free_dynids(drv);
1173}
1174
1175static struct pci_driver pci_compat_driver = {
1176 .name = "compat"
1177};
1178
1179/**
1180 * pci_dev_driver - get the pci_driver of a device
1181 * @dev: the device to query
1182 *
1183 * Returns the appropriate pci_driver structure or %NULL if there is no
1184 * registered driver for the device.
1185 */
1186struct pci_driver *
1187pci_dev_driver(const struct pci_dev *dev)
1188{
1189 if (dev->driver)
1190 return dev->driver;
1191 else {
1192 int i;
1193 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1194 if (dev->resource[i].flags & IORESOURCE_BUSY)
1195 return &pci_compat_driver;
1196 }
1197 return NULL;
1198}
1199
1200/**
1201 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001203 * @drv: the device driver to search for matching PCI device id structures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 *
1205 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001206 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 * pci_device_id structure or %NULL if there is no match.
1208 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001209static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001211 struct pci_dev *pci_dev = to_pci_dev(dev);
1212 struct pci_driver *pci_drv = to_pci_driver(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 const struct pci_device_id *found_id;
1214
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001215 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 if (found_id)
1217 return 1;
1218
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001219 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220}
1221
1222/**
1223 * pci_dev_get - increments the reference count of the pci device structure
1224 * @dev: the device being referenced
1225 *
1226 * Each live reference to a device should be refcounted.
1227 *
1228 * Drivers for PCI devices should normally record such references in
1229 * their probe() methods, when they bind to a device, and release
1230 * them by calling pci_dev_put(), in their disconnect() methods.
1231 *
1232 * A pointer to the device with the incremented reference counter is returned.
1233 */
1234struct pci_dev *pci_dev_get(struct pci_dev *dev)
1235{
1236 if (dev)
1237 get_device(&dev->dev);
1238 return dev;
1239}
1240
1241/**
1242 * pci_dev_put - release a use of the pci device structure
1243 * @dev: device that's been disconnected
1244 *
1245 * Must be called when a user of a device is finished with it. When the last
1246 * user of the device calls this function, the memory of the device is freed.
1247 */
1248void pci_dev_put(struct pci_dev *dev)
1249{
1250 if (dev)
1251 put_device(&dev->dev);
1252}
1253
1254#ifndef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +02001255int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256{
1257 return -ENODEV;
1258}
1259#endif
1260
1261struct bus_type pci_bus_type = {
1262 .name = "pci",
1263 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001264 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001265 .probe = pci_device_probe,
1266 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001267 .shutdown = pci_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 .dev_attrs = pci_dev_attrs,
Alex Chiang705b1aa2009-03-20 14:56:31 -06001269 .bus_attrs = pci_bus_attrs,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001270 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271};
1272
1273static int __init pci_driver_init(void)
1274{
1275 return bus_register(&pci_bus_type);
1276}
1277
1278postcore_initcall(pci_driver_init);
1279
Tejun Heo9dba9102009-09-03 15:26:36 +09001280EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001281EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001282EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283EXPORT_SYMBOL(pci_unregister_driver);
1284EXPORT_SYMBOL(pci_dev_driver);
1285EXPORT_SYMBOL(pci_bus_type);
1286EXPORT_SYMBOL(pci_dev_get);
1287EXPORT_SYMBOL(pci_dev_put);