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 "pci.h" 21 22 static DEFINE_MUTEX(pci_acpi_pm_notify_mtx); 23 24 /** 25 * pci_acpi_wake_bus - Wake-up notification handler for root buses. 26 * @handle: ACPI handle of a device the notification is for. 27 * @event: Type of the signaled event. 28 * @context: PCI root bus to wake up devices on. 29 */ 30 static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context) 31 { 32 struct pci_bus *pci_bus = context; 33 34 if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus) 35 pci_pme_wakeup_bus(pci_bus); 36 } 37 38 /** 39 * pci_acpi_wake_dev - Wake-up notification handler for PCI devices. 40 * @handle: ACPI handle of a device the notification is for. 41 * @event: Type of the signaled event. 42 * @context: PCI device object to wake up. 43 */ 44 static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context) 45 { 46 struct pci_dev *pci_dev = context; 47 48 if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_dev) { 49 if (pci_dev->pme_poll) 50 pci_dev->pme_poll = false; 51 52 pci_wakeup_event(pci_dev); 53 pci_check_pme_status(pci_dev); 54 pm_runtime_resume(&pci_dev->dev); 55 if (pci_dev->subordinate) 56 pci_pme_wakeup_bus(pci_dev->subordinate); 57 } 58 } 59 60 /** 61 * add_pm_notifier - Register PM notifier for given ACPI device. 62 * @dev: ACPI device to add the notifier for. 63 * @context: PCI device or bus to check for PME status if an event is signaled. 64 * 65 * NOTE: @dev need not be a run-wake or wake-up device to be a valid source of 66 * PM wake-up events. For example, wake-up events may be generated for bridges 67 * if one of the devices below the bridge is signaling PME, even if the bridge 68 * itself doesn't have a wake-up GPE associated with it. 69 */ 70 static acpi_status add_pm_notifier(struct acpi_device *dev, 71 acpi_notify_handler handler, 72 void *context) 73 { 74 acpi_status status = AE_ALREADY_EXISTS; 75 76 mutex_lock(&pci_acpi_pm_notify_mtx); 77 78 if (dev->wakeup.flags.notifier_present) 79 goto out; 80 81 status = acpi_install_notify_handler(dev->handle, 82 ACPI_SYSTEM_NOTIFY, 83 handler, context); 84 if (ACPI_FAILURE(status)) 85 goto out; 86 87 dev->wakeup.flags.notifier_present = true; 88 89 out: 90 mutex_unlock(&pci_acpi_pm_notify_mtx); 91 return status; 92 } 93 94 /** 95 * remove_pm_notifier - Unregister PM notifier from given ACPI device. 96 * @dev: ACPI device to remove the notifier from. 97 */ 98 static acpi_status remove_pm_notifier(struct acpi_device *dev, 99 acpi_notify_handler handler) 100 { 101 acpi_status status = AE_BAD_PARAMETER; 102 103 mutex_lock(&pci_acpi_pm_notify_mtx); 104 105 if (!dev->wakeup.flags.notifier_present) 106 goto out; 107 108 status = acpi_remove_notify_handler(dev->handle, 109 ACPI_SYSTEM_NOTIFY, 110 handler); 111 if (ACPI_FAILURE(status)) 112 goto out; 113 114 dev->wakeup.flags.notifier_present = false; 115 116 out: 117 mutex_unlock(&pci_acpi_pm_notify_mtx); 118 return status; 119 } 120 121 /** 122 * pci_acpi_add_bus_pm_notifier - Register PM notifier for given PCI bus. 123 * @dev: ACPI device to add the notifier for. 124 * @pci_bus: PCI bus to walk checking for PME status if an event is signaled. 125 */ 126 acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev, 127 struct pci_bus *pci_bus) 128 { 129 return add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus); 130 } 131 132 /** 133 * pci_acpi_remove_bus_pm_notifier - Unregister PCI bus PM notifier. 134 * @dev: ACPI device to remove the notifier from. 135 */ 136 acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev) 137 { 138 return remove_pm_notifier(dev, pci_acpi_wake_bus); 139 } 140 141 /** 142 * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device. 143 * @dev: ACPI device to add the notifier for. 144 * @pci_dev: PCI device to check for the PME status if an event is signaled. 145 */ 146 acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev, 147 struct pci_dev *pci_dev) 148 { 149 return add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev); 150 } 151 152 /** 153 * pci_acpi_remove_pm_notifier - Unregister PCI device PM notifier. 154 * @dev: ACPI device to remove the notifier from. 155 */ 156 acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev) 157 { 158 return remove_pm_notifier(dev, pci_acpi_wake_dev); 159 } 160 161 /* 162 * _SxD returns the D-state with the highest power 163 * (lowest D-state number) supported in the S-state "x". 164 * 165 * If the devices does not have a _PRW 166 * (Power Resources for Wake) supporting system wakeup from "x" 167 * then the OS is free to choose a lower power (higher number 168 * D-state) than the return value from _SxD. 169 * 170 * But if _PRW is enabled at S-state "x", the OS 171 * must not choose a power lower than _SxD -- 172 * unless the device has an _SxW method specifying 173 * the lowest power (highest D-state number) the device 174 * may enter while still able to wake the system. 175 * 176 * ie. depending on global OS policy: 177 * 178 * if (_PRW at S-state x) 179 * choose from highest power _SxD to lowest power _SxW 180 * else // no _PRW at S-state x 181 * choose highest power _SxD or any lower power 182 */ 183 184 static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev) 185 { 186 int acpi_state; 187 188 acpi_state = acpi_pm_device_sleep_state(&pdev->dev, NULL); 189 if (acpi_state < 0) 190 return PCI_POWER_ERROR; 191 192 switch (acpi_state) { 193 case ACPI_STATE_D0: 194 return PCI_D0; 195 case ACPI_STATE_D1: 196 return PCI_D1; 197 case ACPI_STATE_D2: 198 return PCI_D2; 199 case ACPI_STATE_D3: 200 return PCI_D3hot; 201 case ACPI_STATE_D3_COLD: 202 return PCI_D3cold; 203 } 204 return PCI_POWER_ERROR; 205 } 206 207 static bool acpi_pci_power_manageable(struct pci_dev *dev) 208 { 209 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev); 210 211 return handle ? acpi_bus_power_manageable(handle) : false; 212 } 213 214 static int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) 215 { 216 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev); 217 acpi_handle tmp; 218 static const u8 state_conv[] = { 219 [PCI_D0] = ACPI_STATE_D0, 220 [PCI_D1] = ACPI_STATE_D1, 221 [PCI_D2] = ACPI_STATE_D2, 222 [PCI_D3hot] = ACPI_STATE_D3, 223 [PCI_D3cold] = ACPI_STATE_D3 224 }; 225 int error = -EINVAL; 226 227 /* If the ACPI device has _EJ0, ignore the device */ 228 if (!handle || ACPI_SUCCESS(acpi_get_handle(handle, "_EJ0", &tmp))) 229 return -ENODEV; 230 231 switch (state) { 232 case PCI_D0: 233 case PCI_D1: 234 case PCI_D2: 235 case PCI_D3hot: 236 case PCI_D3cold: 237 error = acpi_bus_set_power(handle, state_conv[state]); 238 } 239 240 if (!error) 241 dev_printk(KERN_INFO, &dev->dev, 242 "power state changed by ACPI to D%d\n", state); 243 244 return error; 245 } 246 247 static bool acpi_pci_can_wakeup(struct pci_dev *dev) 248 { 249 acpi_handle handle = DEVICE_ACPI_HANDLE(&dev->dev); 250 251 return handle ? acpi_bus_can_wakeup(handle) : false; 252 } 253 254 static void acpi_pci_propagate_wakeup_enable(struct pci_bus *bus, bool enable) 255 { 256 while (bus->parent) { 257 if (!acpi_pm_device_sleep_wake(&bus->self->dev, enable)) 258 return; 259 bus = bus->parent; 260 } 261 262 /* We have reached the root bus. */ 263 if (bus->bridge) 264 acpi_pm_device_sleep_wake(bus->bridge, enable); 265 } 266 267 static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable) 268 { 269 if (acpi_pci_can_wakeup(dev)) 270 return acpi_pm_device_sleep_wake(&dev->dev, enable); 271 272 acpi_pci_propagate_wakeup_enable(dev->bus, enable); 273 return 0; 274 } 275 276 /** 277 * acpi_dev_run_wake - Enable/disable wake-up for given device. 278 * @phys_dev: Device to enable/disable the platform to wake-up the system for. 279 * @enable: Whether enable or disable the wake-up functionality. 280 * 281 * Find the ACPI device object corresponding to @pci_dev and try to 282 * enable/disable the GPE associated with it. 283 */ 284 static int acpi_dev_run_wake(struct device *phys_dev, bool enable) 285 { 286 struct acpi_device *dev; 287 acpi_handle handle; 288 289 if (!device_run_wake(phys_dev)) 290 return -EINVAL; 291 292 handle = DEVICE_ACPI_HANDLE(phys_dev); 293 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &dev))) { 294 dev_dbg(phys_dev, "ACPI handle has no context in %s!\n", 295 __func__); 296 return -ENODEV; 297 } 298 299 if (enable) { 300 acpi_enable_wakeup_device_power(dev, ACPI_STATE_S0); 301 acpi_enable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number); 302 } else { 303 acpi_disable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number); 304 acpi_disable_wakeup_device_power(dev); 305 } 306 307 return 0; 308 } 309 310 static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable) 311 { 312 while (bus->parent) { 313 struct pci_dev *bridge = bus->self; 314 315 if (bridge->pme_interrupt) 316 return; 317 if (!acpi_dev_run_wake(&bridge->dev, enable)) 318 return; 319 bus = bus->parent; 320 } 321 322 /* We have reached the root bus. */ 323 if (bus->bridge) 324 acpi_dev_run_wake(bus->bridge, enable); 325 } 326 327 static int acpi_pci_run_wake(struct pci_dev *dev, bool enable) 328 { 329 if (dev->pme_interrupt) 330 return 0; 331 332 if (!acpi_dev_run_wake(&dev->dev, enable)) 333 return 0; 334 335 acpi_pci_propagate_run_wake(dev->bus, enable); 336 return 0; 337 } 338 339 static struct pci_platform_pm_ops acpi_pci_platform_pm = { 340 .is_manageable = acpi_pci_power_manageable, 341 .set_state = acpi_pci_set_power_state, 342 .choose_state = acpi_pci_choose_state, 343 .can_wakeup = acpi_pci_can_wakeup, 344 .sleep_wake = acpi_pci_sleep_wake, 345 .run_wake = acpi_pci_run_wake, 346 }; 347 348 /* ACPI bus type */ 349 static int acpi_pci_find_device(struct device *dev, acpi_handle *handle) 350 { 351 struct pci_dev * pci_dev; 352 u64 addr; 353 354 pci_dev = to_pci_dev(dev); 355 /* Please ref to ACPI spec for the syntax of _ADR */ 356 addr = (PCI_SLOT(pci_dev->devfn) << 16) | PCI_FUNC(pci_dev->devfn); 357 *handle = acpi_get_child(DEVICE_ACPI_HANDLE(dev->parent), addr); 358 if (!*handle) 359 return -ENODEV; 360 return 0; 361 } 362 363 static int acpi_pci_find_root_bridge(struct device *dev, acpi_handle *handle) 364 { 365 int num; 366 unsigned int seg, bus; 367 368 /* 369 * The string should be the same as root bridge's name 370 * Please look at 'pci_scan_bus_parented' 371 */ 372 num = sscanf(dev_name(dev), "pci%04x:%02x", &seg, &bus); 373 if (num != 2) 374 return -ENODEV; 375 *handle = acpi_get_pci_rootbridge_handle(seg, bus); 376 if (!*handle) 377 return -ENODEV; 378 return 0; 379 } 380 381 static struct acpi_bus_type acpi_pci_bus = { 382 .bus = &pci_bus_type, 383 .find_device = acpi_pci_find_device, 384 .find_bridge = acpi_pci_find_root_bridge, 385 }; 386 387 static int __init acpi_pci_init(void) 388 { 389 int ret; 390 391 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_MSI) { 392 printk(KERN_INFO"ACPI FADT declares the system doesn't support MSI, so disable it\n"); 393 pci_no_msi(); 394 } 395 396 if (acpi_gbl_FADT.boot_flags & ACPI_FADT_NO_ASPM) { 397 printk(KERN_INFO"ACPI FADT declares the system doesn't support PCIe ASPM, so disable it\n"); 398 pcie_clear_aspm(); 399 pcie_no_aspm(); 400 } 401 402 ret = register_acpi_bus_type(&acpi_pci_bus); 403 if (ret) 404 return 0; 405 pci_set_platform_pm(&acpi_pci_platform_pm); 406 return 0; 407 } 408 arch_initcall(acpi_pci_init); 409