blob: 9042fdbd724405bc96808ed699a1d543fcf17c17 [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}
Greg Kroah-Hartman2229c1f2013-10-07 14:51:20 -0600138static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Chris Wright09943752009-02-23 21:52:23 -0800140/**
141 * store_remove_id - remove a PCI device ID from this driver
142 * @driver: target device driver
143 * @buf: buffer for scanning device ID data
144 * @count: input size
145 *
146 * Removes a dynamic pci device ID to this driver.
147 */
148static ssize_t
149store_remove_id(struct device_driver *driver, const char *buf, size_t count)
150{
151 struct pci_dynid *dynid, *n;
152 struct pci_driver *pdrv = to_pci_driver(driver);
153 __u32 vendor, device, subvendor = PCI_ANY_ID,
154 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
155 int fields = 0;
156 int retval = -ENODEV;
157
158 fields = sscanf(buf, "%x %x %x %x %x %x",
159 &vendor, &device, &subvendor, &subdevice,
160 &class, &class_mask);
161 if (fields < 2)
162 return -EINVAL;
163
164 spin_lock(&pdrv->dynids.lock);
165 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
166 struct pci_device_id *id = &dynid->id;
167 if ((id->vendor == vendor) &&
168 (id->device == device) &&
169 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
170 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
171 !((id->class ^ class) & class_mask)) {
172 list_del(&dynid->node);
173 kfree(dynid);
174 retval = 0;
175 break;
176 }
177 }
178 spin_unlock(&pdrv->dynids.lock);
179
180 if (retval)
181 return retval;
182 return count;
183}
Greg Kroah-Hartman2229c1f2013-10-07 14:51:20 -0600184static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
Chris Wright09943752009-02-23 21:52:23 -0800185
Greg Kroah-Hartman2229c1f2013-10-07 14:51:20 -0600186static struct attribute *pci_drv_attrs[] = {
187 &driver_attr_new_id.attr,
188 &driver_attr_remove_id.attr,
189 NULL,
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +0400190};
Greg Kroah-Hartman2229c1f2013-10-07 14:51:20 -0600191ATTRIBUTE_GROUPS(pci_drv);
Alan Sterned283e92012-01-24 14:35:13 -0500192
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193/**
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700194 * pci_match_id - See if a pci device matches a given pci_id table
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 * @ids: array of PCI device id structures to search in
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700196 * @dev: the PCI device structure to match against.
197 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 * Used by a driver to check whether a PCI device present in the
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700199 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 * pci_device_id structure or %NULL if there is no match.
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700201 *
Randy Dunlap8b607562007-05-09 07:19:14 +0200202 * Deprecated, don't use this as it will not catch any dynamic ids
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700203 * that a driver might want to check for.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700205const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
206 struct pci_dev *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700208 if (ids) {
209 while (ids->vendor || ids->subvendor || ids->class_mask) {
210 if (pci_match_one_device(ids, dev))
211 return ids;
212 ids++;
213 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215 return NULL;
216}
217
218/**
Randy Dunlapae9608a2007-01-09 21:41:01 -0800219 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700220 * @drv: the PCI driver to match against
Henrik Kretzschmar39ba4872006-08-15 10:57:16 +0200221 * @dev: the PCI device structure to match against
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700222 *
223 * Used by a driver to check whether a PCI device present in the
224 * system is in its list of supported devices. Returns the matching
225 * pci_device_id structure or %NULL if there is no match.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 */
Adrian Bunkd73460d2007-10-24 18:27:18 +0200227static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
228 struct pci_dev *dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700229{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700230 struct pci_dynid *dynid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Russell King7461b602006-11-29 21:18:04 +0000232 /* Look at the dynamic ids first, before the static ones */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700233 spin_lock(&drv->dynids.lock);
234 list_for_each_entry(dynid, &drv->dynids.list, node) {
235 if (pci_match_one_device(&dynid->id, dev)) {
236 spin_unlock(&drv->dynids.lock);
237 return &dynid->id;
238 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 }
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700240 spin_unlock(&drv->dynids.lock);
Russell King7461b602006-11-29 21:18:04 +0000241
242 return pci_match_id(drv->id_table, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243}
244
Rusty Russell873392c2008-12-31 23:54:56 +1030245struct drv_dev_and_id {
246 struct pci_driver *drv;
247 struct pci_dev *dev;
248 const struct pci_device_id *id;
249};
250
251static long local_pci_probe(void *_ddi)
252{
253 struct drv_dev_and_id *ddi = _ddi;
Huang Ying967577b2012-11-20 16:08:22 +0800254 struct pci_dev *pci_dev = ddi->dev;
255 struct pci_driver *pci_drv = ddi->drv;
256 struct device *dev = &pci_dev->dev;
Alan Sternf3ec4f82010-06-08 15:23:51 -0400257 int rc;
Rusty Russell873392c2008-12-31 23:54:56 +1030258
Huang Ying967577b2012-11-20 16:08:22 +0800259 /*
260 * Unbound PCI devices are always put in D0, regardless of
261 * runtime PM status. During probe, the device is set to
262 * active and the usage count is incremented. If the driver
263 * supports runtime PM, it should call pm_runtime_put_noidle()
264 * in its probe routine and pm_runtime_get_noresume() in its
265 * remove routine.
Alan Sternf3ec4f82010-06-08 15:23:51 -0400266 */
Huang Ying967577b2012-11-20 16:08:22 +0800267 pm_runtime_get_sync(dev);
268 pci_dev->driver = pci_drv;
269 rc = pci_drv->probe(pci_dev, ddi->id);
Stephen M. Cameronf92d74c2013-11-01 14:34:55 -0500270 if (!rc)
271 return rc;
272 if (rc < 0) {
Huang Ying967577b2012-11-20 16:08:22 +0800273 pci_dev->driver = NULL;
274 pm_runtime_put_sync(dev);
Stephen M. Cameronf92d74c2013-11-01 14:34:55 -0500275 return rc;
Alan Sternf3ec4f82010-06-08 15:23:51 -0400276 }
Stephen M. Cameronf92d74c2013-11-01 14:34:55 -0500277 /*
278 * Probe function should return < 0 for failure, 0 for success
279 * Treat values > 0 as success, but warn.
280 */
281 dev_warn(dev, "Driver probe function unexpectedly returned %d\n", rc);
282 return 0;
Rusty Russell873392c2008-12-31 23:54:56 +1030283}
284
Andi Kleend42c6992005-07-06 19:56:03 +0200285static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
286 const struct pci_device_id *id)
287{
Rusty Russell873392c2008-12-31 23:54:56 +1030288 int error, node;
289 struct drv_dev_and_id ddi = { drv, dev, id };
Mike Travisf70316d2008-04-04 18:11:06 -0700290
Rusty Russell873392c2008-12-31 23:54:56 +1030291 /* Execute driver initialization on node where the device's
292 bus is attached to. This way the driver likely allocates
293 its local memory on the right node without any need to
294 change it. */
295 node = dev_to_node(&dev->dev);
Mike Travisf70316d2008-04-04 18:11:06 -0700296 if (node >= 0) {
Rusty Russell873392c2008-12-31 23:54:56 +1030297 int cpu;
Rusty Russell873392c2008-12-31 23:54:56 +1030298
299 get_online_cpus();
Rusty Russella70f7302009-03-13 14:49:46 +1030300 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
Rusty Russell873392c2008-12-31 23:54:56 +1030301 if (cpu < nr_cpu_ids)
302 error = work_on_cpu(cpu, local_pci_probe, &ddi);
303 else
304 error = local_pci_probe(&ddi);
305 put_online_cpus();
306 } else
307 error = local_pci_probe(&ddi);
Andi Kleend42c6992005-07-06 19:56:03 +0200308 return error;
309}
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311/**
Randy Dunlap23ea3792010-11-18 15:02:31 -0800312 * __pci_device_probe - check if a driver wants to claim a specific PCI device
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700313 * @drv: driver to call to check if it wants the PCI device
314 * @pci_dev: PCI device being probed
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700315 *
Randy Dunlap8f7020d2005-10-23 11:57:38 -0700316 * returns 0 on success, else error.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
318 */
319static int
320__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700321{
322 const struct pci_device_id *id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 int error = 0;
324
325 if (!pci_dev->driver && drv->probe) {
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700326 error = -ENODEV;
327
328 id = pci_match_device(drv, pci_dev);
329 if (id)
Andi Kleend42c6992005-07-06 19:56:03 +0200330 error = pci_call_probe(drv, pci_dev, id);
Huang Ying967577b2012-11-20 16:08:22 +0800331 if (error >= 0)
Greg Kroah-Hartman75865852005-06-30 02:18:12 -0700332 error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 }
334 return error;
335}
336
337static int pci_device_probe(struct device * dev)
338{
339 int error = 0;
340 struct pci_driver *drv;
341 struct pci_dev *pci_dev;
342
343 drv = to_pci_driver(dev->driver);
344 pci_dev = to_pci_dev(dev);
345 pci_dev_get(pci_dev);
346 error = __pci_device_probe(drv, pci_dev);
347 if (error)
348 pci_dev_put(pci_dev);
349
350 return error;
351}
352
353static int pci_device_remove(struct device * dev)
354{
355 struct pci_dev * pci_dev = to_pci_dev(dev);
356 struct pci_driver * drv = pci_dev->driver;
357
358 if (drv) {
Alan Sternf3ec4f82010-06-08 15:23:51 -0400359 if (drv->remove) {
360 pm_runtime_get_sync(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 drv->remove(pci_dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400362 pm_runtime_put_noidle(dev);
363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 pci_dev->driver = NULL;
365 }
366
Alan Sternf3ec4f82010-06-08 15:23:51 -0400367 /* Undo the runtime PM settings in local_pci_probe() */
Huang Ying967577b2012-11-20 16:08:22 +0800368 pm_runtime_put_sync(dev);
Alan Sternf3ec4f82010-06-08 15:23:51 -0400369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 /*
Shaohua Li2449e062006-10-20 14:45:32 -0700371 * If the device is still on, set the power state as "unknown",
372 * since it might change by the next time we load the driver.
373 */
374 if (pci_dev->current_state == PCI_D0)
375 pci_dev->current_state = PCI_UNKNOWN;
376
377 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 * We would love to complain here if pci_dev->is_enabled is set, that
379 * the driver should have called pci_disable_device(), but the
380 * unfortunate fact is there are too many odd BIOS and bridge setups
Bjorn Helgaasf7625982013-11-14 11:28:18 -0700381 * that don't like drivers doing that all of the time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 * Oh well, we can dream of sane hardware when we sleep, no matter how
383 * horrible the crap we have to deal with is when we are awake...
384 */
385
386 pci_dev_put(pci_dev);
387 return 0;
388}
389
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200390static void pci_device_shutdown(struct device *dev)
391{
392 struct pci_dev *pci_dev = to_pci_dev(dev);
393 struct pci_driver *drv = pci_dev->driver;
394
Huang Ying3ff2de92012-10-24 14:54:14 +0800395 pm_runtime_resume(dev);
396
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200397 if (drv && drv->shutdown)
398 drv->shutdown(pci_dev);
399 pci_msi_shutdown(pci_dev);
400 pci_msix_shutdown(pci_dev);
Rafael J. Wysocki5b415f12012-02-07 00:50:35 +0100401
402 /*
Khalid Azizb566a222012-04-27 13:00:33 -0600403 * Turn off Bus Master bit on the device to tell it to not
Konstantin Khlebnikov6e0eda32013-03-14 18:49:37 +0400404 * continue to do DMA. Don't touch devices in D3cold or unknown states.
Khalid Azizb566a222012-04-27 13:00:33 -0600405 */
Konstantin Khlebnikov6e0eda32013-03-14 18:49:37 +0400406 if (pci_dev->current_state <= PCI_D3hot)
407 pci_clear_master(pci_dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200408}
409
Rafael J. Wysockiaa338602011-02-11 00:06:54 +0100410#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100411
412/* Auxiliary functions used for system resume and run-time resume. */
413
414/**
415 * pci_restore_standard_config - restore standard config registers of PCI device
416 * @pci_dev: PCI device to handle
417 */
418static int pci_restore_standard_config(struct pci_dev *pci_dev)
419{
420 pci_update_current_state(pci_dev, PCI_UNKNOWN);
421
422 if (pci_dev->current_state != PCI_D0) {
423 int error = pci_set_power_state(pci_dev, PCI_D0);
424 if (error)
425 return error;
426 }
427
Jon Mason1d3c16a2010-11-30 17:43:26 -0600428 pci_restore_state(pci_dev);
429 return 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100430}
431
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100432#endif
433
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200434#ifdef CONFIG_PM_SLEEP
435
Rafael J. Wysockidb288c92012-07-05 15:20:00 -0600436static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
437{
438 pci_power_up(pci_dev);
439 pci_restore_state(pci_dev);
440 pci_fixup_device(pci_fixup_resume_early, pci_dev);
441}
442
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200443/*
444 * Default "suspend" method for devices that have no driver provided suspend,
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100445 * or not even a driver at all (second part).
446 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100447static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200448{
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200449 /*
450 * mark its power state as "unknown", since we don't know if
451 * e.g. the BIOS will change its device state when we suspend.
452 */
453 if (pci_dev->current_state == PCI_D0)
454 pci_dev->current_state = PCI_UNKNOWN;
455}
456
457/*
458 * Default "resume" method for devices that have no driver provided resume,
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100459 * or not even a driver at all (second part).
460 */
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100461static int pci_pm_reenable_device(struct pci_dev *pci_dev)
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100462{
463 int retval;
464
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200465 /* if the device was enabled before suspend, reenable */
466 retval = pci_reenable_device(pci_dev);
467 /*
468 * if the device was busmaster before the suspend, make it busmaster
469 * again
470 */
471 if (pci_dev->is_busmaster)
472 pci_set_master(pci_dev);
473
474 return retval;
475}
476
477static int pci_legacy_suspend(struct device *dev, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
479 struct pci_dev * pci_dev = to_pci_dev(dev);
480 struct pci_driver * drv = pci_dev->driver;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100481
Andrew Morton02669492006-03-23 01:38:34 -0800482 if (drv && drv->suspend) {
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100483 pci_power_t prev = pci_dev->current_state;
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100484 int error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100485
Frans Pop57ef8022009-03-16 22:39:56 +0100486 error = drv->suspend(pci_dev, state);
487 suspend_report_result(drv->suspend, error);
488 if (error)
489 return error;
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100490
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100491 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100492 && pci_dev->current_state != PCI_UNKNOWN) {
493 WARN_ONCE(pci_dev->current_state != prev,
494 "PCI PM: Device state not saved by %pF\n",
495 drv->suspend);
Rafael J. Wysocki99dadce2009-02-04 01:59:09 +0100496 }
Andrew Morton02669492006-03-23 01:38:34 -0800497 }
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100498
499 pci_fixup_device(pci_fixup_suspend, pci_dev);
500
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100501 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502}
503
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200504static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700505{
506 struct pci_dev * pci_dev = to_pci_dev(dev);
507 struct pci_driver * drv = pci_dev->driver;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700508
509 if (drv && drv->suspend_late) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100510 pci_power_t prev = pci_dev->current_state;
511 int error;
512
Frans Pop57ef8022009-03-16 22:39:56 +0100513 error = drv->suspend_late(pci_dev, state);
514 suspend_report_result(drv->suspend_late, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100515 if (error)
516 return error;
517
518 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
519 && pci_dev->current_state != PCI_UNKNOWN) {
520 WARN_ONCE(pci_dev->current_state != prev,
521 "PCI PM: Device state not saved by %pF\n",
522 drv->suspend_late);
523 return 0;
524 }
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700525 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100526
527 if (!pci_dev->state_saved)
528 pci_save_state(pci_dev);
529
530 pci_pm_set_unknown_state(pci_dev);
531
532 return 0;
Linus Torvaldscbd69db2006-06-24 14:50:29 -0700533}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100535static int pci_legacy_resume_early(struct device *dev)
536{
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100537 struct pci_dev * pci_dev = to_pci_dev(dev);
538 struct pci_driver * drv = pci_dev->driver;
539
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100540 return drv && drv->resume_early ?
541 drv->resume_early(pci_dev) : 0;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100542}
543
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200544static int pci_legacy_resume(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
546 struct pci_dev * pci_dev = to_pci_dev(dev);
547 struct pci_driver * drv = pci_dev->driver;
548
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100549 pci_fixup_device(pci_fixup_resume, pci_dev);
550
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100551 return drv && drv->resume ?
552 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553}
554
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100555/* Auxiliary functions used by the new power management framework */
556
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100557static void pci_pm_default_resume(struct pci_dev *pci_dev)
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100558{
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100559 pci_fixup_device(pci_fixup_resume, pci_dev);
560
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100561 if (!pci_is_bridge(pci_dev))
562 pci_enable_wake(pci_dev, PCI_D0, false);
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100563}
564
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100565static void pci_pm_default_suspend(struct pci_dev *pci_dev)
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100566{
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100567 /* Disable non-bridge devices without PM support */
Rafael J. Wysockicbbc2f62009-02-04 02:01:15 +0100568 if (!pci_is_bridge(pci_dev))
569 pci_disable_enabled_device(pci_dev);
Rafael J. Wysocki734104292009-01-07 13:07:15 +0100570}
571
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100572static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
573{
574 struct pci_driver *drv = pci_dev->driver;
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100575 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100576 || drv->resume_early);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100577
578 /*
579 * Legacy PM support is used by default, so warn if the new framework is
580 * supported as well. Drivers are supposed to support either the
581 * former, or the latter, but not both at the same time.
582 */
David Fries82440a82011-11-20 15:29:46 -0600583 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
584 drv->name, pci_dev->vendor, pci_dev->device);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100585
586 return ret;
Rafael J. Wysocki07e836e2009-01-07 13:06:10 +0100587}
588
Rafael J. Wysocki571ff752009-01-07 13:05:05 +0100589/* New power management framework */
590
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200591static int pci_pm_prepare(struct device *dev)
592{
593 struct device_driver *drv = dev->driver;
594 int error = 0;
595
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100596 /*
597 * PCI devices suspended at run time need to be resumed at this
598 * point, because in general it is necessary to reconfigure them for
599 * system suspend. Namely, if the device is supposed to wake up the
600 * system from the sleep state, we may need to reconfigure it for this
601 * purpose. In turn, if the device is not supposed to wake up the
602 * system from the sleep state, we'll have to prevent it from signaling
603 * wake-up.
604 */
Rafael J. Wysockieea3fc032011-07-06 10:51:40 +0200605 pm_runtime_resume(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100606
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200607 if (drv && drv->pm && drv->pm->prepare)
608 error = drv->pm->prepare(dev);
609
610 return error;
611}
612
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200613
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100614#else /* !CONFIG_PM_SLEEP */
615
616#define pci_pm_prepare NULL
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100617
618#endif /* !CONFIG_PM_SLEEP */
619
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200620#ifdef CONFIG_SUSPEND
621
622static int pci_pm_suspend(struct device *dev)
623{
624 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700625 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200626
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100627 if (pci_has_legacy_pm_support(pci_dev))
628 return pci_legacy_suspend(dev, PMSG_SUSPEND);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100629
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100630 if (!pm) {
631 pci_pm_default_suspend(pci_dev);
632 goto Fixup;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200633 }
Rafael J. Wysockifa58d302009-01-07 13:03:42 +0100634
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400635 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100636 if (pm->suspend) {
637 pci_power_t prev = pci_dev->current_state;
638 int error;
639
640 error = pm->suspend(dev);
641 suspend_report_result(pm->suspend, error);
642 if (error)
643 return error;
644
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100645 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100646 && pci_dev->current_state != PCI_UNKNOWN) {
647 WARN_ONCE(pci_dev->current_state != prev,
648 "PCI PM: State of device not saved by %pF\n",
649 pm->suspend);
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100650 }
651 }
652
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100653 Fixup:
654 pci_fixup_device(pci_fixup_suspend, pci_dev);
655
656 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200657}
658
659static int pci_pm_suspend_noirq(struct device *dev)
Greg KHc8958172005-04-08 14:53:31 +0900660{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100661 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700662 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Greg KHc8958172005-04-08 14:53:31 +0900663
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100664 if (pci_has_legacy_pm_support(pci_dev))
665 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
666
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100667 if (!pm) {
668 pci_save_state(pci_dev);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100669 return 0;
Rafael J. Wysocki931ff682009-03-16 22:40:50 +0100670 }
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100671
672 if (pm->suspend_noirq) {
673 pci_power_t prev = pci_dev->current_state;
674 int error;
675
676 error = pm->suspend_noirq(dev);
677 suspend_report_result(pm->suspend_noirq, error);
678 if (error)
679 return error;
680
681 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
682 && pci_dev->current_state != PCI_UNKNOWN) {
683 WARN_ONCE(pci_dev->current_state != prev,
684 "PCI PM: State of device not saved by %pF\n",
685 pm->suspend_noirq);
686 return 0;
687 }
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200688 }
689
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100690 if (!pci_dev->state_saved) {
691 pci_save_state(pci_dev);
692 if (!pci_is_bridge(pci_dev))
693 pci_prepare_to_sleep(pci_dev);
694 }
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100695
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100696 pci_pm_set_unknown_state(pci_dev);
697
Alan Sterndbf0e4c2012-07-09 11:09:21 -0400698 /*
699 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
700 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
701 * hasn't been quiesced and tries to turn it off. If the controller
702 * is already in D3, this can hang or cause memory corruption.
703 *
704 * Since the value of the COMMAND register doesn't matter once the
705 * device has been suspended, we can safely set it to 0 here.
706 */
707 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
708 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
709
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100710 return 0;
Greg KHc8958172005-04-08 14:53:31 +0900711}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200713static int pci_pm_resume_noirq(struct device *dev)
714{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100715 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200716 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200717 int error = 0;
718
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100719 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100720
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100721 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100722 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100723
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100724 if (drv && drv->pm && drv->pm->resume_noirq)
725 error = drv->pm->resume_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200726
727 return error;
728}
729
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100730static int pci_pm_resume(struct device *dev)
731{
732 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700733 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100734 int error = 0;
735
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100736 /*
737 * This is necessary for the suspend error path in which resume is
738 * called without restoring the standard config registers of the device.
739 */
740 if (pci_dev->state_saved)
741 pci_restore_standard_config(pci_dev);
742
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100743 if (pci_has_legacy_pm_support(pci_dev))
744 return pci_legacy_resume(dev);
745
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100746 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100747
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100748 if (pm) {
749 if (pm->resume)
750 error = pm->resume(dev);
751 } else {
752 pci_pm_reenable_device(pci_dev);
753 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100754
Rafael J. Wysocki999cce42009-09-09 23:51:27 +0200755 return error;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100756}
757
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200758#else /* !CONFIG_SUSPEND */
759
760#define pci_pm_suspend NULL
761#define pci_pm_suspend_noirq NULL
762#define pci_pm_resume NULL
763#define pci_pm_resume_noirq NULL
764
765#endif /* !CONFIG_SUSPEND */
766
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200767#ifdef CONFIG_HIBERNATE_CALLBACKS
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200768
Sebastian Ott699c1982013-08-20 16:41:02 +0200769
770/*
771 * pcibios_pm_ops - provide arch-specific hooks when a PCI device is doing
772 * a hibernate transition
773 */
774struct dev_pm_ops __weak pcibios_pm_ops;
775
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200776static int pci_pm_freeze(struct device *dev)
777{
778 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700779 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200780
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100781 if (pci_has_legacy_pm_support(pci_dev))
782 return pci_legacy_suspend(dev, PMSG_FREEZE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100783
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100784 if (!pm) {
785 pci_pm_default_suspend(pci_dev);
786 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200787 }
788
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400789 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100790 if (pm->freeze) {
791 int error;
792
793 error = pm->freeze(dev);
794 suspend_report_result(pm->freeze, error);
795 if (error)
796 return error;
797 }
798
Sebastian Ott699c1982013-08-20 16:41:02 +0200799 if (pcibios_pm_ops.freeze)
800 return pcibios_pm_ops.freeze(dev);
801
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100802 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200803}
804
805static int pci_pm_freeze_noirq(struct device *dev)
806{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100807 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200808 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200809
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100810 if (pci_has_legacy_pm_support(pci_dev))
811 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
812
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100813 if (drv && drv->pm && drv->pm->freeze_noirq) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100814 int error;
815
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100816 error = drv->pm->freeze_noirq(dev);
817 suspend_report_result(drv->pm->freeze_noirq, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100818 if (error)
819 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200820 }
821
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100822 if (!pci_dev->state_saved)
823 pci_save_state(pci_dev);
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100824
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100825 pci_pm_set_unknown_state(pci_dev);
826
Sebastian Ott699c1982013-08-20 16:41:02 +0200827 if (pcibios_pm_ops.freeze_noirq)
828 return pcibios_pm_ops.freeze_noirq(dev);
829
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100830 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200831}
832
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200833static int pci_pm_thaw_noirq(struct device *dev)
834{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100835 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200836 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200837 int error = 0;
838
Sebastian Ott699c1982013-08-20 16:41:02 +0200839 if (pcibios_pm_ops.thaw_noirq) {
840 error = pcibios_pm_ops.thaw_noirq(dev);
841 if (error)
842 return error;
843 }
844
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100845 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100846 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100847
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100848 pci_update_current_state(pci_dev, PCI_D0);
849
850 if (drv && drv->pm && drv->pm->thaw_noirq)
851 error = drv->pm->thaw_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200852
853 return error;
854}
855
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100856static int pci_pm_thaw(struct device *dev)
857{
858 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700859 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100860 int error = 0;
861
Sebastian Ott699c1982013-08-20 16:41:02 +0200862 if (pcibios_pm_ops.thaw) {
863 error = pcibios_pm_ops.thaw(dev);
864 if (error)
865 return error;
866 }
867
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100868 if (pci_has_legacy_pm_support(pci_dev))
869 return pci_legacy_resume(dev);
870
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100871 if (pm) {
872 if (pm->thaw)
873 error = pm->thaw(dev);
874 } else {
875 pci_pm_reenable_device(pci_dev);
876 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100877
Rafael J. Wysocki4b77b0a2009-09-09 23:49:59 +0200878 pci_dev->state_saved = false;
879
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100880 return error;
881}
882
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200883static int pci_pm_poweroff(struct device *dev)
884{
Rafael J. Wysocki355a72d2008-12-08 00:34:57 +0100885 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700886 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200887
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100888 if (pci_has_legacy_pm_support(pci_dev))
889 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100890
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100891 if (!pm) {
892 pci_pm_default_suspend(pci_dev);
893 goto Fixup;
894 }
895
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +0400896 pci_dev->state_saved = false;
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100897 if (pm->poweroff) {
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100898 int error;
899
Rafael J. Wysockiddb7c9d2009-02-04 01:56:14 +0100900 error = pm->poweroff(dev);
901 suspend_report_result(pm->poweroff, error);
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100902 if (error)
903 return error;
904 }
905
906 Fixup:
907 pci_fixup_device(pci_fixup_suspend, pci_dev);
908
Sebastian Ott699c1982013-08-20 16:41:02 +0200909 if (pcibios_pm_ops.poweroff)
910 return pcibios_pm_ops.poweroff(dev);
911
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100912 return 0;
913}
914
915static int pci_pm_poweroff_noirq(struct device *dev)
916{
917 struct pci_dev *pci_dev = to_pci_dev(dev);
918 struct device_driver *drv = dev->driver;
919
920 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
921 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
922
923 if (!drv || !drv->pm)
924 return 0;
925
926 if (drv->pm->poweroff_noirq) {
927 int error;
928
929 error = drv->pm->poweroff_noirq(dev);
930 suspend_report_result(drv->pm->poweroff_noirq, error);
931 if (error)
932 return error;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200933 }
934
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100935 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
936 pci_prepare_to_sleep(pci_dev);
937
Rafael J. Wysocki0b68c8e2012-08-12 23:26:07 +0200938 /*
939 * The reason for doing this here is the same as for the analogous code
940 * in pci_pm_suspend_noirq().
941 */
942 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
943 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
944
Sebastian Ott699c1982013-08-20 16:41:02 +0200945 if (pcibios_pm_ops.poweroff_noirq)
946 return pcibios_pm_ops.poweroff_noirq(dev);
947
Rafael J. Wysocki46939f82009-03-16 22:40:26 +0100948 return 0;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200949}
950
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200951static int pci_pm_restore_noirq(struct device *dev)
952{
953 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysockiadf09492008-10-06 22:46:05 +0200954 struct device_driver *drv = dev->driver;
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200955 int error = 0;
956
Sebastian Ott699c1982013-08-20 16:41:02 +0200957 if (pcibios_pm_ops.restore_noirq) {
958 error = pcibios_pm_ops.restore_noirq(dev);
959 if (error)
960 return error;
961 }
962
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +0100963 pci_pm_default_resume_early(pci_dev);
Rafael J. Wysockiaa8c6c92009-01-16 21:54:43 +0100964
Rafael J. Wysockiad8cfa12009-01-07 13:09:37 +0100965 if (pci_has_legacy_pm_support(pci_dev))
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100966 return pci_legacy_resume_early(dev);
Rafael J. Wysockibb808942009-01-07 14:15:17 +0100967
Rafael J. Wysockid67e37d2009-01-07 13:11:28 +0100968 if (drv && drv->pm && drv->pm->restore_noirq)
969 error = drv->pm->restore_noirq(dev);
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +0200970
971 return error;
972}
973
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100974static int pci_pm_restore(struct device *dev)
975{
976 struct pci_dev *pci_dev = to_pci_dev(dev);
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700977 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100978 int error = 0;
979
Sebastian Ott699c1982013-08-20 16:41:02 +0200980 if (pcibios_pm_ops.restore) {
981 error = pcibios_pm_ops.restore(dev);
982 if (error)
983 return error;
984 }
985
Rafael J. Wysocki418e4da2009-01-26 21:43:08 +0100986 /*
987 * This is necessary for the hibernation error path in which restore is
988 * called without restoring the standard config registers of the device.
989 */
990 if (pci_dev->state_saved)
991 pci_restore_standard_config(pci_dev);
992
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100993 if (pci_has_legacy_pm_support(pci_dev))
994 return pci_legacy_resume(dev);
995
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100996 pci_pm_default_resume(pci_dev);
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +0100997
Rafael J. Wysocki5294e252009-02-04 02:09:07 +0100998 if (pm) {
999 if (pm->restore)
1000 error = pm->restore(dev);
1001 } else {
1002 pci_pm_reenable_device(pci_dev);
1003 }
Rafael J. Wysockif6dc1e52009-01-07 13:12:22 +01001004
1005 return error;
1006}
1007
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +02001008#else /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001009
1010#define pci_pm_freeze NULL
1011#define pci_pm_freeze_noirq NULL
1012#define pci_pm_thaw NULL
1013#define pci_pm_thaw_noirq NULL
1014#define pci_pm_poweroff NULL
1015#define pci_pm_poweroff_noirq NULL
1016#define pci_pm_restore NULL
1017#define pci_pm_restore_noirq NULL
1018
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +02001019#endif /* !CONFIG_HIBERNATE_CALLBACKS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001020
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001021#ifdef CONFIG_PM_RUNTIME
1022
1023static int pci_pm_runtime_suspend(struct device *dev)
1024{
1025 struct pci_dev *pci_dev = to_pci_dev(dev);
1026 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1027 pci_power_t prev = pci_dev->current_state;
1028 int error;
1029
Huang Ying967577b2012-11-20 16:08:22 +08001030 /*
1031 * If pci_dev->driver is not set (unbound), the device should
1032 * always remain in D0 regardless of the runtime PM status
1033 */
1034 if (!pci_dev->driver)
1035 return 0;
1036
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001037 if (!pm || !pm->runtime_suspend)
1038 return -ENOSYS;
1039
Rafael J. Wysocki82fee4d2013-02-04 15:56:05 +04001040 pci_dev->state_saved = false;
Huang Ying448bd852012-06-23 10:23:51 +08001041 pci_dev->no_d3cold = false;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001042 error = pm->runtime_suspend(dev);
1043 suspend_report_result(pm->runtime_suspend, error);
1044 if (error)
1045 return error;
Huang Ying448bd852012-06-23 10:23:51 +08001046 if (!pci_dev->d3cold_allowed)
1047 pci_dev->no_d3cold = true;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001048
1049 pci_fixup_device(pci_fixup_suspend, pci_dev);
1050
1051 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1052 && pci_dev->current_state != PCI_UNKNOWN) {
1053 WARN_ONCE(pci_dev->current_state != prev,
1054 "PCI PM: State of device not saved by %pF\n",
1055 pm->runtime_suspend);
1056 return 0;
1057 }
1058
Dave Airlie42eca232012-10-29 17:26:54 -06001059 if (!pci_dev->state_saved) {
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001060 pci_save_state(pci_dev);
Dave Airlie42eca232012-10-29 17:26:54 -06001061 pci_finish_runtime_suspend(pci_dev);
1062 }
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001063
1064 return 0;
1065}
1066
1067static int pci_pm_runtime_resume(struct device *dev)
1068{
Huang Ying448bd852012-06-23 10:23:51 +08001069 int rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001070 struct pci_dev *pci_dev = to_pci_dev(dev);
1071 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1072
Huang Ying967577b2012-11-20 16:08:22 +08001073 /*
1074 * If pci_dev->driver is not set (unbound), the device should
1075 * always remain in D0 regardless of the runtime PM status
1076 */
1077 if (!pci_dev->driver)
1078 return 0;
1079
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001080 if (!pm || !pm->runtime_resume)
1081 return -ENOSYS;
1082
Rafael J. Wysockidb288c92012-07-05 15:20:00 -06001083 pci_restore_standard_config(pci_dev);
1084 pci_fixup_device(pci_fixup_resume_early, pci_dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001085 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1086 pci_fixup_device(pci_fixup_resume, pci_dev);
1087
Huang Ying448bd852012-06-23 10:23:51 +08001088 rc = pm->runtime_resume(dev);
1089
1090 pci_dev->runtime_d3cold = false;
1091
1092 return rc;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001093}
1094
1095static int pci_pm_runtime_idle(struct device *dev)
1096{
Huang Ying967577b2012-11-20 16:08:22 +08001097 struct pci_dev *pci_dev = to_pci_dev(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001098 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001099 int ret = 0;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001100
Huang Ying967577b2012-11-20 16:08:22 +08001101 /*
1102 * If pci_dev->driver is not set (unbound), the device should
1103 * always remain in D0 regardless of the runtime PM status
1104 */
1105 if (!pci_dev->driver)
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001106 return 0;
Huang Ying967577b2012-11-20 16:08:22 +08001107
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001108 if (!pm)
1109 return -ENOSYS;
1110
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001111 if (pm->runtime_idle)
1112 ret = pm->runtime_idle(dev);
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001113
Rafael J. Wysocki45f0a852013-06-03 21:49:52 +02001114 return ret;
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001115}
1116
1117#else /* !CONFIG_PM_RUNTIME */
1118
1119#define pci_pm_runtime_suspend NULL
1120#define pci_pm_runtime_resume NULL
1121#define pci_pm_runtime_idle NULL
1122
1123#endif /* !CONFIG_PM_RUNTIME */
1124
Rafael J. Wysockiaa338602011-02-11 00:06:54 +01001125#ifdef CONFIG_PM
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001126
Sachin Kamatf91da042013-10-04 12:04:44 -06001127static const struct dev_pm_ops pci_dev_pm_ops = {
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001128 .prepare = pci_pm_prepare,
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001129 .suspend = pci_pm_suspend,
1130 .resume = pci_pm_resume,
1131 .freeze = pci_pm_freeze,
1132 .thaw = pci_pm_thaw,
1133 .poweroff = pci_pm_poweroff,
1134 .restore = pci_pm_restore,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001135 .suspend_noirq = pci_pm_suspend_noirq,
1136 .resume_noirq = pci_pm_resume_noirq,
1137 .freeze_noirq = pci_pm_freeze_noirq,
1138 .thaw_noirq = pci_pm_thaw_noirq,
1139 .poweroff_noirq = pci_pm_poweroff_noirq,
1140 .restore_noirq = pci_pm_restore_noirq,
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001141 .runtime_suspend = pci_pm_runtime_suspend,
1142 .runtime_resume = pci_pm_runtime_resume,
1143 .runtime_idle = pci_pm_runtime_idle,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001144};
1145
Rafael J. Wysockiadf09492008-10-06 22:46:05 +02001146#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001147
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001148#else /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001149
1150#define PCI_PM_OPS_PTR NULL
1151
Rafael J. Wysocki6cbf8212010-02-17 23:44:58 +01001152#endif /* !COMFIG_PM_OPS */
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001153
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154/**
Laurent riffard863b18f2005-10-27 23:12:54 +02001155 * __pci_register_driver - register a new pci driver
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 * @drv: the driver structure to register
Laurent riffard863b18f2005-10-27 23:12:54 +02001157 * @owner: owner module of drv
Randy Dunlapf95d8822007-02-10 14:41:56 -08001158 * @mod_name: module name string
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001159 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 * Adds the driver structure to the list of registered drivers.
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001161 * Returns a negative value on error, otherwise 0.
1162 * If no error occurred, the driver remains registered even if
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 * no device was claimed during registration.
1164 */
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001165int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1166 const char *mod_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 /* initialize common driver fields */
1169 drv->driver.name = drv->name;
1170 drv->driver.bus = &pci_bus_type;
Laurent riffard863b18f2005-10-27 23:12:54 +02001171 drv->driver.owner = owner;
Greg Kroah-Hartman725522b2007-01-15 11:50:02 -08001172 drv->driver.mod_name = mod_name;
Alan Cox50b00752006-08-16 17:42:18 +01001173
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001174 spin_lock_init(&drv->dynids.lock);
1175 INIT_LIST_HEAD(&drv->dynids.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
1177 /* register with core */
Konstantin Khlebnikovbfb09a82012-08-08 14:47:51 +04001178 return driver_register(&drv->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179}
1180
1181/**
1182 * pci_unregister_driver - unregister a pci driver
1183 * @drv: the driver structure to unregister
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001184 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 * Deletes the driver structure from the list of registered PCI drivers,
1186 * gives it a chance to clean up by calling its remove() function for
1187 * each device it was responsible for, and marks those devices as
1188 * driverless.
1189 */
1190
1191void
1192pci_unregister_driver(struct pci_driver *drv)
1193{
1194 driver_unregister(&drv->driver);
1195 pci_free_dynids(drv);
1196}
1197
1198static struct pci_driver pci_compat_driver = {
1199 .name = "compat"
1200};
1201
1202/**
1203 * pci_dev_driver - get the pci_driver of a device
1204 * @dev: the device to query
1205 *
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001206 * Returns the appropriate pci_driver structure or %NULL if there is no
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 * registered driver for the device.
1208 */
1209struct pci_driver *
1210pci_dev_driver(const struct pci_dev *dev)
1211{
1212 if (dev->driver)
1213 return dev->driver;
1214 else {
1215 int i;
1216 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1217 if (dev->resource[i].flags & IORESOURCE_BUSY)
1218 return &pci_compat_driver;
1219 }
1220 return NULL;
1221}
1222
1223/**
1224 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 * @dev: the PCI device structure to match against
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001226 * @drv: the device driver to search for matching PCI device id structures
Bjorn Helgaasf7625982013-11-14 11:28:18 -07001227 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 * Used by a driver to check whether a PCI device present in the
Randy Dunlap8f7020d2005-10-23 11:57:38 -07001229 * system is in its list of supported devices. Returns the matching
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 * pci_device_id structure or %NULL if there is no match.
1231 */
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001232static int pci_bus_match(struct device *dev, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233{
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001234 struct pci_dev *pci_dev = to_pci_dev(dev);
Yinghai Lu58d9a382013-01-21 13:20:51 -08001235 struct pci_driver *pci_drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 const struct pci_device_id *found_id;
1237
Yinghai Lu58d9a382013-01-21 13:20:51 -08001238 if (!pci_dev->match_driver)
1239 return 0;
1240
1241 pci_drv = to_pci_driver(drv);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001242 found_id = pci_match_device(pci_drv, pci_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 if (found_id)
1244 return 1;
1245
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001246 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247}
1248
1249/**
1250 * pci_dev_get - increments the reference count of the pci device structure
1251 * @dev: the device being referenced
1252 *
1253 * Each live reference to a device should be refcounted.
1254 *
1255 * Drivers for PCI devices should normally record such references in
1256 * their probe() methods, when they bind to a device, and release
1257 * them by calling pci_dev_put(), in their disconnect() methods.
1258 *
1259 * A pointer to the device with the incremented reference counter is returned.
1260 */
1261struct pci_dev *pci_dev_get(struct pci_dev *dev)
1262{
1263 if (dev)
1264 get_device(&dev->dev);
1265 return dev;
1266}
1267
1268/**
1269 * pci_dev_put - release a use of the pci device structure
1270 * @dev: device that's been disconnected
1271 *
1272 * Must be called when a user of a device is finished with it. When the last
1273 * user of the device calls this function, the memory of the device is freed.
1274 */
1275void pci_dev_put(struct pci_dev *dev)
1276{
1277 if (dev)
1278 put_device(&dev->dev);
1279}
1280
Bill Pemberton8ccc9aa2012-11-21 15:34:58 -05001281static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1282{
1283 struct pci_dev *pdev;
1284
1285 if (!dev)
1286 return -ENODEV;
1287
1288 pdev = to_pci_dev(dev);
1289 if (!pdev)
1290 return -ENODEV;
1291
1292 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1293 return -ENOMEM;
1294
1295 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1296 return -ENOMEM;
1297
1298 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1299 pdev->subsystem_device))
1300 return -ENOMEM;
1301
1302 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1303 return -ENOMEM;
1304
1305 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02x",
1306 pdev->vendor, pdev->device,
1307 pdev->subsystem_vendor, pdev->subsystem_device,
1308 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1309 (u8)(pdev->class)))
1310 return -ENOMEM;
1311 return 0;
1312}
1313
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314struct bus_type pci_bus_type = {
1315 .name = "pci",
1316 .match = pci_bus_match,
Kay Sievers312c0042005-11-16 09:00:00 +01001317 .uevent = pci_uevent,
Russell Kingb15d6862006-01-05 14:30:22 +00001318 .probe = pci_device_probe,
1319 .remove = pci_device_remove,
Linus Torvaldscbd69db2006-06-24 14:50:29 -07001320 .shutdown = pci_device_shutdown,
Greg Kroah-Hartman5136b2d2013-10-06 23:55:40 -07001321 .dev_groups = pci_dev_groups,
Greg Kroah-Hartman0f49ba52013-10-07 14:51:02 -06001322 .bus_groups = pci_bus_groups,
Greg Kroah-Hartman2229c1f2013-10-07 14:51:20 -06001323 .drv_groups = pci_drv_groups,
Rafael J. Wysockibbb44d92008-05-20 00:49:04 +02001324 .pm = PCI_PM_OPS_PTR,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325};
1326
1327static int __init pci_driver_init(void)
1328{
1329 return bus_register(&pci_bus_type);
1330}
1331
1332postcore_initcall(pci_driver_init);
1333
Tejun Heo9dba9102009-09-03 15:26:36 +09001334EXPORT_SYMBOL_GPL(pci_add_dynid);
Greg Kroah-Hartman75865852005-06-30 02:18:12 -07001335EXPORT_SYMBOL(pci_match_id);
Laurent riffard863b18f2005-10-27 23:12:54 +02001336EXPORT_SYMBOL(__pci_register_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337EXPORT_SYMBOL(pci_unregister_driver);
1338EXPORT_SYMBOL(pci_dev_driver);
1339EXPORT_SYMBOL(pci_bus_type);
1340EXPORT_SYMBOL(pci_dev_get);
1341EXPORT_SYMBOL(pci_dev_put);