1ec2cd81cSRafael J. Wysocki /* 2ec2cd81cSRafael J. Wysocki * drivers/acpi/device_pm.c - ACPI device power management routines. 3ec2cd81cSRafael J. Wysocki * 4ec2cd81cSRafael J. Wysocki * Copyright (C) 2012, Intel Corp. 5ec2cd81cSRafael J. Wysocki * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> 6ec2cd81cSRafael J. Wysocki * 7ec2cd81cSRafael J. Wysocki * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8ec2cd81cSRafael J. Wysocki * 9ec2cd81cSRafael J. Wysocki * This program is free software; you can redistribute it and/or modify 10ec2cd81cSRafael J. Wysocki * it under the terms of the GNU General Public License version 2 as published 11ec2cd81cSRafael J. Wysocki * by the Free Software Foundation. 12ec2cd81cSRafael J. Wysocki * 13ec2cd81cSRafael J. Wysocki * This program is distributed in the hope that it will be useful, but 14ec2cd81cSRafael J. Wysocki * WITHOUT ANY WARRANTY; without even the implied warranty of 15ec2cd81cSRafael J. Wysocki * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16ec2cd81cSRafael J. Wysocki * General Public License for more details. 17ec2cd81cSRafael J. Wysocki * 18ec2cd81cSRafael J. Wysocki * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 19ec2cd81cSRafael J. Wysocki */ 20ec2cd81cSRafael J. Wysocki 217b199811SRafael J. Wysocki #include <linux/acpi.h> 2286b3832cSRafael J. Wysocki #include <linux/export.h> 23ec2cd81cSRafael J. Wysocki #include <linux/mutex.h> 2486b3832cSRafael J. Wysocki #include <linux/pm_qos.h> 25989561deSTomeu Vizoso #include <linux/pm_domain.h> 26cd7bd02dSRafael J. Wysocki #include <linux/pm_runtime.h> 2733e4f80eSRafael J. Wysocki #include <linux/suspend.h> 28ec2cd81cSRafael J. Wysocki 299ce4e607SRafael J. Wysocki #include "internal.h" 309ce4e607SRafael J. Wysocki 319ce4e607SRafael J. Wysocki #define _COMPONENT ACPI_POWER_COMPONENT 329ce4e607SRafael J. Wysocki ACPI_MODULE_NAME("device_pm"); 33ec2cd81cSRafael J. Wysocki 3486b3832cSRafael J. Wysocki /** 359ce4e607SRafael J. Wysocki * acpi_power_state_string - String representation of ACPI device power state. 369ce4e607SRafael J. Wysocki * @state: ACPI device power state to return the string representation of. 379ce4e607SRafael J. Wysocki */ 389ce4e607SRafael J. Wysocki const char *acpi_power_state_string(int state) 399ce4e607SRafael J. Wysocki { 409ce4e607SRafael J. Wysocki switch (state) { 419ce4e607SRafael J. Wysocki case ACPI_STATE_D0: 429ce4e607SRafael J. Wysocki return "D0"; 439ce4e607SRafael J. Wysocki case ACPI_STATE_D1: 449ce4e607SRafael J. Wysocki return "D1"; 459ce4e607SRafael J. Wysocki case ACPI_STATE_D2: 469ce4e607SRafael J. Wysocki return "D2"; 479ce4e607SRafael J. Wysocki case ACPI_STATE_D3_HOT: 489ce4e607SRafael J. Wysocki return "D3hot"; 499ce4e607SRafael J. Wysocki case ACPI_STATE_D3_COLD: 50898fee4fSRafael J. Wysocki return "D3cold"; 519ce4e607SRafael J. Wysocki default: 529ce4e607SRafael J. Wysocki return "(unknown)"; 539ce4e607SRafael J. Wysocki } 549ce4e607SRafael J. Wysocki } 559ce4e607SRafael J. Wysocki 569ce4e607SRafael J. Wysocki /** 579ce4e607SRafael J. Wysocki * acpi_device_get_power - Get power state of an ACPI device. 589ce4e607SRafael J. Wysocki * @device: Device to get the power state of. 599ce4e607SRafael J. Wysocki * @state: Place to store the power state of the device. 609ce4e607SRafael J. Wysocki * 619ce4e607SRafael J. Wysocki * This function does not update the device's power.state field, but it may 629ce4e607SRafael J. Wysocki * update its parent's power.state field (when the parent's power state is 639ce4e607SRafael J. Wysocki * unknown and the device's power state turns out to be D0). 649ce4e607SRafael J. Wysocki */ 659ce4e607SRafael J. Wysocki int acpi_device_get_power(struct acpi_device *device, int *state) 669ce4e607SRafael J. Wysocki { 679ce4e607SRafael J. Wysocki int result = ACPI_STATE_UNKNOWN; 689ce4e607SRafael J. Wysocki 699ce4e607SRafael J. Wysocki if (!device || !state) 709ce4e607SRafael J. Wysocki return -EINVAL; 719ce4e607SRafael J. Wysocki 729ce4e607SRafael J. Wysocki if (!device->flags.power_manageable) { 739ce4e607SRafael J. Wysocki /* TBD: Non-recursive algorithm for walking up hierarchy. */ 749ce4e607SRafael J. Wysocki *state = device->parent ? 759ce4e607SRafael J. Wysocki device->parent->power.state : ACPI_STATE_D0; 769ce4e607SRafael J. Wysocki goto out; 779ce4e607SRafael J. Wysocki } 789ce4e607SRafael J. Wysocki 799ce4e607SRafael J. Wysocki /* 8075eb2d13SRafael J. Wysocki * Get the device's power state from power resources settings and _PSC, 8175eb2d13SRafael J. Wysocki * if available. 829ce4e607SRafael J. Wysocki */ 8375eb2d13SRafael J. Wysocki if (device->power.flags.power_resources) { 849ce4e607SRafael J. Wysocki int error = acpi_power_get_inferred_state(device, &result); 859ce4e607SRafael J. Wysocki if (error) 869ce4e607SRafael J. Wysocki return error; 8775eb2d13SRafael J. Wysocki } 8875eb2d13SRafael J. Wysocki if (device->power.flags.explicit_get) { 8975eb2d13SRafael J. Wysocki acpi_handle handle = device->handle; 9075eb2d13SRafael J. Wysocki unsigned long long psc; 9175eb2d13SRafael J. Wysocki acpi_status status; 9275eb2d13SRafael J. Wysocki 9375eb2d13SRafael J. Wysocki status = acpi_evaluate_integer(handle, "_PSC", NULL, &psc); 9475eb2d13SRafael J. Wysocki if (ACPI_FAILURE(status)) 9575eb2d13SRafael J. Wysocki return -ENODEV; 9675eb2d13SRafael J. Wysocki 9775eb2d13SRafael J. Wysocki /* 9875eb2d13SRafael J. Wysocki * The power resources settings may indicate a power state 9920dacb71SRafael J. Wysocki * shallower than the actual power state of the device, because 10020dacb71SRafael J. Wysocki * the same power resources may be referenced by other devices. 10175eb2d13SRafael J. Wysocki * 10220dacb71SRafael J. Wysocki * For systems predating ACPI 4.0 we assume that D3hot is the 10320dacb71SRafael J. Wysocki * deepest state that can be supported. 10475eb2d13SRafael J. Wysocki */ 10575eb2d13SRafael J. Wysocki if (psc > result && psc < ACPI_STATE_D3_COLD) 10675eb2d13SRafael J. Wysocki result = psc; 10775eb2d13SRafael J. Wysocki else if (result == ACPI_STATE_UNKNOWN) 10820dacb71SRafael J. Wysocki result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_HOT : psc; 1099ce4e607SRafael J. Wysocki } 1109ce4e607SRafael J. Wysocki 1119ce4e607SRafael J. Wysocki /* 1129ce4e607SRafael J. Wysocki * If we were unsure about the device parent's power state up to this 1139ce4e607SRafael J. Wysocki * point, the fact that the device is in D0 implies that the parent has 114644f17adSMika Westerberg * to be in D0 too, except if ignore_parent is set. 1159ce4e607SRafael J. Wysocki */ 116644f17adSMika Westerberg if (!device->power.flags.ignore_parent && device->parent 117644f17adSMika Westerberg && device->parent->power.state == ACPI_STATE_UNKNOWN 1189ce4e607SRafael J. Wysocki && result == ACPI_STATE_D0) 1199ce4e607SRafael J. Wysocki device->parent->power.state = ACPI_STATE_D0; 1209ce4e607SRafael J. Wysocki 1219ce4e607SRafael J. Wysocki *state = result; 1229ce4e607SRafael J. Wysocki 1239ce4e607SRafael J. Wysocki out: 1249ce4e607SRafael J. Wysocki ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n", 1259ce4e607SRafael J. Wysocki device->pnp.bus_id, acpi_power_state_string(*state))); 1269ce4e607SRafael J. Wysocki 1279ce4e607SRafael J. Wysocki return 0; 1289ce4e607SRafael J. Wysocki } 1299ce4e607SRafael J. Wysocki 1309c0f45e3SRafael J. Wysocki static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state) 1319c0f45e3SRafael J. Wysocki { 1329c0f45e3SRafael J. Wysocki if (adev->power.states[state].flags.explicit_set) { 1339c0f45e3SRafael J. Wysocki char method[5] = { '_', 'P', 'S', '0' + state, '\0' }; 1349c0f45e3SRafael J. Wysocki acpi_status status; 1359c0f45e3SRafael J. Wysocki 1369c0f45e3SRafael J. Wysocki status = acpi_evaluate_object(adev->handle, method, NULL, NULL); 1379c0f45e3SRafael J. Wysocki if (ACPI_FAILURE(status)) 1389c0f45e3SRafael J. Wysocki return -ENODEV; 1399c0f45e3SRafael J. Wysocki } 1409c0f45e3SRafael J. Wysocki return 0; 1419c0f45e3SRafael J. Wysocki } 1429c0f45e3SRafael J. Wysocki 1439ce4e607SRafael J. Wysocki /** 1449ce4e607SRafael J. Wysocki * acpi_device_set_power - Set power state of an ACPI device. 1459ce4e607SRafael J. Wysocki * @device: Device to set the power state of. 1469ce4e607SRafael J. Wysocki * @state: New power state to set. 1479ce4e607SRafael J. Wysocki * 1489ce4e607SRafael J. Wysocki * Callers must ensure that the device is power manageable before using this 1499ce4e607SRafael J. Wysocki * function. 1509ce4e607SRafael J. Wysocki */ 1519ce4e607SRafael J. Wysocki int acpi_device_set_power(struct acpi_device *device, int state) 1529ce4e607SRafael J. Wysocki { 15320dacb71SRafael J. Wysocki int target_state = state; 1549ce4e607SRafael J. Wysocki int result = 0; 1559ce4e607SRafael J. Wysocki 1562c7d132aSRafael J. Wysocki if (!device || !device->flags.power_manageable 1572c7d132aSRafael J. Wysocki || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD)) 1589ce4e607SRafael J. Wysocki return -EINVAL; 1599ce4e607SRafael J. Wysocki 1609ce4e607SRafael J. Wysocki /* Make sure this is a valid target state */ 1619ce4e607SRafael J. Wysocki 1629ce4e607SRafael J. Wysocki if (state == device->power.state) { 163b69137a7SRafael J. Wysocki ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n", 164b69137a7SRafael J. Wysocki device->pnp.bus_id, 1659ce4e607SRafael J. Wysocki acpi_power_state_string(state))); 1669ce4e607SRafael J. Wysocki return 0; 1679ce4e607SRafael J. Wysocki } 1689ce4e607SRafael J. Wysocki 16920dacb71SRafael J. Wysocki if (state == ACPI_STATE_D3_COLD) { 17020dacb71SRafael J. Wysocki /* 17120dacb71SRafael J. Wysocki * For transitions to D3cold we need to execute _PS3 and then 17220dacb71SRafael J. Wysocki * possibly drop references to the power resources in use. 17320dacb71SRafael J. Wysocki */ 17420dacb71SRafael J. Wysocki state = ACPI_STATE_D3_HOT; 17520dacb71SRafael J. Wysocki /* If _PR3 is not available, use D3hot as the target state. */ 17620dacb71SRafael J. Wysocki if (!device->power.states[ACPI_STATE_D3_COLD].flags.valid) 17720dacb71SRafael J. Wysocki target_state = state; 17820dacb71SRafael J. Wysocki } else if (!device->power.states[state].flags.valid) { 179b69137a7SRafael J. Wysocki dev_warn(&device->dev, "Power state %s not supported\n", 1809ce4e607SRafael J. Wysocki acpi_power_state_string(state)); 1819ce4e607SRafael J. Wysocki return -ENODEV; 1829ce4e607SRafael J. Wysocki } 18320dacb71SRafael J. Wysocki 184644f17adSMika Westerberg if (!device->power.flags.ignore_parent && 185644f17adSMika Westerberg device->parent && (state < device->parent->power.state)) { 186b69137a7SRafael J. Wysocki dev_warn(&device->dev, 187593298e6SAaron Lu "Cannot transition to power state %s for parent in %s\n", 188593298e6SAaron Lu acpi_power_state_string(state), 189593298e6SAaron Lu acpi_power_state_string(device->parent->power.state)); 1909ce4e607SRafael J. Wysocki return -ENODEV; 1919ce4e607SRafael J. Wysocki } 1929ce4e607SRafael J. Wysocki 193e78adb75SRafael J. Wysocki /* 194e78adb75SRafael J. Wysocki * Transition Power 195e78adb75SRafael J. Wysocki * ---------------- 19620dacb71SRafael J. Wysocki * In accordance with ACPI 6, _PSx is executed before manipulating power 19720dacb71SRafael J. Wysocki * resources, unless the target state is D0, in which case _PS0 is 19820dacb71SRafael J. Wysocki * supposed to be executed after turning the power resources on. 199e78adb75SRafael J. Wysocki */ 20020dacb71SRafael J. Wysocki if (state > ACPI_STATE_D0) { 20120dacb71SRafael J. Wysocki /* 20220dacb71SRafael J. Wysocki * According to ACPI 6, devices cannot go from lower-power 20320dacb71SRafael J. Wysocki * (deeper) states to higher-power (shallower) states. 20420dacb71SRafael J. Wysocki */ 20520dacb71SRafael J. Wysocki if (state < device->power.state) { 20620dacb71SRafael J. Wysocki dev_warn(&device->dev, "Cannot transition from %s to %s\n", 20720dacb71SRafael J. Wysocki acpi_power_state_string(device->power.state), 20820dacb71SRafael J. Wysocki acpi_power_state_string(state)); 20920dacb71SRafael J. Wysocki return -ENODEV; 2109ce4e607SRafael J. Wysocki } 21120dacb71SRafael J. Wysocki 212e78adb75SRafael J. Wysocki result = acpi_dev_pm_explicit_set(device, state); 213e78adb75SRafael J. Wysocki if (result) 214e78adb75SRafael J. Wysocki goto end; 2159ce4e607SRafael J. Wysocki 21620dacb71SRafael J. Wysocki if (device->power.flags.power_resources) 21720dacb71SRafael J. Wysocki result = acpi_power_transition(device, target_state); 21820dacb71SRafael J. Wysocki } else { 21920dacb71SRafael J. Wysocki if (device->power.flags.power_resources) { 22020dacb71SRafael J. Wysocki result = acpi_power_transition(device, ACPI_STATE_D0); 22120dacb71SRafael J. Wysocki if (result) 22220dacb71SRafael J. Wysocki goto end; 22320dacb71SRafael J. Wysocki } 22420dacb71SRafael J. Wysocki result = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0); 225e5656271SRafael J. Wysocki } 2269ce4e607SRafael J. Wysocki 2279ce4e607SRafael J. Wysocki end: 228e78adb75SRafael J. Wysocki if (result) { 229b69137a7SRafael J. Wysocki dev_warn(&device->dev, "Failed to change power state to %s\n", 2309ce4e607SRafael J. Wysocki acpi_power_state_string(state)); 231e78adb75SRafael J. Wysocki } else { 23271b65445SMika Westerberg device->power.state = target_state; 2339ce4e607SRafael J. Wysocki ACPI_DEBUG_PRINT((ACPI_DB_INFO, 2349ce4e607SRafael J. Wysocki "Device [%s] transitioned to %s\n", 2359ce4e607SRafael J. Wysocki device->pnp.bus_id, 2369ce4e607SRafael J. Wysocki acpi_power_state_string(state))); 2379ce4e607SRafael J. Wysocki } 2389ce4e607SRafael J. Wysocki 2399ce4e607SRafael J. Wysocki return result; 2409ce4e607SRafael J. Wysocki } 2419ce4e607SRafael J. Wysocki EXPORT_SYMBOL(acpi_device_set_power); 2429ce4e607SRafael J. Wysocki 2439ce4e607SRafael J. Wysocki int acpi_bus_set_power(acpi_handle handle, int state) 2449ce4e607SRafael J. Wysocki { 2459ce4e607SRafael J. Wysocki struct acpi_device *device; 2469ce4e607SRafael J. Wysocki int result; 2479ce4e607SRafael J. Wysocki 2489ce4e607SRafael J. Wysocki result = acpi_bus_get_device(handle, &device); 2499ce4e607SRafael J. Wysocki if (result) 2509ce4e607SRafael J. Wysocki return result; 2519ce4e607SRafael J. Wysocki 2529ce4e607SRafael J. Wysocki return acpi_device_set_power(device, state); 2539ce4e607SRafael J. Wysocki } 2549ce4e607SRafael J. Wysocki EXPORT_SYMBOL(acpi_bus_set_power); 2559ce4e607SRafael J. Wysocki 2569ce4e607SRafael J. Wysocki int acpi_bus_init_power(struct acpi_device *device) 2579ce4e607SRafael J. Wysocki { 2589ce4e607SRafael J. Wysocki int state; 2599ce4e607SRafael J. Wysocki int result; 2609ce4e607SRafael J. Wysocki 2619ce4e607SRafael J. Wysocki if (!device) 2629ce4e607SRafael J. Wysocki return -EINVAL; 2639ce4e607SRafael J. Wysocki 2649ce4e607SRafael J. Wysocki device->power.state = ACPI_STATE_UNKNOWN; 265202317a5SRafael J. Wysocki if (!acpi_device_is_present(device)) 2661b1f3e16SRafael J. Wysocki return -ENXIO; 2679ce4e607SRafael J. Wysocki 2689ce4e607SRafael J. Wysocki result = acpi_device_get_power(device, &state); 2699ce4e607SRafael J. Wysocki if (result) 2709ce4e607SRafael J. Wysocki return result; 2719ce4e607SRafael J. Wysocki 272a2367807SRafael J. Wysocki if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) { 27320dacb71SRafael J. Wysocki /* Reference count the power resources. */ 2749ce4e607SRafael J. Wysocki result = acpi_power_on_resources(device, state); 275a2367807SRafael J. Wysocki if (result) 2769ce4e607SRafael J. Wysocki return result; 277a2367807SRafael J. Wysocki 27820dacb71SRafael J. Wysocki if (state == ACPI_STATE_D0) { 27920dacb71SRafael J. Wysocki /* 28020dacb71SRafael J. Wysocki * If _PSC is not present and the state inferred from 28120dacb71SRafael J. Wysocki * power resources appears to be D0, it still may be 28220dacb71SRafael J. Wysocki * necessary to execute _PS0 at this point, because 28320dacb71SRafael J. Wysocki * another device using the same power resources may 28420dacb71SRafael J. Wysocki * have been put into D0 previously and that's why we 28520dacb71SRafael J. Wysocki * see D0 here. 28620dacb71SRafael J. Wysocki */ 2879c0f45e3SRafael J. Wysocki result = acpi_dev_pm_explicit_set(device, state); 2889c0f45e3SRafael J. Wysocki if (result) 2899c0f45e3SRafael J. Wysocki return result; 29020dacb71SRafael J. Wysocki } 291b3785492SRafael J. Wysocki } else if (state == ACPI_STATE_UNKNOWN) { 2927cd8407dSRafael J. Wysocki /* 2937cd8407dSRafael J. Wysocki * No power resources and missing _PSC? Cross fingers and make 2947cd8407dSRafael J. Wysocki * it D0 in hope that this is what the BIOS put the device into. 2957cd8407dSRafael J. Wysocki * [We tried to force D0 here by executing _PS0, but that broke 2967cd8407dSRafael J. Wysocki * Toshiba P870-303 in a nasty way.] 2977cd8407dSRafael J. Wysocki */ 298b3785492SRafael J. Wysocki state = ACPI_STATE_D0; 299a2367807SRafael J. Wysocki } 300a2367807SRafael J. Wysocki device->power.state = state; 301a2367807SRafael J. Wysocki return 0; 3029ce4e607SRafael J. Wysocki } 3039ce4e607SRafael J. Wysocki 304b9e95fc6SRafael J. Wysocki /** 305b9e95fc6SRafael J. Wysocki * acpi_device_fix_up_power - Force device with missing _PSC into D0. 306b9e95fc6SRafael J. Wysocki * @device: Device object whose power state is to be fixed up. 307b9e95fc6SRafael J. Wysocki * 308b9e95fc6SRafael J. Wysocki * Devices without power resources and _PSC, but having _PS0 and _PS3 defined, 309b9e95fc6SRafael J. Wysocki * are assumed to be put into D0 by the BIOS. However, in some cases that may 310b9e95fc6SRafael J. Wysocki * not be the case and this function should be used then. 311b9e95fc6SRafael J. Wysocki */ 312b9e95fc6SRafael J. Wysocki int acpi_device_fix_up_power(struct acpi_device *device) 313b9e95fc6SRafael J. Wysocki { 314b9e95fc6SRafael J. Wysocki int ret = 0; 315b9e95fc6SRafael J. Wysocki 316b9e95fc6SRafael J. Wysocki if (!device->power.flags.power_resources 317b9e95fc6SRafael J. Wysocki && !device->power.flags.explicit_get 318b9e95fc6SRafael J. Wysocki && device->power.state == ACPI_STATE_D0) 319b9e95fc6SRafael J. Wysocki ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0); 320b9e95fc6SRafael J. Wysocki 321b9e95fc6SRafael J. Wysocki return ret; 322b9e95fc6SRafael J. Wysocki } 32378a898d0SUlf Hansson EXPORT_SYMBOL_GPL(acpi_device_fix_up_power); 324b9e95fc6SRafael J. Wysocki 325202317a5SRafael J. Wysocki int acpi_device_update_power(struct acpi_device *device, int *state_p) 3269ce4e607SRafael J. Wysocki { 3279ce4e607SRafael J. Wysocki int state; 3289ce4e607SRafael J. Wysocki int result; 3299ce4e607SRafael J. Wysocki 330202317a5SRafael J. Wysocki if (device->power.state == ACPI_STATE_UNKNOWN) { 331202317a5SRafael J. Wysocki result = acpi_bus_init_power(device); 332202317a5SRafael J. Wysocki if (!result && state_p) 333202317a5SRafael J. Wysocki *state_p = device->power.state; 334202317a5SRafael J. Wysocki 3359ce4e607SRafael J. Wysocki return result; 336202317a5SRafael J. Wysocki } 3379ce4e607SRafael J. Wysocki 3389ce4e607SRafael J. Wysocki result = acpi_device_get_power(device, &state); 3399ce4e607SRafael J. Wysocki if (result) 3409ce4e607SRafael J. Wysocki return result; 3419ce4e607SRafael J. Wysocki 34291bdad0bSRafael J. Wysocki if (state == ACPI_STATE_UNKNOWN) { 343511d5c42SRafael J. Wysocki state = ACPI_STATE_D0; 3449ce4e607SRafael J. Wysocki result = acpi_device_set_power(device, state); 34591bdad0bSRafael J. Wysocki if (result) 34691bdad0bSRafael J. Wysocki return result; 34791bdad0bSRafael J. Wysocki } else { 34891bdad0bSRafael J. Wysocki if (device->power.flags.power_resources) { 34991bdad0bSRafael J. Wysocki /* 35091bdad0bSRafael J. Wysocki * We don't need to really switch the state, bu we need 35191bdad0bSRafael J. Wysocki * to update the power resources' reference counters. 35291bdad0bSRafael J. Wysocki */ 35391bdad0bSRafael J. Wysocki result = acpi_power_transition(device, state); 35491bdad0bSRafael J. Wysocki if (result) 35591bdad0bSRafael J. Wysocki return result; 35691bdad0bSRafael J. Wysocki } 35791bdad0bSRafael J. Wysocki device->power.state = state; 35891bdad0bSRafael J. Wysocki } 35991bdad0bSRafael J. Wysocki if (state_p) 3609ce4e607SRafael J. Wysocki *state_p = state; 3619ce4e607SRafael J. Wysocki 36291bdad0bSRafael J. Wysocki return 0; 3639ce4e607SRafael J. Wysocki } 3642bb3a2bfSAaron Lu EXPORT_SYMBOL_GPL(acpi_device_update_power); 365202317a5SRafael J. Wysocki 366202317a5SRafael J. Wysocki int acpi_bus_update_power(acpi_handle handle, int *state_p) 367202317a5SRafael J. Wysocki { 368202317a5SRafael J. Wysocki struct acpi_device *device; 369202317a5SRafael J. Wysocki int result; 370202317a5SRafael J. Wysocki 371202317a5SRafael J. Wysocki result = acpi_bus_get_device(handle, &device); 372202317a5SRafael J. Wysocki return result ? result : acpi_device_update_power(device, state_p); 373202317a5SRafael J. Wysocki } 3749ce4e607SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_bus_update_power); 3759ce4e607SRafael J. Wysocki 3769ce4e607SRafael J. Wysocki bool acpi_bus_power_manageable(acpi_handle handle) 3779ce4e607SRafael J. Wysocki { 3789ce4e607SRafael J. Wysocki struct acpi_device *device; 3799ce4e607SRafael J. Wysocki int result; 3809ce4e607SRafael J. Wysocki 3819ce4e607SRafael J. Wysocki result = acpi_bus_get_device(handle, &device); 3829ce4e607SRafael J. Wysocki return result ? false : device->flags.power_manageable; 3839ce4e607SRafael J. Wysocki } 3849ce4e607SRafael J. Wysocki EXPORT_SYMBOL(acpi_bus_power_manageable); 3859ce4e607SRafael J. Wysocki 386ec4602a9SRafael J. Wysocki #ifdef CONFIG_PM 387ec4602a9SRafael J. Wysocki static DEFINE_MUTEX(acpi_pm_notifier_lock); 388ec4602a9SRafael J. Wysocki 38933e4f80eSRafael J. Wysocki void acpi_pm_wakeup_event(struct device *dev) 39033e4f80eSRafael J. Wysocki { 39133e4f80eSRafael J. Wysocki pm_wakeup_dev_event(dev, 0, acpi_s2idle_wakeup()); 39233e4f80eSRafael J. Wysocki } 39333e4f80eSRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_pm_wakeup_event); 39433e4f80eSRafael J. Wysocki 395c072530fSRafael J. Wysocki static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used) 396c072530fSRafael J. Wysocki { 397c072530fSRafael J. Wysocki struct acpi_device *adev; 398c072530fSRafael J. Wysocki 399c072530fSRafael J. Wysocki if (val != ACPI_NOTIFY_DEVICE_WAKE) 400c072530fSRafael J. Wysocki return; 401c072530fSRafael J. Wysocki 402c072530fSRafael J. Wysocki adev = acpi_bus_get_acpi_device(handle); 403c072530fSRafael J. Wysocki if (!adev) 404c072530fSRafael J. Wysocki return; 405c072530fSRafael J. Wysocki 406c072530fSRafael J. Wysocki mutex_lock(&acpi_pm_notifier_lock); 407c072530fSRafael J. Wysocki 408c072530fSRafael J. Wysocki if (adev->wakeup.flags.notifier_present) { 40933e4f80eSRafael J. Wysocki pm_wakeup_ws_event(adev->wakeup.ws, 0, acpi_s2idle_wakeup()); 41064fd1c70SRafael J. Wysocki if (adev->wakeup.context.func) 41164fd1c70SRafael J. Wysocki adev->wakeup.context.func(&adev->wakeup.context); 412c072530fSRafael J. Wysocki } 413c072530fSRafael J. Wysocki 414c072530fSRafael J. Wysocki mutex_unlock(&acpi_pm_notifier_lock); 415c072530fSRafael J. Wysocki 416c072530fSRafael J. Wysocki acpi_bus_put_acpi_device(adev); 417c072530fSRafael J. Wysocki } 418c072530fSRafael J. Wysocki 419ec4602a9SRafael J. Wysocki /** 420c072530fSRafael J. Wysocki * acpi_add_pm_notifier - Register PM notify handler for given ACPI device. 421c072530fSRafael J. Wysocki * @adev: ACPI device to add the notify handler for. 422c072530fSRafael J. Wysocki * @dev: Device to generate a wakeup event for while handling the notification. 42364fd1c70SRafael J. Wysocki * @func: Work function to execute when handling the notification. 424ec4602a9SRafael J. Wysocki * 425ec4602a9SRafael J. Wysocki * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of 426ec4602a9SRafael J. Wysocki * PM wakeup events. For example, wakeup events may be generated for bridges 427ec4602a9SRafael J. Wysocki * if one of the devices below the bridge is signaling wakeup, even if the 428ec4602a9SRafael J. Wysocki * bridge itself doesn't have a wakeup GPE associated with it. 429ec4602a9SRafael J. Wysocki */ 430c072530fSRafael J. Wysocki acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev, 43164fd1c70SRafael J. Wysocki void (*func)(struct acpi_device_wakeup_context *context)) 432ec4602a9SRafael J. Wysocki { 433ec4602a9SRafael J. Wysocki acpi_status status = AE_ALREADY_EXISTS; 434ec4602a9SRafael J. Wysocki 43564fd1c70SRafael J. Wysocki if (!dev && !func) 436c072530fSRafael J. Wysocki return AE_BAD_PARAMETER; 437c072530fSRafael J. Wysocki 438ec4602a9SRafael J. Wysocki mutex_lock(&acpi_pm_notifier_lock); 439ec4602a9SRafael J. Wysocki 440ec4602a9SRafael J. Wysocki if (adev->wakeup.flags.notifier_present) 441ec4602a9SRafael J. Wysocki goto out; 442ec4602a9SRafael J. Wysocki 443c072530fSRafael J. Wysocki adev->wakeup.ws = wakeup_source_register(dev_name(&adev->dev)); 444c072530fSRafael J. Wysocki adev->wakeup.context.dev = dev; 44564fd1c70SRafael J. Wysocki adev->wakeup.context.func = func; 446c072530fSRafael J. Wysocki 447c072530fSRafael J. Wysocki status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY, 448c072530fSRafael J. Wysocki acpi_pm_notify_handler, NULL); 449ec4602a9SRafael J. Wysocki if (ACPI_FAILURE(status)) 450ec4602a9SRafael J. Wysocki goto out; 451ec4602a9SRafael J. Wysocki 452ec4602a9SRafael J. Wysocki adev->wakeup.flags.notifier_present = true; 453ec4602a9SRafael J. Wysocki 454ec4602a9SRafael J. Wysocki out: 455ec4602a9SRafael J. Wysocki mutex_unlock(&acpi_pm_notifier_lock); 456ec4602a9SRafael J. Wysocki return status; 457ec4602a9SRafael J. Wysocki } 458ec4602a9SRafael J. Wysocki 459ec4602a9SRafael J. Wysocki /** 460ec4602a9SRafael J. Wysocki * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device. 461ec4602a9SRafael J. Wysocki * @adev: ACPI device to remove the notifier from. 462ec4602a9SRafael J. Wysocki */ 463c072530fSRafael J. Wysocki acpi_status acpi_remove_pm_notifier(struct acpi_device *adev) 464ec4602a9SRafael J. Wysocki { 465ec4602a9SRafael J. Wysocki acpi_status status = AE_BAD_PARAMETER; 466ec4602a9SRafael J. Wysocki 467ec4602a9SRafael J. Wysocki mutex_lock(&acpi_pm_notifier_lock); 468ec4602a9SRafael J. Wysocki 469ec4602a9SRafael J. Wysocki if (!adev->wakeup.flags.notifier_present) 470ec4602a9SRafael J. Wysocki goto out; 471ec4602a9SRafael J. Wysocki 472ec4602a9SRafael J. Wysocki status = acpi_remove_notify_handler(adev->handle, 473ec4602a9SRafael J. Wysocki ACPI_SYSTEM_NOTIFY, 474c072530fSRafael J. Wysocki acpi_pm_notify_handler); 475ec4602a9SRafael J. Wysocki if (ACPI_FAILURE(status)) 476ec4602a9SRafael J. Wysocki goto out; 477ec4602a9SRafael J. Wysocki 47864fd1c70SRafael J. Wysocki adev->wakeup.context.func = NULL; 479c072530fSRafael J. Wysocki adev->wakeup.context.dev = NULL; 480c072530fSRafael J. Wysocki wakeup_source_unregister(adev->wakeup.ws); 481c072530fSRafael J. Wysocki 482ec4602a9SRafael J. Wysocki adev->wakeup.flags.notifier_present = false; 483ec4602a9SRafael J. Wysocki 484ec4602a9SRafael J. Wysocki out: 485ec4602a9SRafael J. Wysocki mutex_unlock(&acpi_pm_notifier_lock); 486ec4602a9SRafael J. Wysocki return status; 487ec4602a9SRafael J. Wysocki } 488ec4602a9SRafael J. Wysocki 4899ce4e607SRafael J. Wysocki bool acpi_bus_can_wakeup(acpi_handle handle) 4909ce4e607SRafael J. Wysocki { 4919ce4e607SRafael J. Wysocki struct acpi_device *device; 4929ce4e607SRafael J. Wysocki int result; 4939ce4e607SRafael J. Wysocki 4949ce4e607SRafael J. Wysocki result = acpi_bus_get_device(handle, &device); 4959ce4e607SRafael J. Wysocki return result ? false : device->wakeup.flags.valid; 4969ce4e607SRafael J. Wysocki } 4979ce4e607SRafael J. Wysocki EXPORT_SYMBOL(acpi_bus_can_wakeup); 4989ce4e607SRafael J. Wysocki 499*8370c2dcSRafael J. Wysocki bool acpi_pm_device_can_wakeup(struct device *dev) 500*8370c2dcSRafael J. Wysocki { 501*8370c2dcSRafael J. Wysocki struct acpi_device *adev = ACPI_COMPANION(dev); 502*8370c2dcSRafael J. Wysocki 503*8370c2dcSRafael J. Wysocki return adev ? acpi_device_can_wakeup(adev) : false; 504*8370c2dcSRafael J. Wysocki } 505*8370c2dcSRafael J. Wysocki 5069ce4e607SRafael J. Wysocki /** 507b25c77efSRafael J. Wysocki * acpi_dev_pm_get_state - Get preferred power state of ACPI device. 50886b3832cSRafael J. Wysocki * @dev: Device whose preferred target power state to return. 50986b3832cSRafael J. Wysocki * @adev: ACPI device node corresponding to @dev. 51086b3832cSRafael J. Wysocki * @target_state: System state to match the resultant device state. 511fa1675b5SRafael J. Wysocki * @d_min_p: Location to store the highest power state available to the device. 512fa1675b5SRafael J. Wysocki * @d_max_p: Location to store the lowest power state available to the device. 51386b3832cSRafael J. Wysocki * 514fa1675b5SRafael J. Wysocki * Find the lowest power (highest number) and highest power (lowest number) ACPI 515fa1675b5SRafael J. Wysocki * device power states that the device can be in while the system is in the 516fa1675b5SRafael J. Wysocki * state represented by @target_state. Store the integer numbers representing 517fa1675b5SRafael J. Wysocki * those stats in the memory locations pointed to by @d_max_p and @d_min_p, 518fa1675b5SRafael J. Wysocki * respectively. 51986b3832cSRafael J. Wysocki * 52086b3832cSRafael J. Wysocki * Callers must ensure that @dev and @adev are valid pointers and that @adev 52186b3832cSRafael J. Wysocki * actually corresponds to @dev before using this function. 522fa1675b5SRafael J. Wysocki * 523fa1675b5SRafael J. Wysocki * Returns 0 on success or -ENODATA when one of the ACPI methods fails or 524fa1675b5SRafael J. Wysocki * returns a value that doesn't make sense. The memory locations pointed to by 525fa1675b5SRafael J. Wysocki * @d_max_p and @d_min_p are only modified on success. 52686b3832cSRafael J. Wysocki */ 527b25c77efSRafael J. Wysocki static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev, 528fa1675b5SRafael J. Wysocki u32 target_state, int *d_min_p, int *d_max_p) 52986b3832cSRafael J. Wysocki { 530fa1675b5SRafael J. Wysocki char method[] = { '_', 'S', '0' + target_state, 'D', '\0' }; 531fa1675b5SRafael J. Wysocki acpi_handle handle = adev->handle; 532fa1675b5SRafael J. Wysocki unsigned long long ret; 533fa1675b5SRafael J. Wysocki int d_min, d_max; 53486b3832cSRafael J. Wysocki bool wakeup = false; 535fa1675b5SRafael J. Wysocki acpi_status status; 53686b3832cSRafael J. Wysocki 53786b3832cSRafael J. Wysocki /* 538fa1675b5SRafael J. Wysocki * If the system state is S0, the lowest power state the device can be 539fa1675b5SRafael J. Wysocki * in is D3cold, unless the device has _S0W and is supposed to signal 540fa1675b5SRafael J. Wysocki * wakeup, in which case the return value of _S0W has to be used as the 541fa1675b5SRafael J. Wysocki * lowest power state available to the device. 54286b3832cSRafael J. Wysocki */ 54386b3832cSRafael J. Wysocki d_min = ACPI_STATE_D0; 5444c164ae7SRafael J. Wysocki d_max = ACPI_STATE_D3_COLD; 54586b3832cSRafael J. Wysocki 54686b3832cSRafael J. Wysocki /* 54786b3832cSRafael J. Wysocki * If present, _SxD methods return the minimum D-state (highest power 54886b3832cSRafael J. Wysocki * state) we can use for the corresponding S-states. Otherwise, the 54986b3832cSRafael J. Wysocki * minimum D-state is D0 (ACPI 3.x). 55086b3832cSRafael J. Wysocki */ 55186b3832cSRafael J. Wysocki if (target_state > ACPI_STATE_S0) { 552fa1675b5SRafael J. Wysocki /* 553fa1675b5SRafael J. Wysocki * We rely on acpi_evaluate_integer() not clobbering the integer 554fa1675b5SRafael J. Wysocki * provided if AE_NOT_FOUND is returned. 555fa1675b5SRafael J. Wysocki */ 556fa1675b5SRafael J. Wysocki ret = d_min; 557fa1675b5SRafael J. Wysocki status = acpi_evaluate_integer(handle, method, NULL, &ret); 558fa1675b5SRafael J. Wysocki if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND) 559fa1675b5SRafael J. Wysocki || ret > ACPI_STATE_D3_COLD) 560fa1675b5SRafael J. Wysocki return -ENODATA; 561fa1675b5SRafael J. Wysocki 562fa1675b5SRafael J. Wysocki /* 563fa1675b5SRafael J. Wysocki * We need to handle legacy systems where D3hot and D3cold are 564fa1675b5SRafael J. Wysocki * the same and 3 is returned in both cases, so fall back to 565fa1675b5SRafael J. Wysocki * D3cold if D3hot is not a valid state. 566fa1675b5SRafael J. Wysocki */ 567fa1675b5SRafael J. Wysocki if (!adev->power.states[ret].flags.valid) { 568fa1675b5SRafael J. Wysocki if (ret == ACPI_STATE_D3_HOT) 569fa1675b5SRafael J. Wysocki ret = ACPI_STATE_D3_COLD; 570fa1675b5SRafael J. Wysocki else 571fa1675b5SRafael J. Wysocki return -ENODATA; 572fa1675b5SRafael J. Wysocki } 573fa1675b5SRafael J. Wysocki d_min = ret; 57486b3832cSRafael J. Wysocki wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid 57586b3832cSRafael J. Wysocki && adev->wakeup.sleep_state >= target_state; 57686b3832cSRafael J. Wysocki } else if (dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) != 57786b3832cSRafael J. Wysocki PM_QOS_FLAGS_NONE) { 57886b3832cSRafael J. Wysocki wakeup = adev->wakeup.flags.valid; 57986b3832cSRafael J. Wysocki } 58086b3832cSRafael J. Wysocki 58186b3832cSRafael J. Wysocki /* 58286b3832cSRafael J. Wysocki * If _PRW says we can wake up the system from the target sleep state, 58386b3832cSRafael J. Wysocki * the D-state returned by _SxD is sufficient for that (we assume a 58486b3832cSRafael J. Wysocki * wakeup-aware driver if wake is set). Still, if _SxW exists 58586b3832cSRafael J. Wysocki * (ACPI 3.x), it should return the maximum (lowest power) D-state that 58686b3832cSRafael J. Wysocki * can wake the system. _S0W may be valid, too. 58786b3832cSRafael J. Wysocki */ 58886b3832cSRafael J. Wysocki if (wakeup) { 589fa1675b5SRafael J. Wysocki method[3] = 'W'; 590fa1675b5SRafael J. Wysocki status = acpi_evaluate_integer(handle, method, NULL, &ret); 591fa1675b5SRafael J. Wysocki if (status == AE_NOT_FOUND) { 592fa1675b5SRafael J. Wysocki if (target_state > ACPI_STATE_S0) 59386b3832cSRafael J. Wysocki d_max = d_min; 594fa1675b5SRafael J. Wysocki } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) { 595fa1675b5SRafael J. Wysocki /* Fall back to D3cold if ret is not a valid state. */ 596fa1675b5SRafael J. Wysocki if (!adev->power.states[ret].flags.valid) 597fa1675b5SRafael J. Wysocki ret = ACPI_STATE_D3_COLD; 598fa1675b5SRafael J. Wysocki 599fa1675b5SRafael J. Wysocki d_max = ret > d_min ? ret : d_min; 600fa1675b5SRafael J. Wysocki } else { 601fa1675b5SRafael J. Wysocki return -ENODATA; 60286b3832cSRafael J. Wysocki } 60386b3832cSRafael J. Wysocki } 60486b3832cSRafael J. Wysocki 60586b3832cSRafael J. Wysocki if (d_min_p) 60686b3832cSRafael J. Wysocki *d_min_p = d_min; 607fa1675b5SRafael J. Wysocki 608fa1675b5SRafael J. Wysocki if (d_max_p) 609fa1675b5SRafael J. Wysocki *d_max_p = d_max; 610fa1675b5SRafael J. Wysocki 611fa1675b5SRafael J. Wysocki return 0; 61286b3832cSRafael J. Wysocki } 613cd7bd02dSRafael J. Wysocki 614a6ae7594SRafael J. Wysocki /** 615a6ae7594SRafael J. Wysocki * acpi_pm_device_sleep_state - Get preferred power state of ACPI device. 616a6ae7594SRafael J. Wysocki * @dev: Device whose preferred target power state to return. 617a6ae7594SRafael J. Wysocki * @d_min_p: Location to store the upper limit of the allowed states range. 618a6ae7594SRafael J. Wysocki * @d_max_in: Deepest low-power state to take into consideration. 619a6ae7594SRafael J. Wysocki * Return value: Preferred power state of the device on success, -ENODEV 620fa1675b5SRafael J. Wysocki * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is 621fa1675b5SRafael J. Wysocki * incorrect, or -ENODATA on ACPI method failure. 622a6ae7594SRafael J. Wysocki * 623a6ae7594SRafael J. Wysocki * The caller must ensure that @dev is valid before using this function. 624a6ae7594SRafael J. Wysocki */ 625a6ae7594SRafael J. Wysocki int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in) 626a6ae7594SRafael J. Wysocki { 627a6ae7594SRafael J. Wysocki struct acpi_device *adev; 6289b5c7a5aSRafael J. Wysocki int ret, d_min, d_max; 629fa1675b5SRafael J. Wysocki 630fa1675b5SRafael J. Wysocki if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD) 631fa1675b5SRafael J. Wysocki return -EINVAL; 632fa1675b5SRafael J. Wysocki 63320dacb71SRafael J. Wysocki if (d_max_in > ACPI_STATE_D2) { 634fa1675b5SRafael J. Wysocki enum pm_qos_flags_status stat; 635fa1675b5SRafael J. Wysocki 636fa1675b5SRafael J. Wysocki stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF); 637fa1675b5SRafael J. Wysocki if (stat == PM_QOS_FLAGS_ALL) 63820dacb71SRafael J. Wysocki d_max_in = ACPI_STATE_D2; 639fa1675b5SRafael J. Wysocki } 640a6ae7594SRafael J. Wysocki 64117653a3eSRafael J. Wysocki adev = ACPI_COMPANION(dev); 64217653a3eSRafael J. Wysocki if (!adev) { 64317653a3eSRafael J. Wysocki dev_dbg(dev, "ACPI companion missing in %s!\n", __func__); 644a6ae7594SRafael J. Wysocki return -ENODEV; 645a6ae7594SRafael J. Wysocki } 646a6ae7594SRafael J. Wysocki 647fa1675b5SRafael J. Wysocki ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(), 6489b5c7a5aSRafael J. Wysocki &d_min, &d_max); 649fa1675b5SRafael J. Wysocki if (ret) 650fa1675b5SRafael J. Wysocki return ret; 651fa1675b5SRafael J. Wysocki 6529b5c7a5aSRafael J. Wysocki if (d_max_in < d_min) 653fa1675b5SRafael J. Wysocki return -EINVAL; 654fa1675b5SRafael J. Wysocki 655fa1675b5SRafael J. Wysocki if (d_max > d_max_in) { 6569b5c7a5aSRafael J. Wysocki for (d_max = d_max_in; d_max > d_min; d_max--) { 657fa1675b5SRafael J. Wysocki if (adev->power.states[d_max].flags.valid) 658fa1675b5SRafael J. Wysocki break; 659fa1675b5SRafael J. Wysocki } 660fa1675b5SRafael J. Wysocki } 6619b5c7a5aSRafael J. Wysocki 6629b5c7a5aSRafael J. Wysocki if (d_min_p) 6639b5c7a5aSRafael J. Wysocki *d_min_p = d_min; 6649b5c7a5aSRafael J. Wysocki 665fa1675b5SRafael J. Wysocki return d_max; 666a6ae7594SRafael J. Wysocki } 667a6ae7594SRafael J. Wysocki EXPORT_SYMBOL(acpi_pm_device_sleep_state); 668a6ae7594SRafael J. Wysocki 669cd7bd02dSRafael J. Wysocki /** 670c072530fSRafael J. Wysocki * acpi_pm_notify_work_func - ACPI devices wakeup notification work function. 67164fd1c70SRafael J. Wysocki * @context: Device wakeup context. 672e5cc8ef3SRafael J. Wysocki */ 67364fd1c70SRafael J. Wysocki static void acpi_pm_notify_work_func(struct acpi_device_wakeup_context *context) 674e5cc8ef3SRafael J. Wysocki { 67564fd1c70SRafael J. Wysocki struct device *dev = context->dev; 676e5cc8ef3SRafael J. Wysocki 677c072530fSRafael J. Wysocki if (dev) { 678e5cc8ef3SRafael J. Wysocki pm_wakeup_event(dev, 0); 67964fd1c70SRafael J. Wysocki pm_request_resume(dev); 680e5cc8ef3SRafael J. Wysocki } 681e5cc8ef3SRafael J. Wysocki } 682e5cc8ef3SRafael J. Wysocki 683e5cc8ef3SRafael J. Wysocki /** 684f35cec25SRafael J. Wysocki * acpi_device_wakeup - Enable/disable wakeup functionality for device. 685f35cec25SRafael J. Wysocki * @adev: ACPI device to enable/disable wakeup functionality for. 686f35cec25SRafael J. Wysocki * @target_state: State the system is transitioning into. 687cd7bd02dSRafael J. Wysocki * @enable: Whether to enable or disable the wakeup functionality. 688cd7bd02dSRafael J. Wysocki * 689dee8370cSRafael J. Wysocki * Enable/disable the GPE associated with @adev so that it can generate 690dee8370cSRafael J. Wysocki * wakeup signals for the device in response to external (remote) events and 691dee8370cSRafael J. Wysocki * enable/disable device wakeup power. 692dee8370cSRafael J. Wysocki * 693dee8370cSRafael J. Wysocki * Callers must ensure that @adev is a valid ACPI device node before executing 694dee8370cSRafael J. Wysocki * this function. 695dee8370cSRafael J. Wysocki */ 696f35cec25SRafael J. Wysocki static int acpi_device_wakeup(struct acpi_device *adev, u32 target_state, 697f35cec25SRafael J. Wysocki bool enable) 698dee8370cSRafael J. Wysocki { 699dee8370cSRafael J. Wysocki struct acpi_device_wakeup *wakeup = &adev->wakeup; 700dee8370cSRafael J. Wysocki 701dee8370cSRafael J. Wysocki if (enable) { 702dee8370cSRafael J. Wysocki acpi_status res; 703dee8370cSRafael J. Wysocki int error; 704dee8370cSRafael J. Wysocki 705235d81a6SRafael J. Wysocki if (adev->wakeup.flags.enabled) 706235d81a6SRafael J. Wysocki return 0; 707235d81a6SRafael J. Wysocki 708f35cec25SRafael J. Wysocki error = acpi_enable_wakeup_device_power(adev, target_state); 709dee8370cSRafael J. Wysocki if (error) 710dee8370cSRafael J. Wysocki return error; 711dee8370cSRafael J. Wysocki 712dee8370cSRafael J. Wysocki res = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number); 713235d81a6SRafael J. Wysocki if (ACPI_FAILURE(res)) { 714dee8370cSRafael J. Wysocki acpi_disable_wakeup_device_power(adev); 715dee8370cSRafael J. Wysocki return -EIO; 716dee8370cSRafael J. Wysocki } 717235d81a6SRafael J. Wysocki adev->wakeup.flags.enabled = 1; 718235d81a6SRafael J. Wysocki } else if (adev->wakeup.flags.enabled) { 719dee8370cSRafael J. Wysocki acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number); 720dee8370cSRafael J. Wysocki acpi_disable_wakeup_device_power(adev); 721235d81a6SRafael J. Wysocki adev->wakeup.flags.enabled = 0; 722dee8370cSRafael J. Wysocki } 723dee8370cSRafael J. Wysocki return 0; 724dee8370cSRafael J. Wysocki } 725dee8370cSRafael J. Wysocki 726dee8370cSRafael J. Wysocki /** 7274d183d04SRafael J. Wysocki * acpi_pm_set_device_wakeup - Enable/disable remote wakeup for given device. 7284d183d04SRafael J. Wysocki * @dev: Device to enable/disable to generate wakeup events. 729dee8370cSRafael J. Wysocki * @enable: Whether to enable or disable the wakeup functionality. 730cd7bd02dSRafael J. Wysocki */ 7314d183d04SRafael J. Wysocki int acpi_pm_set_device_wakeup(struct device *dev, bool enable) 732a6ae7594SRafael J. Wysocki { 733a6ae7594SRafael J. Wysocki struct acpi_device *adev; 734a6ae7594SRafael J. Wysocki int error; 735a6ae7594SRafael J. Wysocki 73617653a3eSRafael J. Wysocki adev = ACPI_COMPANION(dev); 73717653a3eSRafael J. Wysocki if (!adev) { 73817653a3eSRafael J. Wysocki dev_dbg(dev, "ACPI companion missing in %s!\n", __func__); 739a6ae7594SRafael J. Wysocki return -ENODEV; 740a6ae7594SRafael J. Wysocki } 741a6ae7594SRafael J. Wysocki 7424d183d04SRafael J. Wysocki if (!acpi_device_can_wakeup(adev)) 7434d183d04SRafael J. Wysocki return -EINVAL; 7444d183d04SRafael J. Wysocki 745f35cec25SRafael J. Wysocki error = acpi_device_wakeup(adev, acpi_target_system_state(), enable); 746a6ae7594SRafael J. Wysocki if (!error) 747*8370c2dcSRafael J. Wysocki dev_dbg(dev, "Wakeup %s by ACPI\n", enable ? "enabled" : "disabled"); 748a6ae7594SRafael J. Wysocki 749a6ae7594SRafael J. Wysocki return error; 750a6ae7594SRafael J. Wysocki } 7514d183d04SRafael J. Wysocki EXPORT_SYMBOL(acpi_pm_set_device_wakeup); 752e5cc8ef3SRafael J. Wysocki 753e5cc8ef3SRafael J. Wysocki /** 754e5cc8ef3SRafael J. Wysocki * acpi_dev_pm_low_power - Put ACPI device into a low-power state. 755e5cc8ef3SRafael J. Wysocki * @dev: Device to put into a low-power state. 756e5cc8ef3SRafael J. Wysocki * @adev: ACPI device node corresponding to @dev. 757e5cc8ef3SRafael J. Wysocki * @system_state: System state to choose the device state for. 758e5cc8ef3SRafael J. Wysocki */ 759e5cc8ef3SRafael J. Wysocki static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev, 760e5cc8ef3SRafael J. Wysocki u32 system_state) 761e5cc8ef3SRafael J. Wysocki { 762fa1675b5SRafael J. Wysocki int ret, state; 763e5cc8ef3SRafael J. Wysocki 764e5cc8ef3SRafael J. Wysocki if (!acpi_device_power_manageable(adev)) 765e5cc8ef3SRafael J. Wysocki return 0; 766e5cc8ef3SRafael J. Wysocki 767fa1675b5SRafael J. Wysocki ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state); 768fa1675b5SRafael J. Wysocki return ret ? ret : acpi_device_set_power(adev, state); 769e5cc8ef3SRafael J. Wysocki } 770e5cc8ef3SRafael J. Wysocki 771e5cc8ef3SRafael J. Wysocki /** 772e5cc8ef3SRafael J. Wysocki * acpi_dev_pm_full_power - Put ACPI device into the full-power state. 773e5cc8ef3SRafael J. Wysocki * @adev: ACPI device node to put into the full-power state. 774e5cc8ef3SRafael J. Wysocki */ 775e5cc8ef3SRafael J. Wysocki static int acpi_dev_pm_full_power(struct acpi_device *adev) 776e5cc8ef3SRafael J. Wysocki { 777e5cc8ef3SRafael J. Wysocki return acpi_device_power_manageable(adev) ? 778e5cc8ef3SRafael J. Wysocki acpi_device_set_power(adev, ACPI_STATE_D0) : 0; 779e5cc8ef3SRafael J. Wysocki } 780e5cc8ef3SRafael J. Wysocki 781e5cc8ef3SRafael J. Wysocki /** 782e5cc8ef3SRafael J. Wysocki * acpi_dev_runtime_suspend - Put device into a low-power state using ACPI. 783e5cc8ef3SRafael J. Wysocki * @dev: Device to put into a low-power state. 784e5cc8ef3SRafael J. Wysocki * 785e5cc8ef3SRafael J. Wysocki * Put the given device into a runtime low-power state using the standard ACPI 786e5cc8ef3SRafael J. Wysocki * mechanism. Set up remote wakeup if desired, choose the state to put the 787e5cc8ef3SRafael J. Wysocki * device into (this checks if remote wakeup is expected to work too), and set 788e5cc8ef3SRafael J. Wysocki * the power state of the device. 789e5cc8ef3SRafael J. Wysocki */ 790e5cc8ef3SRafael J. Wysocki int acpi_dev_runtime_suspend(struct device *dev) 791e5cc8ef3SRafael J. Wysocki { 79279c0373fSRafael J. Wysocki struct acpi_device *adev = ACPI_COMPANION(dev); 793e5cc8ef3SRafael J. Wysocki bool remote_wakeup; 794e5cc8ef3SRafael J. Wysocki int error; 795e5cc8ef3SRafael J. Wysocki 796e5cc8ef3SRafael J. Wysocki if (!adev) 797e5cc8ef3SRafael J. Wysocki return 0; 798e5cc8ef3SRafael J. Wysocki 799e5cc8ef3SRafael J. Wysocki remote_wakeup = dev_pm_qos_flags(dev, PM_QOS_FLAG_REMOTE_WAKEUP) > 800e5cc8ef3SRafael J. Wysocki PM_QOS_FLAGS_NONE; 801f35cec25SRafael J. Wysocki error = acpi_device_wakeup(adev, ACPI_STATE_S0, remote_wakeup); 802e5cc8ef3SRafael J. Wysocki if (remote_wakeup && error) 803e5cc8ef3SRafael J. Wysocki return -EAGAIN; 804e5cc8ef3SRafael J. Wysocki 805e5cc8ef3SRafael J. Wysocki error = acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0); 806e5cc8ef3SRafael J. Wysocki if (error) 807f35cec25SRafael J. Wysocki acpi_device_wakeup(adev, ACPI_STATE_S0, false); 808e5cc8ef3SRafael J. Wysocki 809e5cc8ef3SRafael J. Wysocki return error; 810e5cc8ef3SRafael J. Wysocki } 811e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_dev_runtime_suspend); 812e5cc8ef3SRafael J. Wysocki 813e5cc8ef3SRafael J. Wysocki /** 814e5cc8ef3SRafael J. Wysocki * acpi_dev_runtime_resume - Put device into the full-power state using ACPI. 815e5cc8ef3SRafael J. Wysocki * @dev: Device to put into the full-power state. 816e5cc8ef3SRafael J. Wysocki * 817e5cc8ef3SRafael J. Wysocki * Put the given device into the full-power state using the standard ACPI 818e5cc8ef3SRafael J. Wysocki * mechanism at run time. Set the power state of the device to ACPI D0 and 819e5cc8ef3SRafael J. Wysocki * disable remote wakeup. 820e5cc8ef3SRafael J. Wysocki */ 821e5cc8ef3SRafael J. Wysocki int acpi_dev_runtime_resume(struct device *dev) 822e5cc8ef3SRafael J. Wysocki { 82379c0373fSRafael J. Wysocki struct acpi_device *adev = ACPI_COMPANION(dev); 824e5cc8ef3SRafael J. Wysocki int error; 825e5cc8ef3SRafael J. Wysocki 826e5cc8ef3SRafael J. Wysocki if (!adev) 827e5cc8ef3SRafael J. Wysocki return 0; 828e5cc8ef3SRafael J. Wysocki 829e5cc8ef3SRafael J. Wysocki error = acpi_dev_pm_full_power(adev); 830f35cec25SRafael J. Wysocki acpi_device_wakeup(adev, ACPI_STATE_S0, false); 831e5cc8ef3SRafael J. Wysocki return error; 832e5cc8ef3SRafael J. Wysocki } 833e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_dev_runtime_resume); 834e5cc8ef3SRafael J. Wysocki 835e5cc8ef3SRafael J. Wysocki /** 836e5cc8ef3SRafael J. Wysocki * acpi_subsys_runtime_suspend - Suspend device using ACPI. 837e5cc8ef3SRafael J. Wysocki * @dev: Device to suspend. 838e5cc8ef3SRafael J. Wysocki * 839e5cc8ef3SRafael J. Wysocki * Carry out the generic runtime suspend procedure for @dev and use ACPI to put 840e5cc8ef3SRafael J. Wysocki * it into a runtime low-power state. 841e5cc8ef3SRafael J. Wysocki */ 842e5cc8ef3SRafael J. Wysocki int acpi_subsys_runtime_suspend(struct device *dev) 843e5cc8ef3SRafael J. Wysocki { 844e5cc8ef3SRafael J. Wysocki int ret = pm_generic_runtime_suspend(dev); 845e5cc8ef3SRafael J. Wysocki return ret ? ret : acpi_dev_runtime_suspend(dev); 846e5cc8ef3SRafael J. Wysocki } 847e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend); 848e5cc8ef3SRafael J. Wysocki 849e5cc8ef3SRafael J. Wysocki /** 850e5cc8ef3SRafael J. Wysocki * acpi_subsys_runtime_resume - Resume device using ACPI. 851e5cc8ef3SRafael J. Wysocki * @dev: Device to Resume. 852e5cc8ef3SRafael J. Wysocki * 853e5cc8ef3SRafael J. Wysocki * Use ACPI to put the given device into the full-power state and carry out the 854e5cc8ef3SRafael J. Wysocki * generic runtime resume procedure for it. 855e5cc8ef3SRafael J. Wysocki */ 856e5cc8ef3SRafael J. Wysocki int acpi_subsys_runtime_resume(struct device *dev) 857e5cc8ef3SRafael J. Wysocki { 858e5cc8ef3SRafael J. Wysocki int ret = acpi_dev_runtime_resume(dev); 859e5cc8ef3SRafael J. Wysocki return ret ? ret : pm_generic_runtime_resume(dev); 860e5cc8ef3SRafael J. Wysocki } 861e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume); 862e5cc8ef3SRafael J. Wysocki 863e5cc8ef3SRafael J. Wysocki #ifdef CONFIG_PM_SLEEP 864e5cc8ef3SRafael J. Wysocki /** 865e5cc8ef3SRafael J. Wysocki * acpi_dev_suspend_late - Put device into a low-power state using ACPI. 866e5cc8ef3SRafael J. Wysocki * @dev: Device to put into a low-power state. 867e5cc8ef3SRafael J. Wysocki * 868e5cc8ef3SRafael J. Wysocki * Put the given device into a low-power state during system transition to a 869e5cc8ef3SRafael J. Wysocki * sleep state using the standard ACPI mechanism. Set up system wakeup if 870e5cc8ef3SRafael J. Wysocki * desired, choose the state to put the device into (this checks if system 871e5cc8ef3SRafael J. Wysocki * wakeup is expected to work too), and set the power state of the device. 872e5cc8ef3SRafael J. Wysocki */ 873e5cc8ef3SRafael J. Wysocki int acpi_dev_suspend_late(struct device *dev) 874e5cc8ef3SRafael J. Wysocki { 87579c0373fSRafael J. Wysocki struct acpi_device *adev = ACPI_COMPANION(dev); 876e5cc8ef3SRafael J. Wysocki u32 target_state; 877e5cc8ef3SRafael J. Wysocki bool wakeup; 878e5cc8ef3SRafael J. Wysocki int error; 879e5cc8ef3SRafael J. Wysocki 880e5cc8ef3SRafael J. Wysocki if (!adev) 881e5cc8ef3SRafael J. Wysocki return 0; 882e5cc8ef3SRafael J. Wysocki 883e5cc8ef3SRafael J. Wysocki target_state = acpi_target_system_state(); 88478579b7cSRafael J. Wysocki wakeup = device_may_wakeup(dev) && acpi_device_can_wakeup(adev); 885f35cec25SRafael J. Wysocki error = acpi_device_wakeup(adev, target_state, wakeup); 886e5cc8ef3SRafael J. Wysocki if (wakeup && error) 887e5cc8ef3SRafael J. Wysocki return error; 888e5cc8ef3SRafael J. Wysocki 889e5cc8ef3SRafael J. Wysocki error = acpi_dev_pm_low_power(dev, adev, target_state); 890e5cc8ef3SRafael J. Wysocki if (error) 891f35cec25SRafael J. Wysocki acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false); 892e5cc8ef3SRafael J. Wysocki 893e5cc8ef3SRafael J. Wysocki return error; 894e5cc8ef3SRafael J. Wysocki } 895e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_dev_suspend_late); 896e5cc8ef3SRafael J. Wysocki 897e5cc8ef3SRafael J. Wysocki /** 898e5cc8ef3SRafael J. Wysocki * acpi_dev_resume_early - Put device into the full-power state using ACPI. 899e5cc8ef3SRafael J. Wysocki * @dev: Device to put into the full-power state. 900e5cc8ef3SRafael J. Wysocki * 901e5cc8ef3SRafael J. Wysocki * Put the given device into the full-power state using the standard ACPI 902e5cc8ef3SRafael J. Wysocki * mechanism during system transition to the working state. Set the power 903e5cc8ef3SRafael J. Wysocki * state of the device to ACPI D0 and disable remote wakeup. 904e5cc8ef3SRafael J. Wysocki */ 905e5cc8ef3SRafael J. Wysocki int acpi_dev_resume_early(struct device *dev) 906e5cc8ef3SRafael J. Wysocki { 90779c0373fSRafael J. Wysocki struct acpi_device *adev = ACPI_COMPANION(dev); 908e5cc8ef3SRafael J. Wysocki int error; 909e5cc8ef3SRafael J. Wysocki 910e5cc8ef3SRafael J. Wysocki if (!adev) 911e5cc8ef3SRafael J. Wysocki return 0; 912e5cc8ef3SRafael J. Wysocki 913e5cc8ef3SRafael J. Wysocki error = acpi_dev_pm_full_power(adev); 914f35cec25SRafael J. Wysocki acpi_device_wakeup(adev, ACPI_STATE_UNKNOWN, false); 915e5cc8ef3SRafael J. Wysocki return error; 916e5cc8ef3SRafael J. Wysocki } 917e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_dev_resume_early); 918e5cc8ef3SRafael J. Wysocki 919e5cc8ef3SRafael J. Wysocki /** 920e5cc8ef3SRafael J. Wysocki * acpi_subsys_prepare - Prepare device for system transition to a sleep state. 921e5cc8ef3SRafael J. Wysocki * @dev: Device to prepare. 922e5cc8ef3SRafael J. Wysocki */ 923e5cc8ef3SRafael J. Wysocki int acpi_subsys_prepare(struct device *dev) 924e5cc8ef3SRafael J. Wysocki { 925f25c0ae2SRafael J. Wysocki struct acpi_device *adev = ACPI_COMPANION(dev); 926f25c0ae2SRafael J. Wysocki u32 sys_target; 927f25c0ae2SRafael J. Wysocki int ret, state; 92892858c47SRafael J. Wysocki 929f25c0ae2SRafael J. Wysocki ret = pm_generic_prepare(dev); 930f25c0ae2SRafael J. Wysocki if (ret < 0) 931f25c0ae2SRafael J. Wysocki return ret; 932f25c0ae2SRafael J. Wysocki 933f25c0ae2SRafael J. Wysocki if (!adev || !pm_runtime_suspended(dev) 934f25c0ae2SRafael J. Wysocki || device_may_wakeup(dev) != !!adev->wakeup.prepare_count) 935f25c0ae2SRafael J. Wysocki return 0; 936f25c0ae2SRafael J. Wysocki 937f25c0ae2SRafael J. Wysocki sys_target = acpi_target_system_state(); 938f25c0ae2SRafael J. Wysocki if (sys_target == ACPI_STATE_S0) 939f25c0ae2SRafael J. Wysocki return 1; 940f25c0ae2SRafael J. Wysocki 941f25c0ae2SRafael J. Wysocki if (adev->power.flags.dsw_present) 942f25c0ae2SRafael J. Wysocki return 0; 943f25c0ae2SRafael J. Wysocki 944f25c0ae2SRafael J. Wysocki ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state); 945f25c0ae2SRafael J. Wysocki return !ret && state == adev->power.state; 946e5cc8ef3SRafael J. Wysocki } 947e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_subsys_prepare); 948e5cc8ef3SRafael J. Wysocki 949e5cc8ef3SRafael J. Wysocki /** 95092858c47SRafael J. Wysocki * acpi_subsys_suspend - Run the device driver's suspend callback. 95192858c47SRafael J. Wysocki * @dev: Device to handle. 95292858c47SRafael J. Wysocki * 95392858c47SRafael J. Wysocki * Follow PCI and resume devices suspended at run time before running their 95492858c47SRafael J. Wysocki * system suspend callbacks. 95592858c47SRafael J. Wysocki */ 95692858c47SRafael J. Wysocki int acpi_subsys_suspend(struct device *dev) 95792858c47SRafael J. Wysocki { 95892858c47SRafael J. Wysocki pm_runtime_resume(dev); 95992858c47SRafael J. Wysocki return pm_generic_suspend(dev); 96092858c47SRafael J. Wysocki } 9614cf563c5SHeikki Krogerus EXPORT_SYMBOL_GPL(acpi_subsys_suspend); 96292858c47SRafael J. Wysocki 96392858c47SRafael J. Wysocki /** 964e5cc8ef3SRafael J. Wysocki * acpi_subsys_suspend_late - Suspend device using ACPI. 965e5cc8ef3SRafael J. Wysocki * @dev: Device to suspend. 966e5cc8ef3SRafael J. Wysocki * 967e5cc8ef3SRafael J. Wysocki * Carry out the generic late suspend procedure for @dev and use ACPI to put 968e5cc8ef3SRafael J. Wysocki * it into a low-power state during system transition into a sleep state. 969e5cc8ef3SRafael J. Wysocki */ 970e5cc8ef3SRafael J. Wysocki int acpi_subsys_suspend_late(struct device *dev) 971e5cc8ef3SRafael J. Wysocki { 972e5cc8ef3SRafael J. Wysocki int ret = pm_generic_suspend_late(dev); 973e5cc8ef3SRafael J. Wysocki return ret ? ret : acpi_dev_suspend_late(dev); 974e5cc8ef3SRafael J. Wysocki } 975e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late); 976e5cc8ef3SRafael J. Wysocki 977e5cc8ef3SRafael J. Wysocki /** 978e5cc8ef3SRafael J. Wysocki * acpi_subsys_resume_early - Resume device using ACPI. 979e5cc8ef3SRafael J. Wysocki * @dev: Device to Resume. 980e5cc8ef3SRafael J. Wysocki * 981e5cc8ef3SRafael J. Wysocki * Use ACPI to put the given device into the full-power state and carry out the 982e5cc8ef3SRafael J. Wysocki * generic early resume procedure for it during system transition into the 983e5cc8ef3SRafael J. Wysocki * working state. 984e5cc8ef3SRafael J. Wysocki */ 985e5cc8ef3SRafael J. Wysocki int acpi_subsys_resume_early(struct device *dev) 986e5cc8ef3SRafael J. Wysocki { 987e5cc8ef3SRafael J. Wysocki int ret = acpi_dev_resume_early(dev); 988e5cc8ef3SRafael J. Wysocki return ret ? ret : pm_generic_resume_early(dev); 989e5cc8ef3SRafael J. Wysocki } 990e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_subsys_resume_early); 99192858c47SRafael J. Wysocki 99292858c47SRafael J. Wysocki /** 99392858c47SRafael J. Wysocki * acpi_subsys_freeze - Run the device driver's freeze callback. 99492858c47SRafael J. Wysocki * @dev: Device to handle. 99592858c47SRafael J. Wysocki */ 99692858c47SRafael J. Wysocki int acpi_subsys_freeze(struct device *dev) 99792858c47SRafael J. Wysocki { 99892858c47SRafael J. Wysocki /* 99992858c47SRafael J. Wysocki * This used to be done in acpi_subsys_prepare() for all devices and 100092858c47SRafael J. Wysocki * some drivers may depend on it, so do it here. Ideally, however, 100192858c47SRafael J. Wysocki * runtime-suspended devices should not be touched during freeze/thaw 100292858c47SRafael J. Wysocki * transitions. 100392858c47SRafael J. Wysocki */ 100492858c47SRafael J. Wysocki pm_runtime_resume(dev); 100592858c47SRafael J. Wysocki return pm_generic_freeze(dev); 100692858c47SRafael J. Wysocki } 10074cf563c5SHeikki Krogerus EXPORT_SYMBOL_GPL(acpi_subsys_freeze); 100892858c47SRafael J. Wysocki 1009e5cc8ef3SRafael J. Wysocki #endif /* CONFIG_PM_SLEEP */ 1010e5cc8ef3SRafael J. Wysocki 1011e5cc8ef3SRafael J. Wysocki static struct dev_pm_domain acpi_general_pm_domain = { 1012e5cc8ef3SRafael J. Wysocki .ops = { 1013e5cc8ef3SRafael J. Wysocki .runtime_suspend = acpi_subsys_runtime_suspend, 1014e5cc8ef3SRafael J. Wysocki .runtime_resume = acpi_subsys_runtime_resume, 1015e5cc8ef3SRafael J. Wysocki #ifdef CONFIG_PM_SLEEP 1016e5cc8ef3SRafael J. Wysocki .prepare = acpi_subsys_prepare, 101758a1fbbbSRafael J. Wysocki .complete = pm_complete_with_resume_check, 101892858c47SRafael J. Wysocki .suspend = acpi_subsys_suspend, 1019e5cc8ef3SRafael J. Wysocki .suspend_late = acpi_subsys_suspend_late, 1020e5cc8ef3SRafael J. Wysocki .resume_early = acpi_subsys_resume_early, 102192858c47SRafael J. Wysocki .freeze = acpi_subsys_freeze, 102292858c47SRafael J. Wysocki .poweroff = acpi_subsys_suspend, 1023e5cc8ef3SRafael J. Wysocki .poweroff_late = acpi_subsys_suspend_late, 1024e5cc8ef3SRafael J. Wysocki .restore_early = acpi_subsys_resume_early, 1025e5cc8ef3SRafael J. Wysocki #endif 1026e5cc8ef3SRafael J. Wysocki }, 1027e5cc8ef3SRafael J. Wysocki }; 1028e5cc8ef3SRafael J. Wysocki 1029e5cc8ef3SRafael J. Wysocki /** 103091d66cd2SUlf Hansson * acpi_dev_pm_detach - Remove ACPI power management from the device. 103191d66cd2SUlf Hansson * @dev: Device to take care of. 103291d66cd2SUlf Hansson * @power_off: Whether or not to try to remove power from the device. 103391d66cd2SUlf Hansson * 103491d66cd2SUlf Hansson * Remove the device from the general ACPI PM domain and remove its wakeup 103591d66cd2SUlf Hansson * notifier. If @power_off is set, additionally remove power from the device if 103691d66cd2SUlf Hansson * possible. 103791d66cd2SUlf Hansson * 103891d66cd2SUlf Hansson * Callers must ensure proper synchronization of this function with power 103991d66cd2SUlf Hansson * management callbacks. 104091d66cd2SUlf Hansson */ 104191d66cd2SUlf Hansson static void acpi_dev_pm_detach(struct device *dev, bool power_off) 104291d66cd2SUlf Hansson { 104391d66cd2SUlf Hansson struct acpi_device *adev = ACPI_COMPANION(dev); 104491d66cd2SUlf Hansson 104591d66cd2SUlf Hansson if (adev && dev->pm_domain == &acpi_general_pm_domain) { 1046989561deSTomeu Vizoso dev_pm_domain_set(dev, NULL); 104791d66cd2SUlf Hansson acpi_remove_pm_notifier(adev); 104891d66cd2SUlf Hansson if (power_off) { 104991d66cd2SUlf Hansson /* 105091d66cd2SUlf Hansson * If the device's PM QoS resume latency limit or flags 105191d66cd2SUlf Hansson * have been exposed to user space, they have to be 105291d66cd2SUlf Hansson * hidden at this point, so that they don't affect the 105391d66cd2SUlf Hansson * choice of the low-power state to put the device into. 105491d66cd2SUlf Hansson */ 105591d66cd2SUlf Hansson dev_pm_qos_hide_latency_limit(dev); 105691d66cd2SUlf Hansson dev_pm_qos_hide_flags(dev); 105791d66cd2SUlf Hansson acpi_device_wakeup(adev, ACPI_STATE_S0, false); 105891d66cd2SUlf Hansson acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0); 105991d66cd2SUlf Hansson } 106091d66cd2SUlf Hansson } 106191d66cd2SUlf Hansson } 106291d66cd2SUlf Hansson 106391d66cd2SUlf Hansson /** 1064e5cc8ef3SRafael J. Wysocki * acpi_dev_pm_attach - Prepare device for ACPI power management. 1065e5cc8ef3SRafael J. Wysocki * @dev: Device to prepare. 1066b88ce2a4SRafael J. Wysocki * @power_on: Whether or not to power on the device. 1067e5cc8ef3SRafael J. Wysocki * 1068e5cc8ef3SRafael J. Wysocki * If @dev has a valid ACPI handle that has a valid struct acpi_device object 1069e5cc8ef3SRafael J. Wysocki * attached to it, install a wakeup notification handler for the device and 1070b88ce2a4SRafael J. Wysocki * add it to the general ACPI PM domain. If @power_on is set, the device will 1071b88ce2a4SRafael J. Wysocki * be put into the ACPI D0 state before the function returns. 1072e5cc8ef3SRafael J. Wysocki * 1073e5cc8ef3SRafael J. Wysocki * This assumes that the @dev's bus type uses generic power management callbacks 1074e5cc8ef3SRafael J. Wysocki * (or doesn't use any power management callbacks at all). 1075e5cc8ef3SRafael J. Wysocki * 1076e5cc8ef3SRafael J. Wysocki * Callers must ensure proper synchronization of this function with power 1077e5cc8ef3SRafael J. Wysocki * management callbacks. 1078e5cc8ef3SRafael J. Wysocki */ 1079b88ce2a4SRafael J. Wysocki int acpi_dev_pm_attach(struct device *dev, bool power_on) 1080e5cc8ef3SRafael J. Wysocki { 108179c0373fSRafael J. Wysocki struct acpi_device *adev = ACPI_COMPANION(dev); 1082e5cc8ef3SRafael J. Wysocki 1083e5cc8ef3SRafael J. Wysocki if (!adev) 1084e5cc8ef3SRafael J. Wysocki return -ENODEV; 1085e5cc8ef3SRafael J. Wysocki 1086e5cc8ef3SRafael J. Wysocki if (dev->pm_domain) 1087e5cc8ef3SRafael J. Wysocki return -EEXIST; 1088e5cc8ef3SRafael J. Wysocki 1089712e960fSMika Westerberg /* 1090712e960fSMika Westerberg * Only attach the power domain to the first device if the 1091712e960fSMika Westerberg * companion is shared by multiple. This is to prevent doing power 1092712e960fSMika Westerberg * management twice. 1093712e960fSMika Westerberg */ 1094712e960fSMika Westerberg if (!acpi_device_is_first_physical_node(adev, dev)) 1095712e960fSMika Westerberg return -EBUSY; 1096712e960fSMika Westerberg 1097c072530fSRafael J. Wysocki acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func); 1098989561deSTomeu Vizoso dev_pm_domain_set(dev, &acpi_general_pm_domain); 1099b88ce2a4SRafael J. Wysocki if (power_on) { 1100b88ce2a4SRafael J. Wysocki acpi_dev_pm_full_power(adev); 1101f35cec25SRafael J. Wysocki acpi_device_wakeup(adev, ACPI_STATE_S0, false); 1102b88ce2a4SRafael J. Wysocki } 110386f1e15fSUlf Hansson 110486f1e15fSUlf Hansson dev->pm_domain->detach = acpi_dev_pm_detach; 1105e5cc8ef3SRafael J. Wysocki return 0; 1106e5cc8ef3SRafael J. Wysocki } 1107e5cc8ef3SRafael J. Wysocki EXPORT_SYMBOL_GPL(acpi_dev_pm_attach); 1108ec4602a9SRafael J. Wysocki #endif /* CONFIG_PM */ 1109