Loading...
1/*
2 * drivers/pci/pci-driver.c
3 *
4 * (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 *
9 */
10
11#include <linux/pci.h>
12#include <linux/module.h>
13#include <linux/init.h>
14#include <linux/device.h>
15#include <linux/mempolicy.h>
16#include <linux/string.h>
17#include <linux/slab.h>
18#include <linux/sched.h>
19#include <linux/cpu.h>
20#include <linux/pm_runtime.h>
21#include <linux/suspend.h>
22#include "pci.h"
23
24struct pci_dynid {
25 struct list_head node;
26 struct pci_device_id id;
27};
28
29/**
30 * 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
75 get_driver(&drv->driver);
76 retval = driver_attach(&drv->driver);
77 put_driver(&drv->driver);
78
79 return retval;
80}
81
82static void pci_free_dynids(struct pci_driver *drv)
83{
84 struct pci_dynid *dynid, *n;
85
86 spin_lock(&drv->dynids.lock);
87 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
88 list_del(&dynid->node);
89 kfree(dynid);
90 }
91 spin_unlock(&drv->dynids.lock);
92}
93
94/*
95 * Dynamic device ID manipulation via sysfs is disabled for !CONFIG_HOTPLUG
96 */
97#ifdef CONFIG_HOTPLUG
98/**
99 * store_new_id - sysfs frontend to pci_add_dynid()
100 * @driver: target device driver
101 * @buf: buffer for scanning device ID data
102 * @count: input size
103 *
104 * Allow PCI IDs to be added to an existing driver via sysfs.
105 */
106static ssize_t
107store_new_id(struct device_driver *driver, const char *buf, size_t count)
108{
109 struct pci_driver *pdrv = to_pci_driver(driver);
110 const struct pci_device_id *ids = pdrv->id_table;
111 __u32 vendor, device, subvendor=PCI_ANY_ID,
112 subdevice=PCI_ANY_ID, class=0, class_mask=0;
113 unsigned long driver_data=0;
114 int fields=0;
115 int retval;
116
117 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
118 &vendor, &device, &subvendor, &subdevice,
119 &class, &class_mask, &driver_data);
120 if (fields < 2)
121 return -EINVAL;
122
123 /* Only accept driver_data values that match an existing id_table
124 entry */
125 if (ids) {
126 retval = -EINVAL;
127 while (ids->vendor || ids->subvendor || ids->class_mask) {
128 if (driver_data == ids->driver_data) {
129 retval = 0;
130 break;
131 }
132 ids++;
133 }
134 if (retval) /* No match */
135 return retval;
136 }
137
138 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
139 class, class_mask, driver_data);
140 if (retval)
141 return retval;
142 return count;
143}
144static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
145
146/**
147 * store_remove_id - remove a PCI device ID from this driver
148 * @driver: target device driver
149 * @buf: buffer for scanning device ID data
150 * @count: input size
151 *
152 * Removes a dynamic pci device ID to this driver.
153 */
154static ssize_t
155store_remove_id(struct device_driver *driver, const char *buf, size_t count)
156{
157 struct pci_dynid *dynid, *n;
158 struct pci_driver *pdrv = to_pci_driver(driver);
159 __u32 vendor, device, subvendor = PCI_ANY_ID,
160 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
161 int fields = 0;
162 int retval = -ENODEV;
163
164 fields = sscanf(buf, "%x %x %x %x %x %x",
165 &vendor, &device, &subvendor, &subdevice,
166 &class, &class_mask);
167 if (fields < 2)
168 return -EINVAL;
169
170 spin_lock(&pdrv->dynids.lock);
171 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
172 struct pci_device_id *id = &dynid->id;
173 if ((id->vendor == vendor) &&
174 (id->device == device) &&
175 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
176 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
177 !((id->class ^ class) & class_mask)) {
178 list_del(&dynid->node);
179 kfree(dynid);
180 retval = 0;
181 break;
182 }
183 }
184 spin_unlock(&pdrv->dynids.lock);
185
186 if (retval)
187 return retval;
188 return count;
189}
190static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
191
192static int
193pci_create_newid_file(struct pci_driver *drv)
194{
195 int error = 0;
196 if (drv->probe != NULL)
197 error = driver_create_file(&drv->driver, &driver_attr_new_id);
198 return error;
199}
200
201static void pci_remove_newid_file(struct pci_driver *drv)
202{
203 driver_remove_file(&drv->driver, &driver_attr_new_id);
204}
205
206static int
207pci_create_removeid_file(struct pci_driver *drv)
208{
209 int error = 0;
210 if (drv->probe != NULL)
211 error = driver_create_file(&drv->driver,&driver_attr_remove_id);
212 return error;
213}
214
215static void pci_remove_removeid_file(struct pci_driver *drv)
216{
217 driver_remove_file(&drv->driver, &driver_attr_remove_id);
218}
219#else /* !CONFIG_HOTPLUG */
220static inline int pci_create_newid_file(struct pci_driver *drv)
221{
222 return 0;
223}
224static inline void pci_remove_newid_file(struct pci_driver *drv) {}
225static inline int pci_create_removeid_file(struct pci_driver *drv)
226{
227 return 0;
228}
229static inline void pci_remove_removeid_file(struct pci_driver *drv) {}
230#endif
231
232/**
233 * pci_match_id - See if a pci device matches a given pci_id table
234 * @ids: array of PCI device id structures to search in
235 * @dev: the PCI device structure to match against.
236 *
237 * Used by a driver to check whether a PCI device present in the
238 * system is in its list of supported devices. Returns the matching
239 * pci_device_id structure or %NULL if there is no match.
240 *
241 * Deprecated, don't use this as it will not catch any dynamic ids
242 * that a driver might want to check for.
243 */
244const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
245 struct pci_dev *dev)
246{
247 if (ids) {
248 while (ids->vendor || ids->subvendor || ids->class_mask) {
249 if (pci_match_one_device(ids, dev))
250 return ids;
251 ids++;
252 }
253 }
254 return NULL;
255}
256
257/**
258 * pci_match_device - Tell if a PCI device structure has a matching PCI device id structure
259 * @drv: the PCI driver to match against
260 * @dev: the PCI device structure to match against
261 *
262 * Used by a driver to check whether a PCI device present in the
263 * system is in its list of supported devices. Returns the matching
264 * pci_device_id structure or %NULL if there is no match.
265 */
266static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
267 struct pci_dev *dev)
268{
269 struct pci_dynid *dynid;
270
271 /* Look at the dynamic ids first, before the static ones */
272 spin_lock(&drv->dynids.lock);
273 list_for_each_entry(dynid, &drv->dynids.list, node) {
274 if (pci_match_one_device(&dynid->id, dev)) {
275 spin_unlock(&drv->dynids.lock);
276 return &dynid->id;
277 }
278 }
279 spin_unlock(&drv->dynids.lock);
280
281 return pci_match_id(drv->id_table, dev);
282}
283
284struct drv_dev_and_id {
285 struct pci_driver *drv;
286 struct pci_dev *dev;
287 const struct pci_device_id *id;
288};
289
290static long local_pci_probe(void *_ddi)
291{
292 struct drv_dev_and_id *ddi = _ddi;
293 struct device *dev = &ddi->dev->dev;
294 int rc;
295
296 /* Unbound PCI devices are always set to disabled and suspended.
297 * During probe, the device is set to enabled and active and the
298 * usage count is incremented. If the driver supports runtime PM,
299 * it should call pm_runtime_put_noidle() in its probe routine and
300 * pm_runtime_get_noresume() in its remove routine.
301 */
302 pm_runtime_get_noresume(dev);
303 pm_runtime_set_active(dev);
304 pm_runtime_enable(dev);
305
306 rc = ddi->drv->probe(ddi->dev, ddi->id);
307 if (rc) {
308 pm_runtime_disable(dev);
309 pm_runtime_set_suspended(dev);
310 pm_runtime_put_noidle(dev);
311 }
312 return rc;
313}
314
315static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
316 const struct pci_device_id *id)
317{
318 int error, node;
319 struct drv_dev_and_id ddi = { drv, dev, id };
320
321 /* Execute driver initialization on node where the device's
322 bus is attached to. This way the driver likely allocates
323 its local memory on the right node without any need to
324 change it. */
325 node = dev_to_node(&dev->dev);
326 if (node >= 0) {
327 int cpu;
328
329 get_online_cpus();
330 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
331 if (cpu < nr_cpu_ids)
332 error = work_on_cpu(cpu, local_pci_probe, &ddi);
333 else
334 error = local_pci_probe(&ddi);
335 put_online_cpus();
336 } else
337 error = local_pci_probe(&ddi);
338 return error;
339}
340
341/**
342 * __pci_device_probe - check if a driver wants to claim a specific PCI device
343 * @drv: driver to call to check if it wants the PCI device
344 * @pci_dev: PCI device being probed
345 *
346 * returns 0 on success, else error.
347 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
348 */
349static int
350__pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
351{
352 const struct pci_device_id *id;
353 int error = 0;
354
355 if (!pci_dev->driver && drv->probe) {
356 error = -ENODEV;
357
358 id = pci_match_device(drv, pci_dev);
359 if (id)
360 error = pci_call_probe(drv, pci_dev, id);
361 if (error >= 0) {
362 pci_dev->driver = drv;
363 error = 0;
364 }
365 }
366 return error;
367}
368
369static int pci_device_probe(struct device * dev)
370{
371 int error = 0;
372 struct pci_driver *drv;
373 struct pci_dev *pci_dev;
374
375 drv = to_pci_driver(dev->driver);
376 pci_dev = to_pci_dev(dev);
377 pci_dev_get(pci_dev);
378 error = __pci_device_probe(drv, pci_dev);
379 if (error)
380 pci_dev_put(pci_dev);
381
382 return error;
383}
384
385static int pci_device_remove(struct device * dev)
386{
387 struct pci_dev * pci_dev = to_pci_dev(dev);
388 struct pci_driver * drv = pci_dev->driver;
389
390 if (drv) {
391 if (drv->remove) {
392 pm_runtime_get_sync(dev);
393 drv->remove(pci_dev);
394 pm_runtime_put_noidle(dev);
395 }
396 pci_dev->driver = NULL;
397 }
398
399 /* Undo the runtime PM settings in local_pci_probe() */
400 pm_runtime_disable(dev);
401 pm_runtime_set_suspended(dev);
402 pm_runtime_put_noidle(dev);
403
404 /*
405 * If the device is still on, set the power state as "unknown",
406 * since it might change by the next time we load the driver.
407 */
408 if (pci_dev->current_state == PCI_D0)
409 pci_dev->current_state = PCI_UNKNOWN;
410
411 /*
412 * We would love to complain here if pci_dev->is_enabled is set, that
413 * the driver should have called pci_disable_device(), but the
414 * unfortunate fact is there are too many odd BIOS and bridge setups
415 * that don't like drivers doing that all of the time.
416 * Oh well, we can dream of sane hardware when we sleep, no matter how
417 * horrible the crap we have to deal with is when we are awake...
418 */
419
420 pci_dev_put(pci_dev);
421 return 0;
422}
423
424static void pci_device_shutdown(struct device *dev)
425{
426 struct pci_dev *pci_dev = to_pci_dev(dev);
427 struct pci_driver *drv = pci_dev->driver;
428
429 if (drv && drv->shutdown)
430 drv->shutdown(pci_dev);
431 pci_msi_shutdown(pci_dev);
432 pci_msix_shutdown(pci_dev);
433}
434
435#ifdef CONFIG_PM
436
437/* Auxiliary functions used for system resume and run-time resume. */
438
439/**
440 * pci_restore_standard_config - restore standard config registers of PCI device
441 * @pci_dev: PCI device to handle
442 */
443static int pci_restore_standard_config(struct pci_dev *pci_dev)
444{
445 pci_update_current_state(pci_dev, PCI_UNKNOWN);
446
447 if (pci_dev->current_state != PCI_D0) {
448 int error = pci_set_power_state(pci_dev, PCI_D0);
449 if (error)
450 return error;
451 }
452
453 pci_restore_state(pci_dev);
454 return 0;
455}
456
457static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
458{
459 pci_restore_standard_config(pci_dev);
460 pci_fixup_device(pci_fixup_resume_early, pci_dev);
461}
462
463#endif
464
465#ifdef CONFIG_PM_SLEEP
466
467/*
468 * Default "suspend" method for devices that have no driver provided suspend,
469 * or not even a driver at all (second part).
470 */
471static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
472{
473 /*
474 * mark its power state as "unknown", since we don't know if
475 * e.g. the BIOS will change its device state when we suspend.
476 */
477 if (pci_dev->current_state == PCI_D0)
478 pci_dev->current_state = PCI_UNKNOWN;
479}
480
481/*
482 * Default "resume" method for devices that have no driver provided resume,
483 * or not even a driver at all (second part).
484 */
485static int pci_pm_reenable_device(struct pci_dev *pci_dev)
486{
487 int retval;
488
489 /* if the device was enabled before suspend, reenable */
490 retval = pci_reenable_device(pci_dev);
491 /*
492 * if the device was busmaster before the suspend, make it busmaster
493 * again
494 */
495 if (pci_dev->is_busmaster)
496 pci_set_master(pci_dev);
497
498 return retval;
499}
500
501static int pci_legacy_suspend(struct device *dev, pm_message_t state)
502{
503 struct pci_dev * pci_dev = to_pci_dev(dev);
504 struct pci_driver * drv = pci_dev->driver;
505
506 if (drv && drv->suspend) {
507 pci_power_t prev = pci_dev->current_state;
508 int error;
509
510 error = drv->suspend(pci_dev, state);
511 suspend_report_result(drv->suspend, error);
512 if (error)
513 return error;
514
515 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
516 && pci_dev->current_state != PCI_UNKNOWN) {
517 WARN_ONCE(pci_dev->current_state != prev,
518 "PCI PM: Device state not saved by %pF\n",
519 drv->suspend);
520 }
521 }
522
523 pci_fixup_device(pci_fixup_suspend, pci_dev);
524
525 return 0;
526}
527
528static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
529{
530 struct pci_dev * pci_dev = to_pci_dev(dev);
531 struct pci_driver * drv = pci_dev->driver;
532
533 if (drv && drv->suspend_late) {
534 pci_power_t prev = pci_dev->current_state;
535 int error;
536
537 error = drv->suspend_late(pci_dev, state);
538 suspend_report_result(drv->suspend_late, error);
539 if (error)
540 return error;
541
542 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
543 && pci_dev->current_state != PCI_UNKNOWN) {
544 WARN_ONCE(pci_dev->current_state != prev,
545 "PCI PM: Device state not saved by %pF\n",
546 drv->suspend_late);
547 return 0;
548 }
549 }
550
551 if (!pci_dev->state_saved)
552 pci_save_state(pci_dev);
553
554 pci_pm_set_unknown_state(pci_dev);
555
556 return 0;
557}
558
559static int pci_legacy_resume_early(struct device *dev)
560{
561 struct pci_dev * pci_dev = to_pci_dev(dev);
562 struct pci_driver * drv = pci_dev->driver;
563
564 return drv && drv->resume_early ?
565 drv->resume_early(pci_dev) : 0;
566}
567
568static int pci_legacy_resume(struct device *dev)
569{
570 struct pci_dev * pci_dev = to_pci_dev(dev);
571 struct pci_driver * drv = pci_dev->driver;
572
573 pci_fixup_device(pci_fixup_resume, pci_dev);
574
575 return drv && drv->resume ?
576 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
577}
578
579/* Auxiliary functions used by the new power management framework */
580
581static void pci_pm_default_resume(struct pci_dev *pci_dev)
582{
583 pci_fixup_device(pci_fixup_resume, pci_dev);
584
585 if (!pci_is_bridge(pci_dev))
586 pci_enable_wake(pci_dev, PCI_D0, false);
587}
588
589static void pci_pm_default_suspend(struct pci_dev *pci_dev)
590{
591 /* Disable non-bridge devices without PM support */
592 if (!pci_is_bridge(pci_dev))
593 pci_disable_enabled_device(pci_dev);
594}
595
596static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
597{
598 struct pci_driver *drv = pci_dev->driver;
599 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
600 || drv->resume_early);
601
602 /*
603 * Legacy PM support is used by default, so warn if the new framework is
604 * supported as well. Drivers are supposed to support either the
605 * former, or the latter, but not both at the same time.
606 */
607 WARN_ON(ret && drv->driver.pm);
608
609 return ret;
610}
611
612/* New power management framework */
613
614static int pci_pm_prepare(struct device *dev)
615{
616 struct device_driver *drv = dev->driver;
617 int error = 0;
618
619 /*
620 * If a PCI device configured to wake up the system from sleep states
621 * has been suspended at run time and there's a resume request pending
622 * for it, this is equivalent to the device signaling wakeup, so the
623 * system suspend operation should be aborted.
624 */
625 pm_runtime_get_noresume(dev);
626 if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
627 pm_wakeup_event(dev, 0);
628
629 if (pm_wakeup_pending()) {
630 pm_runtime_put_sync(dev);
631 return -EBUSY;
632 }
633
634 /*
635 * PCI devices suspended at run time need to be resumed at this
636 * point, because in general it is necessary to reconfigure them for
637 * system suspend. Namely, if the device is supposed to wake up the
638 * system from the sleep state, we may need to reconfigure it for this
639 * purpose. In turn, if the device is not supposed to wake up the
640 * system from the sleep state, we'll have to prevent it from signaling
641 * wake-up.
642 */
643 pm_runtime_resume(dev);
644
645 if (drv && drv->pm && drv->pm->prepare)
646 error = drv->pm->prepare(dev);
647
648 return error;
649}
650
651static void pci_pm_complete(struct device *dev)
652{
653 struct device_driver *drv = dev->driver;
654
655 if (drv && drv->pm && drv->pm->complete)
656 drv->pm->complete(dev);
657
658 pm_runtime_put_sync(dev);
659}
660
661#else /* !CONFIG_PM_SLEEP */
662
663#define pci_pm_prepare NULL
664#define pci_pm_complete NULL
665
666#endif /* !CONFIG_PM_SLEEP */
667
668#ifdef CONFIG_SUSPEND
669
670static int pci_pm_suspend(struct device *dev)
671{
672 struct pci_dev *pci_dev = to_pci_dev(dev);
673 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
674
675 if (pci_has_legacy_pm_support(pci_dev))
676 return pci_legacy_suspend(dev, PMSG_SUSPEND);
677
678 if (!pm) {
679 pci_pm_default_suspend(pci_dev);
680 goto Fixup;
681 }
682
683 if (pm->suspend) {
684 pci_power_t prev = pci_dev->current_state;
685 int error;
686
687 error = pm->suspend(dev);
688 suspend_report_result(pm->suspend, error);
689 if (error)
690 return error;
691
692 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
693 && pci_dev->current_state != PCI_UNKNOWN) {
694 WARN_ONCE(pci_dev->current_state != prev,
695 "PCI PM: State of device not saved by %pF\n",
696 pm->suspend);
697 }
698 }
699
700 Fixup:
701 pci_fixup_device(pci_fixup_suspend, pci_dev);
702
703 return 0;
704}
705
706static int pci_pm_suspend_noirq(struct device *dev)
707{
708 struct pci_dev *pci_dev = to_pci_dev(dev);
709 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
710
711 if (pci_has_legacy_pm_support(pci_dev))
712 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
713
714 if (!pm) {
715 pci_save_state(pci_dev);
716 return 0;
717 }
718
719 if (pm->suspend_noirq) {
720 pci_power_t prev = pci_dev->current_state;
721 int error;
722
723 error = pm->suspend_noirq(dev);
724 suspend_report_result(pm->suspend_noirq, error);
725 if (error)
726 return error;
727
728 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
729 && pci_dev->current_state != PCI_UNKNOWN) {
730 WARN_ONCE(pci_dev->current_state != prev,
731 "PCI PM: State of device not saved by %pF\n",
732 pm->suspend_noirq);
733 return 0;
734 }
735 }
736
737 if (!pci_dev->state_saved) {
738 pci_save_state(pci_dev);
739 if (!pci_is_bridge(pci_dev))
740 pci_prepare_to_sleep(pci_dev);
741 }
742
743 pci_pm_set_unknown_state(pci_dev);
744
745 return 0;
746}
747
748static int pci_pm_resume_noirq(struct device *dev)
749{
750 struct pci_dev *pci_dev = to_pci_dev(dev);
751 struct device_driver *drv = dev->driver;
752 int error = 0;
753
754 pci_pm_default_resume_early(pci_dev);
755
756 if (pci_has_legacy_pm_support(pci_dev))
757 return pci_legacy_resume_early(dev);
758
759 if (drv && drv->pm && drv->pm->resume_noirq)
760 error = drv->pm->resume_noirq(dev);
761
762 return error;
763}
764
765static int pci_pm_resume(struct device *dev)
766{
767 struct pci_dev *pci_dev = to_pci_dev(dev);
768 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
769 int error = 0;
770
771 /*
772 * This is necessary for the suspend error path in which resume is
773 * called without restoring the standard config registers of the device.
774 */
775 if (pci_dev->state_saved)
776 pci_restore_standard_config(pci_dev);
777
778 if (pci_has_legacy_pm_support(pci_dev))
779 return pci_legacy_resume(dev);
780
781 pci_pm_default_resume(pci_dev);
782
783 if (pm) {
784 if (pm->resume)
785 error = pm->resume(dev);
786 } else {
787 pci_pm_reenable_device(pci_dev);
788 }
789
790 return error;
791}
792
793#else /* !CONFIG_SUSPEND */
794
795#define pci_pm_suspend NULL
796#define pci_pm_suspend_noirq NULL
797#define pci_pm_resume NULL
798#define pci_pm_resume_noirq NULL
799
800#endif /* !CONFIG_SUSPEND */
801
802#ifdef CONFIG_HIBERNATE_CALLBACKS
803
804static int pci_pm_freeze(struct device *dev)
805{
806 struct pci_dev *pci_dev = to_pci_dev(dev);
807 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
808
809 if (pci_has_legacy_pm_support(pci_dev))
810 return pci_legacy_suspend(dev, PMSG_FREEZE);
811
812 if (!pm) {
813 pci_pm_default_suspend(pci_dev);
814 return 0;
815 }
816
817 if (pm->freeze) {
818 int error;
819
820 error = pm->freeze(dev);
821 suspend_report_result(pm->freeze, error);
822 if (error)
823 return error;
824 }
825
826 return 0;
827}
828
829static int pci_pm_freeze_noirq(struct device *dev)
830{
831 struct pci_dev *pci_dev = to_pci_dev(dev);
832 struct device_driver *drv = dev->driver;
833
834 if (pci_has_legacy_pm_support(pci_dev))
835 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
836
837 if (drv && drv->pm && drv->pm->freeze_noirq) {
838 int error;
839
840 error = drv->pm->freeze_noirq(dev);
841 suspend_report_result(drv->pm->freeze_noirq, error);
842 if (error)
843 return error;
844 }
845
846 if (!pci_dev->state_saved)
847 pci_save_state(pci_dev);
848
849 pci_pm_set_unknown_state(pci_dev);
850
851 return 0;
852}
853
854static int pci_pm_thaw_noirq(struct device *dev)
855{
856 struct pci_dev *pci_dev = to_pci_dev(dev);
857 struct device_driver *drv = dev->driver;
858 int error = 0;
859
860 if (pci_has_legacy_pm_support(pci_dev))
861 return pci_legacy_resume_early(dev);
862
863 pci_update_current_state(pci_dev, PCI_D0);
864
865 if (drv && drv->pm && drv->pm->thaw_noirq)
866 error = drv->pm->thaw_noirq(dev);
867
868 return error;
869}
870
871static int pci_pm_thaw(struct device *dev)
872{
873 struct pci_dev *pci_dev = to_pci_dev(dev);
874 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
875 int error = 0;
876
877 if (pci_has_legacy_pm_support(pci_dev))
878 return pci_legacy_resume(dev);
879
880 if (pm) {
881 if (pm->thaw)
882 error = pm->thaw(dev);
883 } else {
884 pci_pm_reenable_device(pci_dev);
885 }
886
887 pci_dev->state_saved = false;
888
889 return error;
890}
891
892static int pci_pm_poweroff(struct device *dev)
893{
894 struct pci_dev *pci_dev = to_pci_dev(dev);
895 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
896
897 if (pci_has_legacy_pm_support(pci_dev))
898 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
899
900 if (!pm) {
901 pci_pm_default_suspend(pci_dev);
902 goto Fixup;
903 }
904
905 if (pm->poweroff) {
906 int error;
907
908 error = pm->poweroff(dev);
909 suspend_report_result(pm->poweroff, error);
910 if (error)
911 return error;
912 }
913
914 Fixup:
915 pci_fixup_device(pci_fixup_suspend, pci_dev);
916
917 return 0;
918}
919
920static int pci_pm_poweroff_noirq(struct device *dev)
921{
922 struct pci_dev *pci_dev = to_pci_dev(dev);
923 struct device_driver *drv = dev->driver;
924
925 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
926 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
927
928 if (!drv || !drv->pm)
929 return 0;
930
931 if (drv->pm->poweroff_noirq) {
932 int error;
933
934 error = drv->pm->poweroff_noirq(dev);
935 suspend_report_result(drv->pm->poweroff_noirq, error);
936 if (error)
937 return error;
938 }
939
940 if (!pci_dev->state_saved && !pci_is_bridge(pci_dev))
941 pci_prepare_to_sleep(pci_dev);
942
943 return 0;
944}
945
946static int pci_pm_restore_noirq(struct device *dev)
947{
948 struct pci_dev *pci_dev = to_pci_dev(dev);
949 struct device_driver *drv = dev->driver;
950 int error = 0;
951
952 pci_pm_default_resume_early(pci_dev);
953
954 if (pci_has_legacy_pm_support(pci_dev))
955 return pci_legacy_resume_early(dev);
956
957 if (drv && drv->pm && drv->pm->restore_noirq)
958 error = drv->pm->restore_noirq(dev);
959
960 return error;
961}
962
963static int pci_pm_restore(struct device *dev)
964{
965 struct pci_dev *pci_dev = to_pci_dev(dev);
966 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
967 int error = 0;
968
969 /*
970 * This is necessary for the hibernation error path in which restore is
971 * called without restoring the standard config registers of the device.
972 */
973 if (pci_dev->state_saved)
974 pci_restore_standard_config(pci_dev);
975
976 if (pci_has_legacy_pm_support(pci_dev))
977 return pci_legacy_resume(dev);
978
979 pci_pm_default_resume(pci_dev);
980
981 if (pm) {
982 if (pm->restore)
983 error = pm->restore(dev);
984 } else {
985 pci_pm_reenable_device(pci_dev);
986 }
987
988 return error;
989}
990
991#else /* !CONFIG_HIBERNATE_CALLBACKS */
992
993#define pci_pm_freeze NULL
994#define pci_pm_freeze_noirq NULL
995#define pci_pm_thaw NULL
996#define pci_pm_thaw_noirq NULL
997#define pci_pm_poweroff NULL
998#define pci_pm_poweroff_noirq NULL
999#define pci_pm_restore NULL
1000#define pci_pm_restore_noirq NULL
1001
1002#endif /* !CONFIG_HIBERNATE_CALLBACKS */
1003
1004#ifdef CONFIG_PM_RUNTIME
1005
1006static int pci_pm_runtime_suspend(struct device *dev)
1007{
1008 struct pci_dev *pci_dev = to_pci_dev(dev);
1009 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1010 pci_power_t prev = pci_dev->current_state;
1011 int error;
1012
1013 if (!pm || !pm->runtime_suspend)
1014 return -ENOSYS;
1015
1016 error = pm->runtime_suspend(dev);
1017 suspend_report_result(pm->runtime_suspend, error);
1018 if (error)
1019 return error;
1020
1021 pci_fixup_device(pci_fixup_suspend, pci_dev);
1022
1023 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
1024 && pci_dev->current_state != PCI_UNKNOWN) {
1025 WARN_ONCE(pci_dev->current_state != prev,
1026 "PCI PM: State of device not saved by %pF\n",
1027 pm->runtime_suspend);
1028 return 0;
1029 }
1030
1031 if (!pci_dev->state_saved)
1032 pci_save_state(pci_dev);
1033
1034 pci_finish_runtime_suspend(pci_dev);
1035
1036 return 0;
1037}
1038
1039static int pci_pm_runtime_resume(struct device *dev)
1040{
1041 struct pci_dev *pci_dev = to_pci_dev(dev);
1042 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1043
1044 if (!pm || !pm->runtime_resume)
1045 return -ENOSYS;
1046
1047 pci_pm_default_resume_early(pci_dev);
1048 __pci_enable_wake(pci_dev, PCI_D0, true, false);
1049 pci_fixup_device(pci_fixup_resume, pci_dev);
1050
1051 return pm->runtime_resume(dev);
1052}
1053
1054static int pci_pm_runtime_idle(struct device *dev)
1055{
1056 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1057
1058 if (!pm)
1059 return -ENOSYS;
1060
1061 if (pm->runtime_idle) {
1062 int ret = pm->runtime_idle(dev);
1063 if (ret)
1064 return ret;
1065 }
1066
1067 pm_runtime_suspend(dev);
1068
1069 return 0;
1070}
1071
1072#else /* !CONFIG_PM_RUNTIME */
1073
1074#define pci_pm_runtime_suspend NULL
1075#define pci_pm_runtime_resume NULL
1076#define pci_pm_runtime_idle NULL
1077
1078#endif /* !CONFIG_PM_RUNTIME */
1079
1080#ifdef CONFIG_PM
1081
1082const struct dev_pm_ops pci_dev_pm_ops = {
1083 .prepare = pci_pm_prepare,
1084 .complete = pci_pm_complete,
1085 .suspend = pci_pm_suspend,
1086 .resume = pci_pm_resume,
1087 .freeze = pci_pm_freeze,
1088 .thaw = pci_pm_thaw,
1089 .poweroff = pci_pm_poweroff,
1090 .restore = pci_pm_restore,
1091 .suspend_noirq = pci_pm_suspend_noirq,
1092 .resume_noirq = pci_pm_resume_noirq,
1093 .freeze_noirq = pci_pm_freeze_noirq,
1094 .thaw_noirq = pci_pm_thaw_noirq,
1095 .poweroff_noirq = pci_pm_poweroff_noirq,
1096 .restore_noirq = pci_pm_restore_noirq,
1097 .runtime_suspend = pci_pm_runtime_suspend,
1098 .runtime_resume = pci_pm_runtime_resume,
1099 .runtime_idle = pci_pm_runtime_idle,
1100};
1101
1102#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1103
1104#else /* !COMFIG_PM_OPS */
1105
1106#define PCI_PM_OPS_PTR NULL
1107
1108#endif /* !COMFIG_PM_OPS */
1109
1110/**
1111 * __pci_register_driver - register a new pci driver
1112 * @drv: the driver structure to register
1113 * @owner: owner module of drv
1114 * @mod_name: module name string
1115 *
1116 * Adds the driver structure to the list of registered drivers.
1117 * Returns a negative value on error, otherwise 0.
1118 * If no error occurred, the driver remains registered even if
1119 * no device was claimed during registration.
1120 */
1121int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1122 const char *mod_name)
1123{
1124 int error;
1125
1126 /* initialize common driver fields */
1127 drv->driver.name = drv->name;
1128 drv->driver.bus = &pci_bus_type;
1129 drv->driver.owner = owner;
1130 drv->driver.mod_name = mod_name;
1131
1132 spin_lock_init(&drv->dynids.lock);
1133 INIT_LIST_HEAD(&drv->dynids.list);
1134
1135 /* register with core */
1136 error = driver_register(&drv->driver);
1137 if (error)
1138 goto out;
1139
1140 error = pci_create_newid_file(drv);
1141 if (error)
1142 goto out_newid;
1143
1144 error = pci_create_removeid_file(drv);
1145 if (error)
1146 goto out_removeid;
1147out:
1148 return error;
1149
1150out_removeid:
1151 pci_remove_newid_file(drv);
1152out_newid:
1153 driver_unregister(&drv->driver);
1154 goto out;
1155}
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{
1170 pci_remove_removeid_file(drv);
1171 pci_remove_newid_file(drv);
1172 driver_unregister(&drv->driver);
1173 pci_free_dynids(drv);
1174}
1175
1176static struct pci_driver pci_compat_driver = {
1177 .name = "compat"
1178};
1179
1180/**
1181 * pci_dev_driver - get the pci_driver of a device
1182 * @dev: the device to query
1183 *
1184 * Returns the appropriate pci_driver structure or %NULL if there is no
1185 * registered driver for the device.
1186 */
1187struct pci_driver *
1188pci_dev_driver(const struct pci_dev *dev)
1189{
1190 if (dev->driver)
1191 return dev->driver;
1192 else {
1193 int i;
1194 for(i=0; i<=PCI_ROM_RESOURCE; i++)
1195 if (dev->resource[i].flags & IORESOURCE_BUSY)
1196 return &pci_compat_driver;
1197 }
1198 return NULL;
1199}
1200
1201/**
1202 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1203 * @dev: the PCI device structure to match against
1204 * @drv: the device driver to search for matching PCI device id structures
1205 *
1206 * Used by a driver to check whether a PCI device present in the
1207 * system is in its list of supported devices. Returns the matching
1208 * pci_device_id structure or %NULL if there is no match.
1209 */
1210static int pci_bus_match(struct device *dev, struct device_driver *drv)
1211{
1212 struct pci_dev *pci_dev = to_pci_dev(dev);
1213 struct pci_driver *pci_drv = to_pci_driver(drv);
1214 const struct pci_device_id *found_id;
1215
1216 found_id = pci_match_device(pci_drv, pci_dev);
1217 if (found_id)
1218 return 1;
1219
1220 return 0;
1221}
1222
1223/**
1224 * pci_dev_get - increments the reference count of the pci device structure
1225 * @dev: the device being referenced
1226 *
1227 * Each live reference to a device should be refcounted.
1228 *
1229 * Drivers for PCI devices should normally record such references in
1230 * their probe() methods, when they bind to a device, and release
1231 * them by calling pci_dev_put(), in their disconnect() methods.
1232 *
1233 * A pointer to the device with the incremented reference counter is returned.
1234 */
1235struct pci_dev *pci_dev_get(struct pci_dev *dev)
1236{
1237 if (dev)
1238 get_device(&dev->dev);
1239 return dev;
1240}
1241
1242/**
1243 * pci_dev_put - release a use of the pci device structure
1244 * @dev: device that's been disconnected
1245 *
1246 * Must be called when a user of a device is finished with it. When the last
1247 * user of the device calls this function, the memory of the device is freed.
1248 */
1249void pci_dev_put(struct pci_dev *dev)
1250{
1251 if (dev)
1252 put_device(&dev->dev);
1253}
1254
1255#ifndef CONFIG_HOTPLUG
1256int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1257{
1258 return -ENODEV;
1259}
1260#endif
1261
1262struct bus_type pci_bus_type = {
1263 .name = "pci",
1264 .match = pci_bus_match,
1265 .uevent = pci_uevent,
1266 .probe = pci_device_probe,
1267 .remove = pci_device_remove,
1268 .shutdown = pci_device_shutdown,
1269 .dev_attrs = pci_dev_attrs,
1270 .bus_attrs = pci_bus_attrs,
1271 .pm = PCI_PM_OPS_PTR,
1272};
1273
1274static int __init pci_driver_init(void)
1275{
1276 return bus_register(&pci_bus_type);
1277}
1278
1279postcore_initcall(pci_driver_init);
1280
1281EXPORT_SYMBOL_GPL(pci_add_dynid);
1282EXPORT_SYMBOL(pci_match_id);
1283EXPORT_SYMBOL(__pci_register_driver);
1284EXPORT_SYMBOL(pci_unregister_driver);
1285EXPORT_SYMBOL(pci_dev_driver);
1286EXPORT_SYMBOL(pci_bus_type);
1287EXPORT_SYMBOL(pci_dev_get);
1288EXPORT_SYMBOL(pci_dev_put);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * (C) Copyright 2002-2004, 2007 Greg Kroah-Hartman <greg@kroah.com>
4 * (C) Copyright 2007 Novell Inc.
5 */
6
7#include <linux/pci.h>
8#include <linux/module.h>
9#include <linux/init.h>
10#include <linux/device.h>
11#include <linux/mempolicy.h>
12#include <linux/string.h>
13#include <linux/slab.h>
14#include <linux/sched.h>
15#include <linux/sched/isolation.h>
16#include <linux/cpu.h>
17#include <linux/pm_runtime.h>
18#include <linux/suspend.h>
19#include <linux/kexec.h>
20#include <linux/of_device.h>
21#include <linux/acpi.h>
22#include <linux/dma-map-ops.h>
23#include <linux/iommu.h>
24#include "pci.h"
25#include "pcie/portdrv.h"
26
27struct pci_dynid {
28 struct list_head node;
29 struct pci_device_id id;
30};
31
32/**
33 * pci_add_dynid - add a new PCI device ID to this driver and re-probe devices
34 * @drv: target pci driver
35 * @vendor: PCI vendor ID
36 * @device: PCI device ID
37 * @subvendor: PCI subvendor ID
38 * @subdevice: PCI subdevice ID
39 * @class: PCI class
40 * @class_mask: PCI class mask
41 * @driver_data: private driver data
42 *
43 * Adds a new dynamic pci device ID to this driver and causes the
44 * driver to probe for all devices again. @drv must have been
45 * registered prior to calling this function.
46 *
47 * CONTEXT:
48 * Does GFP_KERNEL allocation.
49 *
50 * RETURNS:
51 * 0 on success, -errno on failure.
52 */
53int pci_add_dynid(struct pci_driver *drv,
54 unsigned int vendor, unsigned int device,
55 unsigned int subvendor, unsigned int subdevice,
56 unsigned int class, unsigned int class_mask,
57 unsigned long driver_data)
58{
59 struct pci_dynid *dynid;
60
61 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
62 if (!dynid)
63 return -ENOMEM;
64
65 dynid->id.vendor = vendor;
66 dynid->id.device = device;
67 dynid->id.subvendor = subvendor;
68 dynid->id.subdevice = subdevice;
69 dynid->id.class = class;
70 dynid->id.class_mask = class_mask;
71 dynid->id.driver_data = driver_data;
72
73 spin_lock(&drv->dynids.lock);
74 list_add_tail(&dynid->node, &drv->dynids.list);
75 spin_unlock(&drv->dynids.lock);
76
77 return driver_attach(&drv->driver);
78}
79EXPORT_SYMBOL_GPL(pci_add_dynid);
80
81static void pci_free_dynids(struct pci_driver *drv)
82{
83 struct pci_dynid *dynid, *n;
84
85 spin_lock(&drv->dynids.lock);
86 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
87 list_del(&dynid->node);
88 kfree(dynid);
89 }
90 spin_unlock(&drv->dynids.lock);
91}
92
93/**
94 * pci_match_id - See if a PCI device matches a given pci_id table
95 * @ids: array of PCI device ID structures to search in
96 * @dev: the PCI device structure to match against.
97 *
98 * Used by a driver to check whether a PCI device is in its list of
99 * supported devices. Returns the matching pci_device_id structure or
100 * %NULL if there is no match.
101 *
102 * Deprecated; don't use this as it will not catch any dynamic IDs
103 * that a driver might want to check for.
104 */
105const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
106 struct pci_dev *dev)
107{
108 if (ids) {
109 while (ids->vendor || ids->subvendor || ids->class_mask) {
110 if (pci_match_one_device(ids, dev))
111 return ids;
112 ids++;
113 }
114 }
115 return NULL;
116}
117EXPORT_SYMBOL(pci_match_id);
118
119static const struct pci_device_id pci_device_id_any = {
120 .vendor = PCI_ANY_ID,
121 .device = PCI_ANY_ID,
122 .subvendor = PCI_ANY_ID,
123 .subdevice = PCI_ANY_ID,
124};
125
126/**
127 * pci_match_device - See if a device matches a driver's list of IDs
128 * @drv: the PCI driver to match against
129 * @dev: the PCI device structure to match against
130 *
131 * Used by a driver to check whether a PCI device is in its list of
132 * supported devices or in the dynids list, which may have been augmented
133 * via the sysfs "new_id" file. Returns the matching pci_device_id
134 * structure or %NULL if there is no match.
135 */
136static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
137 struct pci_dev *dev)
138{
139 struct pci_dynid *dynid;
140 const struct pci_device_id *found_id = NULL, *ids;
141
142 /* When driver_override is set, only bind to the matching driver */
143 if (dev->driver_override && strcmp(dev->driver_override, drv->name))
144 return NULL;
145
146 /* Look at the dynamic ids first, before the static ones */
147 spin_lock(&drv->dynids.lock);
148 list_for_each_entry(dynid, &drv->dynids.list, node) {
149 if (pci_match_one_device(&dynid->id, dev)) {
150 found_id = &dynid->id;
151 break;
152 }
153 }
154 spin_unlock(&drv->dynids.lock);
155
156 if (found_id)
157 return found_id;
158
159 for (ids = drv->id_table; (found_id = pci_match_id(ids, dev));
160 ids = found_id + 1) {
161 /*
162 * The match table is split based on driver_override.
163 * In case override_only was set, enforce driver_override
164 * matching.
165 */
166 if (found_id->override_only) {
167 if (dev->driver_override)
168 return found_id;
169 } else {
170 return found_id;
171 }
172 }
173
174 /* driver_override will always match, send a dummy id */
175 if (dev->driver_override)
176 return &pci_device_id_any;
177 return NULL;
178}
179
180/**
181 * new_id_store - sysfs frontend to pci_add_dynid()
182 * @driver: target device driver
183 * @buf: buffer for scanning device ID data
184 * @count: input size
185 *
186 * Allow PCI IDs to be added to an existing driver via sysfs.
187 */
188static ssize_t new_id_store(struct device_driver *driver, const char *buf,
189 size_t count)
190{
191 struct pci_driver *pdrv = to_pci_driver(driver);
192 const struct pci_device_id *ids = pdrv->id_table;
193 u32 vendor, device, subvendor = PCI_ANY_ID,
194 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
195 unsigned long driver_data = 0;
196 int fields;
197 int retval = 0;
198
199 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
200 &vendor, &device, &subvendor, &subdevice,
201 &class, &class_mask, &driver_data);
202 if (fields < 2)
203 return -EINVAL;
204
205 if (fields != 7) {
206 struct pci_dev *pdev = kzalloc(sizeof(*pdev), GFP_KERNEL);
207 if (!pdev)
208 return -ENOMEM;
209
210 pdev->vendor = vendor;
211 pdev->device = device;
212 pdev->subsystem_vendor = subvendor;
213 pdev->subsystem_device = subdevice;
214 pdev->class = class;
215
216 if (pci_match_device(pdrv, pdev))
217 retval = -EEXIST;
218
219 kfree(pdev);
220
221 if (retval)
222 return retval;
223 }
224
225 /* Only accept driver_data values that match an existing id_table
226 entry */
227 if (ids) {
228 retval = -EINVAL;
229 while (ids->vendor || ids->subvendor || ids->class_mask) {
230 if (driver_data == ids->driver_data) {
231 retval = 0;
232 break;
233 }
234 ids++;
235 }
236 if (retval) /* No match */
237 return retval;
238 }
239
240 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
241 class, class_mask, driver_data);
242 if (retval)
243 return retval;
244 return count;
245}
246static DRIVER_ATTR_WO(new_id);
247
248/**
249 * remove_id_store - remove a PCI device ID from this driver
250 * @driver: target device driver
251 * @buf: buffer for scanning device ID data
252 * @count: input size
253 *
254 * Removes a dynamic pci device ID to this driver.
255 */
256static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
257 size_t count)
258{
259 struct pci_dynid *dynid, *n;
260 struct pci_driver *pdrv = to_pci_driver(driver);
261 u32 vendor, device, subvendor = PCI_ANY_ID,
262 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
263 int fields;
264 size_t retval = -ENODEV;
265
266 fields = sscanf(buf, "%x %x %x %x %x %x",
267 &vendor, &device, &subvendor, &subdevice,
268 &class, &class_mask);
269 if (fields < 2)
270 return -EINVAL;
271
272 spin_lock(&pdrv->dynids.lock);
273 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
274 struct pci_device_id *id = &dynid->id;
275 if ((id->vendor == vendor) &&
276 (id->device == device) &&
277 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
278 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
279 !((id->class ^ class) & class_mask)) {
280 list_del(&dynid->node);
281 kfree(dynid);
282 retval = count;
283 break;
284 }
285 }
286 spin_unlock(&pdrv->dynids.lock);
287
288 return retval;
289}
290static DRIVER_ATTR_WO(remove_id);
291
292static struct attribute *pci_drv_attrs[] = {
293 &driver_attr_new_id.attr,
294 &driver_attr_remove_id.attr,
295 NULL,
296};
297ATTRIBUTE_GROUPS(pci_drv);
298
299struct drv_dev_and_id {
300 struct pci_driver *drv;
301 struct pci_dev *dev;
302 const struct pci_device_id *id;
303};
304
305static long local_pci_probe(void *_ddi)
306{
307 struct drv_dev_and_id *ddi = _ddi;
308 struct pci_dev *pci_dev = ddi->dev;
309 struct pci_driver *pci_drv = ddi->drv;
310 struct device *dev = &pci_dev->dev;
311 int rc;
312
313 /*
314 * Unbound PCI devices are always put in D0, regardless of
315 * runtime PM status. During probe, the device is set to
316 * active and the usage count is incremented. If the driver
317 * supports runtime PM, it should call pm_runtime_put_noidle(),
318 * or any other runtime PM helper function decrementing the usage
319 * count, in its probe routine and pm_runtime_get_noresume() in
320 * its remove routine.
321 */
322 pm_runtime_get_sync(dev);
323 pci_dev->driver = pci_drv;
324 rc = pci_drv->probe(pci_dev, ddi->id);
325 if (!rc)
326 return rc;
327 if (rc < 0) {
328 pci_dev->driver = NULL;
329 pm_runtime_put_sync(dev);
330 return rc;
331 }
332 /*
333 * Probe function should return < 0 for failure, 0 for success
334 * Treat values > 0 as success, but warn.
335 */
336 pci_warn(pci_dev, "Driver probe function unexpectedly returned %d\n",
337 rc);
338 return 0;
339}
340
341static bool pci_physfn_is_probed(struct pci_dev *dev)
342{
343#ifdef CONFIG_PCI_IOV
344 return dev->is_virtfn && dev->physfn->is_probed;
345#else
346 return false;
347#endif
348}
349
350static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
351 const struct pci_device_id *id)
352{
353 int error, node, cpu;
354 struct drv_dev_and_id ddi = { drv, dev, id };
355
356 /*
357 * Execute driver initialization on node where the device is
358 * attached. This way the driver likely allocates its local memory
359 * on the right node.
360 */
361 node = dev_to_node(&dev->dev);
362 dev->is_probed = 1;
363
364 cpu_hotplug_disable();
365
366 /*
367 * Prevent nesting work_on_cpu() for the case where a Virtual Function
368 * device is probed from work_on_cpu() of the Physical device.
369 */
370 if (node < 0 || node >= MAX_NUMNODES || !node_online(node) ||
371 pci_physfn_is_probed(dev)) {
372 cpu = nr_cpu_ids;
373 } else {
374 cpumask_var_t wq_domain_mask;
375
376 if (!zalloc_cpumask_var(&wq_domain_mask, GFP_KERNEL)) {
377 error = -ENOMEM;
378 goto out;
379 }
380 cpumask_and(wq_domain_mask,
381 housekeeping_cpumask(HK_TYPE_WQ),
382 housekeeping_cpumask(HK_TYPE_DOMAIN));
383
384 cpu = cpumask_any_and(cpumask_of_node(node),
385 wq_domain_mask);
386 free_cpumask_var(wq_domain_mask);
387 }
388
389 if (cpu < nr_cpu_ids)
390 error = work_on_cpu(cpu, local_pci_probe, &ddi);
391 else
392 error = local_pci_probe(&ddi);
393out:
394 dev->is_probed = 0;
395 cpu_hotplug_enable();
396 return error;
397}
398
399/**
400 * __pci_device_probe - check if a driver wants to claim a specific PCI device
401 * @drv: driver to call to check if it wants the PCI device
402 * @pci_dev: PCI device being probed
403 *
404 * returns 0 on success, else error.
405 * side-effect: pci_dev->driver is set to drv when drv claims pci_dev.
406 */
407static int __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
408{
409 const struct pci_device_id *id;
410 int error = 0;
411
412 if (drv->probe) {
413 error = -ENODEV;
414
415 id = pci_match_device(drv, pci_dev);
416 if (id)
417 error = pci_call_probe(drv, pci_dev, id);
418 }
419 return error;
420}
421
422#ifdef CONFIG_PCI_IOV
423static inline bool pci_device_can_probe(struct pci_dev *pdev)
424{
425 return (!pdev->is_virtfn || pdev->physfn->sriov->drivers_autoprobe ||
426 pdev->driver_override);
427}
428#else
429static inline bool pci_device_can_probe(struct pci_dev *pdev)
430{
431 return true;
432}
433#endif
434
435static int pci_device_probe(struct device *dev)
436{
437 int error;
438 struct pci_dev *pci_dev = to_pci_dev(dev);
439 struct pci_driver *drv = to_pci_driver(dev->driver);
440
441 if (!pci_device_can_probe(pci_dev))
442 return -ENODEV;
443
444 pci_assign_irq(pci_dev);
445
446 error = pcibios_alloc_irq(pci_dev);
447 if (error < 0)
448 return error;
449
450 pci_dev_get(pci_dev);
451 error = __pci_device_probe(drv, pci_dev);
452 if (error) {
453 pcibios_free_irq(pci_dev);
454 pci_dev_put(pci_dev);
455 }
456
457 return error;
458}
459
460static void pci_device_remove(struct device *dev)
461{
462 struct pci_dev *pci_dev = to_pci_dev(dev);
463 struct pci_driver *drv = pci_dev->driver;
464
465 if (drv->remove) {
466 pm_runtime_get_sync(dev);
467 /*
468 * If the driver provides a .runtime_idle() callback and it has
469 * started to run already, it may continue to run in parallel
470 * with the code below, so wait until all of the runtime PM
471 * activity has completed.
472 */
473 pm_runtime_barrier(dev);
474 drv->remove(pci_dev);
475 pm_runtime_put_noidle(dev);
476 }
477 pcibios_free_irq(pci_dev);
478 pci_dev->driver = NULL;
479 pci_iov_remove(pci_dev);
480
481 /* Undo the runtime PM settings in local_pci_probe() */
482 pm_runtime_put_sync(dev);
483
484 /*
485 * If the device is still on, set the power state as "unknown",
486 * since it might change by the next time we load the driver.
487 */
488 if (pci_dev->current_state == PCI_D0)
489 pci_dev->current_state = PCI_UNKNOWN;
490
491 /*
492 * We would love to complain here if pci_dev->is_enabled is set, that
493 * the driver should have called pci_disable_device(), but the
494 * unfortunate fact is there are too many odd BIOS and bridge setups
495 * that don't like drivers doing that all of the time.
496 * Oh well, we can dream of sane hardware when we sleep, no matter how
497 * horrible the crap we have to deal with is when we are awake...
498 */
499
500 pci_dev_put(pci_dev);
501}
502
503static void pci_device_shutdown(struct device *dev)
504{
505 struct pci_dev *pci_dev = to_pci_dev(dev);
506 struct pci_driver *drv = pci_dev->driver;
507
508 pm_runtime_resume(dev);
509
510 if (drv && drv->shutdown)
511 drv->shutdown(pci_dev);
512
513 /*
514 * If this is a kexec reboot, turn off Bus Master bit on the
515 * device to tell it to not continue to do DMA. Don't touch
516 * devices in D3cold or unknown states.
517 * If it is not a kexec reboot, firmware will hit the PCI
518 * devices with big hammer and stop their DMA any way.
519 */
520 if (kexec_in_progress && (pci_dev->current_state <= PCI_D3hot))
521 pci_clear_master(pci_dev);
522}
523
524#ifdef CONFIG_PM_SLEEP
525
526/* Auxiliary functions used for system resume */
527
528/**
529 * pci_restore_standard_config - restore standard config registers of PCI device
530 * @pci_dev: PCI device to handle
531 */
532static int pci_restore_standard_config(struct pci_dev *pci_dev)
533{
534 pci_update_current_state(pci_dev, PCI_UNKNOWN);
535
536 if (pci_dev->current_state != PCI_D0) {
537 int error = pci_set_power_state(pci_dev, PCI_D0);
538 if (error)
539 return error;
540 }
541
542 pci_restore_state(pci_dev);
543 pci_pme_restore(pci_dev);
544 return 0;
545}
546#endif /* CONFIG_PM_SLEEP */
547
548#ifdef CONFIG_PM
549
550/* Auxiliary functions used for system resume and run-time resume */
551
552static void pci_pm_default_resume(struct pci_dev *pci_dev)
553{
554 pci_fixup_device(pci_fixup_resume, pci_dev);
555 pci_enable_wake(pci_dev, PCI_D0, false);
556}
557
558static void pci_pm_power_up_and_verify_state(struct pci_dev *pci_dev)
559{
560 pci_power_up(pci_dev);
561 pci_update_current_state(pci_dev, PCI_D0);
562}
563
564static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
565{
566 pci_pm_power_up_and_verify_state(pci_dev);
567 pci_restore_state(pci_dev);
568 pci_pme_restore(pci_dev);
569}
570
571static void pci_pm_bridge_power_up_actions(struct pci_dev *pci_dev)
572{
573 int ret;
574
575 ret = pci_bridge_wait_for_secondary_bus(pci_dev, "resume");
576 if (ret) {
577 /*
578 * The downstream link failed to come up, so mark the
579 * devices below as disconnected to make sure we don't
580 * attempt to resume them.
581 */
582 pci_walk_bus(pci_dev->subordinate, pci_dev_set_disconnected,
583 NULL);
584 return;
585 }
586
587 /*
588 * When powering on a bridge from D3cold, the whole hierarchy may be
589 * powered on into D0uninitialized state, resume them to give them a
590 * chance to suspend again
591 */
592 pci_resume_bus(pci_dev->subordinate);
593}
594
595#endif /* CONFIG_PM */
596
597#ifdef CONFIG_PM_SLEEP
598
599/*
600 * Default "suspend" method for devices that have no driver provided suspend,
601 * or not even a driver at all (second part).
602 */
603static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
604{
605 /*
606 * mark its power state as "unknown", since we don't know if
607 * e.g. the BIOS will change its device state when we suspend.
608 */
609 if (pci_dev->current_state == PCI_D0)
610 pci_dev->current_state = PCI_UNKNOWN;
611}
612
613/*
614 * Default "resume" method for devices that have no driver provided resume,
615 * or not even a driver at all (second part).
616 */
617static int pci_pm_reenable_device(struct pci_dev *pci_dev)
618{
619 int retval;
620
621 /* if the device was enabled before suspend, re-enable */
622 retval = pci_reenable_device(pci_dev);
623 /*
624 * if the device was busmaster before the suspend, make it busmaster
625 * again
626 */
627 if (pci_dev->is_busmaster)
628 pci_set_master(pci_dev);
629
630 return retval;
631}
632
633static int pci_legacy_suspend(struct device *dev, pm_message_t state)
634{
635 struct pci_dev *pci_dev = to_pci_dev(dev);
636 struct pci_driver *drv = pci_dev->driver;
637
638 if (drv && drv->suspend) {
639 pci_power_t prev = pci_dev->current_state;
640 int error;
641
642 error = drv->suspend(pci_dev, state);
643 suspend_report_result(dev, drv->suspend, error);
644 if (error)
645 return error;
646
647 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
648 && pci_dev->current_state != PCI_UNKNOWN) {
649 pci_WARN_ONCE(pci_dev, pci_dev->current_state != prev,
650 "PCI PM: Device state not saved by %pS\n",
651 drv->suspend);
652 }
653 }
654
655 pci_fixup_device(pci_fixup_suspend, pci_dev);
656
657 return 0;
658}
659
660static int pci_legacy_suspend_late(struct device *dev)
661{
662 struct pci_dev *pci_dev = to_pci_dev(dev);
663
664 if (!pci_dev->state_saved)
665 pci_save_state(pci_dev);
666
667 pci_pm_set_unknown_state(pci_dev);
668
669 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
670
671 return 0;
672}
673
674static int pci_legacy_resume(struct device *dev)
675{
676 struct pci_dev *pci_dev = to_pci_dev(dev);
677 struct pci_driver *drv = pci_dev->driver;
678
679 pci_fixup_device(pci_fixup_resume, pci_dev);
680
681 return drv && drv->resume ?
682 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
683}
684
685/* Auxiliary functions used by the new power management framework */
686
687static void pci_pm_default_suspend(struct pci_dev *pci_dev)
688{
689 /* Disable non-bridge devices without PM support */
690 if (!pci_has_subordinate(pci_dev))
691 pci_disable_enabled_device(pci_dev);
692}
693
694static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
695{
696 struct pci_driver *drv = pci_dev->driver;
697 bool ret = drv && (drv->suspend || drv->resume);
698
699 /*
700 * Legacy PM support is used by default, so warn if the new framework is
701 * supported as well. Drivers are supposed to support either the
702 * former, or the latter, but not both at the same time.
703 */
704 pci_WARN(pci_dev, ret && drv->driver.pm, "device %04x:%04x\n",
705 pci_dev->vendor, pci_dev->device);
706
707 return ret;
708}
709
710/* New power management framework */
711
712static int pci_pm_prepare(struct device *dev)
713{
714 struct pci_dev *pci_dev = to_pci_dev(dev);
715 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
716
717 if (pm && pm->prepare) {
718 int error = pm->prepare(dev);
719 if (error < 0)
720 return error;
721
722 if (!error && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
723 return 0;
724 }
725 if (pci_dev_need_resume(pci_dev))
726 return 0;
727
728 /*
729 * The PME setting needs to be adjusted here in case the direct-complete
730 * optimization is used with respect to this device.
731 */
732 pci_dev_adjust_pme(pci_dev);
733 return 1;
734}
735
736static void pci_pm_complete(struct device *dev)
737{
738 struct pci_dev *pci_dev = to_pci_dev(dev);
739
740 pci_dev_complete_resume(pci_dev);
741 pm_generic_complete(dev);
742
743 /* Resume device if platform firmware has put it in reset-power-on */
744 if (pm_runtime_suspended(dev) && pm_resume_via_firmware()) {
745 pci_power_t pre_sleep_state = pci_dev->current_state;
746
747 pci_refresh_power_state(pci_dev);
748 /*
749 * On platforms with ACPI this check may also trigger for
750 * devices sharing power resources if one of those power
751 * resources has been activated as a result of a change of the
752 * power state of another device sharing it. However, in that
753 * case it is also better to resume the device, in general.
754 */
755 if (pci_dev->current_state < pre_sleep_state)
756 pm_request_resume(dev);
757 }
758}
759
760#else /* !CONFIG_PM_SLEEP */
761
762#define pci_pm_prepare NULL
763#define pci_pm_complete NULL
764
765#endif /* !CONFIG_PM_SLEEP */
766
767#ifdef CONFIG_SUSPEND
768static void pcie_pme_root_status_cleanup(struct pci_dev *pci_dev)
769{
770 /*
771 * Some BIOSes forget to clear Root PME Status bits after system
772 * wakeup, which breaks ACPI-based runtime wakeup on PCI Express.
773 * Clear those bits now just in case (shouldn't hurt).
774 */
775 if (pci_is_pcie(pci_dev) &&
776 (pci_pcie_type(pci_dev) == PCI_EXP_TYPE_ROOT_PORT ||
777 pci_pcie_type(pci_dev) == PCI_EXP_TYPE_RC_EC))
778 pcie_clear_root_pme_status(pci_dev);
779}
780
781static int pci_pm_suspend(struct device *dev)
782{
783 struct pci_dev *pci_dev = to_pci_dev(dev);
784 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
785
786 pci_dev->skip_bus_pm = false;
787
788 /*
789 * Disabling PTM allows some systems, e.g., Intel mobile chips
790 * since Coffee Lake, to enter a lower-power PM state.
791 */
792 pci_suspend_ptm(pci_dev);
793
794 if (pci_has_legacy_pm_support(pci_dev))
795 return pci_legacy_suspend(dev, PMSG_SUSPEND);
796
797 if (!pm) {
798 pci_pm_default_suspend(pci_dev);
799 return 0;
800 }
801
802 /*
803 * PCI devices suspended at run time may need to be resumed at this
804 * point, because in general it may be necessary to reconfigure them for
805 * system suspend. Namely, if the device is expected to wake up the
806 * system from the sleep state, it may have to be reconfigured for this
807 * purpose, or if the device is not expected to wake up the system from
808 * the sleep state, it should be prevented from signaling wakeup events
809 * going forward.
810 *
811 * Also if the driver of the device does not indicate that its system
812 * suspend callbacks can cope with runtime-suspended devices, it is
813 * better to resume the device from runtime suspend here.
814 */
815 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
816 pci_dev_need_resume(pci_dev)) {
817 pm_runtime_resume(dev);
818 pci_dev->state_saved = false;
819 } else {
820 pci_dev_adjust_pme(pci_dev);
821 }
822
823 if (pm->suspend) {
824 pci_power_t prev = pci_dev->current_state;
825 int error;
826
827 error = pm->suspend(dev);
828 suspend_report_result(dev, pm->suspend, error);
829 if (error)
830 return error;
831
832 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
833 && pci_dev->current_state != PCI_UNKNOWN) {
834 pci_WARN_ONCE(pci_dev, pci_dev->current_state != prev,
835 "PCI PM: State of device not saved by %pS\n",
836 pm->suspend);
837 }
838 }
839
840 return 0;
841}
842
843static int pci_pm_suspend_late(struct device *dev)
844{
845 if (dev_pm_skip_suspend(dev))
846 return 0;
847
848 pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
849
850 return pm_generic_suspend_late(dev);
851}
852
853static int pci_pm_suspend_noirq(struct device *dev)
854{
855 struct pci_dev *pci_dev = to_pci_dev(dev);
856 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
857
858 if (dev_pm_skip_suspend(dev))
859 return 0;
860
861 if (pci_has_legacy_pm_support(pci_dev))
862 return pci_legacy_suspend_late(dev);
863
864 if (!pm) {
865 pci_save_state(pci_dev);
866 goto Fixup;
867 }
868
869 if (pm->suspend_noirq) {
870 pci_power_t prev = pci_dev->current_state;
871 int error;
872
873 error = pm->suspend_noirq(dev);
874 suspend_report_result(dev, pm->suspend_noirq, error);
875 if (error)
876 return error;
877
878 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
879 && pci_dev->current_state != PCI_UNKNOWN) {
880 pci_WARN_ONCE(pci_dev, pci_dev->current_state != prev,
881 "PCI PM: State of device not saved by %pS\n",
882 pm->suspend_noirq);
883 goto Fixup;
884 }
885 }
886
887 if (!pci_dev->state_saved) {
888 pci_save_state(pci_dev);
889
890 /*
891 * If the device is a bridge with a child in D0 below it,
892 * it needs to stay in D0, so check skip_bus_pm to avoid
893 * putting it into a low-power state in that case.
894 */
895 if (!pci_dev->skip_bus_pm && pci_power_manageable(pci_dev))
896 pci_prepare_to_sleep(pci_dev);
897 }
898
899 pci_dbg(pci_dev, "PCI PM: Suspend power state: %s\n",
900 pci_power_name(pci_dev->current_state));
901
902 if (pci_dev->current_state == PCI_D0) {
903 pci_dev->skip_bus_pm = true;
904 /*
905 * Per PCI PM r1.2, table 6-1, a bridge must be in D0 if any
906 * downstream device is in D0, so avoid changing the power state
907 * of the parent bridge by setting the skip_bus_pm flag for it.
908 */
909 if (pci_dev->bus->self)
910 pci_dev->bus->self->skip_bus_pm = true;
911 }
912
913 if (pci_dev->skip_bus_pm && pm_suspend_no_platform()) {
914 pci_dbg(pci_dev, "PCI PM: Skipped\n");
915 goto Fixup;
916 }
917
918 pci_pm_set_unknown_state(pci_dev);
919
920 /*
921 * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
922 * PCI COMMAND register isn't 0, the BIOS assumes that the controller
923 * hasn't been quiesced and tries to turn it off. If the controller
924 * is already in D3, this can hang or cause memory corruption.
925 *
926 * Since the value of the COMMAND register doesn't matter once the
927 * device has been suspended, we can safely set it to 0 here.
928 */
929 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
930 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
931
932Fixup:
933 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
934
935 /*
936 * If the target system sleep state is suspend-to-idle, it is sufficient
937 * to check whether or not the device's wakeup settings are good for
938 * runtime PM. Otherwise, the pm_resume_via_firmware() check will cause
939 * pci_pm_complete() to take care of fixing up the device's state
940 * anyway, if need be.
941 */
942 if (device_can_wakeup(dev) && !device_may_wakeup(dev))
943 dev->power.may_skip_resume = false;
944
945 return 0;
946}
947
948static int pci_pm_resume_noirq(struct device *dev)
949{
950 struct pci_dev *pci_dev = to_pci_dev(dev);
951 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
952 pci_power_t prev_state = pci_dev->current_state;
953 bool skip_bus_pm = pci_dev->skip_bus_pm;
954
955 if (dev_pm_skip_resume(dev))
956 return 0;
957
958 /*
959 * In the suspend-to-idle case, devices left in D0 during suspend will
960 * stay in D0, so it is not necessary to restore or update their
961 * configuration here and attempting to put them into D0 again is
962 * pointless, so avoid doing that.
963 */
964 if (!(skip_bus_pm && pm_suspend_no_platform()))
965 pci_pm_default_resume_early(pci_dev);
966
967 pci_fixup_device(pci_fixup_resume_early, pci_dev);
968 pcie_pme_root_status_cleanup(pci_dev);
969
970 if (!skip_bus_pm && prev_state == PCI_D3cold)
971 pci_pm_bridge_power_up_actions(pci_dev);
972
973 if (pci_has_legacy_pm_support(pci_dev))
974 return 0;
975
976 if (pm && pm->resume_noirq)
977 return pm->resume_noirq(dev);
978
979 return 0;
980}
981
982static int pci_pm_resume_early(struct device *dev)
983{
984 if (dev_pm_skip_resume(dev))
985 return 0;
986
987 return pm_generic_resume_early(dev);
988}
989
990static int pci_pm_resume(struct device *dev)
991{
992 struct pci_dev *pci_dev = to_pci_dev(dev);
993 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
994
995 /*
996 * This is necessary for the suspend error path in which resume is
997 * called without restoring the standard config registers of the device.
998 */
999 if (pci_dev->state_saved)
1000 pci_restore_standard_config(pci_dev);
1001
1002 pci_resume_ptm(pci_dev);
1003
1004 if (pci_has_legacy_pm_support(pci_dev))
1005 return pci_legacy_resume(dev);
1006
1007 pci_pm_default_resume(pci_dev);
1008
1009 if (pm) {
1010 if (pm->resume)
1011 return pm->resume(dev);
1012 } else {
1013 pci_pm_reenable_device(pci_dev);
1014 }
1015
1016 return 0;
1017}
1018
1019#else /* !CONFIG_SUSPEND */
1020
1021#define pci_pm_suspend NULL
1022#define pci_pm_suspend_late NULL
1023#define pci_pm_suspend_noirq NULL
1024#define pci_pm_resume NULL
1025#define pci_pm_resume_early NULL
1026#define pci_pm_resume_noirq NULL
1027
1028#endif /* !CONFIG_SUSPEND */
1029
1030#ifdef CONFIG_HIBERNATE_CALLBACKS
1031
1032static int pci_pm_freeze(struct device *dev)
1033{
1034 struct pci_dev *pci_dev = to_pci_dev(dev);
1035 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1036
1037 if (pci_has_legacy_pm_support(pci_dev))
1038 return pci_legacy_suspend(dev, PMSG_FREEZE);
1039
1040 if (!pm) {
1041 pci_pm_default_suspend(pci_dev);
1042 return 0;
1043 }
1044
1045 /*
1046 * Resume all runtime-suspended devices before creating a snapshot
1047 * image of system memory, because the restore kernel generally cannot
1048 * be expected to always handle them consistently and they need to be
1049 * put into the runtime-active metastate during system resume anyway,
1050 * so it is better to ensure that the state saved in the image will be
1051 * always consistent with that.
1052 */
1053 pm_runtime_resume(dev);
1054 pci_dev->state_saved = false;
1055
1056 if (pm->freeze) {
1057 int error;
1058
1059 error = pm->freeze(dev);
1060 suspend_report_result(dev, pm->freeze, error);
1061 if (error)
1062 return error;
1063 }
1064
1065 return 0;
1066}
1067
1068static int pci_pm_freeze_noirq(struct device *dev)
1069{
1070 struct pci_dev *pci_dev = to_pci_dev(dev);
1071 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1072
1073 if (pci_has_legacy_pm_support(pci_dev))
1074 return pci_legacy_suspend_late(dev);
1075
1076 if (pm && pm->freeze_noirq) {
1077 int error;
1078
1079 error = pm->freeze_noirq(dev);
1080 suspend_report_result(dev, pm->freeze_noirq, error);
1081 if (error)
1082 return error;
1083 }
1084
1085 if (!pci_dev->state_saved)
1086 pci_save_state(pci_dev);
1087
1088 pci_pm_set_unknown_state(pci_dev);
1089
1090 return 0;
1091}
1092
1093static int pci_pm_thaw_noirq(struct device *dev)
1094{
1095 struct pci_dev *pci_dev = to_pci_dev(dev);
1096 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1097
1098 /*
1099 * The pm->thaw_noirq() callback assumes the device has been
1100 * returned to D0 and its config state has been restored.
1101 *
1102 * In addition, pci_restore_state() restores MSI-X state in MMIO
1103 * space, which requires the device to be in D0, so return it to D0
1104 * in case the driver's "freeze" callbacks put it into a low-power
1105 * state.
1106 */
1107 pci_pm_power_up_and_verify_state(pci_dev);
1108 pci_restore_state(pci_dev);
1109
1110 if (pci_has_legacy_pm_support(pci_dev))
1111 return 0;
1112
1113 if (pm && pm->thaw_noirq)
1114 return pm->thaw_noirq(dev);
1115
1116 return 0;
1117}
1118
1119static int pci_pm_thaw(struct device *dev)
1120{
1121 struct pci_dev *pci_dev = to_pci_dev(dev);
1122 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1123 int error = 0;
1124
1125 if (pci_has_legacy_pm_support(pci_dev))
1126 return pci_legacy_resume(dev);
1127
1128 if (pm) {
1129 if (pm->thaw)
1130 error = pm->thaw(dev);
1131 } else {
1132 pci_pm_reenable_device(pci_dev);
1133 }
1134
1135 pci_dev->state_saved = false;
1136
1137 return error;
1138}
1139
1140static int pci_pm_poweroff(struct device *dev)
1141{
1142 struct pci_dev *pci_dev = to_pci_dev(dev);
1143 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1144
1145 if (pci_has_legacy_pm_support(pci_dev))
1146 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
1147
1148 if (!pm) {
1149 pci_pm_default_suspend(pci_dev);
1150 return 0;
1151 }
1152
1153 /* The reason to do that is the same as in pci_pm_suspend(). */
1154 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1155 pci_dev_need_resume(pci_dev)) {
1156 pm_runtime_resume(dev);
1157 pci_dev->state_saved = false;
1158 } else {
1159 pci_dev_adjust_pme(pci_dev);
1160 }
1161
1162 if (pm->poweroff) {
1163 int error;
1164
1165 error = pm->poweroff(dev);
1166 suspend_report_result(dev, pm->poweroff, error);
1167 if (error)
1168 return error;
1169 }
1170
1171 return 0;
1172}
1173
1174static int pci_pm_poweroff_late(struct device *dev)
1175{
1176 if (dev_pm_skip_suspend(dev))
1177 return 0;
1178
1179 pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
1180
1181 return pm_generic_poweroff_late(dev);
1182}
1183
1184static int pci_pm_poweroff_noirq(struct device *dev)
1185{
1186 struct pci_dev *pci_dev = to_pci_dev(dev);
1187 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1188
1189 if (dev_pm_skip_suspend(dev))
1190 return 0;
1191
1192 if (pci_has_legacy_pm_support(pci_dev))
1193 return pci_legacy_suspend_late(dev);
1194
1195 if (!pm) {
1196 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
1197 return 0;
1198 }
1199
1200 if (pm->poweroff_noirq) {
1201 int error;
1202
1203 error = pm->poweroff_noirq(dev);
1204 suspend_report_result(dev, pm->poweroff_noirq, error);
1205 if (error)
1206 return error;
1207 }
1208
1209 if (!pci_dev->state_saved && !pci_has_subordinate(pci_dev))
1210 pci_prepare_to_sleep(pci_dev);
1211
1212 /*
1213 * The reason for doing this here is the same as for the analogous code
1214 * in pci_pm_suspend_noirq().
1215 */
1216 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
1217 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
1218
1219 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
1220
1221 return 0;
1222}
1223
1224static int pci_pm_restore_noirq(struct device *dev)
1225{
1226 struct pci_dev *pci_dev = to_pci_dev(dev);
1227 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1228
1229 pci_pm_default_resume_early(pci_dev);
1230 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1231
1232 if (pci_has_legacy_pm_support(pci_dev))
1233 return 0;
1234
1235 if (pm && pm->restore_noirq)
1236 return pm->restore_noirq(dev);
1237
1238 return 0;
1239}
1240
1241static int pci_pm_restore(struct device *dev)
1242{
1243 struct pci_dev *pci_dev = to_pci_dev(dev);
1244 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1245
1246 /*
1247 * This is necessary for the hibernation error path in which restore is
1248 * called without restoring the standard config registers of the device.
1249 */
1250 if (pci_dev->state_saved)
1251 pci_restore_standard_config(pci_dev);
1252
1253 if (pci_has_legacy_pm_support(pci_dev))
1254 return pci_legacy_resume(dev);
1255
1256 pci_pm_default_resume(pci_dev);
1257
1258 if (pm) {
1259 if (pm->restore)
1260 return pm->restore(dev);
1261 } else {
1262 pci_pm_reenable_device(pci_dev);
1263 }
1264
1265 return 0;
1266}
1267
1268#else /* !CONFIG_HIBERNATE_CALLBACKS */
1269
1270#define pci_pm_freeze NULL
1271#define pci_pm_freeze_noirq NULL
1272#define pci_pm_thaw NULL
1273#define pci_pm_thaw_noirq NULL
1274#define pci_pm_poweroff NULL
1275#define pci_pm_poweroff_late NULL
1276#define pci_pm_poweroff_noirq NULL
1277#define pci_pm_restore NULL
1278#define pci_pm_restore_noirq NULL
1279
1280#endif /* !CONFIG_HIBERNATE_CALLBACKS */
1281
1282#ifdef CONFIG_PM
1283
1284static int pci_pm_runtime_suspend(struct device *dev)
1285{
1286 struct pci_dev *pci_dev = to_pci_dev(dev);
1287 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1288 pci_power_t prev = pci_dev->current_state;
1289 int error;
1290
1291 pci_suspend_ptm(pci_dev);
1292
1293 /*
1294 * If pci_dev->driver is not set (unbound), we leave the device in D0,
1295 * but it may go to D3cold when the bridge above it runtime suspends.
1296 * Save its config space in case that happens.
1297 */
1298 if (!pci_dev->driver) {
1299 pci_save_state(pci_dev);
1300 return 0;
1301 }
1302
1303 pci_dev->state_saved = false;
1304 if (pm && pm->runtime_suspend) {
1305 error = pm->runtime_suspend(dev);
1306 /*
1307 * -EBUSY and -EAGAIN is used to request the runtime PM core
1308 * to schedule a new suspend, so log the event only with debug
1309 * log level.
1310 */
1311 if (error == -EBUSY || error == -EAGAIN) {
1312 pci_dbg(pci_dev, "can't suspend now (%ps returned %d)\n",
1313 pm->runtime_suspend, error);
1314 return error;
1315 } else if (error) {
1316 pci_err(pci_dev, "can't suspend (%ps returned %d)\n",
1317 pm->runtime_suspend, error);
1318 return error;
1319 }
1320 }
1321
1322 pci_fixup_device(pci_fixup_suspend, pci_dev);
1323
1324 if (pm && pm->runtime_suspend
1325 && !pci_dev->state_saved && pci_dev->current_state != PCI_D0
1326 && pci_dev->current_state != PCI_UNKNOWN) {
1327 pci_WARN_ONCE(pci_dev, pci_dev->current_state != prev,
1328 "PCI PM: State of device not saved by %pS\n",
1329 pm->runtime_suspend);
1330 return 0;
1331 }
1332
1333 if (!pci_dev->state_saved) {
1334 pci_save_state(pci_dev);
1335 pci_finish_runtime_suspend(pci_dev);
1336 }
1337
1338 return 0;
1339}
1340
1341static int pci_pm_runtime_resume(struct device *dev)
1342{
1343 struct pci_dev *pci_dev = to_pci_dev(dev);
1344 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1345 pci_power_t prev_state = pci_dev->current_state;
1346 int error = 0;
1347
1348 /*
1349 * Restoring config space is necessary even if the device is not bound
1350 * to a driver because although we left it in D0, it may have gone to
1351 * D3cold when the bridge above it runtime suspended.
1352 */
1353 pci_pm_default_resume_early(pci_dev);
1354 pci_resume_ptm(pci_dev);
1355
1356 if (!pci_dev->driver)
1357 return 0;
1358
1359 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1360 pci_pm_default_resume(pci_dev);
1361
1362 if (prev_state == PCI_D3cold)
1363 pci_pm_bridge_power_up_actions(pci_dev);
1364
1365 if (pm && pm->runtime_resume)
1366 error = pm->runtime_resume(dev);
1367
1368 return error;
1369}
1370
1371static int pci_pm_runtime_idle(struct device *dev)
1372{
1373 struct pci_dev *pci_dev = to_pci_dev(dev);
1374 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1375
1376 /*
1377 * If pci_dev->driver is not set (unbound), the device should
1378 * always remain in D0 regardless of the runtime PM status
1379 */
1380 if (!pci_dev->driver)
1381 return 0;
1382
1383 if (pm && pm->runtime_idle)
1384 return pm->runtime_idle(dev);
1385
1386 return 0;
1387}
1388
1389static const struct dev_pm_ops pci_dev_pm_ops = {
1390 .prepare = pci_pm_prepare,
1391 .complete = pci_pm_complete,
1392 .suspend = pci_pm_suspend,
1393 .suspend_late = pci_pm_suspend_late,
1394 .resume = pci_pm_resume,
1395 .resume_early = pci_pm_resume_early,
1396 .freeze = pci_pm_freeze,
1397 .thaw = pci_pm_thaw,
1398 .poweroff = pci_pm_poweroff,
1399 .poweroff_late = pci_pm_poweroff_late,
1400 .restore = pci_pm_restore,
1401 .suspend_noirq = pci_pm_suspend_noirq,
1402 .resume_noirq = pci_pm_resume_noirq,
1403 .freeze_noirq = pci_pm_freeze_noirq,
1404 .thaw_noirq = pci_pm_thaw_noirq,
1405 .poweroff_noirq = pci_pm_poweroff_noirq,
1406 .restore_noirq = pci_pm_restore_noirq,
1407 .runtime_suspend = pci_pm_runtime_suspend,
1408 .runtime_resume = pci_pm_runtime_resume,
1409 .runtime_idle = pci_pm_runtime_idle,
1410};
1411
1412#define PCI_PM_OPS_PTR (&pci_dev_pm_ops)
1413
1414#else /* !CONFIG_PM */
1415
1416#define pci_pm_runtime_suspend NULL
1417#define pci_pm_runtime_resume NULL
1418#define pci_pm_runtime_idle NULL
1419
1420#define PCI_PM_OPS_PTR NULL
1421
1422#endif /* !CONFIG_PM */
1423
1424/**
1425 * __pci_register_driver - register a new pci driver
1426 * @drv: the driver structure to register
1427 * @owner: owner module of drv
1428 * @mod_name: module name string
1429 *
1430 * Adds the driver structure to the list of registered drivers.
1431 * Returns a negative value on error, otherwise 0.
1432 * If no error occurred, the driver remains registered even if
1433 * no device was claimed during registration.
1434 */
1435int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1436 const char *mod_name)
1437{
1438 /* initialize common driver fields */
1439 drv->driver.name = drv->name;
1440 drv->driver.bus = &pci_bus_type;
1441 drv->driver.owner = owner;
1442 drv->driver.mod_name = mod_name;
1443 drv->driver.groups = drv->groups;
1444 drv->driver.dev_groups = drv->dev_groups;
1445
1446 spin_lock_init(&drv->dynids.lock);
1447 INIT_LIST_HEAD(&drv->dynids.list);
1448
1449 /* register with core */
1450 return driver_register(&drv->driver);
1451}
1452EXPORT_SYMBOL(__pci_register_driver);
1453
1454/**
1455 * pci_unregister_driver - unregister a pci driver
1456 * @drv: the driver structure to unregister
1457 *
1458 * Deletes the driver structure from the list of registered PCI drivers,
1459 * gives it a chance to clean up by calling its remove() function for
1460 * each device it was responsible for, and marks those devices as
1461 * driverless.
1462 */
1463
1464void pci_unregister_driver(struct pci_driver *drv)
1465{
1466 driver_unregister(&drv->driver);
1467 pci_free_dynids(drv);
1468}
1469EXPORT_SYMBOL(pci_unregister_driver);
1470
1471static struct pci_driver pci_compat_driver = {
1472 .name = "compat"
1473};
1474
1475/**
1476 * pci_dev_driver - get the pci_driver of a device
1477 * @dev: the device to query
1478 *
1479 * Returns the appropriate pci_driver structure or %NULL if there is no
1480 * registered driver for the device.
1481 */
1482struct pci_driver *pci_dev_driver(const struct pci_dev *dev)
1483{
1484 int i;
1485
1486 if (dev->driver)
1487 return dev->driver;
1488
1489 for (i = 0; i <= PCI_ROM_RESOURCE; i++)
1490 if (dev->resource[i].flags & IORESOURCE_BUSY)
1491 return &pci_compat_driver;
1492
1493 return NULL;
1494}
1495EXPORT_SYMBOL(pci_dev_driver);
1496
1497/**
1498 * pci_bus_match - Tell if a PCI device structure has a matching PCI device id structure
1499 * @dev: the PCI device structure to match against
1500 * @drv: the device driver to search for matching PCI device id structures
1501 *
1502 * Used by a driver to check whether a PCI device present in the
1503 * system is in its list of supported devices. Returns the matching
1504 * pci_device_id structure or %NULL if there is no match.
1505 */
1506static int pci_bus_match(struct device *dev, const struct device_driver *drv)
1507{
1508 struct pci_dev *pci_dev = to_pci_dev(dev);
1509 struct pci_driver *pci_drv;
1510 const struct pci_device_id *found_id;
1511
1512 if (!pci_dev->match_driver)
1513 return 0;
1514
1515 pci_drv = (struct pci_driver *)to_pci_driver(drv);
1516 found_id = pci_match_device(pci_drv, pci_dev);
1517 if (found_id)
1518 return 1;
1519
1520 return 0;
1521}
1522
1523/**
1524 * pci_dev_get - increments the reference count of the pci device structure
1525 * @dev: the device being referenced
1526 *
1527 * Each live reference to a device should be refcounted.
1528 *
1529 * Drivers for PCI devices should normally record such references in
1530 * their probe() methods, when they bind to a device, and release
1531 * them by calling pci_dev_put(), in their disconnect() methods.
1532 *
1533 * A pointer to the device with the incremented reference counter is returned.
1534 */
1535struct pci_dev *pci_dev_get(struct pci_dev *dev)
1536{
1537 if (dev)
1538 get_device(&dev->dev);
1539 return dev;
1540}
1541EXPORT_SYMBOL(pci_dev_get);
1542
1543/**
1544 * pci_dev_put - release a use of the pci device structure
1545 * @dev: device that's been disconnected
1546 *
1547 * Must be called when a user of a device is finished with it. When the last
1548 * user of the device calls this function, the memory of the device is freed.
1549 */
1550void pci_dev_put(struct pci_dev *dev)
1551{
1552 if (dev)
1553 put_device(&dev->dev);
1554}
1555EXPORT_SYMBOL(pci_dev_put);
1556
1557static int pci_uevent(const struct device *dev, struct kobj_uevent_env *env)
1558{
1559 const struct pci_dev *pdev;
1560
1561 if (!dev)
1562 return -ENODEV;
1563
1564 pdev = to_pci_dev(dev);
1565
1566 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1567 return -ENOMEM;
1568
1569 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1570 return -ENOMEM;
1571
1572 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1573 pdev->subsystem_device))
1574 return -ENOMEM;
1575
1576 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1577 return -ENOMEM;
1578
1579 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X",
1580 pdev->vendor, pdev->device,
1581 pdev->subsystem_vendor, pdev->subsystem_device,
1582 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1583 (u8)(pdev->class)))
1584 return -ENOMEM;
1585
1586 return 0;
1587}
1588
1589#if defined(CONFIG_PCIEAER) || defined(CONFIG_EEH)
1590/**
1591 * pci_uevent_ers - emit a uevent during recovery path of PCI device
1592 * @pdev: PCI device undergoing error recovery
1593 * @err_type: type of error event
1594 */
1595void pci_uevent_ers(struct pci_dev *pdev, enum pci_ers_result err_type)
1596{
1597 int idx = 0;
1598 char *envp[3];
1599
1600 switch (err_type) {
1601 case PCI_ERS_RESULT_NONE:
1602 case PCI_ERS_RESULT_CAN_RECOVER:
1603 envp[idx++] = "ERROR_EVENT=BEGIN_RECOVERY";
1604 envp[idx++] = "DEVICE_ONLINE=0";
1605 break;
1606 case PCI_ERS_RESULT_RECOVERED:
1607 envp[idx++] = "ERROR_EVENT=SUCCESSFUL_RECOVERY";
1608 envp[idx++] = "DEVICE_ONLINE=1";
1609 break;
1610 case PCI_ERS_RESULT_DISCONNECT:
1611 envp[idx++] = "ERROR_EVENT=FAILED_RECOVERY";
1612 envp[idx++] = "DEVICE_ONLINE=0";
1613 break;
1614 default:
1615 break;
1616 }
1617
1618 if (idx > 0) {
1619 envp[idx++] = NULL;
1620 kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp);
1621 }
1622}
1623#endif
1624
1625static int pci_bus_num_vf(struct device *dev)
1626{
1627 return pci_num_vf(to_pci_dev(dev));
1628}
1629
1630/**
1631 * pci_dma_configure - Setup DMA configuration
1632 * @dev: ptr to dev structure
1633 *
1634 * Function to update PCI devices's DMA configuration using the same
1635 * info from the OF node or ACPI node of host bridge's parent (if any).
1636 */
1637static int pci_dma_configure(struct device *dev)
1638{
1639 struct pci_driver *driver = to_pci_driver(dev->driver);
1640 struct device *bridge;
1641 int ret = 0;
1642
1643 bridge = pci_get_host_bridge_device(to_pci_dev(dev));
1644
1645 if (IS_ENABLED(CONFIG_OF) && bridge->parent &&
1646 bridge->parent->of_node) {
1647 ret = of_dma_configure(dev, bridge->parent->of_node, true);
1648 } else if (has_acpi_companion(bridge)) {
1649 struct acpi_device *adev = to_acpi_device_node(bridge->fwnode);
1650
1651 ret = acpi_dma_configure(dev, acpi_get_dma_attr(adev));
1652 }
1653
1654 pci_put_host_bridge_device(bridge);
1655
1656 if (!ret && !driver->driver_managed_dma) {
1657 ret = iommu_device_use_default_domain(dev);
1658 if (ret)
1659 arch_teardown_dma_ops(dev);
1660 }
1661
1662 return ret;
1663}
1664
1665static void pci_dma_cleanup(struct device *dev)
1666{
1667 struct pci_driver *driver = to_pci_driver(dev->driver);
1668
1669 if (!driver->driver_managed_dma)
1670 iommu_device_unuse_default_domain(dev);
1671}
1672
1673const struct bus_type pci_bus_type = {
1674 .name = "pci",
1675 .match = pci_bus_match,
1676 .uevent = pci_uevent,
1677 .probe = pci_device_probe,
1678 .remove = pci_device_remove,
1679 .shutdown = pci_device_shutdown,
1680 .dev_groups = pci_dev_groups,
1681 .bus_groups = pci_bus_groups,
1682 .drv_groups = pci_drv_groups,
1683 .pm = PCI_PM_OPS_PTR,
1684 .num_vf = pci_bus_num_vf,
1685 .dma_configure = pci_dma_configure,
1686 .dma_cleanup = pci_dma_cleanup,
1687};
1688EXPORT_SYMBOL(pci_bus_type);
1689
1690#ifdef CONFIG_PCIEPORTBUS
1691static int pcie_port_bus_match(struct device *dev, const struct device_driver *drv)
1692{
1693 struct pcie_device *pciedev;
1694 const struct pcie_port_service_driver *driver;
1695
1696 if (drv->bus != &pcie_port_bus_type || dev->bus != &pcie_port_bus_type)
1697 return 0;
1698
1699 pciedev = to_pcie_device(dev);
1700 driver = to_service_driver(drv);
1701
1702 if (driver->service != pciedev->service)
1703 return 0;
1704
1705 if (driver->port_type != PCIE_ANY_PORT &&
1706 driver->port_type != pci_pcie_type(pciedev->port))
1707 return 0;
1708
1709 return 1;
1710}
1711
1712const struct bus_type pcie_port_bus_type = {
1713 .name = "pci_express",
1714 .match = pcie_port_bus_match,
1715};
1716#endif
1717
1718static int __init pci_driver_init(void)
1719{
1720 int ret;
1721
1722 ret = bus_register(&pci_bus_type);
1723 if (ret)
1724 return ret;
1725
1726#ifdef CONFIG_PCIEPORTBUS
1727 ret = bus_register(&pcie_port_bus_type);
1728 if (ret)
1729 return ret;
1730#endif
1731 dma_debug_add_bus(&pci_bus_type);
1732 return 0;
1733}
1734postcore_initcall(pci_driver_init);