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/module.h> 14 #include <linux/pci-aspm.h> 15 #include <linux/pci-acpi.h> 16 #include <linux/pm_runtime.h> 17 #include <linux/pm_qos.h> 18 #include "pci.h" 19 20 /** 21 * pci_acpi_wake_bus - Wake-up notification handler for root buses. 22 * @handle: ACPI handle of a device the notification is for. 23 * @event: Type of the signaled event. 24 * @context: PCI root bus to wake up devices on. 25 */ 26 static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context) 27 { 28 struct pci_bus *pci_bus = context; 29 30 if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus) 31 pci_pme_wakeup_bus(pci_bus); 32 } 33 34 /** 35 * pci_acpi_wake_dev - Wake-up notification handler for PCI devices. 36 * @handle: ACPI handle of a device the notification is for. 37 * @event: Type of the signaled event. 38 * @context: PCI device object to wake up. 39 */ 40 static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context) 41 { 42 struct pci_dev *pci_dev = context; 43 44 if (event != ACPI_NOTIFY_DEVICE_WAKE || !pci_dev) 45 return; 46 47 if (pci_dev->pme_poll) 48 pci_dev->pme_poll = false; 49 50 if (pci_dev->current_state == PCI_D3cold) { 51 pci_wakeup_event(pci_dev); 52 pm_runtime_resume(&pci_dev->dev); 53 return; 54 } 55 56 /* Clear PME Status if set. */ 57 if (pci_dev->pme_support) 58 pci_check_pme_status(pci_dev); 59 60 pci_wakeup_event(pci_dev); 61 pm_runtime_resume(&pci_dev->dev); 62 63 if (pci_dev->subordinate) 64 pci_pme_wakeup_bus(pci_dev->subordinate); 65 } 66 67 /** 68 * pci_acpi_add_bus_pm_notifier - Register PM notifier for given PCI bus. 69 * @dev: ACPI device to add the notifier for. 70 * @pci_bus: PCI bus to walk checking for PME status if an event is signaled. 71 */ 72 acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev, 73 struct pci_bus *pci_bus) 74 { 75 return acpi_add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus); 76 } 77 78 /** 79 * pci_acpi_remove_bus_pm_notifier - Unregister PCI bus PM notifier. 80 * @dev: ACPI device to remove the notifier from. 81 */ 82 acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev) 83 { 84 return acpi_remove_pm_notifier(dev, pci_acpi_wake_bus); 85 } 86 87 /** 88 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device. 89 * @dev: ACPI device to add the notifier for. 90 * @pci_dev: PCI device to check for the PME status if an event is signaled. 91 */ 92 acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev, 93 struct pci_dev *pci_dev) 94 { 95 return acpi_add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev); 96 } 97 98 /** 99 * pci_acpi_remove_pm_notifier - Unregister PCI device PM notifier. 100 * @dev: ACPI device to remove the notifier from. 101 */ 102 acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev) 103 { 104 return acpi_remove_pm_notifier(dev, pci_acpi_wake_dev); 105 } 106 107 phys_addr_t acpi_pci_root_get_mcfg_addr(acpi_handle handle) 108 { 109 acpi_status status = AE_NOT_EXIST; 110 unsigned long long mcfg_addr; 111 112 if (handle) 113 status = acpi_evaluate_integer(handle, METHOD_NAME__CBA, 114 NULL, &mcfg_addr); 115 if (ACPI_FAILURE(status)) 116 return 0; 117 118 return (phys_addr_t)mcfg_addr; 119 } 120 121 /* 122 * _SxD returns the D-state with the highest power 123 * (lowest D-state number) supported in the S-state "x". 124 * 125 * If the devices does not have a _PRW 126 * (Power Resources for Wake) supporting system wakeup from "x" 127 * then the OS is free to choose a lower power (higher number 128 * D-state) than the return value from _SxD. 129 * 130 * But if _PRW is enabled at S-state "x", the OS 131 * must not choose a power lower than _SxD -- 132 * unless the device has an _SxW method specifying 133 * the lowest power (highest D-state number) the device 134 * may enter while still able to wake the system. 135 * 136 * ie. depending on global OS policy: 137 * 138 * if (_PRW at S-state x) 139 * choose from highest power _SxD to lowest power _SxW 140 * else // no _PRW at S-state x 141 * choose highest power _SxD or any lower power 142 */ 143 144 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev) 145 { 146 int acpi_state, d_max; 147 148 if (pdev->no_d3cold) 149 d_max = ACPI_STATE_D3_HOT; 150 else 151 d_max = ACPI_STATE_D3_COLD; 152 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL, d_max); 153 if (acpi_state < 0) 154 return PCI_POWER_ERROR; 155 156 switch (acpi_state) { 157 case ACPI_STATE_D0: 158 return PCI_D0; 159 case ACPI_STATE_D1: 160 return PCI_D1; 161 case ACPI_STATE_D2: 162 return PCI_D2; 163 case ACPI_STATE_D3_HOT: 164 return PCI_D3hot; 165 case ACPI_STATE_D3_COLD: 166 return PCI_D3cold; 167 } 168 return PCI_POWER_ERROR; 169 } 170 171 static bool acpi_pci_power_manageable(struct pci_dev *dev) 172 { 173 acpi_handle handle = ACPI_HANDLE(&dev->dev); 174 175 return handle ? acpi_bus_power_manageable(handle) : false; 176 } 177 178 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) 179 { 180 acpi_handle handle = ACPI_HANDLE(&dev->dev); 181 static const u8 state_conv[] = { 182 [PCI_D0] = ACPI_STATE_D0, 183 [PCI_D1] = ACPI_STATE_D1, 184 [PCI_D2] = ACPI_STATE_D2, 185 [PCI_D3hot] = ACPI_STATE_D3_COLD, 186 [PCI_D3cold] = ACPI_STATE_D3_COLD, 187 }; 188 int error = -EINVAL; 189 190 /* If the ACPI device has _EJ0, ignore the device */ 191 if (!handle || acpi_has_method(handle, "_EJ0")) 192 return -ENODEV; 193 194 switch (state) { 195 case PCI_D3cold: 196 if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) == 197 PM_QOS_FLAGS_ALL) { 198 error = -EBUSY; 199 break; 200 } 201 case PCI_D0: 202 case PCI_D1: 203 case PCI_D2: 204 case PCI_D3hot: 205 error = acpi_bus_set_power(handle, state_conv[state]); 206 } 207 208 if (!error) 209 dev_dbg(&dev->dev, "power state changed by ACPI to %s\n", 210 acpi_power_state_string(state_conv[state])); 211 212 return error; 213 } 214 215 static bool acpi_pci_can_wakeup(struct pci_dev *dev) 216 { 217 acpi_handle handle = ACPI_HANDLE(&dev->dev); 218 219 return handle ? acpi_bus_can_wakeup(handle) : false; 220 } 221 222 static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable) 223 { 224 while (bus->parent) { 225 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable)) 226 return; 227 bus = bus->parent; 228 } 229 230 /* We have reached the root bus. */ 231 if (bus->bridge) 232 acpi_pm_device_sleep_wake(bus->bridge, enable); 233 } 234 235 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable) 236 { 237 if (acpi_pci_can_wakeup(dev)) 238 return acpi_pm_device_sleep_wake(&dev->dev, enable); 239 240 acpi_pci_propagate_wakeup_enable(dev->bus, enable); 241 return 0; 242 } 243 244 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable) 245 { 246 while (bus->parent) { 247 struct pci_dev *bridge = bus->self; 248 249 if (bridge->pme_interrupt) 250 return; 251 if (!acpi_pm_device_run_wake(&bridge->dev, enable)) 252 return; 253 bus = bus->parent; 254 } 255 256 /* We have reached the root bus. */ 257 if (bus->bridge) 258 acpi_pm_device_run_wake(bus->bridge, enable); 259 } 260 261 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable) 262 { 263 /* 264 * Per PCI Express Base Specification Revision 2.0 section 265 * 5.3.3.2 Link Wakeup, platform support is needed for D3cold 266 * waking up to power on the main link even if there is PME 267 * support for D3cold 268 */ 269 if (dev->pme_interrupt && !dev->runtime_d3cold) 270 return 0; 271 272 if (!acpi_pm_device_run_wake(&dev->dev, enable)) 273 return 0; 274 275 acpi_pci_propagate_run_wake(dev->bus, enable); 276 return 0; 277 } 278 279 static struct pci_platform_pm_ops acpi_pci_platform_pm = { 280 .is_manageable = acpi_pci_power_manageable, 281 .set_state = acpi_pci_set_power_state, 282 .choose_state = acpi_pci_choose_state, 283 .sleep_wake = acpi_pci_sleep_wake, 284 .run_wake = acpi_pci_run_wake, 285 }; 286 287 void acpi_pci_add_bus(struct pci_bus *bus) 288 { 289 if (acpi_pci_disabled || !bus->bridge) 290 return; 291 292 acpi_pci_slot_enumerate(bus); 293 acpiphp_enumerate_slots(bus); 294 } 295 296 void acpi_pci_remove_bus(struct pci_bus *bus) 297 { 298 if (acpi_pci_disabled || !bus->bridge) 299 return; 300 301 acpiphp_remove_slots(bus); 302 acpi_pci_slot_remove(bus); 303 } 304 305 /* ACPI bus type */ 306 static struct acpi_device *acpi_pci_find_companion(struct device *dev) 307 { 308 struct pci_dev *pci_dev = to_pci_dev(dev); 309 bool check_children; 310 u64 addr; 311 312 /* 313 * pci_is_bridge() is not suitable here, because pci_dev->subordinate 314 * is set only after acpi_pci_find_device() has been called for the 315 * given device. 316 */ 317 check_children = pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE 318 || pci_dev->hdr_type == PCI_HEADER_TYPE_CARDBUS; 319 /* Please ref to ACPI spec for the syntax of _ADR */ 320 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn); 321 return acpi_find_child_device(ACPI_COMPANION(dev->parent), addr, 322 check_children); 323 } 324 325 static void pci_acpi_setup(struct device *dev) 326 { 327 struct pci_dev *pci_dev = to_pci_dev(dev); 328 struct acpi_device *adev = ACPI_COMPANION(dev); 329 330 if (!adev) 331 return; 332 333 pci_acpi_add_pm_notifier(adev, pci_dev); 334 if (!adev->wakeup.flags.valid) 335 return; 336 337 device_set_wakeup_capable(dev, true); 338 acpi_pci_sleep_wake(pci_dev, false); 339 if (adev->wakeup.flags.run_wake) 340 device_set_run_wake(dev, true); 341 } 342 343 static void pci_acpi_cleanup(struct device *dev) 344 { 345 struct acpi_device *adev = ACPI_COMPANION(dev); 346 347 if (!adev) 348 return; 349 350 pci_acpi_remove_pm_notifier(adev); 351 if (adev->wakeup.flags.valid) { 352 device_set_wakeup_capable(dev, false); 353 device_set_run_wake(dev, false); 354 } 355 } 356 357 static bool pci_acpi_bus_match(struct device *dev) 358 { 359 return dev_is_pci(dev); 360 } 361 362 static struct acpi_bus_type acpi_pci_bus = { 363 .name = "PCI", 364 .match = pci_acpi_bus_match, 365 .find_companion = acpi_pci_find_companion, 366 .setup = pci_acpi_setup, 367 .cleanup = pci_acpi_cleanup, 368 }; 369 370 static int __init acpi_pci_init(void) 371 { 372 int ret; 373 374 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) { 375 pr_info("ACPI FADT declares the system doesn't support MSI, so disable it\n"); 376 pci_no_msi(); 377 } 378 379 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) { 380 pr_info("ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n"); 381 pcie_no_aspm(); 382 } 383 384 ret = register_acpi_bus_type(&acpi_pci_bus); 385 if (ret) 386 return 0; 387 388 pci_set_platform_pm(&acpi_pci_platform_pm); 389 acpi_pci_slot_init(); 390 acpiphp_init(); 391 392 return 0; 393 } 394 arch_initcall(acpi_pci_init); 395