This source file includes following definitions.
- pci_add_dynid
- pci_free_dynids
- new_id_store
- remove_id_store
- pci_match_id
- pci_match_device
- local_pci_probe
- pci_physfn_is_probed
- pci_call_probe
- __pci_device_probe
- pcibios_alloc_irq
- pcibios_free_irq
- pci_device_can_probe
- pci_device_can_probe
- pci_device_probe
- pci_device_remove
- pci_device_shutdown
- pci_restore_standard_config
- pci_pm_default_resume_early
- pci_pm_set_unknown_state
- pci_pm_reenable_device
- pci_legacy_suspend
- pci_legacy_suspend_late
- pci_legacy_resume_early
- pci_legacy_resume
- pci_pm_default_resume
- pci_pm_default_suspend
- pci_has_legacy_pm_support
- pci_pm_prepare
- pci_pm_complete
- pcie_pme_root_status_cleanup
- pci_pm_suspend
- pci_pm_suspend_late
- pci_pm_suspend_noirq
- pci_pm_resume_noirq
- pci_pm_resume
- pci_pm_freeze
- pci_pm_freeze_noirq
- pci_pm_thaw_noirq
- pci_pm_thaw
- pci_pm_poweroff
- pci_pm_poweroff_late
- pci_pm_poweroff_noirq
- pci_pm_restore_noirq
- pci_pm_restore
- pci_pm_runtime_suspend
- pci_pm_runtime_resume
- pci_pm_runtime_idle
- __pci_register_driver
- pci_unregister_driver
- pci_dev_driver
- pci_bus_match
- pci_dev_get
- pci_dev_put
- pci_uevent
- pci_uevent_ers
- pci_bus_num_vf
- pci_dma_configure
- pcie_port_bus_match
- pci_driver_init
1
2
3
4
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/cpu.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/suspend.h>
18 #include <linux/kexec.h>
19 #include <linux/of_device.h>
20 #include <linux/acpi.h>
21 #include "pci.h"
22 #include "pcie/portdrv.h"
23
24 struct pci_dynid {
25 struct list_head node;
26 struct pci_device_id id;
27 };
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 int 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
58 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
59 if (!dynid)
60 return -ENOMEM;
61
62 dynid->id.vendor = vendor;
63 dynid->id.device = device;
64 dynid->id.subvendor = subvendor;
65 dynid->id.subdevice = subdevice;
66 dynid->id.class = class;
67 dynid->id.class_mask = class_mask;
68 dynid->id.driver_data = driver_data;
69
70 spin_lock(&drv->dynids.lock);
71 list_add_tail(&dynid->node, &drv->dynids.list);
72 spin_unlock(&drv->dynids.lock);
73
74 return driver_attach(&drv->driver);
75 }
76 EXPORT_SYMBOL_GPL(pci_add_dynid);
77
78 static void pci_free_dynids(struct pci_driver *drv)
79 {
80 struct pci_dynid *dynid, *n;
81
82 spin_lock(&drv->dynids.lock);
83 list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) {
84 list_del(&dynid->node);
85 kfree(dynid);
86 }
87 spin_unlock(&drv->dynids.lock);
88 }
89
90
91
92
93
94
95
96
97
98 static ssize_t new_id_store(struct device_driver *driver, const char *buf,
99 size_t count)
100 {
101 struct pci_driver *pdrv = to_pci_driver(driver);
102 const struct pci_device_id *ids = pdrv->id_table;
103 u32 vendor, device, subvendor = PCI_ANY_ID,
104 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
105 unsigned long driver_data = 0;
106 int fields = 0;
107 int retval = 0;
108
109 fields = sscanf(buf, "%x %x %x %x %x %x %lx",
110 &vendor, &device, &subvendor, &subdevice,
111 &class, &class_mask, &driver_data);
112 if (fields < 2)
113 return -EINVAL;
114
115 if (fields != 7) {
116 struct pci_dev *pdev = kzalloc(sizeof(*pdev), GFP_KERNEL);
117 if (!pdev)
118 return -ENOMEM;
119
120 pdev->vendor = vendor;
121 pdev->device = device;
122 pdev->subsystem_vendor = subvendor;
123 pdev->subsystem_device = subdevice;
124 pdev->class = class;
125
126 if (pci_match_id(pdrv->id_table, pdev))
127 retval = -EEXIST;
128
129 kfree(pdev);
130
131 if (retval)
132 return retval;
133 }
134
135
136
137 if (ids) {
138 retval = -EINVAL;
139 while (ids->vendor || ids->subvendor || ids->class_mask) {
140 if (driver_data == ids->driver_data) {
141 retval = 0;
142 break;
143 }
144 ids++;
145 }
146 if (retval)
147 return retval;
148 }
149
150 retval = pci_add_dynid(pdrv, vendor, device, subvendor, subdevice,
151 class, class_mask, driver_data);
152 if (retval)
153 return retval;
154 return count;
155 }
156 static DRIVER_ATTR_WO(new_id);
157
158
159
160
161
162
163
164
165
166 static ssize_t remove_id_store(struct device_driver *driver, const char *buf,
167 size_t count)
168 {
169 struct pci_dynid *dynid, *n;
170 struct pci_driver *pdrv = to_pci_driver(driver);
171 u32 vendor, device, subvendor = PCI_ANY_ID,
172 subdevice = PCI_ANY_ID, class = 0, class_mask = 0;
173 int fields = 0;
174 size_t retval = -ENODEV;
175
176 fields = sscanf(buf, "%x %x %x %x %x %x",
177 &vendor, &device, &subvendor, &subdevice,
178 &class, &class_mask);
179 if (fields < 2)
180 return -EINVAL;
181
182 spin_lock(&pdrv->dynids.lock);
183 list_for_each_entry_safe(dynid, n, &pdrv->dynids.list, node) {
184 struct pci_device_id *id = &dynid->id;
185 if ((id->vendor == vendor) &&
186 (id->device == device) &&
187 (subvendor == PCI_ANY_ID || id->subvendor == subvendor) &&
188 (subdevice == PCI_ANY_ID || id->subdevice == subdevice) &&
189 !((id->class ^ class) & class_mask)) {
190 list_del(&dynid->node);
191 kfree(dynid);
192 retval = count;
193 break;
194 }
195 }
196 spin_unlock(&pdrv->dynids.lock);
197
198 return retval;
199 }
200 static DRIVER_ATTR_WO(remove_id);
201
202 static struct attribute *pci_drv_attrs[] = {
203 &driver_attr_new_id.attr,
204 &driver_attr_remove_id.attr,
205 NULL,
206 };
207 ATTRIBUTE_GROUPS(pci_drv);
208
209
210
211
212
213
214
215
216
217
218
219
220
221 const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
222 struct pci_dev *dev)
223 {
224 if (ids) {
225 while (ids->vendor || ids->subvendor || ids->class_mask) {
226 if (pci_match_one_device(ids, dev))
227 return ids;
228 ids++;
229 }
230 }
231 return NULL;
232 }
233 EXPORT_SYMBOL(pci_match_id);
234
235 static const struct pci_device_id pci_device_id_any = {
236 .vendor = PCI_ANY_ID,
237 .device = PCI_ANY_ID,
238 .subvendor = PCI_ANY_ID,
239 .subdevice = PCI_ANY_ID,
240 };
241
242
243
244
245
246
247
248
249
250
251 static const struct pci_device_id *pci_match_device(struct pci_driver *drv,
252 struct pci_dev *dev)
253 {
254 struct pci_dynid *dynid;
255 const struct pci_device_id *found_id = NULL;
256
257
258 if (dev->driver_override && strcmp(dev->driver_override, drv->name))
259 return NULL;
260
261
262 spin_lock(&drv->dynids.lock);
263 list_for_each_entry(dynid, &drv->dynids.list, node) {
264 if (pci_match_one_device(&dynid->id, dev)) {
265 found_id = &dynid->id;
266 break;
267 }
268 }
269 spin_unlock(&drv->dynids.lock);
270
271 if (!found_id)
272 found_id = pci_match_id(drv->id_table, dev);
273
274
275 if (!found_id && dev->driver_override)
276 found_id = &pci_device_id_any;
277
278 return found_id;
279 }
280
281 struct drv_dev_and_id {
282 struct pci_driver *drv;
283 struct pci_dev *dev;
284 const struct pci_device_id *id;
285 };
286
287 static long local_pci_probe(void *_ddi)
288 {
289 struct drv_dev_and_id *ddi = _ddi;
290 struct pci_dev *pci_dev = ddi->dev;
291 struct pci_driver *pci_drv = ddi->drv;
292 struct device *dev = &pci_dev->dev;
293 int rc;
294
295
296
297
298
299
300
301
302
303
304 pm_runtime_get_sync(dev);
305 pci_dev->driver = pci_drv;
306 rc = pci_drv->probe(pci_dev, ddi->id);
307 if (!rc)
308 return rc;
309 if (rc < 0) {
310 pci_dev->driver = NULL;
311 pm_runtime_put_sync(dev);
312 return rc;
313 }
314
315
316
317
318 dev_warn(dev, "Driver probe function unexpectedly returned %d\n", rc);
319 return 0;
320 }
321
322 static bool pci_physfn_is_probed(struct pci_dev *dev)
323 {
324 #ifdef CONFIG_PCI_IOV
325 return dev->is_virtfn && dev->physfn->is_probed;
326 #else
327 return false;
328 #endif
329 }
330
331 static int pci_call_probe(struct pci_driver *drv, struct pci_dev *dev,
332 const struct pci_device_id *id)
333 {
334 int error, node, cpu;
335 struct drv_dev_and_id ddi = { drv, dev, id };
336
337
338
339
340
341
342 node = dev_to_node(&dev->dev);
343 dev->is_probed = 1;
344
345 cpu_hotplug_disable();
346
347
348
349
350
351 if (node < 0 || node >= MAX_NUMNODES || !node_online(node) ||
352 pci_physfn_is_probed(dev))
353 cpu = nr_cpu_ids;
354 else
355 cpu = cpumask_any_and(cpumask_of_node(node), cpu_online_mask);
356
357 if (cpu < nr_cpu_ids)
358 error = work_on_cpu(cpu, local_pci_probe, &ddi);
359 else
360 error = local_pci_probe(&ddi);
361
362 dev->is_probed = 0;
363 cpu_hotplug_enable();
364 return error;
365 }
366
367
368
369
370
371
372
373
374
375 static int __pci_device_probe(struct pci_driver *drv, struct pci_dev *pci_dev)
376 {
377 const struct pci_device_id *id;
378 int error = 0;
379
380 if (!pci_dev->driver && drv->probe) {
381 error = -ENODEV;
382
383 id = pci_match_device(drv, pci_dev);
384 if (id)
385 error = pci_call_probe(drv, pci_dev, id);
386 }
387 return error;
388 }
389
390 int __weak pcibios_alloc_irq(struct pci_dev *dev)
391 {
392 return 0;
393 }
394
395 void __weak pcibios_free_irq(struct pci_dev *dev)
396 {
397 }
398
399 #ifdef CONFIG_PCI_IOV
400 static inline bool pci_device_can_probe(struct pci_dev *pdev)
401 {
402 return (!pdev->is_virtfn || pdev->physfn->sriov->drivers_autoprobe ||
403 pdev->driver_override);
404 }
405 #else
406 static inline bool pci_device_can_probe(struct pci_dev *pdev)
407 {
408 return true;
409 }
410 #endif
411
412 static int pci_device_probe(struct device *dev)
413 {
414 int error;
415 struct pci_dev *pci_dev = to_pci_dev(dev);
416 struct pci_driver *drv = to_pci_driver(dev->driver);
417
418 if (!pci_device_can_probe(pci_dev))
419 return -ENODEV;
420
421 pci_assign_irq(pci_dev);
422
423 error = pcibios_alloc_irq(pci_dev);
424 if (error < 0)
425 return error;
426
427 pci_dev_get(pci_dev);
428 error = __pci_device_probe(drv, pci_dev);
429 if (error) {
430 pcibios_free_irq(pci_dev);
431 pci_dev_put(pci_dev);
432 }
433
434 return error;
435 }
436
437 static int pci_device_remove(struct device *dev)
438 {
439 struct pci_dev *pci_dev = to_pci_dev(dev);
440 struct pci_driver *drv = pci_dev->driver;
441
442 if (drv) {
443 if (drv->remove) {
444 pm_runtime_get_sync(dev);
445 drv->remove(pci_dev);
446 pm_runtime_put_noidle(dev);
447 }
448 pcibios_free_irq(pci_dev);
449 pci_dev->driver = NULL;
450 pci_iov_remove(pci_dev);
451 }
452
453
454 pm_runtime_put_sync(dev);
455
456
457
458
459
460 if (pci_dev->current_state == PCI_D0)
461 pci_dev->current_state = PCI_UNKNOWN;
462
463
464
465
466
467
468
469
470
471
472 pci_dev_put(pci_dev);
473 return 0;
474 }
475
476 static void pci_device_shutdown(struct device *dev)
477 {
478 struct pci_dev *pci_dev = to_pci_dev(dev);
479 struct pci_driver *drv = pci_dev->driver;
480
481 pm_runtime_resume(dev);
482
483 if (drv && drv->shutdown)
484 drv->shutdown(pci_dev);
485
486
487
488
489
490
491
492
493 if (kexec_in_progress && (pci_dev->current_state <= PCI_D3hot))
494 pci_clear_master(pci_dev);
495 }
496
497 #ifdef CONFIG_PM
498
499
500
501
502
503
504
505 static int pci_restore_standard_config(struct pci_dev *pci_dev)
506 {
507 pci_update_current_state(pci_dev, PCI_UNKNOWN);
508
509 if (pci_dev->current_state != PCI_D0) {
510 int error = pci_set_power_state(pci_dev, PCI_D0);
511 if (error)
512 return error;
513 }
514
515 pci_restore_state(pci_dev);
516 pci_pme_restore(pci_dev);
517 return 0;
518 }
519
520 #endif
521
522 #ifdef CONFIG_PM_SLEEP
523
524 static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
525 {
526 pci_power_up(pci_dev);
527 pci_restore_state(pci_dev);
528 pci_pme_restore(pci_dev);
529 }
530
531
532
533
534
535 static void pci_pm_set_unknown_state(struct pci_dev *pci_dev)
536 {
537
538
539
540
541 if (pci_dev->current_state == PCI_D0)
542 pci_dev->current_state = PCI_UNKNOWN;
543 }
544
545
546
547
548
549 static int pci_pm_reenable_device(struct pci_dev *pci_dev)
550 {
551 int retval;
552
553
554 retval = pci_reenable_device(pci_dev);
555
556
557
558
559 if (pci_dev->is_busmaster)
560 pci_set_master(pci_dev);
561
562 return retval;
563 }
564
565 static int pci_legacy_suspend(struct device *dev, pm_message_t state)
566 {
567 struct pci_dev *pci_dev = to_pci_dev(dev);
568 struct pci_driver *drv = pci_dev->driver;
569
570 if (drv && drv->suspend) {
571 pci_power_t prev = pci_dev->current_state;
572 int error;
573
574 error = drv->suspend(pci_dev, state);
575 suspend_report_result(drv->suspend, error);
576 if (error)
577 return error;
578
579 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
580 && pci_dev->current_state != PCI_UNKNOWN) {
581 WARN_ONCE(pci_dev->current_state != prev,
582 "PCI PM: Device state not saved by %pS\n",
583 drv->suspend);
584 }
585 }
586
587 pci_fixup_device(pci_fixup_suspend, pci_dev);
588
589 return 0;
590 }
591
592 static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
593 {
594 struct pci_dev *pci_dev = to_pci_dev(dev);
595 struct pci_driver *drv = pci_dev->driver;
596
597 if (drv && drv->suspend_late) {
598 pci_power_t prev = pci_dev->current_state;
599 int error;
600
601 error = drv->suspend_late(pci_dev, state);
602 suspend_report_result(drv->suspend_late, error);
603 if (error)
604 return error;
605
606 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
607 && pci_dev->current_state != PCI_UNKNOWN) {
608 WARN_ONCE(pci_dev->current_state != prev,
609 "PCI PM: Device state not saved by %pS\n",
610 drv->suspend_late);
611 goto Fixup;
612 }
613 }
614
615 if (!pci_dev->state_saved)
616 pci_save_state(pci_dev);
617
618 pci_pm_set_unknown_state(pci_dev);
619
620 Fixup:
621 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
622
623 return 0;
624 }
625
626 static int pci_legacy_resume_early(struct device *dev)
627 {
628 struct pci_dev *pci_dev = to_pci_dev(dev);
629 struct pci_driver *drv = pci_dev->driver;
630
631 return drv && drv->resume_early ?
632 drv->resume_early(pci_dev) : 0;
633 }
634
635 static int pci_legacy_resume(struct device *dev)
636 {
637 struct pci_dev *pci_dev = to_pci_dev(dev);
638 struct pci_driver *drv = pci_dev->driver;
639
640 pci_fixup_device(pci_fixup_resume, pci_dev);
641
642 return drv && drv->resume ?
643 drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
644 }
645
646
647
648 static void pci_pm_default_resume(struct pci_dev *pci_dev)
649 {
650 pci_fixup_device(pci_fixup_resume, pci_dev);
651 pci_enable_wake(pci_dev, PCI_D0, false);
652 }
653
654 static void pci_pm_default_suspend(struct pci_dev *pci_dev)
655 {
656
657 if (!pci_has_subordinate(pci_dev))
658 pci_disable_enabled_device(pci_dev);
659 }
660
661 static bool pci_has_legacy_pm_support(struct pci_dev *pci_dev)
662 {
663 struct pci_driver *drv = pci_dev->driver;
664 bool ret = drv && (drv->suspend || drv->suspend_late || drv->resume
665 || drv->resume_early);
666
667
668
669
670
671
672 WARN(ret && drv->driver.pm, "driver %s device %04x:%04x\n",
673 drv->name, pci_dev->vendor, pci_dev->device);
674
675 return ret;
676 }
677
678
679
680 static int pci_pm_prepare(struct device *dev)
681 {
682 struct device_driver *drv = dev->driver;
683 struct pci_dev *pci_dev = to_pci_dev(dev);
684
685 if (drv && drv->pm && drv->pm->prepare) {
686 int error = drv->pm->prepare(dev);
687 if (error < 0)
688 return error;
689
690 if (!error && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
691 return 0;
692 }
693 if (pci_dev_need_resume(pci_dev))
694 return 0;
695
696
697
698
699
700 pci_dev_adjust_pme(pci_dev);
701 return 1;
702 }
703
704 static void pci_pm_complete(struct device *dev)
705 {
706 struct pci_dev *pci_dev = to_pci_dev(dev);
707
708 pci_dev_complete_resume(pci_dev);
709 pm_generic_complete(dev);
710
711
712 if (pm_runtime_suspended(dev) && pm_resume_via_firmware()) {
713 pci_power_t pre_sleep_state = pci_dev->current_state;
714
715 pci_refresh_power_state(pci_dev);
716
717
718
719
720
721
722
723 if (pci_dev->current_state < pre_sleep_state)
724 pm_request_resume(dev);
725 }
726 }
727
728 #else
729
730 #define pci_pm_prepare NULL
731 #define pci_pm_complete NULL
732
733 #endif
734
735 #ifdef CONFIG_SUSPEND
736 static void pcie_pme_root_status_cleanup(struct pci_dev *pci_dev)
737 {
738
739
740
741
742
743 if (pci_is_pcie(pci_dev) &&
744 (pci_pcie_type(pci_dev) == PCI_EXP_TYPE_ROOT_PORT ||
745 pci_pcie_type(pci_dev) == PCI_EXP_TYPE_RC_EC))
746 pcie_clear_root_pme_status(pci_dev);
747 }
748
749 static int pci_pm_suspend(struct device *dev)
750 {
751 struct pci_dev *pci_dev = to_pci_dev(dev);
752 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
753
754 pci_dev->skip_bus_pm = false;
755
756 if (pci_has_legacy_pm_support(pci_dev))
757 return pci_legacy_suspend(dev, PMSG_SUSPEND);
758
759 if (!pm) {
760 pci_pm_default_suspend(pci_dev);
761 return 0;
762 }
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
778 pci_dev_need_resume(pci_dev)) {
779 pm_runtime_resume(dev);
780 pci_dev->state_saved = false;
781 } else {
782 pci_dev_adjust_pme(pci_dev);
783 }
784
785 if (pm->suspend) {
786 pci_power_t prev = pci_dev->current_state;
787 int error;
788
789 error = pm->suspend(dev);
790 suspend_report_result(pm->suspend, error);
791 if (error)
792 return error;
793
794 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
795 && pci_dev->current_state != PCI_UNKNOWN) {
796 WARN_ONCE(pci_dev->current_state != prev,
797 "PCI PM: State of device not saved by %pS\n",
798 pm->suspend);
799 }
800 }
801
802 return 0;
803 }
804
805 static int pci_pm_suspend_late(struct device *dev)
806 {
807 if (dev_pm_smart_suspend_and_suspended(dev))
808 return 0;
809
810 pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
811
812 return pm_generic_suspend_late(dev);
813 }
814
815 static int pci_pm_suspend_noirq(struct device *dev)
816 {
817 struct pci_dev *pci_dev = to_pci_dev(dev);
818 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
819
820 if (dev_pm_smart_suspend_and_suspended(dev)) {
821 dev->power.may_skip_resume = true;
822 return 0;
823 }
824
825 if (pci_has_legacy_pm_support(pci_dev))
826 return pci_legacy_suspend_late(dev, PMSG_SUSPEND);
827
828 if (!pm) {
829 pci_save_state(pci_dev);
830 goto Fixup;
831 }
832
833 if (pm->suspend_noirq) {
834 pci_power_t prev = pci_dev->current_state;
835 int error;
836
837 error = pm->suspend_noirq(dev);
838 suspend_report_result(pm->suspend_noirq, error);
839 if (error)
840 return error;
841
842 if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
843 && pci_dev->current_state != PCI_UNKNOWN) {
844 WARN_ONCE(pci_dev->current_state != prev,
845 "PCI PM: State of device not saved by %pS\n",
846 pm->suspend_noirq);
847 goto Fixup;
848 }
849 }
850
851 if (pci_dev->skip_bus_pm) {
852
853
854
855
856
857
858
859
860 if (!pci_dev->state_saved)
861 pci_save_state(pci_dev);
862 } else if (!pci_dev->state_saved) {
863 pci_save_state(pci_dev);
864 if (pci_power_manageable(pci_dev))
865 pci_prepare_to_sleep(pci_dev);
866 }
867
868 dev_dbg(dev, "PCI PM: Suspend power state: %s\n",
869 pci_power_name(pci_dev->current_state));
870
871 if (pci_dev->current_state == PCI_D0) {
872 pci_dev->skip_bus_pm = true;
873
874
875
876
877
878 if (pci_dev->bus->self)
879 pci_dev->bus->self->skip_bus_pm = true;
880 }
881
882 if (pci_dev->skip_bus_pm && pm_suspend_no_platform()) {
883 dev_dbg(dev, "PCI PM: Skipped\n");
884 goto Fixup;
885 }
886
887 pci_pm_set_unknown_state(pci_dev);
888
889
890
891
892
893
894
895
896
897
898 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
899 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
900
901 Fixup:
902 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
903
904
905
906
907
908
909
910
911 dev->power.may_skip_resume = device_may_wakeup(dev) ||
912 !device_can_wakeup(dev);
913
914 return 0;
915 }
916
917 static int pci_pm_resume_noirq(struct device *dev)
918 {
919 struct pci_dev *pci_dev = to_pci_dev(dev);
920 struct device_driver *drv = dev->driver;
921 int error = 0;
922 pci_power_t prev_state = pci_dev->current_state;
923 bool skip_bus_pm = pci_dev->skip_bus_pm;
924
925 if (dev_pm_may_skip_resume(dev))
926 return 0;
927
928
929
930
931
932
933 if (dev_pm_smart_suspend_and_suspended(dev))
934 pm_runtime_set_active(dev);
935
936
937
938
939
940
941
942 if (!(skip_bus_pm && pm_suspend_no_platform()))
943 pci_pm_default_resume_early(pci_dev);
944
945 pci_fixup_device(pci_fixup_resume_early, pci_dev);
946 pcie_pme_root_status_cleanup(pci_dev);
947
948 if (!skip_bus_pm && prev_state == PCI_D3cold)
949 pci_bridge_wait_for_secondary_bus(pci_dev);
950
951 if (pci_has_legacy_pm_support(pci_dev))
952 return pci_legacy_resume_early(dev);
953
954 if (drv && drv->pm && drv->pm->resume_noirq)
955 error = drv->pm->resume_noirq(dev);
956
957 return error;
958 }
959
960 static int pci_pm_resume(struct device *dev)
961 {
962 struct pci_dev *pci_dev = to_pci_dev(dev);
963 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
964 int error = 0;
965
966
967
968
969
970 if (pci_dev->state_saved)
971 pci_restore_standard_config(pci_dev);
972
973 if (pci_has_legacy_pm_support(pci_dev))
974 return pci_legacy_resume(dev);
975
976 pci_pm_default_resume(pci_dev);
977
978 if (pm) {
979 if (pm->resume)
980 error = pm->resume(dev);
981 } else {
982 pci_pm_reenable_device(pci_dev);
983 }
984
985 return error;
986 }
987
988 #else
989
990 #define pci_pm_suspend NULL
991 #define pci_pm_suspend_late NULL
992 #define pci_pm_suspend_noirq NULL
993 #define pci_pm_resume NULL
994 #define pci_pm_resume_noirq NULL
995
996 #endif
997
998 #ifdef CONFIG_HIBERNATE_CALLBACKS
999
1000
1001
1002
1003
1004
1005 struct dev_pm_ops __weak pcibios_pm_ops;
1006
1007 static int pci_pm_freeze(struct device *dev)
1008 {
1009 struct pci_dev *pci_dev = to_pci_dev(dev);
1010 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1011
1012 if (pci_has_legacy_pm_support(pci_dev))
1013 return pci_legacy_suspend(dev, PMSG_FREEZE);
1014
1015 if (!pm) {
1016 pci_pm_default_suspend(pci_dev);
1017 return 0;
1018 }
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028 pm_runtime_resume(dev);
1029 pci_dev->state_saved = false;
1030
1031 if (pm->freeze) {
1032 int error;
1033
1034 error = pm->freeze(dev);
1035 suspend_report_result(pm->freeze, error);
1036 if (error)
1037 return error;
1038 }
1039
1040 return 0;
1041 }
1042
1043 static int pci_pm_freeze_noirq(struct device *dev)
1044 {
1045 struct pci_dev *pci_dev = to_pci_dev(dev);
1046 struct device_driver *drv = dev->driver;
1047
1048 if (pci_has_legacy_pm_support(pci_dev))
1049 return pci_legacy_suspend_late(dev, PMSG_FREEZE);
1050
1051 if (drv && drv->pm && drv->pm->freeze_noirq) {
1052 int error;
1053
1054 error = drv->pm->freeze_noirq(dev);
1055 suspend_report_result(drv->pm->freeze_noirq, error);
1056 if (error)
1057 return error;
1058 }
1059
1060 if (!pci_dev->state_saved)
1061 pci_save_state(pci_dev);
1062
1063 pci_pm_set_unknown_state(pci_dev);
1064
1065 if (pcibios_pm_ops.freeze_noirq)
1066 return pcibios_pm_ops.freeze_noirq(dev);
1067
1068 return 0;
1069 }
1070
1071 static int pci_pm_thaw_noirq(struct device *dev)
1072 {
1073 struct pci_dev *pci_dev = to_pci_dev(dev);
1074 struct device_driver *drv = dev->driver;
1075 int error = 0;
1076
1077 if (pcibios_pm_ops.thaw_noirq) {
1078 error = pcibios_pm_ops.thaw_noirq(dev);
1079 if (error)
1080 return error;
1081 }
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093 pci_set_power_state(pci_dev, PCI_D0);
1094 pci_restore_state(pci_dev);
1095
1096 if (pci_has_legacy_pm_support(pci_dev))
1097 return pci_legacy_resume_early(dev);
1098
1099 if (drv && drv->pm && drv->pm->thaw_noirq)
1100 error = drv->pm->thaw_noirq(dev);
1101
1102 return error;
1103 }
1104
1105 static int pci_pm_thaw(struct device *dev)
1106 {
1107 struct pci_dev *pci_dev = to_pci_dev(dev);
1108 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1109 int error = 0;
1110
1111 if (pci_has_legacy_pm_support(pci_dev))
1112 return pci_legacy_resume(dev);
1113
1114 if (pm) {
1115 if (pm->thaw)
1116 error = pm->thaw(dev);
1117 } else {
1118 pci_pm_reenable_device(pci_dev);
1119 }
1120
1121 pci_dev->state_saved = false;
1122
1123 return error;
1124 }
1125
1126 static int pci_pm_poweroff(struct device *dev)
1127 {
1128 struct pci_dev *pci_dev = to_pci_dev(dev);
1129 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1130
1131 if (pci_has_legacy_pm_support(pci_dev))
1132 return pci_legacy_suspend(dev, PMSG_HIBERNATE);
1133
1134 if (!pm) {
1135 pci_pm_default_suspend(pci_dev);
1136 return 0;
1137 }
1138
1139
1140 if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
1141 pci_dev_need_resume(pci_dev)) {
1142 pm_runtime_resume(dev);
1143 pci_dev->state_saved = false;
1144 } else {
1145 pci_dev_adjust_pme(pci_dev);
1146 }
1147
1148 if (pm->poweroff) {
1149 int error;
1150
1151 error = pm->poweroff(dev);
1152 suspend_report_result(pm->poweroff, error);
1153 if (error)
1154 return error;
1155 }
1156
1157 return 0;
1158 }
1159
1160 static int pci_pm_poweroff_late(struct device *dev)
1161 {
1162 if (dev_pm_smart_suspend_and_suspended(dev))
1163 return 0;
1164
1165 pci_fixup_device(pci_fixup_suspend, to_pci_dev(dev));
1166
1167 return pm_generic_poweroff_late(dev);
1168 }
1169
1170 static int pci_pm_poweroff_noirq(struct device *dev)
1171 {
1172 struct pci_dev *pci_dev = to_pci_dev(dev);
1173 struct device_driver *drv = dev->driver;
1174
1175 if (dev_pm_smart_suspend_and_suspended(dev))
1176 return 0;
1177
1178 if (pci_has_legacy_pm_support(to_pci_dev(dev)))
1179 return pci_legacy_suspend_late(dev, PMSG_HIBERNATE);
1180
1181 if (!drv || !drv->pm) {
1182 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
1183 return 0;
1184 }
1185
1186 if (drv->pm->poweroff_noirq) {
1187 int error;
1188
1189 error = drv->pm->poweroff_noirq(dev);
1190 suspend_report_result(drv->pm->poweroff_noirq, error);
1191 if (error)
1192 return error;
1193 }
1194
1195 if (!pci_dev->state_saved && !pci_has_subordinate(pci_dev))
1196 pci_prepare_to_sleep(pci_dev);
1197
1198
1199
1200
1201
1202 if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
1203 pci_write_config_word(pci_dev, PCI_COMMAND, 0);
1204
1205 pci_fixup_device(pci_fixup_suspend_late, pci_dev);
1206
1207 if (pcibios_pm_ops.poweroff_noirq)
1208 return pcibios_pm_ops.poweroff_noirq(dev);
1209
1210 return 0;
1211 }
1212
1213 static int pci_pm_restore_noirq(struct device *dev)
1214 {
1215 struct pci_dev *pci_dev = to_pci_dev(dev);
1216 struct device_driver *drv = dev->driver;
1217 int error = 0;
1218
1219 if (pcibios_pm_ops.restore_noirq) {
1220 error = pcibios_pm_ops.restore_noirq(dev);
1221 if (error)
1222 return error;
1223 }
1224
1225 pci_pm_default_resume_early(pci_dev);
1226 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1227
1228 if (pci_has_legacy_pm_support(pci_dev))
1229 return pci_legacy_resume_early(dev);
1230
1231 if (drv && drv->pm && drv->pm->restore_noirq)
1232 error = drv->pm->restore_noirq(dev);
1233
1234 return error;
1235 }
1236
1237 static int pci_pm_restore(struct device *dev)
1238 {
1239 struct pci_dev *pci_dev = to_pci_dev(dev);
1240 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1241 int error = 0;
1242
1243
1244
1245
1246
1247 if (pci_dev->state_saved)
1248 pci_restore_standard_config(pci_dev);
1249
1250 if (pci_has_legacy_pm_support(pci_dev))
1251 return pci_legacy_resume(dev);
1252
1253 pci_pm_default_resume(pci_dev);
1254
1255 if (pm) {
1256 if (pm->restore)
1257 error = pm->restore(dev);
1258 } else {
1259 pci_pm_reenable_device(pci_dev);
1260 }
1261
1262 return error;
1263 }
1264
1265 #else
1266
1267 #define pci_pm_freeze NULL
1268 #define pci_pm_freeze_noirq NULL
1269 #define pci_pm_thaw NULL
1270 #define pci_pm_thaw_noirq NULL
1271 #define pci_pm_poweroff NULL
1272 #define pci_pm_poweroff_late NULL
1273 #define pci_pm_poweroff_noirq NULL
1274 #define pci_pm_restore NULL
1275 #define pci_pm_restore_noirq NULL
1276
1277 #endif
1278
1279 #ifdef CONFIG_PM
1280
1281 static int pci_pm_runtime_suspend(struct device *dev)
1282 {
1283 struct pci_dev *pci_dev = to_pci_dev(dev);
1284 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1285 pci_power_t prev = pci_dev->current_state;
1286 int error;
1287
1288
1289
1290
1291
1292
1293 if (!pci_dev->driver) {
1294 pci_save_state(pci_dev);
1295 return 0;
1296 }
1297
1298 pci_dev->state_saved = false;
1299 if (pm && pm->runtime_suspend) {
1300 error = pm->runtime_suspend(dev);
1301
1302
1303
1304
1305
1306 if (error == -EBUSY || error == -EAGAIN) {
1307 dev_dbg(dev, "can't suspend now (%ps returned %d)\n",
1308 pm->runtime_suspend, error);
1309 return error;
1310 } else if (error) {
1311 dev_err(dev, "can't suspend (%ps returned %d)\n",
1312 pm->runtime_suspend, error);
1313 return error;
1314 }
1315 }
1316
1317 pci_fixup_device(pci_fixup_suspend, pci_dev);
1318
1319 if (pm && pm->runtime_suspend
1320 && !pci_dev->state_saved && pci_dev->current_state != PCI_D0
1321 && pci_dev->current_state != PCI_UNKNOWN) {
1322 WARN_ONCE(pci_dev->current_state != prev,
1323 "PCI PM: State of device not saved by %pS\n",
1324 pm->runtime_suspend);
1325 return 0;
1326 }
1327
1328 if (!pci_dev->state_saved) {
1329 pci_save_state(pci_dev);
1330 pci_finish_runtime_suspend(pci_dev);
1331 }
1332
1333 return 0;
1334 }
1335
1336 static int pci_pm_runtime_resume(struct device *dev)
1337 {
1338 int rc = 0;
1339 struct pci_dev *pci_dev = to_pci_dev(dev);
1340 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1341 pci_power_t prev_state = pci_dev->current_state;
1342
1343
1344
1345
1346
1347
1348 pci_restore_standard_config(pci_dev);
1349
1350 if (!pci_dev->driver)
1351 return 0;
1352
1353 pci_fixup_device(pci_fixup_resume_early, pci_dev);
1354 pci_enable_wake(pci_dev, PCI_D0, false);
1355 pci_fixup_device(pci_fixup_resume, pci_dev);
1356
1357 if (prev_state == PCI_D3cold)
1358 pci_bridge_wait_for_secondary_bus(pci_dev);
1359
1360 if (pm && pm->runtime_resume)
1361 rc = pm->runtime_resume(dev);
1362
1363 pci_dev->runtime_d3cold = false;
1364
1365 return rc;
1366 }
1367
1368 static int pci_pm_runtime_idle(struct device *dev)
1369 {
1370 struct pci_dev *pci_dev = to_pci_dev(dev);
1371 const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
1372 int ret = 0;
1373
1374
1375
1376
1377
1378 if (!pci_dev->driver)
1379 return 0;
1380
1381 if (!pm)
1382 return -ENOSYS;
1383
1384 if (pm->runtime_idle)
1385 ret = pm->runtime_idle(dev);
1386
1387 return ret;
1388 }
1389
1390 static const struct dev_pm_ops pci_dev_pm_ops = {
1391 .prepare = pci_pm_prepare,
1392 .complete = pci_pm_complete,
1393 .suspend = pci_pm_suspend,
1394 .suspend_late = pci_pm_suspend_late,
1395 .resume = pci_pm_resume,
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
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
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435 int __pci_register_driver(struct pci_driver *drv, struct module *owner,
1436 const char *mod_name)
1437 {
1438
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
1445 spin_lock_init(&drv->dynids.lock);
1446 INIT_LIST_HEAD(&drv->dynids.list);
1447
1448
1449 return driver_register(&drv->driver);
1450 }
1451 EXPORT_SYMBOL(__pci_register_driver);
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463 void pci_unregister_driver(struct pci_driver *drv)
1464 {
1465 driver_unregister(&drv->driver);
1466 pci_free_dynids(drv);
1467 }
1468 EXPORT_SYMBOL(pci_unregister_driver);
1469
1470 static struct pci_driver pci_compat_driver = {
1471 .name = "compat"
1472 };
1473
1474
1475
1476
1477
1478
1479
1480
1481 struct pci_driver *pci_dev_driver(const struct pci_dev *dev)
1482 {
1483 if (dev->driver)
1484 return dev->driver;
1485 else {
1486 int i;
1487 for (i = 0; i <= PCI_ROM_RESOURCE; i++)
1488 if (dev->resource[i].flags & IORESOURCE_BUSY)
1489 return &pci_compat_driver;
1490 }
1491 return NULL;
1492 }
1493 EXPORT_SYMBOL(pci_dev_driver);
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504 static int pci_bus_match(struct device *dev, struct device_driver *drv)
1505 {
1506 struct pci_dev *pci_dev = to_pci_dev(dev);
1507 struct pci_driver *pci_drv;
1508 const struct pci_device_id *found_id;
1509
1510 if (!pci_dev->match_driver)
1511 return 0;
1512
1513 pci_drv = to_pci_driver(drv);
1514 found_id = pci_match_device(pci_drv, pci_dev);
1515 if (found_id)
1516 return 1;
1517
1518 return 0;
1519 }
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533 struct pci_dev *pci_dev_get(struct pci_dev *dev)
1534 {
1535 if (dev)
1536 get_device(&dev->dev);
1537 return dev;
1538 }
1539 EXPORT_SYMBOL(pci_dev_get);
1540
1541
1542
1543
1544
1545
1546
1547
1548 void pci_dev_put(struct pci_dev *dev)
1549 {
1550 if (dev)
1551 put_device(&dev->dev);
1552 }
1553 EXPORT_SYMBOL(pci_dev_put);
1554
1555 static int pci_uevent(struct device *dev, struct kobj_uevent_env *env)
1556 {
1557 struct pci_dev *pdev;
1558
1559 if (!dev)
1560 return -ENODEV;
1561
1562 pdev = to_pci_dev(dev);
1563
1564 if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class))
1565 return -ENOMEM;
1566
1567 if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device))
1568 return -ENOMEM;
1569
1570 if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor,
1571 pdev->subsystem_device))
1572 return -ENOMEM;
1573
1574 if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev)))
1575 return -ENOMEM;
1576
1577 if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X",
1578 pdev->vendor, pdev->device,
1579 pdev->subsystem_vendor, pdev->subsystem_device,
1580 (u8)(pdev->class >> 16), (u8)(pdev->class >> 8),
1581 (u8)(pdev->class)))
1582 return -ENOMEM;
1583
1584 return 0;
1585 }
1586
1587 #if defined(CONFIG_PCIEPORTBUS) || defined(CONFIG_EEH)
1588
1589
1590
1591
1592
1593 void pci_uevent_ers(struct pci_dev *pdev, enum pci_ers_result err_type)
1594 {
1595 int idx = 0;
1596 char *envp[3];
1597
1598 switch (err_type) {
1599 case PCI_ERS_RESULT_NONE:
1600 case PCI_ERS_RESULT_CAN_RECOVER:
1601 envp[idx++] = "ERROR_EVENT=BEGIN_RECOVERY";
1602 envp[idx++] = "DEVICE_ONLINE=0";
1603 break;
1604 case PCI_ERS_RESULT_RECOVERED:
1605 envp[idx++] = "ERROR_EVENT=SUCCESSFUL_RECOVERY";
1606 envp[idx++] = "DEVICE_ONLINE=1";
1607 break;
1608 case PCI_ERS_RESULT_DISCONNECT:
1609 envp[idx++] = "ERROR_EVENT=FAILED_RECOVERY";
1610 envp[idx++] = "DEVICE_ONLINE=0";
1611 break;
1612 default:
1613 break;
1614 }
1615
1616 if (idx > 0) {
1617 envp[idx++] = NULL;
1618 kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp);
1619 }
1620 }
1621 #endif
1622
1623 static int pci_bus_num_vf(struct device *dev)
1624 {
1625 return pci_num_vf(to_pci_dev(dev));
1626 }
1627
1628
1629
1630
1631
1632
1633
1634
1635 static int pci_dma_configure(struct device *dev)
1636 {
1637 struct device *bridge;
1638 int ret = 0;
1639
1640 bridge = pci_get_host_bridge_device(to_pci_dev(dev));
1641
1642 if (IS_ENABLED(CONFIG_OF) && bridge->parent &&
1643 bridge->parent->of_node) {
1644 ret = of_dma_configure(dev, bridge->parent->of_node, true);
1645 } else if (has_acpi_companion(bridge)) {
1646 struct acpi_device *adev = to_acpi_device_node(bridge->fwnode);
1647
1648 ret = acpi_dma_configure(dev, acpi_get_dma_attr(adev));
1649 }
1650
1651 pci_put_host_bridge_device(bridge);
1652 return ret;
1653 }
1654
1655 struct bus_type pci_bus_type = {
1656 .name = "pci",
1657 .match = pci_bus_match,
1658 .uevent = pci_uevent,
1659 .probe = pci_device_probe,
1660 .remove = pci_device_remove,
1661 .shutdown = pci_device_shutdown,
1662 .dev_groups = pci_dev_groups,
1663 .bus_groups = pci_bus_groups,
1664 .drv_groups = pci_drv_groups,
1665 .pm = PCI_PM_OPS_PTR,
1666 .num_vf = pci_bus_num_vf,
1667 .dma_configure = pci_dma_configure,
1668 };
1669 EXPORT_SYMBOL(pci_bus_type);
1670
1671 #ifdef CONFIG_PCIEPORTBUS
1672 static int pcie_port_bus_match(struct device *dev, struct device_driver *drv)
1673 {
1674 struct pcie_device *pciedev;
1675 struct pcie_port_service_driver *driver;
1676
1677 if (drv->bus != &pcie_port_bus_type || dev->bus != &pcie_port_bus_type)
1678 return 0;
1679
1680 pciedev = to_pcie_device(dev);
1681 driver = to_service_driver(drv);
1682
1683 if (driver->service != pciedev->service)
1684 return 0;
1685
1686 if (driver->port_type != PCIE_ANY_PORT &&
1687 driver->port_type != pci_pcie_type(pciedev->port))
1688 return 0;
1689
1690 return 1;
1691 }
1692
1693 struct bus_type pcie_port_bus_type = {
1694 .name = "pci_express",
1695 .match = pcie_port_bus_match,
1696 };
1697 EXPORT_SYMBOL_GPL(pcie_port_bus_type);
1698 #endif
1699
1700 static int __init pci_driver_init(void)
1701 {
1702 int ret;
1703
1704 ret = bus_register(&pci_bus_type);
1705 if (ret)
1706 return ret;
1707
1708 #ifdef CONFIG_PCIEPORTBUS
1709 ret = bus_register(&pcie_port_bus_type);
1710 if (ret)
1711 return ret;
1712 #endif
1713 dma_debug_add_bus(&pci_bus_type);
1714 return 0;
1715 }
1716 postcore_initcall(pci_driver_init);