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