Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma
[firefly-linux-kernel-4.4.55.git] / drivers / pci / pci-acpi.c
1 /*
2  * File:        pci-acpi.c
3  * Purpose:     Provide PCI support in ACPI
4  *
5  * Copyright (C) 2005 David Shaohua Li <shaohua.li@intel.com>
6  * Copyright (C) 2004 Tom Long Nguyen <tom.l.nguyen@intel.com>
7  * Copyright (C) 2004 Intel Corp.
8  */
9
10 #include <linux/delay.h>
11 #include <linux/init.h>
12 #include <linux/pci.h>
13 #include <linux/pci_hotplug.h>
14 #include <linux/module.h>
15 #include <linux/pci-aspm.h>
16 #include <linux/pci-acpi.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/pm_qos.h>
19 #include "pci.h"
20
21 /*
22  * The UUID is defined in the PCI Firmware Specification available here:
23  * https://www.pcisig.com/members/downloads/pcifw_r3_1_13Dec10.pdf
24  */
25 const u8 pci_acpi_dsm_uuid[] = {
26         0xd0, 0x37, 0xc9, 0xe5, 0x53, 0x35, 0x7a, 0x4d,
27         0x91, 0x17, 0xea, 0x4d, 0x19, 0xc3, 0x43, 0x4d
28 };
29
30 phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle)
31 {
32         acpi_status status = AE_NOT_EXIST;
33         unsigned long long mcfg_addr;
34
35         if (handle)
36                 status = acpi_evaluate_integer(handle, METHOD_NAME__CBA,
37                                                NULL, &mcfg_addr);
38         if (ACPI_FAILURE(status))
39                 return 0;
40
41         return (phys_addr_t)mcfg_addr;
42 }
43
44 static acpi_status decode_type0_hpx_record(union acpi_object *record,
45                                            struct hotplug_params *hpx)
46 {
47         int i;
48         union acpi_object *fields = record->package.elements;
49         u32 revision = fields[1].integer.value;
50
51         switch (revision) {
52         case 1:
53                 if (record->package.count != 6)
54                         return AE_ERROR;
55                 for (i = 2; i < 6; i++)
56                         if (fields[i].type != ACPI_TYPE_INTEGER)
57                                 return AE_ERROR;
58                 hpx->t0 = &hpx->type0_data;
59                 hpx->t0->revision        = revision;
60                 hpx->t0->cache_line_size = fields[2].integer.value;
61                 hpx->t0->latency_timer   = fields[3].integer.value;
62                 hpx->t0->enable_serr     = fields[4].integer.value;
63                 hpx->t0->enable_perr     = fields[5].integer.value;
64                 break;
65         default:
66                 printk(KERN_WARNING
67                        "%s: Type 0 Revision %d record not supported\n",
68                        __func__, revision);
69                 return AE_ERROR;
70         }
71         return AE_OK;
72 }
73
74 static acpi_status decode_type1_hpx_record(union acpi_object *record,
75                                            struct hotplug_params *hpx)
76 {
77         int i;
78         union acpi_object *fields = record->package.elements;
79         u32 revision = fields[1].integer.value;
80
81         switch (revision) {
82         case 1:
83                 if (record->package.count != 5)
84                         return AE_ERROR;
85                 for (i = 2; i < 5; i++)
86                         if (fields[i].type != ACPI_TYPE_INTEGER)
87                                 return AE_ERROR;
88                 hpx->t1 = &hpx->type1_data;
89                 hpx->t1->revision      = revision;
90                 hpx->t1->max_mem_read  = fields[2].integer.value;
91                 hpx->t1->avg_max_split = fields[3].integer.value;
92                 hpx->t1->tot_max_split = fields[4].integer.value;
93                 break;
94         default:
95                 printk(KERN_WARNING
96                        "%s: Type 1 Revision %d record not supported\n",
97                        __func__, revision);
98                 return AE_ERROR;
99         }
100         return AE_OK;
101 }
102
103 static acpi_status decode_type2_hpx_record(union acpi_object *record,
104                                            struct hotplug_params *hpx)
105 {
106         int i;
107         union acpi_object *fields = record->package.elements;
108         u32 revision = fields[1].integer.value;
109
110         switch (revision) {
111         case 1:
112                 if (record->package.count != 18)
113                         return AE_ERROR;
114                 for (i = 2; i < 18; i++)
115                         if (fields[i].type != ACPI_TYPE_INTEGER)
116                                 return AE_ERROR;
117                 hpx->t2 = &hpx->type2_data;
118                 hpx->t2->revision      = revision;
119                 hpx->t2->unc_err_mask_and      = fields[2].integer.value;
120                 hpx->t2->unc_err_mask_or       = fields[3].integer.value;
121                 hpx->t2->unc_err_sever_and     = fields[4].integer.value;
122                 hpx->t2->unc_err_sever_or      = fields[5].integer.value;
123                 hpx->t2->cor_err_mask_and      = fields[6].integer.value;
124                 hpx->t2->cor_err_mask_or       = fields[7].integer.value;
125                 hpx->t2->adv_err_cap_and       = fields[8].integer.value;
126                 hpx->t2->adv_err_cap_or        = fields[9].integer.value;
127                 hpx->t2->pci_exp_devctl_and    = fields[10].integer.value;
128                 hpx->t2->pci_exp_devctl_or     = fields[11].integer.value;
129                 hpx->t2->pci_exp_lnkctl_and    = fields[12].integer.value;
130                 hpx->t2->pci_exp_lnkctl_or     = fields[13].integer.value;
131                 hpx->t2->sec_unc_err_sever_and = fields[14].integer.value;
132                 hpx->t2->sec_unc_err_sever_or  = fields[15].integer.value;
133                 hpx->t2->sec_unc_err_mask_and  = fields[16].integer.value;
134                 hpx->t2->sec_unc_err_mask_or   = fields[17].integer.value;
135                 break;
136         default:
137                 printk(KERN_WARNING
138                        "%s: Type 2 Revision %d record not supported\n",
139                        __func__, revision);
140                 return AE_ERROR;
141         }
142         return AE_OK;
143 }
144
145 static acpi_status acpi_run_hpx(acpi_handle handle, struct hotplug_params *hpx)
146 {
147         acpi_status status;
148         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
149         union acpi_object *package, *record, *fields;
150         u32 type;
151         int i;
152
153         /* Clear the return buffer with zeros */
154         memset(hpx, 0, sizeof(struct hotplug_params));
155
156         status = acpi_evaluate_object(handle, "_HPX", NULL, &buffer);
157         if (ACPI_FAILURE(status))
158                 return status;
159
160         package = (union acpi_object *)buffer.pointer;
161         if (package->type != ACPI_TYPE_PACKAGE) {
162                 status = AE_ERROR;
163                 goto exit;
164         }
165
166         for (i = 0; i < package->package.count; i++) {
167                 record = &package->package.elements[i];
168                 if (record->type != ACPI_TYPE_PACKAGE) {
169                         status = AE_ERROR;
170                         goto exit;
171                 }
172
173                 fields = record->package.elements;
174                 if (fields[0].type != ACPI_TYPE_INTEGER ||
175                     fields[1].type != ACPI_TYPE_INTEGER) {
176                         status = AE_ERROR;
177                         goto exit;
178                 }
179
180                 type = fields[0].integer.value;
181                 switch (type) {
182                 case 0:
183                         status = decode_type0_hpx_record(record, hpx);
184                         if (ACPI_FAILURE(status))
185                                 goto exit;
186                         break;
187                 case 1:
188                         status = decode_type1_hpx_record(record, hpx);
189                         if (ACPI_FAILURE(status))
190                                 goto exit;
191                         break;
192                 case 2:
193                         status = decode_type2_hpx_record(record, hpx);
194                         if (ACPI_FAILURE(status))
195                                 goto exit;
196                         break;
197                 default:
198                         printk(KERN_ERR "%s: Type %d record not supported\n",
199                                __func__, type);
200                         status = AE_ERROR;
201                         goto exit;
202                 }
203         }
204  exit:
205         kfree(buffer.pointer);
206         return status;
207 }
208
209 static acpi_status acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp)
210 {
211         acpi_status status;
212         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
213         union acpi_object *package, *fields;
214         int i;
215
216         memset(hpp, 0, sizeof(struct hotplug_params));
217
218         status = acpi_evaluate_object(handle, "_HPP", NULL, &buffer);
219         if (ACPI_FAILURE(status))
220                 return status;
221
222         package = (union acpi_object *) buffer.pointer;
223         if (package->type != ACPI_TYPE_PACKAGE ||
224             package->package.count != 4) {
225                 status = AE_ERROR;
226                 goto exit;
227         }
228
229         fields = package->package.elements;
230         for (i = 0; i < 4; i++) {
231                 if (fields[i].type != ACPI_TYPE_INTEGER) {
232                         status = AE_ERROR;
233                         goto exit;
234                 }
235         }
236
237         hpp->t0 = &hpp->type0_data;
238         hpp->t0->revision        = 1;
239         hpp->t0->cache_line_size = fields[0].integer.value;
240         hpp->t0->latency_timer   = fields[1].integer.value;
241         hpp->t0->enable_serr     = fields[2].integer.value;
242         hpp->t0->enable_perr     = fields[3].integer.value;
243
244 exit:
245         kfree(buffer.pointer);
246         return status;
247 }
248
249 /* pci_get_hp_params
250  *
251  * @dev - the pci_dev for which we want parameters
252  * @hpp - allocated by the caller
253  */
254 int pci_get_hp_params(struct pci_dev *dev, struct hotplug_params *hpp)
255 {
256         acpi_status status;
257         acpi_handle handle, phandle;
258         struct pci_bus *pbus;
259
260         if (acpi_pci_disabled)
261                 return -ENODEV;
262
263         handle = NULL;
264         for (pbus = dev->bus; pbus; pbus = pbus->parent) {
265                 handle = acpi_pci_get_bridge_handle(pbus);
266                 if (handle)
267                         break;
268         }
269
270         /*
271          * _HPP settings apply to all child buses, until another _HPP is
272          * encountered. If we don't find an _HPP for the input pci dev,
273          * look for it in the parent device scope since that would apply to
274          * this pci dev.
275          */
276         while (handle) {
277                 status = acpi_run_hpx(handle, hpp);
278                 if (ACPI_SUCCESS(status))
279                         return 0;
280                 status = acpi_run_hpp(handle, hpp);
281                 if (ACPI_SUCCESS(status))
282                         return 0;
283                 if (acpi_is_root_bridge(handle))
284                         break;
285                 status = acpi_get_parent(handle, &phandle);
286                 if (ACPI_FAILURE(status))
287                         break;
288                 handle = phandle;
289         }
290         return -ENODEV;
291 }
292 EXPORT_SYMBOL_GPL(pci_get_hp_params);
293
294 /**
295  * pci_acpi_wake_bus - Root bus wakeup notification fork function.
296  * @work: Work item to handle.
297  */
298 static void pci_acpi_wake_bus(struct work_struct *work)
299 {
300         struct acpi_device *adev;
301         struct acpi_pci_root *root;
302
303         adev = container_of(work, struct acpi_device, wakeup.context.work);
304         root = acpi_driver_data(adev);
305         pci_pme_wakeup_bus(root->bus);
306 }
307
308 /**
309  * pci_acpi_wake_dev - PCI device wakeup notification work function.
310  * @handle: ACPI handle of a device the notification is for.
311  * @work: Work item to handle.
312  */
313 static void pci_acpi_wake_dev(struct work_struct *work)
314 {
315         struct acpi_device_wakeup_context *context;
316         struct pci_dev *pci_dev;
317
318         context = container_of(work, struct acpi_device_wakeup_context, work);
319         pci_dev = to_pci_dev(context->dev);
320
321         if (pci_dev->pme_poll)
322                 pci_dev->pme_poll = false;
323
324         if (pci_dev->current_state == PCI_D3cold) {
325                 pci_wakeup_event(pci_dev);
326                 pm_runtime_resume(&pci_dev->dev);
327                 return;
328         }
329
330         /* Clear PME Status if set. */
331         if (pci_dev->pme_support)
332                 pci_check_pme_status(pci_dev);
333
334         pci_wakeup_event(pci_dev);
335         pm_runtime_resume(&pci_dev->dev);
336
337         pci_pme_wakeup_bus(pci_dev->subordinate);
338 }
339
340 /**
341  * pci_acpi_add_bus_pm_notifier - Register PM notifier for root PCI bus.
342  * @dev: PCI root bridge ACPI device.
343  */
344 acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev)
345 {
346         return acpi_add_pm_notifier(dev, NULL, pci_acpi_wake_bus);
347 }
348
349 /**
350  * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
351  * @dev: ACPI device to add the notifier for.
352  * @pci_dev: PCI device to check for the PME status if an event is signaled.
353  */
354 acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
355                                      struct pci_dev *pci_dev)
356 {
357         return acpi_add_pm_notifier(dev, &pci_dev->dev, pci_acpi_wake_dev);
358 }
359
360 /*
361  * _SxD returns the D-state with the highest power
362  * (lowest D-state number) supported in the S-state "x".
363  *
364  * If the devices does not have a _PRW
365  * (Power Resources for Wake) supporting system wakeup from "x"
366  * then the OS is free to choose a lower power (higher number
367  * D-state) than the return value from _SxD.
368  *
369  * But if _PRW is enabled at S-state "x", the OS
370  * must not choose a power lower than _SxD --
371  * unless the device has an _SxW method specifying
372  * the lowest power (highest D-state number) the device
373  * may enter while still able to wake the system.
374  *
375  * ie. depending on global OS policy:
376  *
377  * if (_PRW at S-state x)
378  *      choose from highest power _SxD to lowest power _SxW
379  * else // no _PRW at S-state x
380  *      choose highest power _SxD or any lower power
381  */
382
383 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
384 {
385         int acpi_state, d_max;
386
387         if (pdev->no_d3cold)
388                 d_max = ACPI_STATE_D3_HOT;
389         else
390                 d_max = ACPI_STATE_D3_COLD;
391         acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max);
392         if (acpi_state < 0)
393                 return PCI_POWER_ERROR;
394
395         switch (acpi_state) {
396         case ACPI_STATE_D0:
397                 return PCI_D0;
398         case ACPI_STATE_D1:
399                 return PCI_D1;
400         case ACPI_STATE_D2:
401                 return PCI_D2;
402         case ACPI_STATE_D3_HOT:
403                 return PCI_D3hot;
404         case ACPI_STATE_D3_COLD:
405                 return PCI_D3cold;
406         }
407         return PCI_POWER_ERROR;
408 }
409
410 static bool acpi_pci_power_manageable(struct pci_dev *dev)
411 {
412         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
413         return adev ? acpi_device_power_manageable(adev) : false;
414 }
415
416 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state)
417 {
418         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
419         static const u8 state_conv[] = {
420                 [PCI_D0] = ACPI_STATE_D0,
421                 [PCI_D1] = ACPI_STATE_D1,
422                 [PCI_D2] = ACPI_STATE_D2,
423                 [PCI_D3hot] = ACPI_STATE_D3_HOT,
424                 [PCI_D3cold] = ACPI_STATE_D3_COLD,
425         };
426         int error = -EINVAL;
427
428         /* If the ACPI device has _EJ0, ignore the device */
429         if (!adev || acpi_has_method(adev->handle, "_EJ0"))
430                 return -ENODEV;
431
432         switch (state) {
433         case PCI_D3cold:
434                 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) ==
435                                 PM_QOS_FLAGS_ALL) {
436                         error = -EBUSY;
437                         break;
438                 }
439         case PCI_D0:
440         case PCI_D1:
441         case PCI_D2:
442         case PCI_D3hot:
443                 error = acpi_device_set_power(adev, state_conv[state]);
444         }
445
446         if (!error)
447                 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n",
448                          acpi_power_state_string(state_conv[state]));
449
450         return error;
451 }
452
453 static bool acpi_pci_can_wakeup(struct pci_dev *dev)
454 {
455         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
456         return adev ? acpi_device_can_wakeup(adev) : false;
457 }
458
459 static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable)
460 {
461         while (bus->parent) {
462                 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable))
463                         return;
464                 bus = bus->parent;
465         }
466
467         /* We have reached the root bus. */
468         if (bus->bridge)
469                 acpi_pm_device_sleep_wake(bus->bridge, enable);
470 }
471
472 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
473 {
474         if (acpi_pci_can_wakeup(dev))
475                 return acpi_pm_device_sleep_wake(&dev->dev, enable);
476
477         acpi_pci_propagate_wakeup_enable(dev->bus, enable);
478         return 0;
479 }
480
481 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
482 {
483         while (bus->parent) {
484                 struct pci_dev *bridge = bus->self;
485
486                 if (bridge->pme_interrupt)
487                         return;
488                 if (!acpi_pm_device_run_wake(&bridge->dev, enable))
489                         return;
490                 bus = bus->parent;
491         }
492
493         /* We have reached the root bus. */
494         if (bus->bridge)
495                 acpi_pm_device_run_wake(bus->bridge, enable);
496 }
497
498 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
499 {
500         /*
501          * Per PCI Express Base Specification Revision 2.0 section
502          * 5.3.3.2 Link Wakeup, platform support is needed for D3cold
503          * waking up to power on the main link even if there is PME
504          * support for D3cold
505          */
506         if (dev->pme_interrupt && !dev->runtime_d3cold)
507                 return 0;
508
509         if (!acpi_pm_device_run_wake(&dev->dev, enable))
510                 return 0;
511
512         acpi_pci_propagate_run_wake(dev->bus, enable);
513         return 0;
514 }
515
516 static bool acpi_pci_need_resume(struct pci_dev *dev)
517 {
518         struct acpi_device *adev = ACPI_COMPANION(&dev->dev);
519
520         if (!adev || !acpi_device_power_manageable(adev))
521                 return false;
522
523         if (device_may_wakeup(&dev->dev) != !!adev->wakeup.prepare_count)
524                 return true;
525
526         if (acpi_target_system_state() == ACPI_STATE_S0)
527                 return false;
528
529         return !!adev->power.flags.dsw_present;
530 }
531
532 static struct pci_platform_pm_ops acpi_pci_platform_pm = {
533         .is_manageable = acpi_pci_power_manageable,
534         .set_state = acpi_pci_set_power_state,
535         .choose_state = acpi_pci_choose_state,
536         .sleep_wake = acpi_pci_sleep_wake,
537         .run_wake = acpi_pci_run_wake,
538         .need_resume = acpi_pci_need_resume,
539 };
540
541 void acpi_pci_add_bus(struct pci_bus *bus)
542 {
543         union acpi_object *obj;
544         struct pci_host_bridge *bridge;
545
546         if (acpi_pci_disabled || !bus->bridge)
547                 return;
548
549         acpi_pci_slot_enumerate(bus);
550         acpiphp_enumerate_slots(bus);
551
552         /*
553          * For a host bridge, check its _DSM for function 8 and if
554          * that is available, mark it in pci_host_bridge.
555          */
556         if (!pci_is_root_bus(bus))
557                 return;
558
559         obj = acpi_evaluate_dsm(ACPI_HANDLE(bus->bridge), pci_acpi_dsm_uuid, 3,
560                                 RESET_DELAY_DSM, NULL);
561         if (!obj)
562                 return;
563
564         if (obj->type == ACPI_TYPE_INTEGER && obj->integer.value == 1) {
565                 bridge = pci_find_host_bridge(bus);
566                 bridge->ignore_reset_delay = 1;
567         }
568         ACPI_FREE(obj);
569 }
570
571 void acpi_pci_remove_bus(struct pci_bus *bus)
572 {
573         if (acpi_pci_disabled || !bus->bridge)
574                 return;
575
576         acpiphp_remove_slots(bus);
577         acpi_pci_slot_remove(bus);
578 }
579
580 /* ACPI bus type */
581 static struct acpi_device *acpi_pci_find_companion(struct device *dev)
582 {
583         struct pci_dev *pci_dev = to_pci_dev(dev);
584         bool check_children;
585         u64 addr;
586
587         check_children = pci_is_bridge(pci_dev);
588         /* Please ref to ACPI spec for the syntax of _ADR */
589         addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn);
590         return acpi_find_child_device(ACPI_COMPANION(dev->parent), addr,
591                                       check_children);
592 }
593
594 /**
595  * pci_acpi_optimize_delay - optimize PCI D3 and D3cold delay from ACPI
596  * @pdev: the PCI device whose delay is to be updated
597  * @handle: ACPI handle of this device
598  *
599  * Update the d3_delay and d3cold_delay of a PCI device from the ACPI _DSM
600  * control method of either the device itself or the PCI host bridge.
601  *
602  * Function 8, "Reset Delay," applies to the entire hierarchy below a PCI
603  * host bridge.  If it returns one, the OS may assume that all devices in
604  * the hierarchy have already completed power-on reset delays.
605  *
606  * Function 9, "Device Readiness Durations," applies only to the object
607  * where it is located.  It returns delay durations required after various
608  * events if the device requires less time than the spec requires.  Delays
609  * from this function take precedence over the Reset Delay function.
610  *
611  * These _DSM functions are defined by the draft ECN of January 28, 2014,
612  * titled "ACPI additions for FW latency optimizations."
613  */
614 static void pci_acpi_optimize_delay(struct pci_dev *pdev,
615                                     acpi_handle handle)
616 {
617         struct pci_host_bridge *bridge = pci_find_host_bridge(pdev->bus);
618         int value;
619         union acpi_object *obj, *elements;
620
621         if (bridge->ignore_reset_delay)
622                 pdev->d3cold_delay = 0;
623
624         obj = acpi_evaluate_dsm(handle, pci_acpi_dsm_uuid, 3,
625                                 FUNCTION_DELAY_DSM, NULL);
626         if (!obj)
627                 return;
628
629         if (obj->type == ACPI_TYPE_PACKAGE && obj->package.count == 5) {
630                 elements = obj->package.elements;
631                 if (elements[0].type == ACPI_TYPE_INTEGER) {
632                         value = (int)elements[0].integer.value / 1000;
633                         if (value < PCI_PM_D3COLD_WAIT)
634                                 pdev->d3cold_delay = value;
635                 }
636                 if (elements[3].type == ACPI_TYPE_INTEGER) {
637                         value = (int)elements[3].integer.value / 1000;
638                         if (value < PCI_PM_D3_WAIT)
639                                 pdev->d3_delay = value;
640                 }
641         }
642         ACPI_FREE(obj);
643 }
644
645 static void pci_acpi_setup(struct device *dev)
646 {
647         struct pci_dev *pci_dev = to_pci_dev(dev);
648         struct acpi_device *adev = ACPI_COMPANION(dev);
649
650         if (!adev)
651                 return;
652
653         pci_acpi_optimize_delay(pci_dev, adev->handle);
654
655         pci_acpi_add_pm_notifier(adev, pci_dev);
656         if (!adev->wakeup.flags.valid)
657                 return;
658
659         device_set_wakeup_capable(dev, true);
660         acpi_pci_sleep_wake(pci_dev, false);
661         if (adev->wakeup.flags.run_wake)
662                 device_set_run_wake(dev, true);
663 }
664
665 static void pci_acpi_cleanup(struct device *dev)
666 {
667         struct acpi_device *adev = ACPI_COMPANION(dev);
668
669         if (!adev)
670                 return;
671
672         pci_acpi_remove_pm_notifier(adev);
673         if (adev->wakeup.flags.valid) {
674                 device_set_wakeup_capable(dev, false);
675                 device_set_run_wake(dev, false);
676         }
677 }
678
679 static bool pci_acpi_bus_match(struct device *dev)
680 {
681         return dev_is_pci(dev);
682 }
683
684 static struct acpi_bus_type acpi_pci_bus = {
685         .name = "PCI",
686         .match = pci_acpi_bus_match,
687         .find_companion = acpi_pci_find_companion,
688         .setup = pci_acpi_setup,
689         .cleanup = pci_acpi_cleanup,
690 };
691
692 static int __init acpi_pci_init(void)
693 {
694         int ret;
695
696         if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) {
697                 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n");
698                 pci_no_msi();
699         }
700
701         if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) {
702                 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n");
703                 pcie_no_aspm();
704         }
705
706         ret = register_acpi_bus_type(&acpi_pci_bus);
707         if (ret)
708                 return 0;
709
710         pci_set_platform_pm(&acpi_pci_platform_pm);
711         acpi_pci_slot_init();
712         acpiphp_init();
713
714         return 0;
715 }
716 arch_initcall(acpi_pci_init);