LCOV - code coverage report
Current view: top level - drivers/acpi - device_pm.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 25 447 5.6 %
Date: 2022-04-01 14:35:51 Functions: 3 44 6.8 %
Branches: 7 362 1.9 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * drivers/acpi/device_pm.c - ACPI device power management routines.
       4                 :            :  *
       5                 :            :  * Copyright (C) 2012, Intel Corp.
       6                 :            :  * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
       7                 :            :  *
       8                 :            :  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       9                 :            :  *
      10                 :            :  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      11                 :            :  */
      12                 :            : 
      13                 :            : #include <linux/acpi.h>
      14                 :            : #include <linux/export.h>
      15                 :            : #include <linux/mutex.h>
      16                 :            : #include <linux/pm_qos.h>
      17                 :            : #include <linux/pm_domain.h>
      18                 :            : #include <linux/pm_runtime.h>
      19                 :            : #include <linux/suspend.h>
      20                 :            : 
      21                 :            : #include "internal.h"
      22                 :            : 
      23                 :            : #define _COMPONENT      ACPI_POWER_COMPONENT
      24                 :            : ACPI_MODULE_NAME("device_pm");
      25                 :            : 
      26                 :            : /**
      27                 :            :  * acpi_power_state_string - String representation of ACPI device power state.
      28                 :            :  * @state: ACPI device power state to return the string representation of.
      29                 :            :  */
      30                 :          0 : const char *acpi_power_state_string(int state)
      31                 :            : {
      32         [ #  # ]:          0 :         switch (state) {
      33                 :            :         case ACPI_STATE_D0:
      34                 :            :                 return "D0";
      35                 :            :         case ACPI_STATE_D1:
      36                 :            :                 return "D1";
      37                 :            :         case ACPI_STATE_D2:
      38                 :            :                 return "D2";
      39                 :            :         case ACPI_STATE_D3_HOT:
      40                 :            :                 return "D3hot";
      41                 :            :         case ACPI_STATE_D3_COLD:
      42                 :            :                 return "D3cold";
      43                 :            :         default:
      44                 :            :                 return "(unknown)";
      45                 :            :         }
      46                 :            : }
      47                 :            : 
      48                 :          0 : static int acpi_dev_pm_explicit_get(struct acpi_device *device, int *state)
      49                 :            : {
      50                 :          0 :         unsigned long long psc;
      51                 :          0 :         acpi_status status;
      52                 :            : 
      53                 :          0 :         status = acpi_evaluate_integer(device->handle, "_PSC", NULL, &psc);
      54   [ #  #  #  # ]:          0 :         if (ACPI_FAILURE(status))
      55                 :            :                 return -ENODEV;
      56                 :            : 
      57                 :          0 :         *state = psc;
      58                 :          0 :         return 0;
      59                 :            : }
      60                 :            : 
      61                 :            : /**
      62                 :            :  * acpi_device_get_power - Get power state of an ACPI device.
      63                 :            :  * @device: Device to get the power state of.
      64                 :            :  * @state: Place to store the power state of the device.
      65                 :            :  *
      66                 :            :  * This function does not update the device's power.state field, but it may
      67                 :            :  * update its parent's power.state field (when the parent's power state is
      68                 :            :  * unknown and the device's power state turns out to be D0).
      69                 :            :  *
      70                 :            :  * Also, it does not update power resource reference counters to ensure that
      71                 :            :  * the power state returned by it will be persistent and it may return a power
      72                 :            :  * state shallower than previously set by acpi_device_set_power() for @device
      73                 :            :  * (if that power state depends on any power resources).
      74                 :            :  */
      75                 :          0 : int acpi_device_get_power(struct acpi_device *device, int *state)
      76                 :            : {
      77                 :          0 :         int result = ACPI_STATE_UNKNOWN;
      78                 :          0 :         int error;
      79                 :            : 
      80         [ #  # ]:          0 :         if (!device || !state)
      81                 :            :                 return -EINVAL;
      82                 :            : 
      83         [ #  # ]:          0 :         if (!device->flags.power_manageable) {
      84                 :            :                 /* TBD: Non-recursive algorithm for walking up hierarchy. */
      85                 :          0 :                 *state = device->parent ?
      86         [ #  # ]:          0 :                         device->parent->power.state : ACPI_STATE_D0;
      87                 :          0 :                 goto out;
      88                 :            :         }
      89                 :            : 
      90                 :            :         /*
      91                 :            :          * Get the device's power state from power resources settings and _PSC,
      92                 :            :          * if available.
      93                 :            :          */
      94         [ #  # ]:          0 :         if (device->power.flags.power_resources) {
      95                 :          0 :                 error = acpi_power_get_inferred_state(device, &result);
      96         [ #  # ]:          0 :                 if (error)
      97                 :            :                         return error;
      98                 :            :         }
      99         [ #  # ]:          0 :         if (device->power.flags.explicit_get) {
     100                 :          0 :                 int psc;
     101                 :            : 
     102                 :          0 :                 error = acpi_dev_pm_explicit_get(device, &psc);
     103                 :          0 :                 if (error)
     104                 :          0 :                         return error;
     105                 :            : 
     106                 :            :                 /*
     107                 :            :                  * The power resources settings may indicate a power state
     108                 :            :                  * shallower than the actual power state of the device, because
     109                 :            :                  * the same power resources may be referenced by other devices.
     110                 :            :                  *
     111                 :            :                  * For systems predating ACPI 4.0 we assume that D3hot is the
     112                 :            :                  * deepest state that can be supported.
     113                 :            :                  */
     114   [ #  #  #  # ]:          0 :                 if (psc > result && psc < ACPI_STATE_D3_COLD)
     115                 :          0 :                         result = psc;
     116         [ #  # ]:          0 :                 else if (result == ACPI_STATE_UNKNOWN)
     117                 :          0 :                         result = psc > ACPI_STATE_D2 ? ACPI_STATE_D3_HOT : psc;
     118                 :            :         }
     119                 :            : 
     120                 :            :         /*
     121                 :            :          * If we were unsure about the device parent's power state up to this
     122                 :            :          * point, the fact that the device is in D0 implies that the parent has
     123                 :            :          * to be in D0 too, except if ignore_parent is set.
     124                 :            :          */
     125   [ #  #  #  # ]:          0 :         if (!device->power.flags.ignore_parent && device->parent
     126         [ #  # ]:          0 :             && device->parent->power.state == ACPI_STATE_UNKNOWN
     127         [ #  # ]:          0 :             && result == ACPI_STATE_D0)
     128                 :          0 :                 device->parent->power.state = ACPI_STATE_D0;
     129                 :            : 
     130                 :          0 :         *state = result;
     131                 :            : 
     132                 :            :  out:
     133                 :            :         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is %s\n",
     134                 :            :                           device->pnp.bus_id, acpi_power_state_string(*state)));
     135                 :            : 
     136                 :            :         return 0;
     137                 :            : }
     138                 :            : 
     139                 :          0 : static int acpi_dev_pm_explicit_set(struct acpi_device *adev, int state)
     140                 :            : {
     141         [ #  # ]:          0 :         if (adev->power.states[state].flags.explicit_set) {
     142                 :          0 :                 char method[5] = { '_', 'P', 'S', '0' + state, '\0' };
     143                 :          0 :                 acpi_status status;
     144                 :            : 
     145                 :          0 :                 status = acpi_evaluate_object(adev->handle, method, NULL, NULL);
     146         [ #  # ]:          0 :                 if (ACPI_FAILURE(status))
     147                 :          0 :                         return -ENODEV;
     148                 :            :         }
     149                 :            :         return 0;
     150                 :            : }
     151                 :            : 
     152                 :            : /**
     153                 :            :  * acpi_device_set_power - Set power state of an ACPI device.
     154                 :            :  * @device: Device to set the power state of.
     155                 :            :  * @state: New power state to set.
     156                 :            :  *
     157                 :            :  * Callers must ensure that the device is power manageable before using this
     158                 :            :  * function.
     159                 :            :  */
     160                 :          0 : int acpi_device_set_power(struct acpi_device *device, int state)
     161                 :            : {
     162                 :          0 :         int target_state = state;
     163                 :          0 :         int result = 0;
     164                 :            : 
     165   [ #  #  #  # ]:          0 :         if (!device || !device->flags.power_manageable
     166         [ #  # ]:          0 :             || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
     167                 :            :                 return -EINVAL;
     168                 :            : 
     169                 :          0 :         acpi_handle_debug(device->handle, "Power state change: %s -> %s\n",
     170                 :            :                           acpi_power_state_string(device->power.state),
     171                 :            :                           acpi_power_state_string(state));
     172                 :            : 
     173                 :            :         /* Make sure this is a valid target state */
     174                 :            : 
     175                 :            :         /* There is a special case for D0 addressed below. */
     176   [ #  #  #  # ]:          0 :         if (state > ACPI_STATE_D0 && state == device->power.state) {
     177                 :            :                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] already in %s\n",
     178                 :            :                                   device->pnp.bus_id,
     179                 :            :                                   acpi_power_state_string(state)));
     180                 :            :                 return 0;
     181                 :            :         }
     182                 :            : 
     183         [ #  # ]:          0 :         if (state == ACPI_STATE_D3_COLD) {
     184                 :            :                 /*
     185                 :            :                  * For transitions to D3cold we need to execute _PS3 and then
     186                 :            :                  * possibly drop references to the power resources in use.
     187                 :            :                  */
     188                 :          0 :                 state = ACPI_STATE_D3_HOT;
     189                 :            :                 /* If _PR3 is not available, use D3hot as the target state. */
     190                 :          0 :                 if (!device->power.states[ACPI_STATE_D3_COLD].flags.valid)
     191                 :            :                         target_state = state;
     192         [ #  # ]:          0 :         } else if (!device->power.states[state].flags.valid) {
     193                 :          0 :                 dev_warn(&device->dev, "Power state %s not supported\n",
     194                 :            :                          acpi_power_state_string(state));
     195                 :          0 :                 return -ENODEV;
     196                 :            :         }
     197                 :            : 
     198         [ #  # ]:          0 :         if (!device->power.flags.ignore_parent &&
     199   [ #  #  #  # ]:          0 :             device->parent && (state < device->parent->power.state)) {
     200         [ #  # ]:          0 :                 dev_warn(&device->dev,
     201                 :            :                          "Cannot transition to power state %s for parent in %s\n",
     202                 :            :                          acpi_power_state_string(state),
     203                 :            :                          acpi_power_state_string(device->parent->power.state));
     204                 :          0 :                 return -ENODEV;
     205                 :            :         }
     206                 :            : 
     207                 :            :         /*
     208                 :            :          * Transition Power
     209                 :            :          * ----------------
     210                 :            :          * In accordance with ACPI 6, _PSx is executed before manipulating power
     211                 :            :          * resources, unless the target state is D0, in which case _PS0 is
     212                 :            :          * supposed to be executed after turning the power resources on.
     213                 :            :          */
     214         [ #  # ]:          0 :         if (state > ACPI_STATE_D0) {
     215                 :            :                 /*
     216                 :            :                  * According to ACPI 6, devices cannot go from lower-power
     217                 :            :                  * (deeper) states to higher-power (shallower) states.
     218                 :            :                  */
     219         [ #  # ]:          0 :                 if (state < device->power.state) {
     220         [ #  # ]:          0 :                         dev_warn(&device->dev, "Cannot transition from %s to %s\n",
     221                 :            :                                  acpi_power_state_string(device->power.state),
     222                 :            :                                  acpi_power_state_string(state));
     223                 :          0 :                         return -ENODEV;
     224                 :            :                 }
     225                 :            : 
     226                 :            :                 /*
     227                 :            :                  * If the device goes from D3hot to D3cold, _PS3 has been
     228                 :            :                  * evaluated for it already, so skip it in that case.
     229                 :            :                  */
     230         [ #  # ]:          0 :                 if (device->power.state < ACPI_STATE_D3_HOT) {
     231                 :          0 :                         result = acpi_dev_pm_explicit_set(device, state);
     232         [ #  # ]:          0 :                         if (result)
     233                 :          0 :                                 goto end;
     234                 :            :                 }
     235                 :            : 
     236         [ #  # ]:          0 :                 if (device->power.flags.power_resources)
     237                 :          0 :                         result = acpi_power_transition(device, target_state);
     238                 :            :         } else {
     239                 :          0 :                 int cur_state = device->power.state;
     240                 :            : 
     241         [ #  # ]:          0 :                 if (device->power.flags.power_resources) {
     242                 :          0 :                         result = acpi_power_transition(device, ACPI_STATE_D0);
     243         [ #  # ]:          0 :                         if (result)
     244                 :          0 :                                 goto end;
     245                 :            :                 }
     246                 :            : 
     247         [ #  # ]:          0 :                 if (cur_state == ACPI_STATE_D0) {
     248                 :          0 :                         int psc;
     249                 :            : 
     250                 :            :                         /* Nothing to do here if _PSC is not present. */
     251         [ #  # ]:          0 :                         if (!device->power.flags.explicit_get)
     252                 :            :                                 return 0;
     253                 :            : 
     254                 :            :                         /*
     255                 :            :                          * The power state of the device was set to D0 last
     256                 :            :                          * time, but that might have happened before a
     257                 :            :                          * system-wide transition involving the platform
     258                 :            :                          * firmware, so it may be necessary to evaluate _PS0
     259                 :            :                          * for the device here.  However, use extra care here
     260                 :            :                          * and evaluate _PSC to check the device's current power
     261                 :            :                          * state, and only invoke _PS0 if the evaluation of _PSC
     262                 :            :                          * is successful and it returns a power state different
     263                 :            :                          * from D0.
     264                 :            :                          */
     265                 :          0 :                         result = acpi_dev_pm_explicit_get(device, &psc);
     266         [ #  # ]:          0 :                         if (result || psc == ACPI_STATE_D0)
     267                 :          0 :                                 return 0;
     268                 :            :                 }
     269                 :            : 
     270                 :          0 :                 result = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
     271                 :            :         }
     272                 :            : 
     273                 :          0 :  end:
     274         [ #  # ]:          0 :         if (result) {
     275                 :          0 :                 dev_warn(&device->dev, "Failed to change power state to %s\n",
     276                 :            :                          acpi_power_state_string(state));
     277                 :            :         } else {
     278                 :          0 :                 device->power.state = target_state;
     279                 :            :                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
     280                 :            :                                   "Device [%s] transitioned to %s\n",
     281                 :            :                                   device->pnp.bus_id,
     282                 :            :                                   acpi_power_state_string(state)));
     283                 :            :         }
     284                 :            : 
     285                 :            :         return result;
     286                 :            : }
     287                 :            : EXPORT_SYMBOL(acpi_device_set_power);
     288                 :            : 
     289                 :          0 : int acpi_bus_set_power(acpi_handle handle, int state)
     290                 :            : {
     291                 :          0 :         struct acpi_device *device;
     292                 :          0 :         int result;
     293                 :            : 
     294                 :          0 :         result = acpi_bus_get_device(handle, &device);
     295         [ #  # ]:          0 :         if (result)
     296                 :            :                 return result;
     297                 :            : 
     298                 :          0 :         return acpi_device_set_power(device, state);
     299                 :            : }
     300                 :            : EXPORT_SYMBOL(acpi_bus_set_power);
     301                 :            : 
     302                 :          0 : int acpi_bus_init_power(struct acpi_device *device)
     303                 :            : {
     304                 :          0 :         int state;
     305                 :          0 :         int result;
     306                 :            : 
     307         [ #  # ]:          0 :         if (!device)
     308                 :            :                 return -EINVAL;
     309                 :            : 
     310                 :          0 :         device->power.state = ACPI_STATE_UNKNOWN;
     311         [ #  # ]:          0 :         if (!acpi_device_is_present(device)) {
     312                 :          0 :                 device->flags.initialized = false;
     313                 :          0 :                 return -ENXIO;
     314                 :            :         }
     315                 :            : 
     316                 :          0 :         result = acpi_device_get_power(device, &state);
     317         [ #  # ]:          0 :         if (result)
     318                 :            :                 return result;
     319                 :            : 
     320   [ #  #  #  # ]:          0 :         if (state < ACPI_STATE_D3_COLD && device->power.flags.power_resources) {
     321                 :            :                 /* Reference count the power resources. */
     322                 :          0 :                 result = acpi_power_on_resources(device, state);
     323         [ #  # ]:          0 :                 if (result)
     324                 :            :                         return result;
     325                 :            : 
     326         [ #  # ]:          0 :                 if (state == ACPI_STATE_D0) {
     327                 :            :                         /*
     328                 :            :                          * If _PSC is not present and the state inferred from
     329                 :            :                          * power resources appears to be D0, it still may be
     330                 :            :                          * necessary to execute _PS0 at this point, because
     331                 :            :                          * another device using the same power resources may
     332                 :            :                          * have been put into D0 previously and that's why we
     333                 :            :                          * see D0 here.
     334                 :            :                          */
     335                 :          0 :                         result = acpi_dev_pm_explicit_set(device, state);
     336         [ #  # ]:          0 :                         if (result)
     337                 :            :                                 return result;
     338                 :            :                 }
     339         [ #  # ]:          0 :         } else if (state == ACPI_STATE_UNKNOWN) {
     340                 :            :                 /*
     341                 :            :                  * No power resources and missing _PSC?  Cross fingers and make
     342                 :            :                  * it D0 in hope that this is what the BIOS put the device into.
     343                 :            :                  * [We tried to force D0 here by executing _PS0, but that broke
     344                 :            :                  * Toshiba P870-303 in a nasty way.]
     345                 :            :                  */
     346                 :          0 :                 state = ACPI_STATE_D0;
     347                 :            :         }
     348                 :          0 :         device->power.state = state;
     349                 :          0 :         return 0;
     350                 :            : }
     351                 :            : 
     352                 :            : /**
     353                 :            :  * acpi_device_fix_up_power - Force device with missing _PSC into D0.
     354                 :            :  * @device: Device object whose power state is to be fixed up.
     355                 :            :  *
     356                 :            :  * Devices without power resources and _PSC, but having _PS0 and _PS3 defined,
     357                 :            :  * are assumed to be put into D0 by the BIOS.  However, in some cases that may
     358                 :            :  * not be the case and this function should be used then.
     359                 :            :  */
     360                 :          0 : int acpi_device_fix_up_power(struct acpi_device *device)
     361                 :            : {
     362                 :          0 :         int ret = 0;
     363                 :            : 
     364                 :          0 :         if (!device->power.flags.power_resources
     365                 :            :             && !device->power.flags.explicit_get
     366         [ #  # ]:          0 :             && device->power.state == ACPI_STATE_D0)
     367                 :          0 :                 ret = acpi_dev_pm_explicit_set(device, ACPI_STATE_D0);
     368                 :            : 
     369                 :          0 :         return ret;
     370                 :            : }
     371                 :            : EXPORT_SYMBOL_GPL(acpi_device_fix_up_power);
     372                 :            : 
     373                 :          0 : int acpi_device_update_power(struct acpi_device *device, int *state_p)
     374                 :            : {
     375                 :          0 :         int state;
     376                 :          0 :         int result;
     377                 :            : 
     378         [ #  # ]:          0 :         if (device->power.state == ACPI_STATE_UNKNOWN) {
     379                 :          0 :                 result = acpi_bus_init_power(device);
     380         [ #  # ]:          0 :                 if (!result && state_p)
     381                 :          0 :                         *state_p = device->power.state;
     382                 :            : 
     383                 :          0 :                 return result;
     384                 :            :         }
     385                 :            : 
     386                 :          0 :         result = acpi_device_get_power(device, &state);
     387         [ #  # ]:          0 :         if (result)
     388                 :            :                 return result;
     389                 :            : 
     390         [ #  # ]:          0 :         if (state == ACPI_STATE_UNKNOWN) {
     391                 :          0 :                 state = ACPI_STATE_D0;
     392                 :          0 :                 result = acpi_device_set_power(device, state);
     393         [ #  # ]:          0 :                 if (result)
     394                 :            :                         return result;
     395                 :            :         } else {
     396         [ #  # ]:          0 :                 if (device->power.flags.power_resources) {
     397                 :            :                         /*
     398                 :            :                          * We don't need to really switch the state, bu we need
     399                 :            :                          * to update the power resources' reference counters.
     400                 :            :                          */
     401                 :          0 :                         result = acpi_power_transition(device, state);
     402         [ #  # ]:          0 :                         if (result)
     403                 :            :                                 return result;
     404                 :            :                 }
     405                 :          0 :                 device->power.state = state;
     406                 :            :         }
     407         [ #  # ]:          0 :         if (state_p)
     408                 :          0 :                 *state_p = state;
     409                 :            : 
     410                 :            :         return 0;
     411                 :            : }
     412                 :            : EXPORT_SYMBOL_GPL(acpi_device_update_power);
     413                 :            : 
     414                 :          0 : int acpi_bus_update_power(acpi_handle handle, int *state_p)
     415                 :            : {
     416                 :          0 :         struct acpi_device *device;
     417                 :          0 :         int result;
     418                 :            : 
     419                 :          0 :         result = acpi_bus_get_device(handle, &device);
     420         [ #  # ]:          0 :         return result ? result : acpi_device_update_power(device, state_p);
     421                 :            : }
     422                 :            : EXPORT_SYMBOL_GPL(acpi_bus_update_power);
     423                 :            : 
     424                 :          0 : bool acpi_bus_power_manageable(acpi_handle handle)
     425                 :            : {
     426                 :          0 :         struct acpi_device *device;
     427                 :          0 :         int result;
     428                 :            : 
     429                 :          0 :         result = acpi_bus_get_device(handle, &device);
     430   [ #  #  #  # ]:          0 :         return result ? false : device->flags.power_manageable;
     431                 :            : }
     432                 :            : EXPORT_SYMBOL(acpi_bus_power_manageable);
     433                 :            : 
     434                 :            : #ifdef CONFIG_PM
     435                 :            : static DEFINE_MUTEX(acpi_pm_notifier_lock);
     436                 :            : static DEFINE_MUTEX(acpi_pm_notifier_install_lock);
     437                 :            : 
     438                 :          0 : void acpi_pm_wakeup_event(struct device *dev)
     439                 :            : {
     440                 :          0 :         pm_wakeup_dev_event(dev, 0, acpi_s2idle_wakeup());
     441                 :          0 : }
     442                 :            : EXPORT_SYMBOL_GPL(acpi_pm_wakeup_event);
     443                 :            : 
     444                 :          0 : static void acpi_pm_notify_handler(acpi_handle handle, u32 val, void *not_used)
     445                 :            : {
     446                 :          0 :         struct acpi_device *adev;
     447                 :            : 
     448         [ #  # ]:          0 :         if (val != ACPI_NOTIFY_DEVICE_WAKE)
     449                 :            :                 return;
     450                 :            : 
     451                 :          0 :         acpi_handle_debug(handle, "Wake notify\n");
     452                 :            : 
     453                 :          0 :         adev = acpi_bus_get_acpi_device(handle);
     454         [ #  # ]:          0 :         if (!adev)
     455                 :            :                 return;
     456                 :            : 
     457                 :          0 :         mutex_lock(&acpi_pm_notifier_lock);
     458                 :            : 
     459         [ #  # ]:          0 :         if (adev->wakeup.flags.notifier_present) {
     460                 :          0 :                 pm_wakeup_ws_event(adev->wakeup.ws, 0, acpi_s2idle_wakeup());
     461         [ #  # ]:          0 :                 if (adev->wakeup.context.func) {
     462                 :          0 :                         acpi_handle_debug(handle, "Running %pS for %s\n",
     463                 :            :                                           adev->wakeup.context.func,
     464                 :            :                                           dev_name(adev->wakeup.context.dev));
     465                 :          0 :                         adev->wakeup.context.func(&adev->wakeup.context);
     466                 :            :                 }
     467                 :            :         }
     468                 :            : 
     469                 :          0 :         mutex_unlock(&acpi_pm_notifier_lock);
     470                 :            : 
     471                 :          0 :         acpi_bus_put_acpi_device(adev);
     472                 :            : }
     473                 :            : 
     474                 :            : /**
     475                 :            :  * acpi_add_pm_notifier - Register PM notify handler for given ACPI device.
     476                 :            :  * @adev: ACPI device to add the notify handler for.
     477                 :            :  * @dev: Device to generate a wakeup event for while handling the notification.
     478                 :            :  * @func: Work function to execute when handling the notification.
     479                 :            :  *
     480                 :            :  * NOTE: @adev need not be a run-wake or wakeup device to be a valid source of
     481                 :            :  * PM wakeup events.  For example, wakeup events may be generated for bridges
     482                 :            :  * if one of the devices below the bridge is signaling wakeup, even if the
     483                 :            :  * bridge itself doesn't have a wakeup GPE associated with it.
     484                 :            :  */
     485                 :        147 : acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
     486                 :            :                         void (*func)(struct acpi_device_wakeup_context *context))
     487                 :            : {
     488                 :        147 :         acpi_status status = AE_ALREADY_EXISTS;
     489                 :            : 
     490         [ +  - ]:        147 :         if (!dev && !func)
     491                 :            :                 return AE_BAD_PARAMETER;
     492                 :            : 
     493                 :        147 :         mutex_lock(&acpi_pm_notifier_install_lock);
     494                 :            : 
     495         [ -  + ]:        147 :         if (adev->wakeup.flags.notifier_present)
     496                 :          0 :                 goto out;
     497                 :            : 
     498                 :        147 :         status = acpi_install_notify_handler(adev->handle, ACPI_SYSTEM_NOTIFY,
     499                 :            :                                              acpi_pm_notify_handler, NULL);
     500         [ -  + ]:        147 :         if (ACPI_FAILURE(status))
     501                 :          0 :                 goto out;
     502                 :            : 
     503                 :        147 :         mutex_lock(&acpi_pm_notifier_lock);
     504         [ +  - ]:        294 :         adev->wakeup.ws = wakeup_source_register(&adev->dev,
     505                 :            :                                                  dev_name(&adev->dev));
     506                 :        147 :         adev->wakeup.context.dev = dev;
     507                 :        147 :         adev->wakeup.context.func = func;
     508                 :        147 :         adev->wakeup.flags.notifier_present = true;
     509                 :        147 :         mutex_unlock(&acpi_pm_notifier_lock);
     510                 :            : 
     511                 :        147 :  out:
     512                 :        147 :         mutex_unlock(&acpi_pm_notifier_install_lock);
     513                 :        147 :         return status;
     514                 :            : }
     515                 :            : 
     516                 :            : /**
     517                 :            :  * acpi_remove_pm_notifier - Unregister PM notifier from given ACPI device.
     518                 :            :  * @adev: ACPI device to remove the notifier from.
     519                 :            :  */
     520                 :          0 : acpi_status acpi_remove_pm_notifier(struct acpi_device *adev)
     521                 :            : {
     522                 :          0 :         acpi_status status = AE_BAD_PARAMETER;
     523                 :            : 
     524                 :          0 :         mutex_lock(&acpi_pm_notifier_install_lock);
     525                 :            : 
     526         [ #  # ]:          0 :         if (!adev->wakeup.flags.notifier_present)
     527                 :          0 :                 goto out;
     528                 :            : 
     529                 :          0 :         status = acpi_remove_notify_handler(adev->handle,
     530                 :            :                                             ACPI_SYSTEM_NOTIFY,
     531                 :            :                                             acpi_pm_notify_handler);
     532         [ #  # ]:          0 :         if (ACPI_FAILURE(status))
     533                 :          0 :                 goto out;
     534                 :            : 
     535                 :          0 :         mutex_lock(&acpi_pm_notifier_lock);
     536                 :          0 :         adev->wakeup.context.func = NULL;
     537                 :          0 :         adev->wakeup.context.dev = NULL;
     538                 :          0 :         wakeup_source_unregister(adev->wakeup.ws);
     539                 :          0 :         adev->wakeup.flags.notifier_present = false;
     540                 :          0 :         mutex_unlock(&acpi_pm_notifier_lock);
     541                 :            : 
     542                 :          0 :  out:
     543                 :          0 :         mutex_unlock(&acpi_pm_notifier_install_lock);
     544                 :          0 :         return status;
     545                 :            : }
     546                 :            : 
     547                 :        126 : bool acpi_bus_can_wakeup(acpi_handle handle)
     548                 :            : {
     549                 :        126 :         struct acpi_device *device;
     550                 :        126 :         int result;
     551                 :            : 
     552                 :        126 :         result = acpi_bus_get_device(handle, &device);
     553   [ +  -  +  - ]:        126 :         return result ? false : device->wakeup.flags.valid;
     554                 :            : }
     555                 :            : EXPORT_SYMBOL(acpi_bus_can_wakeup);
     556                 :            : 
     557                 :          0 : bool acpi_pm_device_can_wakeup(struct device *dev)
     558                 :            : {
     559         [ #  # ]:          0 :         struct acpi_device *adev = ACPI_COMPANION(dev);
     560                 :            : 
     561   [ #  #  #  # ]:          0 :         return adev ? acpi_device_can_wakeup(adev) : false;
     562                 :            : }
     563                 :            : 
     564                 :            : /**
     565                 :            :  * acpi_dev_pm_get_state - Get preferred power state of ACPI device.
     566                 :            :  * @dev: Device whose preferred target power state to return.
     567                 :            :  * @adev: ACPI device node corresponding to @dev.
     568                 :            :  * @target_state: System state to match the resultant device state.
     569                 :            :  * @d_min_p: Location to store the highest power state available to the device.
     570                 :            :  * @d_max_p: Location to store the lowest power state available to the device.
     571                 :            :  *
     572                 :            :  * Find the lowest power (highest number) and highest power (lowest number) ACPI
     573                 :            :  * device power states that the device can be in while the system is in the
     574                 :            :  * state represented by @target_state.  Store the integer numbers representing
     575                 :            :  * those stats in the memory locations pointed to by @d_max_p and @d_min_p,
     576                 :            :  * respectively.
     577                 :            :  *
     578                 :            :  * Callers must ensure that @dev and @adev are valid pointers and that @adev
     579                 :            :  * actually corresponds to @dev before using this function.
     580                 :            :  *
     581                 :            :  * Returns 0 on success or -ENODATA when one of the ACPI methods fails or
     582                 :            :  * returns a value that doesn't make sense.  The memory locations pointed to by
     583                 :            :  * @d_max_p and @d_min_p are only modified on success.
     584                 :            :  */
     585                 :          0 : static int acpi_dev_pm_get_state(struct device *dev, struct acpi_device *adev,
     586                 :            :                                  u32 target_state, int *d_min_p, int *d_max_p)
     587                 :            : {
     588                 :          0 :         char method[] = { '_', 'S', '0' + target_state, 'D', '\0' };
     589                 :          0 :         acpi_handle handle = adev->handle;
     590                 :          0 :         unsigned long long ret;
     591                 :          0 :         int d_min, d_max;
     592                 :          0 :         bool wakeup = false;
     593                 :          0 :         bool has_sxd = false;
     594                 :          0 :         acpi_status status;
     595                 :            : 
     596                 :            :         /*
     597                 :            :          * If the system state is S0, the lowest power state the device can be
     598                 :            :          * in is D3cold, unless the device has _S0W and is supposed to signal
     599                 :            :          * wakeup, in which case the return value of _S0W has to be used as the
     600                 :            :          * lowest power state available to the device.
     601                 :            :          */
     602                 :          0 :         d_min = ACPI_STATE_D0;
     603                 :          0 :         d_max = ACPI_STATE_D3_COLD;
     604                 :            : 
     605                 :            :         /*
     606                 :            :          * If present, _SxD methods return the minimum D-state (highest power
     607                 :            :          * state) we can use for the corresponding S-states.  Otherwise, the
     608                 :            :          * minimum D-state is D0 (ACPI 3.x).
     609                 :            :          */
     610         [ #  # ]:          0 :         if (target_state > ACPI_STATE_S0) {
     611                 :            :                 /*
     612                 :            :                  * We rely on acpi_evaluate_integer() not clobbering the integer
     613                 :            :                  * provided if AE_NOT_FOUND is returned.
     614                 :            :                  */
     615                 :          0 :                 ret = d_min;
     616                 :          0 :                 status = acpi_evaluate_integer(handle, method, NULL, &ret);
     617         [ #  # ]:          0 :                 if ((ACPI_FAILURE(status) && status != AE_NOT_FOUND)
     618         [ #  # ]:          0 :                     || ret > ACPI_STATE_D3_COLD)
     619                 :            :                         return -ENODATA;
     620                 :            : 
     621                 :            :                 /*
     622                 :            :                  * We need to handle legacy systems where D3hot and D3cold are
     623                 :            :                  * the same and 3 is returned in both cases, so fall back to
     624                 :            :                  * D3cold if D3hot is not a valid state.
     625                 :            :                  */
     626         [ #  # ]:          0 :                 if (!adev->power.states[ret].flags.valid) {
     627         [ #  # ]:          0 :                         if (ret == ACPI_STATE_D3_HOT)
     628                 :          0 :                                 ret = ACPI_STATE_D3_COLD;
     629                 :            :                         else
     630                 :            :                                 return -ENODATA;
     631                 :            :                 }
     632                 :            : 
     633         [ #  # ]:          0 :                 if (status == AE_OK)
     634                 :          0 :                         has_sxd = true;
     635                 :            : 
     636                 :          0 :                 d_min = ret;
     637   [ #  #  #  # ]:          0 :                 wakeup = device_may_wakeup(dev) && adev->wakeup.flags.valid
     638   [ #  #  #  # ]:          0 :                         && adev->wakeup.sleep_state >= target_state;
     639                 :            :         } else {
     640                 :          0 :                 wakeup = adev->wakeup.flags.valid;
     641                 :            :         }
     642                 :            : 
     643                 :            :         /*
     644                 :            :          * If _PRW says we can wake up the system from the target sleep state,
     645                 :            :          * the D-state returned by _SxD is sufficient for that (we assume a
     646                 :            :          * wakeup-aware driver if wake is set).  Still, if _SxW exists
     647                 :            :          * (ACPI 3.x), it should return the maximum (lowest power) D-state that
     648                 :            :          * can wake the system.  _S0W may be valid, too.
     649                 :            :          */
     650         [ #  # ]:          0 :         if (wakeup) {
     651                 :          0 :                 method[3] = 'W';
     652                 :          0 :                 status = acpi_evaluate_integer(handle, method, NULL, &ret);
     653         [ #  # ]:          0 :                 if (status == AE_NOT_FOUND) {
     654                 :            :                         /* No _SxW. In this case, the ACPI spec says that we
     655                 :            :                          * must not go into any power state deeper than the
     656                 :            :                          * value returned from _SxD.
     657                 :            :                          */
     658         [ #  # ]:          0 :                         if (has_sxd && target_state > ACPI_STATE_S0)
     659                 :          0 :                                 d_max = d_min;
     660   [ #  #  #  # ]:          0 :                 } else if (ACPI_SUCCESS(status) && ret <= ACPI_STATE_D3_COLD) {
     661                 :            :                         /* Fall back to D3cold if ret is not a valid state. */
     662         [ #  # ]:          0 :                         if (!adev->power.states[ret].flags.valid)
     663                 :          0 :                                 ret = ACPI_STATE_D3_COLD;
     664                 :            : 
     665                 :          0 :                         d_max = ret > d_min ? ret : d_min;
     666                 :            :                 } else {
     667                 :            :                         return -ENODATA;
     668                 :            :                 }
     669                 :            :         }
     670                 :            : 
     671         [ #  # ]:          0 :         if (d_min_p)
     672                 :          0 :                 *d_min_p = d_min;
     673                 :            : 
     674         [ #  # ]:          0 :         if (d_max_p)
     675                 :          0 :                 *d_max_p = d_max;
     676                 :            : 
     677                 :            :         return 0;
     678                 :            : }
     679                 :            : 
     680                 :            : /**
     681                 :            :  * acpi_pm_device_sleep_state - Get preferred power state of ACPI device.
     682                 :            :  * @dev: Device whose preferred target power state to return.
     683                 :            :  * @d_min_p: Location to store the upper limit of the allowed states range.
     684                 :            :  * @d_max_in: Deepest low-power state to take into consideration.
     685                 :            :  * Return value: Preferred power state of the device on success, -ENODEV
     686                 :            :  * if there's no 'struct acpi_device' for @dev, -EINVAL if @d_max_in is
     687                 :            :  * incorrect, or -ENODATA on ACPI method failure.
     688                 :            :  *
     689                 :            :  * The caller must ensure that @dev is valid before using this function.
     690                 :            :  */
     691                 :          0 : int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in)
     692                 :            : {
     693                 :          0 :         struct acpi_device *adev;
     694                 :          0 :         int ret, d_min, d_max;
     695                 :            : 
     696         [ #  # ]:          0 :         if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3_COLD)
     697                 :            :                 return -EINVAL;
     698                 :            : 
     699         [ #  # ]:          0 :         if (d_max_in > ACPI_STATE_D2) {
     700                 :          0 :                 enum pm_qos_flags_status stat;
     701                 :            : 
     702                 :          0 :                 stat = dev_pm_qos_flags(dev, PM_QOS_FLAG_NO_POWER_OFF);
     703         [ #  # ]:          0 :                 if (stat == PM_QOS_FLAGS_ALL)
     704                 :          0 :                         d_max_in = ACPI_STATE_D2;
     705                 :            :         }
     706                 :            : 
     707         [ #  # ]:          0 :         adev = ACPI_COMPANION(dev);
     708         [ #  # ]:          0 :         if (!adev) {
     709                 :            :                 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
     710                 :            :                 return -ENODEV;
     711                 :            :         }
     712                 :            : 
     713                 :          0 :         ret = acpi_dev_pm_get_state(dev, adev, acpi_target_system_state(),
     714                 :            :                                     &d_min, &d_max);
     715         [ #  # ]:          0 :         if (ret)
     716                 :            :                 return ret;
     717                 :            : 
     718         [ #  # ]:          0 :         if (d_max_in < d_min)
     719                 :            :                 return -EINVAL;
     720                 :            : 
     721         [ #  # ]:          0 :         if (d_max > d_max_in) {
     722         [ #  # ]:          0 :                 for (d_max = d_max_in; d_max > d_min; d_max--) {
     723         [ #  # ]:          0 :                         if (adev->power.states[d_max].flags.valid)
     724                 :            :                                 break;
     725                 :            :                 }
     726                 :            :         }
     727                 :            : 
     728         [ #  # ]:          0 :         if (d_min_p)
     729                 :          0 :                 *d_min_p = d_min;
     730                 :            : 
     731                 :          0 :         return d_max;
     732                 :            : }
     733                 :            : EXPORT_SYMBOL(acpi_pm_device_sleep_state);
     734                 :            : 
     735                 :            : /**
     736                 :            :  * acpi_pm_notify_work_func - ACPI devices wakeup notification work function.
     737                 :            :  * @context: Device wakeup context.
     738                 :            :  */
     739                 :          0 : static void acpi_pm_notify_work_func(struct acpi_device_wakeup_context *context)
     740                 :            : {
     741                 :          0 :         struct device *dev = context->dev;
     742                 :            : 
     743         [ #  # ]:          0 :         if (dev) {
     744                 :          0 :                 pm_wakeup_event(dev, 0);
     745                 :          0 :                 pm_request_resume(dev);
     746                 :            :         }
     747                 :          0 : }
     748                 :            : 
     749                 :            : static DEFINE_MUTEX(acpi_wakeup_lock);
     750                 :            : 
     751                 :          0 : static int __acpi_device_wakeup_enable(struct acpi_device *adev,
     752                 :            :                                        u32 target_state, int max_count)
     753                 :            : {
     754                 :          0 :         struct acpi_device_wakeup *wakeup = &adev->wakeup;
     755                 :          0 :         acpi_status status;
     756                 :          0 :         int error = 0;
     757                 :            : 
     758                 :          0 :         mutex_lock(&acpi_wakeup_lock);
     759                 :            : 
     760         [ #  # ]:          0 :         if (wakeup->enable_count >= max_count)
     761                 :          0 :                 goto out;
     762                 :            : 
     763         [ #  # ]:          0 :         if (wakeup->enable_count > 0)
     764                 :          0 :                 goto inc;
     765                 :            : 
     766                 :          0 :         error = acpi_enable_wakeup_device_power(adev, target_state);
     767         [ #  # ]:          0 :         if (error)
     768                 :          0 :                 goto out;
     769                 :            : 
     770                 :          0 :         status = acpi_enable_gpe(wakeup->gpe_device, wakeup->gpe_number);
     771         [ #  # ]:          0 :         if (ACPI_FAILURE(status)) {
     772                 :          0 :                 acpi_disable_wakeup_device_power(adev);
     773                 :          0 :                 error = -EIO;
     774                 :          0 :                 goto out;
     775                 :            :         }
     776                 :            : 
     777                 :            :         acpi_handle_debug(adev->handle, "GPE%2X enabled for wakeup\n",
     778                 :            :                           (unsigned int)wakeup->gpe_number);
     779                 :            : 
     780                 :          0 : inc:
     781                 :          0 :         wakeup->enable_count++;
     782                 :            : 
     783                 :          0 : out:
     784                 :          0 :         mutex_unlock(&acpi_wakeup_lock);
     785                 :          0 :         return error;
     786                 :            : }
     787                 :            : 
     788                 :            : /**
     789                 :            :  * acpi_device_wakeup_enable - Enable wakeup functionality for device.
     790                 :            :  * @adev: ACPI device to enable wakeup functionality for.
     791                 :            :  * @target_state: State the system is transitioning into.
     792                 :            :  *
     793                 :            :  * Enable the GPE associated with @adev so that it can generate wakeup signals
     794                 :            :  * for the device in response to external (remote) events and enable wakeup
     795                 :            :  * power for it.
     796                 :            :  *
     797                 :            :  * Callers must ensure that @adev is a valid ACPI device node before executing
     798                 :            :  * this function.
     799                 :            :  */
     800                 :          0 : static int acpi_device_wakeup_enable(struct acpi_device *adev, u32 target_state)
     801                 :            : {
     802                 :          0 :         return __acpi_device_wakeup_enable(adev, target_state, 1);
     803                 :            : }
     804                 :            : 
     805                 :            : /**
     806                 :            :  * acpi_device_wakeup_disable - Disable wakeup functionality for device.
     807                 :            :  * @adev: ACPI device to disable wakeup functionality for.
     808                 :            :  *
     809                 :            :  * Disable the GPE associated with @adev and disable wakeup power for it.
     810                 :            :  *
     811                 :            :  * Callers must ensure that @adev is a valid ACPI device node before executing
     812                 :            :  * this function.
     813                 :            :  */
     814                 :          0 : static void acpi_device_wakeup_disable(struct acpi_device *adev)
     815                 :            : {
     816                 :          0 :         struct acpi_device_wakeup *wakeup = &adev->wakeup;
     817                 :            : 
     818                 :          0 :         mutex_lock(&acpi_wakeup_lock);
     819                 :            : 
     820         [ #  # ]:          0 :         if (!wakeup->enable_count)
     821                 :          0 :                 goto out;
     822                 :            : 
     823                 :          0 :         acpi_disable_gpe(wakeup->gpe_device, wakeup->gpe_number);
     824                 :          0 :         acpi_disable_wakeup_device_power(adev);
     825                 :            : 
     826                 :          0 :         wakeup->enable_count--;
     827                 :            : 
     828                 :          0 : out:
     829                 :          0 :         mutex_unlock(&acpi_wakeup_lock);
     830                 :          0 : }
     831                 :            : 
     832                 :          0 : static int __acpi_pm_set_device_wakeup(struct device *dev, bool enable,
     833                 :            :                                        int max_count)
     834                 :            : {
     835                 :          0 :         struct acpi_device *adev;
     836                 :          0 :         int error;
     837                 :            : 
     838         [ #  # ]:          0 :         adev = ACPI_COMPANION(dev);
     839         [ #  # ]:          0 :         if (!adev) {
     840                 :            :                 dev_dbg(dev, "ACPI companion missing in %s!\n", __func__);
     841                 :            :                 return -ENODEV;
     842                 :            :         }
     843                 :            : 
     844         [ #  # ]:          0 :         if (!acpi_device_can_wakeup(adev))
     845                 :            :                 return -EINVAL;
     846                 :            : 
     847         [ #  # ]:          0 :         if (!enable) {
     848                 :          0 :                 acpi_device_wakeup_disable(adev);
     849                 :          0 :                 dev_dbg(dev, "Wakeup disabled by ACPI\n");
     850                 :          0 :                 return 0;
     851                 :            :         }
     852                 :            : 
     853                 :          0 :         error = __acpi_device_wakeup_enable(adev, acpi_target_system_state(),
     854                 :            :                                             max_count);
     855                 :          0 :         if (!error)
     856                 :            :                 dev_dbg(dev, "Wakeup enabled by ACPI\n");
     857                 :            : 
     858                 :          0 :         return error;
     859                 :            : }
     860                 :            : 
     861                 :            : /**
     862                 :            :  * acpi_pm_set_device_wakeup - Enable/disable remote wakeup for given device.
     863                 :            :  * @dev: Device to enable/disable to generate wakeup events.
     864                 :            :  * @enable: Whether to enable or disable the wakeup functionality.
     865                 :            :  */
     866                 :          0 : int acpi_pm_set_device_wakeup(struct device *dev, bool enable)
     867                 :            : {
     868                 :          0 :         return __acpi_pm_set_device_wakeup(dev, enable, 1);
     869                 :            : }
     870                 :            : EXPORT_SYMBOL_GPL(acpi_pm_set_device_wakeup);
     871                 :            : 
     872                 :            : /**
     873                 :            :  * acpi_pm_set_bridge_wakeup - Enable/disable remote wakeup for given bridge.
     874                 :            :  * @dev: Bridge device to enable/disable to generate wakeup events.
     875                 :            :  * @enable: Whether to enable or disable the wakeup functionality.
     876                 :            :  */
     877                 :          0 : int acpi_pm_set_bridge_wakeup(struct device *dev, bool enable)
     878                 :            : {
     879                 :          0 :         return __acpi_pm_set_device_wakeup(dev, enable, INT_MAX);
     880                 :            : }
     881                 :            : EXPORT_SYMBOL_GPL(acpi_pm_set_bridge_wakeup);
     882                 :            : 
     883                 :            : /**
     884                 :            :  * acpi_dev_pm_low_power - Put ACPI device into a low-power state.
     885                 :            :  * @dev: Device to put into a low-power state.
     886                 :            :  * @adev: ACPI device node corresponding to @dev.
     887                 :            :  * @system_state: System state to choose the device state for.
     888                 :            :  */
     889                 :          0 : static int acpi_dev_pm_low_power(struct device *dev, struct acpi_device *adev,
     890                 :            :                                  u32 system_state)
     891                 :            : {
     892                 :          0 :         int ret, state;
     893                 :            : 
     894         [ #  # ]:          0 :         if (!acpi_device_power_manageable(adev))
     895                 :            :                 return 0;
     896                 :            : 
     897                 :          0 :         ret = acpi_dev_pm_get_state(dev, adev, system_state, NULL, &state);
     898         [ #  # ]:          0 :         return ret ? ret : acpi_device_set_power(adev, state);
     899                 :            : }
     900                 :            : 
     901                 :            : /**
     902                 :            :  * acpi_dev_pm_full_power - Put ACPI device into the full-power state.
     903                 :            :  * @adev: ACPI device node to put into the full-power state.
     904                 :            :  */
     905                 :          0 : static int acpi_dev_pm_full_power(struct acpi_device *adev)
     906                 :            : {
     907                 :          0 :         return acpi_device_power_manageable(adev) ?
     908   [ #  #  #  # ]:          0 :                 acpi_device_set_power(adev, ACPI_STATE_D0) : 0;
     909                 :            : }
     910                 :            : 
     911                 :            : /**
     912                 :            :  * acpi_dev_suspend - Put device into a low-power state using ACPI.
     913                 :            :  * @dev: Device to put into a low-power state.
     914                 :            :  * @wakeup: Whether or not to enable wakeup for the device.
     915                 :            :  *
     916                 :            :  * Put the given device into a low-power state using the standard ACPI
     917                 :            :  * mechanism.  Set up remote wakeup if desired, choose the state to put the
     918                 :            :  * device into (this checks if remote wakeup is expected to work too), and set
     919                 :            :  * the power state of the device.
     920                 :            :  */
     921                 :          0 : int acpi_dev_suspend(struct device *dev, bool wakeup)
     922                 :            : {
     923         [ #  # ]:          0 :         struct acpi_device *adev = ACPI_COMPANION(dev);
     924                 :          0 :         u32 target_state = acpi_target_system_state();
     925                 :          0 :         int error;
     926                 :            : 
     927         [ #  # ]:          0 :         if (!adev)
     928                 :            :                 return 0;
     929                 :            : 
     930   [ #  #  #  # ]:          0 :         if (wakeup && acpi_device_can_wakeup(adev)) {
     931                 :          0 :                 error = acpi_device_wakeup_enable(adev, target_state);
     932         [ #  # ]:          0 :                 if (error)
     933                 :            :                         return -EAGAIN;
     934                 :            :         } else {
     935                 :            :                 wakeup = false;
     936                 :            :         }
     937                 :            : 
     938                 :          0 :         error = acpi_dev_pm_low_power(dev, adev, target_state);
     939         [ #  # ]:          0 :         if (error && wakeup)
     940                 :          0 :                 acpi_device_wakeup_disable(adev);
     941                 :            : 
     942                 :            :         return error;
     943                 :            : }
     944                 :            : EXPORT_SYMBOL_GPL(acpi_dev_suspend);
     945                 :            : 
     946                 :            : /**
     947                 :            :  * acpi_dev_resume - Put device into the full-power state using ACPI.
     948                 :            :  * @dev: Device to put into the full-power state.
     949                 :            :  *
     950                 :            :  * Put the given device into the full-power state using the standard ACPI
     951                 :            :  * mechanism.  Set the power state of the device to ACPI D0 and disable wakeup.
     952                 :            :  */
     953                 :          0 : int acpi_dev_resume(struct device *dev)
     954                 :            : {
     955         [ #  # ]:          0 :         struct acpi_device *adev = ACPI_COMPANION(dev);
     956                 :          0 :         int error;
     957                 :            : 
     958         [ #  # ]:          0 :         if (!adev)
     959                 :            :                 return 0;
     960                 :            : 
     961         [ #  # ]:          0 :         error = acpi_dev_pm_full_power(adev);
     962                 :          0 :         acpi_device_wakeup_disable(adev);
     963                 :          0 :         return error;
     964                 :            : }
     965                 :            : EXPORT_SYMBOL_GPL(acpi_dev_resume);
     966                 :            : 
     967                 :            : /**
     968                 :            :  * acpi_subsys_runtime_suspend - Suspend device using ACPI.
     969                 :            :  * @dev: Device to suspend.
     970                 :            :  *
     971                 :            :  * Carry out the generic runtime suspend procedure for @dev and use ACPI to put
     972                 :            :  * it into a runtime low-power state.
     973                 :            :  */
     974                 :          0 : int acpi_subsys_runtime_suspend(struct device *dev)
     975                 :            : {
     976                 :          0 :         int ret = pm_generic_runtime_suspend(dev);
     977         [ #  # ]:          0 :         return ret ? ret : acpi_dev_suspend(dev, true);
     978                 :            : }
     979                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_runtime_suspend);
     980                 :            : 
     981                 :            : /**
     982                 :            :  * acpi_subsys_runtime_resume - Resume device using ACPI.
     983                 :            :  * @dev: Device to Resume.
     984                 :            :  *
     985                 :            :  * Use ACPI to put the given device into the full-power state and carry out the
     986                 :            :  * generic runtime resume procedure for it.
     987                 :            :  */
     988                 :          0 : int acpi_subsys_runtime_resume(struct device *dev)
     989                 :            : {
     990                 :          0 :         int ret = acpi_dev_resume(dev);
     991         [ #  # ]:          0 :         return ret ? ret : pm_generic_runtime_resume(dev);
     992                 :            : }
     993                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_runtime_resume);
     994                 :            : 
     995                 :            : #ifdef CONFIG_PM_SLEEP
     996                 :          0 : static bool acpi_dev_needs_resume(struct device *dev, struct acpi_device *adev)
     997                 :            : {
     998                 :          0 :         u32 sys_target = acpi_target_system_state();
     999                 :          0 :         int ret, state;
    1000                 :            : 
    1001   [ #  #  #  #  :          0 :         if (!pm_runtime_suspended(dev) || !adev || (adev->wakeup.flags.valid &&
             #  #  #  # ]
    1002         [ #  # ]:          0 :             device_may_wakeup(dev) != !!adev->wakeup.prepare_count))
    1003                 :            :                 return true;
    1004                 :            : 
    1005         [ #  # ]:          0 :         if (sys_target == ACPI_STATE_S0)
    1006                 :            :                 return false;
    1007                 :            : 
    1008         [ #  # ]:          0 :         if (adev->power.flags.dsw_present)
    1009                 :            :                 return true;
    1010                 :            : 
    1011                 :          0 :         ret = acpi_dev_pm_get_state(dev, adev, sys_target, NULL, &state);
    1012         [ #  # ]:          0 :         if (ret)
    1013                 :            :                 return true;
    1014                 :            : 
    1015                 :          0 :         return state != adev->power.state;
    1016                 :            : }
    1017                 :            : 
    1018                 :            : /**
    1019                 :            :  * acpi_subsys_prepare - Prepare device for system transition to a sleep state.
    1020                 :            :  * @dev: Device to prepare.
    1021                 :            :  */
    1022                 :          0 : int acpi_subsys_prepare(struct device *dev)
    1023                 :            : {
    1024         [ #  # ]:          0 :         struct acpi_device *adev = ACPI_COMPANION(dev);
    1025                 :            : 
    1026   [ #  #  #  #  :          0 :         if (dev->driver && dev->driver->pm && dev->driver->pm->prepare) {
                   #  # ]
    1027                 :          0 :                 int ret = dev->driver->pm->prepare(dev);
    1028                 :            : 
    1029         [ #  # ]:          0 :                 if (ret < 0)
    1030                 :            :                         return ret;
    1031                 :            : 
    1032   [ #  #  #  # ]:          0 :                 if (!ret && dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_PREPARE))
    1033                 :            :                         return 0;
    1034                 :            :         }
    1035                 :            : 
    1036                 :          0 :         return !acpi_dev_needs_resume(dev, adev);
    1037                 :            : }
    1038                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_prepare);
    1039                 :            : 
    1040                 :            : /**
    1041                 :            :  * acpi_subsys_complete - Finalize device's resume during system resume.
    1042                 :            :  * @dev: Device to handle.
    1043                 :            :  */
    1044                 :          0 : void acpi_subsys_complete(struct device *dev)
    1045                 :            : {
    1046                 :          0 :         pm_generic_complete(dev);
    1047                 :            :         /*
    1048                 :            :          * If the device had been runtime-suspended before the system went into
    1049                 :            :          * the sleep state it is going out of and it has never been resumed till
    1050                 :            :          * now, resume it in case the firmware powered it up.
    1051                 :            :          */
    1052   [ #  #  #  #  :          0 :         if (pm_runtime_suspended(dev) && pm_resume_via_firmware())
                   #  # ]
    1053                 :          0 :                 pm_request_resume(dev);
    1054                 :          0 : }
    1055                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_complete);
    1056                 :            : 
    1057                 :            : /**
    1058                 :            :  * acpi_subsys_suspend - Run the device driver's suspend callback.
    1059                 :            :  * @dev: Device to handle.
    1060                 :            :  *
    1061                 :            :  * Follow PCI and resume devices from runtime suspend before running their
    1062                 :            :  * system suspend callbacks, unless the driver can cope with runtime-suspended
    1063                 :            :  * devices during system suspend and there are no ACPI-specific reasons for
    1064                 :            :  * resuming them.
    1065                 :            :  */
    1066                 :          0 : int acpi_subsys_suspend(struct device *dev)
    1067                 :            : {
    1068   [ #  #  #  # ]:          0 :         if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
    1069         [ #  # ]:          0 :             acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
    1070                 :          0 :                 pm_runtime_resume(dev);
    1071                 :            : 
    1072                 :          0 :         return pm_generic_suspend(dev);
    1073                 :            : }
    1074                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_suspend);
    1075                 :            : 
    1076                 :            : /**
    1077                 :            :  * acpi_subsys_suspend_late - Suspend device using ACPI.
    1078                 :            :  * @dev: Device to suspend.
    1079                 :            :  *
    1080                 :            :  * Carry out the generic late suspend procedure for @dev and use ACPI to put
    1081                 :            :  * it into a low-power state during system transition into a sleep state.
    1082                 :            :  */
    1083                 :          0 : int acpi_subsys_suspend_late(struct device *dev)
    1084                 :            : {
    1085                 :          0 :         int ret;
    1086                 :            : 
    1087         [ #  # ]:          0 :         if (dev_pm_smart_suspend_and_suspended(dev))
    1088                 :            :                 return 0;
    1089                 :            : 
    1090                 :          0 :         ret = pm_generic_suspend_late(dev);
    1091         [ #  # ]:          0 :         return ret ? ret : acpi_dev_suspend(dev, device_may_wakeup(dev));
    1092                 :            : }
    1093                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_suspend_late);
    1094                 :            : 
    1095                 :            : /**
    1096                 :            :  * acpi_subsys_suspend_noirq - Run the device driver's "noirq" suspend callback.
    1097                 :            :  * @dev: Device to suspend.
    1098                 :            :  */
    1099                 :          0 : int acpi_subsys_suspend_noirq(struct device *dev)
    1100                 :            : {
    1101                 :          0 :         int ret;
    1102                 :            : 
    1103         [ #  # ]:          0 :         if (dev_pm_smart_suspend_and_suspended(dev)) {
    1104                 :          0 :                 dev->power.may_skip_resume = true;
    1105                 :          0 :                 return 0;
    1106                 :            :         }
    1107                 :            : 
    1108                 :          0 :         ret = pm_generic_suspend_noirq(dev);
    1109         [ #  # ]:          0 :         if (ret)
    1110                 :            :                 return ret;
    1111                 :            : 
    1112                 :            :         /*
    1113                 :            :          * If the target system sleep state is suspend-to-idle, it is sufficient
    1114                 :            :          * to check whether or not the device's wakeup settings are good for
    1115                 :            :          * runtime PM.  Otherwise, the pm_resume_via_firmware() check will cause
    1116                 :            :          * acpi_subsys_complete() to take care of fixing up the device's state
    1117                 :            :          * anyway, if need be.
    1118                 :            :          */
    1119   [ #  #  #  #  :          0 :         dev->power.may_skip_resume = device_may_wakeup(dev) ||
                   #  # ]
    1120                 :            :                                         !device_can_wakeup(dev);
    1121                 :            : 
    1122                 :          0 :         return 0;
    1123                 :            : }
    1124                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_suspend_noirq);
    1125                 :            : 
    1126                 :            : /**
    1127                 :            :  * acpi_subsys_resume_noirq - Run the device driver's "noirq" resume callback.
    1128                 :            :  * @dev: Device to handle.
    1129                 :            :  */
    1130                 :          0 : static int acpi_subsys_resume_noirq(struct device *dev)
    1131                 :            : {
    1132         [ #  # ]:          0 :         if (dev_pm_may_skip_resume(dev))
    1133                 :            :                 return 0;
    1134                 :            : 
    1135                 :            :         /*
    1136                 :            :          * Devices with DPM_FLAG_SMART_SUSPEND may be left in runtime suspend
    1137                 :            :          * during system suspend, so update their runtime PM status to "active"
    1138                 :            :          * as they will be put into D0 going forward.
    1139                 :            :          */
    1140         [ #  # ]:          0 :         if (dev_pm_smart_suspend_and_suspended(dev))
    1141                 :          0 :                 pm_runtime_set_active(dev);
    1142                 :            : 
    1143                 :          0 :         return pm_generic_resume_noirq(dev);
    1144                 :            : }
    1145                 :            : 
    1146                 :            : /**
    1147                 :            :  * acpi_subsys_resume_early - Resume device using ACPI.
    1148                 :            :  * @dev: Device to Resume.
    1149                 :            :  *
    1150                 :            :  * Use ACPI to put the given device into the full-power state and carry out the
    1151                 :            :  * generic early resume procedure for it during system transition into the
    1152                 :            :  * working state.
    1153                 :            :  */
    1154                 :          0 : static int acpi_subsys_resume_early(struct device *dev)
    1155                 :            : {
    1156                 :          0 :         int ret = acpi_dev_resume(dev);
    1157         [ #  # ]:          0 :         return ret ? ret : pm_generic_resume_early(dev);
    1158                 :            : }
    1159                 :            : 
    1160                 :            : /**
    1161                 :            :  * acpi_subsys_freeze - Run the device driver's freeze callback.
    1162                 :            :  * @dev: Device to handle.
    1163                 :            :  */
    1164                 :          0 : int acpi_subsys_freeze(struct device *dev)
    1165                 :            : {
    1166                 :            :         /*
    1167                 :            :          * Resume all runtime-suspended devices before creating a snapshot
    1168                 :            :          * image of system memory, because the restore kernel generally cannot
    1169                 :            :          * be expected to always handle them consistently and they need to be
    1170                 :            :          * put into the runtime-active metastate during system resume anyway,
    1171                 :            :          * so it is better to ensure that the state saved in the image will be
    1172                 :            :          * always consistent with that.
    1173                 :            :          */
    1174                 :          0 :         pm_runtime_resume(dev);
    1175                 :            : 
    1176                 :          0 :         return pm_generic_freeze(dev);
    1177                 :            : }
    1178                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_freeze);
    1179                 :            : 
    1180                 :            : /**
    1181                 :            :  * acpi_subsys_restore_early - Restore device using ACPI.
    1182                 :            :  * @dev: Device to restore.
    1183                 :            :  */
    1184                 :          0 : int acpi_subsys_restore_early(struct device *dev)
    1185                 :            : {
    1186                 :          0 :         int ret = acpi_dev_resume(dev);
    1187         [ #  # ]:          0 :         return ret ? ret : pm_generic_restore_early(dev);
    1188                 :            : }
    1189                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_restore_early);
    1190                 :            : 
    1191                 :            : /**
    1192                 :            :  * acpi_subsys_poweroff - Run the device driver's poweroff callback.
    1193                 :            :  * @dev: Device to handle.
    1194                 :            :  *
    1195                 :            :  * Follow PCI and resume devices from runtime suspend before running their
    1196                 :            :  * system poweroff callbacks, unless the driver can cope with runtime-suspended
    1197                 :            :  * devices during system suspend and there are no ACPI-specific reasons for
    1198                 :            :  * resuming them.
    1199                 :            :  */
    1200                 :          0 : int acpi_subsys_poweroff(struct device *dev)
    1201                 :            : {
    1202   [ #  #  #  # ]:          0 :         if (!dev_pm_test_driver_flags(dev, DPM_FLAG_SMART_SUSPEND) ||
    1203         [ #  # ]:          0 :             acpi_dev_needs_resume(dev, ACPI_COMPANION(dev)))
    1204                 :          0 :                 pm_runtime_resume(dev);
    1205                 :            : 
    1206                 :          0 :         return pm_generic_poweroff(dev);
    1207                 :            : }
    1208                 :            : EXPORT_SYMBOL_GPL(acpi_subsys_poweroff);
    1209                 :            : 
    1210                 :            : /**
    1211                 :            :  * acpi_subsys_poweroff_late - Run the device driver's poweroff callback.
    1212                 :            :  * @dev: Device to handle.
    1213                 :            :  *
    1214                 :            :  * Carry out the generic late poweroff procedure for @dev and use ACPI to put
    1215                 :            :  * it into a low-power state during system transition into a sleep state.
    1216                 :            :  */
    1217                 :          0 : static int acpi_subsys_poweroff_late(struct device *dev)
    1218                 :            : {
    1219                 :          0 :         int ret;
    1220                 :            : 
    1221         [ #  # ]:          0 :         if (dev_pm_smart_suspend_and_suspended(dev))
    1222                 :            :                 return 0;
    1223                 :            : 
    1224                 :          0 :         ret = pm_generic_poweroff_late(dev);
    1225         [ #  # ]:          0 :         if (ret)
    1226                 :            :                 return ret;
    1227                 :            : 
    1228         [ #  # ]:          0 :         return acpi_dev_suspend(dev, device_may_wakeup(dev));
    1229                 :            : }
    1230                 :            : 
    1231                 :            : /**
    1232                 :            :  * acpi_subsys_poweroff_noirq - Run the driver's "noirq" poweroff callback.
    1233                 :            :  * @dev: Device to suspend.
    1234                 :            :  */
    1235                 :          0 : static int acpi_subsys_poweroff_noirq(struct device *dev)
    1236                 :            : {
    1237         [ #  # ]:          0 :         if (dev_pm_smart_suspend_and_suspended(dev))
    1238                 :            :                 return 0;
    1239                 :            : 
    1240                 :          0 :         return pm_generic_poweroff_noirq(dev);
    1241                 :            : }
    1242                 :            : #endif /* CONFIG_PM_SLEEP */
    1243                 :            : 
    1244                 :            : static struct dev_pm_domain acpi_general_pm_domain = {
    1245                 :            :         .ops = {
    1246                 :            :                 .runtime_suspend = acpi_subsys_runtime_suspend,
    1247                 :            :                 .runtime_resume = acpi_subsys_runtime_resume,
    1248                 :            : #ifdef CONFIG_PM_SLEEP
    1249                 :            :                 .prepare = acpi_subsys_prepare,
    1250                 :            :                 .complete = acpi_subsys_complete,
    1251                 :            :                 .suspend = acpi_subsys_suspend,
    1252                 :            :                 .suspend_late = acpi_subsys_suspend_late,
    1253                 :            :                 .suspend_noirq = acpi_subsys_suspend_noirq,
    1254                 :            :                 .resume_noirq = acpi_subsys_resume_noirq,
    1255                 :            :                 .resume_early = acpi_subsys_resume_early,
    1256                 :            :                 .freeze = acpi_subsys_freeze,
    1257                 :            :                 .poweroff = acpi_subsys_poweroff,
    1258                 :            :                 .poweroff_late = acpi_subsys_poweroff_late,
    1259                 :            :                 .poweroff_noirq = acpi_subsys_poweroff_noirq,
    1260                 :            :                 .restore_early = acpi_subsys_restore_early,
    1261                 :            : #endif
    1262                 :            :         },
    1263                 :            : };
    1264                 :            : 
    1265                 :            : /**
    1266                 :            :  * acpi_dev_pm_detach - Remove ACPI power management from the device.
    1267                 :            :  * @dev: Device to take care of.
    1268                 :            :  * @power_off: Whether or not to try to remove power from the device.
    1269                 :            :  *
    1270                 :            :  * Remove the device from the general ACPI PM domain and remove its wakeup
    1271                 :            :  * notifier.  If @power_off is set, additionally remove power from the device if
    1272                 :            :  * possible.
    1273                 :            :  *
    1274                 :            :  * Callers must ensure proper synchronization of this function with power
    1275                 :            :  * management callbacks.
    1276                 :            :  */
    1277                 :          0 : static void acpi_dev_pm_detach(struct device *dev, bool power_off)
    1278                 :            : {
    1279         [ #  # ]:          0 :         struct acpi_device *adev = ACPI_COMPANION(dev);
    1280                 :            : 
    1281   [ #  #  #  # ]:          0 :         if (adev && dev->pm_domain == &acpi_general_pm_domain) {
    1282                 :          0 :                 dev_pm_domain_set(dev, NULL);
    1283                 :          0 :                 acpi_remove_pm_notifier(adev);
    1284         [ #  # ]:          0 :                 if (power_off) {
    1285                 :            :                         /*
    1286                 :            :                          * If the device's PM QoS resume latency limit or flags
    1287                 :            :                          * have been exposed to user space, they have to be
    1288                 :            :                          * hidden at this point, so that they don't affect the
    1289                 :            :                          * choice of the low-power state to put the device into.
    1290                 :            :                          */
    1291                 :          0 :                         dev_pm_qos_hide_latency_limit(dev);
    1292                 :          0 :                         dev_pm_qos_hide_flags(dev);
    1293                 :          0 :                         acpi_device_wakeup_disable(adev);
    1294                 :          0 :                         acpi_dev_pm_low_power(dev, adev, ACPI_STATE_S0);
    1295                 :            :                 }
    1296                 :            :         }
    1297                 :          0 : }
    1298                 :            : 
    1299                 :            : /**
    1300                 :            :  * acpi_dev_pm_attach - Prepare device for ACPI power management.
    1301                 :            :  * @dev: Device to prepare.
    1302                 :            :  * @power_on: Whether or not to power on the device.
    1303                 :            :  *
    1304                 :            :  * If @dev has a valid ACPI handle that has a valid struct acpi_device object
    1305                 :            :  * attached to it, install a wakeup notification handler for the device and
    1306                 :            :  * add it to the general ACPI PM domain.  If @power_on is set, the device will
    1307                 :            :  * be put into the ACPI D0 state before the function returns.
    1308                 :            :  *
    1309                 :            :  * This assumes that the @dev's bus type uses generic power management callbacks
    1310                 :            :  * (or doesn't use any power management callbacks at all).
    1311                 :            :  *
    1312                 :            :  * Callers must ensure proper synchronization of this function with power
    1313                 :            :  * management callbacks.
    1314                 :            :  */
    1315                 :         63 : int acpi_dev_pm_attach(struct device *dev, bool power_on)
    1316                 :            : {
    1317                 :            :         /*
    1318                 :            :          * Skip devices whose ACPI companions match the device IDs below,
    1319                 :            :          * because they require special power management handling incompatible
    1320                 :            :          * with the generic ACPI PM domain.
    1321                 :            :          */
    1322                 :         63 :         static const struct acpi_device_id special_pm_ids[] = {
    1323                 :            :                 {"PNP0C0B", }, /* Generic ACPI fan */
    1324                 :            :                 {"INT1044", }, /* Fan for Tiger Lake generation */
    1325                 :            :                 {"INT3404", }, /* Fan */
    1326                 :            :                 {}
    1327                 :            :         };
    1328         [ -  + ]:         63 :         struct acpi_device *adev = ACPI_COMPANION(dev);
    1329                 :            : 
    1330   [ #  #  #  # ]:          0 :         if (!adev || !acpi_match_device_ids(adev, special_pm_ids))
    1331                 :         63 :                 return 0;
    1332                 :            : 
    1333                 :            :         /*
    1334                 :            :          * Only attach the power domain to the first device if the
    1335                 :            :          * companion is shared by multiple. This is to prevent doing power
    1336                 :            :          * management twice.
    1337                 :            :          */
    1338         [ #  # ]:          0 :         if (!acpi_device_is_first_physical_node(adev, dev))
    1339                 :            :                 return 0;
    1340                 :            : 
    1341                 :          0 :         acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);
    1342                 :          0 :         dev_pm_domain_set(dev, &acpi_general_pm_domain);
    1343         [ #  # ]:          0 :         if (power_on) {
    1344         [ #  # ]:          0 :                 acpi_dev_pm_full_power(adev);
    1345                 :          0 :                 acpi_device_wakeup_disable(adev);
    1346                 :            :         }
    1347                 :            : 
    1348                 :          0 :         dev->pm_domain->detach = acpi_dev_pm_detach;
    1349                 :          0 :         return 1;
    1350                 :            : }
    1351                 :            : EXPORT_SYMBOL_GPL(acpi_dev_pm_attach);
    1352                 :            : #endif /* CONFIG_PM */

Generated by: LCOV version 1.14