LCOV - code coverage report
Current view: top level - drivers/base/power - sysfs.c (source / functions) Hit Total Coverage
Test: Real Lines: 29 120 24.2 %
Date: 2020-10-17 15:46:16 Functions: 1 24 4.2 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /* sysfs entries for device PM */
       3                 :            : #include <linux/device.h>
       4                 :            : #include <linux/string.h>
       5                 :            : #include <linux/export.h>
       6                 :            : #include <linux/pm_qos.h>
       7                 :            : #include <linux/pm_runtime.h>
       8                 :            : #include <linux/pm_wakeup.h>
       9                 :            : #include <linux/atomic.h>
      10                 :            : #include <linux/jiffies.h>
      11                 :            : #include "power.h"
      12                 :            : 
      13                 :            : /*
      14                 :            :  *      control - Report/change current runtime PM setting of the device
      15                 :            :  *
      16                 :            :  *      Runtime power management of a device can be blocked with the help of
      17                 :            :  *      this attribute.  All devices have one of the following two values for
      18                 :            :  *      the power/control file:
      19                 :            :  *
      20                 :            :  *       + "auto\n" to allow the device to be power managed at run time;
      21                 :            :  *       + "on\n" to prevent the device from being power managed at run time;
      22                 :            :  *
      23                 :            :  *      The default for all devices is "auto", which means that devices may be
      24                 :            :  *      subject to automatic power management, depending on their drivers.
      25                 :            :  *      Changing this attribute to "on" prevents the driver from power managing
      26                 :            :  *      the device at run time.  Doing that while the device is suspended causes
      27                 :            :  *      it to be woken up.
      28                 :            :  *
      29                 :            :  *      wakeup - Report/change current wakeup option for device
      30                 :            :  *
      31                 :            :  *      Some devices support "wakeup" events, which are hardware signals
      32                 :            :  *      used to activate devices from suspended or low power states.  Such
      33                 :            :  *      devices have one of three values for the sysfs power/wakeup file:
      34                 :            :  *
      35                 :            :  *       + "enabled\n" to issue the events;
      36                 :            :  *       + "disabled\n" not to do so; or
      37                 :            :  *       + "\n" for temporary or permanent inability to issue wakeup.
      38                 :            :  *
      39                 :            :  *      (For example, unconfigured USB devices can't issue wakeups.)
      40                 :            :  *
      41                 :            :  *      Familiar examples of devices that can issue wakeup events include
      42                 :            :  *      keyboards and mice (both PS2 and USB styles), power buttons, modems,
      43                 :            :  *      "Wake-On-LAN" Ethernet links, GPIO lines, and more.  Some events
      44                 :            :  *      will wake the entire system from a suspend state; others may just
      45                 :            :  *      wake up the device (if the system as a whole is already active).
      46                 :            :  *      Some wakeup events use normal IRQ lines; other use special out
      47                 :            :  *      of band signaling.
      48                 :            :  *
      49                 :            :  *      It is the responsibility of device drivers to enable (or disable)
      50                 :            :  *      wakeup signaling as part of changing device power states, respecting
      51                 :            :  *      the policy choices provided through the driver model.
      52                 :            :  *
      53                 :            :  *      Devices may not be able to generate wakeup events from all power
      54                 :            :  *      states.  Also, the events may be ignored in some configurations;
      55                 :            :  *      for example, they might need help from other devices that aren't
      56                 :            :  *      active, or which may have wakeup disabled.  Some drivers rely on
      57                 :            :  *      wakeup events internally (unless they are disabled), keeping
      58                 :            :  *      their hardware in low power modes whenever they're unused.  This
      59                 :            :  *      saves runtime power, without requiring system-wide sleep states.
      60                 :            :  *
      61                 :            :  *      async - Report/change current async suspend setting for the device
      62                 :            :  *
      63                 :            :  *      Asynchronous suspend and resume of the device during system-wide power
      64                 :            :  *      state transitions can be enabled by writing "enabled" to this file.
      65                 :            :  *      Analogously, if "disabled" is written to this file, the device will be
      66                 :            :  *      suspended and resumed synchronously.
      67                 :            :  *
      68                 :            :  *      All devices have one of the following two values for power/async:
      69                 :            :  *
      70                 :            :  *       + "enabled\n" to permit the asynchronous suspend/resume of the device;
      71                 :            :  *       + "disabled\n" to forbid it;
      72                 :            :  *
      73                 :            :  *      NOTE: It generally is unsafe to permit the asynchronous suspend/resume
      74                 :            :  *      of a device unless it is certain that all of the PM dependencies of the
      75                 :            :  *      device are known to the PM core.  However, for some devices this
      76                 :            :  *      attribute is set to "enabled" by bus type code or device drivers and in
      77                 :            :  *      that cases it should be safe to leave the default value.
      78                 :            :  *
      79                 :            :  *      autosuspend_delay_ms - Report/change a device's autosuspend_delay value
      80                 :            :  *
      81                 :            :  *      Some drivers don't want to carry out a runtime suspend as soon as a
      82                 :            :  *      device becomes idle; they want it always to remain idle for some period
      83                 :            :  *      of time before suspending it.  This period is the autosuspend_delay
      84                 :            :  *      value (expressed in milliseconds) and it can be controlled by the user.
      85                 :            :  *      If the value is negative then the device will never be runtime
      86                 :            :  *      suspended.
      87                 :            :  *
      88                 :            :  *      NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay
      89                 :            :  *      value are used only if the driver calls pm_runtime_use_autosuspend().
      90                 :            :  *
      91                 :            :  *      wakeup_count - Report the number of wakeup events related to the device
      92                 :            :  */
      93                 :            : 
      94                 :            : const char power_group_name[] = "power";
      95                 :            : EXPORT_SYMBOL_GPL(power_group_name);
      96                 :            : 
      97                 :            : static const char ctrl_auto[] = "auto";
      98                 :            : static const char ctrl_on[] = "on";
      99                 :            : 
     100                 :          0 : static ssize_t control_show(struct device *dev, struct device_attribute *attr,
     101                 :            :                             char *buf)
     102                 :            : {
     103                 :          0 :         return sprintf(buf, "%s\n",
     104                 :          0 :                                 dev->power.runtime_auto ? ctrl_auto : ctrl_on);
     105                 :            : }
     106                 :            : 
     107                 :          0 : static ssize_t control_store(struct device * dev, struct device_attribute *attr,
     108                 :            :                              const char * buf, size_t n)
     109                 :            : {
     110                 :            :         device_lock(dev);
     111                 :          0 :         if (sysfs_streq(buf, ctrl_auto))
     112                 :          0 :                 pm_runtime_allow(dev);
     113                 :          0 :         else if (sysfs_streq(buf, ctrl_on))
     114                 :          0 :                 pm_runtime_forbid(dev);
     115                 :            :         else
     116                 :            :                 n = -EINVAL;
     117                 :            :         device_unlock(dev);
     118                 :          0 :         return n;
     119                 :            : }
     120                 :            : 
     121                 :            : static DEVICE_ATTR_RW(control);
     122                 :            : 
     123                 :          0 : static ssize_t runtime_active_time_show(struct device *dev,
     124                 :            :                                 struct device_attribute *attr, char *buf)
     125                 :            : {
     126                 :            :         int ret;
     127                 :          0 :         u64 tmp = pm_runtime_active_time(dev);
     128                 :          0 :         do_div(tmp, NSEC_PER_MSEC);
     129                 :          0 :         ret = sprintf(buf, "%llu\n", tmp);
     130                 :          0 :         return ret;
     131                 :            : }
     132                 :            : 
     133                 :            : static DEVICE_ATTR_RO(runtime_active_time);
     134                 :            : 
     135                 :          0 : static ssize_t runtime_suspended_time_show(struct device *dev,
     136                 :            :                                 struct device_attribute *attr, char *buf)
     137                 :            : {
     138                 :            :         int ret;
     139                 :          0 :         u64 tmp = pm_runtime_suspended_time(dev);
     140                 :          0 :         do_div(tmp, NSEC_PER_MSEC);
     141                 :          0 :         ret = sprintf(buf, "%llu\n", tmp);
     142                 :          0 :         return ret;
     143                 :            : }
     144                 :            : 
     145                 :            : static DEVICE_ATTR_RO(runtime_suspended_time);
     146                 :            : 
     147                 :          0 : static ssize_t runtime_status_show(struct device *dev,
     148                 :            :                                 struct device_attribute *attr, char *buf)
     149                 :            : {
     150                 :            :         const char *p;
     151                 :            : 
     152                 :          0 :         if (dev->power.runtime_error) {
     153                 :            :                 p = "error\n";
     154                 :          0 :         } else if (dev->power.disable_depth) {
     155                 :            :                 p = "unsupported\n";
     156                 :            :         } else {
     157                 :          0 :                 switch (dev->power.runtime_status) {
     158                 :            :                 case RPM_SUSPENDED:
     159                 :            :                         p = "suspended\n";
     160                 :            :                         break;
     161                 :            :                 case RPM_SUSPENDING:
     162                 :            :                         p = "suspending\n";
     163                 :          0 :                         break;
     164                 :            :                 case RPM_RESUMING:
     165                 :            :                         p = "resuming\n";
     166                 :          0 :                         break;
     167                 :            :                 case RPM_ACTIVE:
     168                 :            :                         p = "active\n";
     169                 :          0 :                         break;
     170                 :            :                 default:
     171                 :            :                         return -EIO;
     172                 :            :                 }
     173                 :            :         }
     174                 :          0 :         return sprintf(buf, p);
     175                 :            : }
     176                 :            : 
     177                 :            : static DEVICE_ATTR_RO(runtime_status);
     178                 :            : 
     179                 :          0 : static ssize_t autosuspend_delay_ms_show(struct device *dev,
     180                 :            :                 struct device_attribute *attr, char *buf)
     181                 :            : {
     182                 :          0 :         if (!dev->power.use_autosuspend)
     183                 :            :                 return -EIO;
     184                 :          0 :         return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
     185                 :            : }
     186                 :            : 
     187                 :          0 : static ssize_t autosuspend_delay_ms_store(struct device *dev,
     188                 :            :                 struct device_attribute *attr, const char *buf, size_t n)
     189                 :            : {
     190                 :            :         long delay;
     191                 :            : 
     192                 :          0 :         if (!dev->power.use_autosuspend)
     193                 :            :                 return -EIO;
     194                 :            : 
     195                 :          0 :         if (kstrtol(buf, 10, &delay) != 0 || delay != (int) delay)
     196                 :            :                 return -EINVAL;
     197                 :            : 
     198                 :            :         device_lock(dev);
     199                 :          0 :         pm_runtime_set_autosuspend_delay(dev, delay);
     200                 :            :         device_unlock(dev);
     201                 :          0 :         return n;
     202                 :            : }
     203                 :            : 
     204                 :            : static DEVICE_ATTR_RW(autosuspend_delay_ms);
     205                 :            : 
     206                 :          0 : static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
     207                 :            :                                              struct device_attribute *attr,
     208                 :            :                                              char *buf)
     209                 :            : {
     210                 :            :         s32 value = dev_pm_qos_requested_resume_latency(dev);
     211                 :            : 
     212                 :          0 :         if (value == 0)
     213                 :          0 :                 return sprintf(buf, "n/a\n");
     214                 :          0 :         if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
     215                 :            :                 value = 0;
     216                 :            : 
     217                 :          0 :         return sprintf(buf, "%d\n", value);
     218                 :            : }
     219                 :            : 
     220                 :          0 : static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
     221                 :            :                                               struct device_attribute *attr,
     222                 :            :                                               const char *buf, size_t n)
     223                 :            : {
     224                 :            :         s32 value;
     225                 :            :         int ret;
     226                 :            : 
     227                 :          0 :         if (!kstrtos32(buf, 0, &value)) {
     228                 :            :                 /*
     229                 :            :                  * Prevent users from writing negative or "no constraint" values
     230                 :            :                  * directly.
     231                 :            :                  */
     232                 :          0 :                 if (value < 0 || value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
     233                 :            :                         return -EINVAL;
     234                 :            : 
     235                 :          0 :                 if (value == 0)
     236                 :          0 :                         value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;
     237                 :          0 :         } else if (sysfs_streq(buf, "n/a")) {
     238                 :          0 :                 value = 0;
     239                 :            :         } else {
     240                 :            :                 return -EINVAL;
     241                 :            :         }
     242                 :            : 
     243                 :          0 :         ret = dev_pm_qos_update_request(dev->power.qos->resume_latency_req,
     244                 :            :                                         value);
     245                 :          0 :         return ret < 0 ? ret : n;
     246                 :            : }
     247                 :            : 
     248                 :            : static DEVICE_ATTR_RW(pm_qos_resume_latency_us);
     249                 :            : 
     250                 :          0 : static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
     251                 :            :                                                 struct device_attribute *attr,
     252                 :            :                                                 char *buf)
     253                 :            : {
     254                 :          0 :         s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
     255                 :            : 
     256                 :          0 :         if (value < 0)
     257                 :          0 :                 return sprintf(buf, "auto\n");
     258                 :          0 :         if (value == PM_QOS_LATENCY_ANY)
     259                 :          0 :                 return sprintf(buf, "any\n");
     260                 :            : 
     261                 :          0 :         return sprintf(buf, "%d\n", value);
     262                 :            : }
     263                 :            : 
     264                 :          0 : static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
     265                 :            :                                                  struct device_attribute *attr,
     266                 :            :                                                  const char *buf, size_t n)
     267                 :            : {
     268                 :            :         s32 value;
     269                 :            :         int ret;
     270                 :            : 
     271                 :          0 :         if (kstrtos32(buf, 0, &value) == 0) {
     272                 :            :                 /* Users can't write negative values directly */
     273                 :          0 :                 if (value < 0)
     274                 :            :                         return -EINVAL;
     275                 :            :         } else {
     276                 :          0 :                 if (sysfs_streq(buf, "auto"))
     277                 :          0 :                         value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;
     278                 :          0 :                 else if (sysfs_streq(buf, "any"))
     279                 :          0 :                         value = PM_QOS_LATENCY_ANY;
     280                 :            :                 else
     281                 :            :                         return -EINVAL;
     282                 :            :         }
     283                 :          0 :         ret = dev_pm_qos_update_user_latency_tolerance(dev, value);
     284                 :          0 :         return ret < 0 ? ret : n;
     285                 :            : }
     286                 :            : 
     287                 :            : static DEVICE_ATTR_RW(pm_qos_latency_tolerance_us);
     288                 :            : 
     289                 :          0 : static ssize_t pm_qos_no_power_off_show(struct device *dev,
     290                 :            :                                         struct device_attribute *attr,
     291                 :            :                                         char *buf)
     292                 :            : {
     293                 :          0 :         return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
     294                 :          0 :                                         & PM_QOS_FLAG_NO_POWER_OFF));
     295                 :            : }
     296                 :            : 
     297                 :          0 : static ssize_t pm_qos_no_power_off_store(struct device *dev,
     298                 :            :                                          struct device_attribute *attr,
     299                 :            :                                          const char *buf, size_t n)
     300                 :            : {
     301                 :            :         int ret;
     302                 :            : 
     303                 :          0 :         if (kstrtoint(buf, 0, &ret))
     304                 :            :                 return -EINVAL;
     305                 :            : 
     306                 :          0 :         if (ret != 0 && ret != 1)
     307                 :            :                 return -EINVAL;
     308                 :            : 
     309                 :          0 :         ret = dev_pm_qos_update_flags(dev, PM_QOS_FLAG_NO_POWER_OFF, ret);
     310                 :          0 :         return ret < 0 ? ret : n;
     311                 :            : }
     312                 :            : 
     313                 :            : static DEVICE_ATTR_RW(pm_qos_no_power_off);
     314                 :            : 
     315                 :            : #ifdef CONFIG_PM_SLEEP
     316                 :            : static const char _enabled[] = "enabled";
     317                 :            : static const char _disabled[] = "disabled";
     318                 :            : 
     319                 :            : static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
     320                 :            :                            char *buf)
     321                 :            : {
     322                 :            :         return sprintf(buf, "%s\n", device_can_wakeup(dev)
     323                 :            :                 ? (device_may_wakeup(dev) ? _enabled : _disabled)
     324                 :            :                 : "");
     325                 :            : }
     326                 :            : 
     327                 :            : static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
     328                 :            :                             const char *buf, size_t n)
     329                 :            : {
     330                 :            :         if (!device_can_wakeup(dev))
     331                 :            :                 return -EINVAL;
     332                 :            : 
     333                 :            :         if (sysfs_streq(buf, _enabled))
     334                 :            :                 device_set_wakeup_enable(dev, 1);
     335                 :            :         else if (sysfs_streq(buf, _disabled))
     336                 :            :                 device_set_wakeup_enable(dev, 0);
     337                 :            :         else
     338                 :            :                 return -EINVAL;
     339                 :            :         return n;
     340                 :            : }
     341                 :            : 
     342                 :            : static DEVICE_ATTR_RW(wakeup);
     343                 :            : 
     344                 :            : static ssize_t wakeup_count_show(struct device *dev,
     345                 :            :                                  struct device_attribute *attr, char *buf)
     346                 :            : {
     347                 :            :         unsigned long count = 0;
     348                 :            :         bool enabled = false;
     349                 :            : 
     350                 :            :         spin_lock_irq(&dev->power.lock);
     351                 :            :         if (dev->power.wakeup) {
     352                 :            :                 count = dev->power.wakeup->wakeup_count;
     353                 :            :                 enabled = true;
     354                 :            :         }
     355                 :            :         spin_unlock_irq(&dev->power.lock);
     356                 :            :         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
     357                 :            : }
     358                 :            : 
     359                 :            : static DEVICE_ATTR_RO(wakeup_count);
     360                 :            : 
     361                 :            : static ssize_t wakeup_active_count_show(struct device *dev,
     362                 :            :                                         struct device_attribute *attr,
     363                 :            :                                         char *buf)
     364                 :            : {
     365                 :            :         unsigned long count = 0;
     366                 :            :         bool enabled = false;
     367                 :            : 
     368                 :            :         spin_lock_irq(&dev->power.lock);
     369                 :            :         if (dev->power.wakeup) {
     370                 :            :                 count = dev->power.wakeup->active_count;
     371                 :            :                 enabled = true;
     372                 :            :         }
     373                 :            :         spin_unlock_irq(&dev->power.lock);
     374                 :            :         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
     375                 :            : }
     376                 :            : 
     377                 :            : static DEVICE_ATTR_RO(wakeup_active_count);
     378                 :            : 
     379                 :            : static ssize_t wakeup_abort_count_show(struct device *dev,
     380                 :            :                                        struct device_attribute *attr,
     381                 :            :                                        char *buf)
     382                 :            : {
     383                 :            :         unsigned long count = 0;
     384                 :            :         bool enabled = false;
     385                 :            : 
     386                 :            :         spin_lock_irq(&dev->power.lock);
     387                 :            :         if (dev->power.wakeup) {
     388                 :            :                 count = dev->power.wakeup->wakeup_count;
     389                 :            :                 enabled = true;
     390                 :            :         }
     391                 :            :         spin_unlock_irq(&dev->power.lock);
     392                 :            :         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
     393                 :            : }
     394                 :            : 
     395                 :            : static DEVICE_ATTR_RO(wakeup_abort_count);
     396                 :            : 
     397                 :            : static ssize_t wakeup_expire_count_show(struct device *dev,
     398                 :            :                                         struct device_attribute *attr,
     399                 :            :                                         char *buf)
     400                 :            : {
     401                 :            :         unsigned long count = 0;
     402                 :            :         bool enabled = false;
     403                 :            : 
     404                 :            :         spin_lock_irq(&dev->power.lock);
     405                 :            :         if (dev->power.wakeup) {
     406                 :            :                 count = dev->power.wakeup->expire_count;
     407                 :            :                 enabled = true;
     408                 :            :         }
     409                 :            :         spin_unlock_irq(&dev->power.lock);
     410                 :            :         return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
     411                 :            : }
     412                 :            : 
     413                 :            : static DEVICE_ATTR_RO(wakeup_expire_count);
     414                 :            : 
     415                 :            : static ssize_t wakeup_active_show(struct device *dev,
     416                 :            :                                   struct device_attribute *attr, char *buf)
     417                 :            : {
     418                 :            :         unsigned int active = 0;
     419                 :            :         bool enabled = false;
     420                 :            : 
     421                 :            :         spin_lock_irq(&dev->power.lock);
     422                 :            :         if (dev->power.wakeup) {
     423                 :            :                 active = dev->power.wakeup->active;
     424                 :            :                 enabled = true;
     425                 :            :         }
     426                 :            :         spin_unlock_irq(&dev->power.lock);
     427                 :            :         return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
     428                 :            : }
     429                 :            : 
     430                 :            : static DEVICE_ATTR_RO(wakeup_active);
     431                 :            : 
     432                 :            : static ssize_t wakeup_total_time_ms_show(struct device *dev,
     433                 :            :                                          struct device_attribute *attr,
     434                 :            :                                          char *buf)
     435                 :            : {
     436                 :            :         s64 msec = 0;
     437                 :            :         bool enabled = false;
     438                 :            : 
     439                 :            :         spin_lock_irq(&dev->power.lock);
     440                 :            :         if (dev->power.wakeup) {
     441                 :            :                 msec = ktime_to_ms(dev->power.wakeup->total_time);
     442                 :            :                 enabled = true;
     443                 :            :         }
     444                 :            :         spin_unlock_irq(&dev->power.lock);
     445                 :            :         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
     446                 :            : }
     447                 :            : 
     448                 :            : static DEVICE_ATTR_RO(wakeup_total_time_ms);
     449                 :            : 
     450                 :            : static ssize_t wakeup_max_time_ms_show(struct device *dev,
     451                 :            :                                        struct device_attribute *attr, char *buf)
     452                 :            : {
     453                 :            :         s64 msec = 0;
     454                 :            :         bool enabled = false;
     455                 :            : 
     456                 :            :         spin_lock_irq(&dev->power.lock);
     457                 :            :         if (dev->power.wakeup) {
     458                 :            :                 msec = ktime_to_ms(dev->power.wakeup->max_time);
     459                 :            :                 enabled = true;
     460                 :            :         }
     461                 :            :         spin_unlock_irq(&dev->power.lock);
     462                 :            :         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
     463                 :            : }
     464                 :            : 
     465                 :            : static DEVICE_ATTR_RO(wakeup_max_time_ms);
     466                 :            : 
     467                 :            : static ssize_t wakeup_last_time_ms_show(struct device *dev,
     468                 :            :                                         struct device_attribute *attr,
     469                 :            :                                         char *buf)
     470                 :            : {
     471                 :            :         s64 msec = 0;
     472                 :            :         bool enabled = false;
     473                 :            : 
     474                 :            :         spin_lock_irq(&dev->power.lock);
     475                 :            :         if (dev->power.wakeup) {
     476                 :            :                 msec = ktime_to_ms(dev->power.wakeup->last_time);
     477                 :            :                 enabled = true;
     478                 :            :         }
     479                 :            :         spin_unlock_irq(&dev->power.lock);
     480                 :            :         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
     481                 :            : }
     482                 :            : 
     483                 :            : static DEVICE_ATTR_RO(wakeup_last_time_ms);
     484                 :            : 
     485                 :            : #ifdef CONFIG_PM_AUTOSLEEP
     486                 :            : static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
     487                 :            :                                                  struct device_attribute *attr,
     488                 :            :                                                  char *buf)
     489                 :            : {
     490                 :            :         s64 msec = 0;
     491                 :            :         bool enabled = false;
     492                 :            : 
     493                 :            :         spin_lock_irq(&dev->power.lock);
     494                 :            :         if (dev->power.wakeup) {
     495                 :            :                 msec = ktime_to_ms(dev->power.wakeup->prevent_sleep_time);
     496                 :            :                 enabled = true;
     497                 :            :         }
     498                 :            :         spin_unlock_irq(&dev->power.lock);
     499                 :            :         return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
     500                 :            : }
     501                 :            : 
     502                 :            : static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
     503                 :            : #endif /* CONFIG_PM_AUTOSLEEP */
     504                 :            : #endif /* CONFIG_PM_SLEEP */
     505                 :            : 
     506                 :            : #ifdef CONFIG_PM_ADVANCED_DEBUG
     507                 :            : static ssize_t runtime_usage_show(struct device *dev,
     508                 :            :                                   struct device_attribute *attr, char *buf)
     509                 :            : {
     510                 :            :         return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
     511                 :            : }
     512                 :            : static DEVICE_ATTR_RO(runtime_usage);
     513                 :            : 
     514                 :            : static ssize_t runtime_active_kids_show(struct device *dev,
     515                 :            :                                         struct device_attribute *attr,
     516                 :            :                                         char *buf)
     517                 :            : {
     518                 :            :         return sprintf(buf, "%d\n", dev->power.ignore_children ?
     519                 :            :                 0 : atomic_read(&dev->power.child_count));
     520                 :            : }
     521                 :            : static DEVICE_ATTR_RO(runtime_active_kids);
     522                 :            : 
     523                 :            : static ssize_t runtime_enabled_show(struct device *dev,
     524                 :            :                                     struct device_attribute *attr, char *buf)
     525                 :            : {
     526                 :            :         if (dev->power.disable_depth && (dev->power.runtime_auto == false))
     527                 :            :                 return sprintf(buf, "disabled & forbidden\n");
     528                 :            :         if (dev->power.disable_depth)
     529                 :            :                 return sprintf(buf, "disabled\n");
     530                 :            :         if (dev->power.runtime_auto == false)
     531                 :            :                 return sprintf(buf, "forbidden\n");
     532                 :            :         return sprintf(buf, "enabled\n");
     533                 :            : }
     534                 :            : static DEVICE_ATTR_RO(runtime_enabled);
     535                 :            : 
     536                 :            : #ifdef CONFIG_PM_SLEEP
     537                 :            : static ssize_t async_show(struct device *dev, struct device_attribute *attr,
     538                 :            :                           char *buf)
     539                 :            : {
     540                 :            :         return sprintf(buf, "%s\n",
     541                 :            :                         device_async_suspend_enabled(dev) ?
     542                 :            :                                 _enabled : _disabled);
     543                 :            : }
     544                 :            : 
     545                 :            : static ssize_t async_store(struct device *dev, struct device_attribute *attr,
     546                 :            :                            const char *buf, size_t n)
     547                 :            : {
     548                 :            :         if (sysfs_streq(buf, _enabled))
     549                 :            :                 device_enable_async_suspend(dev);
     550                 :            :         else if (sysfs_streq(buf, _disabled))
     551                 :            :                 device_disable_async_suspend(dev);
     552                 :            :         else
     553                 :            :                 return -EINVAL;
     554                 :            :         return n;
     555                 :            : }
     556                 :            : 
     557                 :            : static DEVICE_ATTR_RW(async);
     558                 :            : 
     559                 :            : #endif /* CONFIG_PM_SLEEP */
     560                 :            : #endif /* CONFIG_PM_ADVANCED_DEBUG */
     561                 :            : 
     562                 :            : static struct attribute *power_attrs[] = {
     563                 :            : #ifdef CONFIG_PM_ADVANCED_DEBUG
     564                 :            : #ifdef CONFIG_PM_SLEEP
     565                 :            :         &dev_attr_async.attr,
     566                 :            : #endif
     567                 :            :         &dev_attr_runtime_status.attr,
     568                 :            :         &dev_attr_runtime_usage.attr,
     569                 :            :         &dev_attr_runtime_active_kids.attr,
     570                 :            :         &dev_attr_runtime_enabled.attr,
     571                 :            : #endif /* CONFIG_PM_ADVANCED_DEBUG */
     572                 :            :         NULL,
     573                 :            : };
     574                 :            : static const struct attribute_group pm_attr_group = {
     575                 :            :         .name   = power_group_name,
     576                 :            :         .attrs  = power_attrs,
     577                 :            : };
     578                 :            : 
     579                 :            : static struct attribute *wakeup_attrs[] = {
     580                 :            : #ifdef CONFIG_PM_SLEEP
     581                 :            :         &dev_attr_wakeup.attr,
     582                 :            :         &dev_attr_wakeup_count.attr,
     583                 :            :         &dev_attr_wakeup_active_count.attr,
     584                 :            :         &dev_attr_wakeup_abort_count.attr,
     585                 :            :         &dev_attr_wakeup_expire_count.attr,
     586                 :            :         &dev_attr_wakeup_active.attr,
     587                 :            :         &dev_attr_wakeup_total_time_ms.attr,
     588                 :            :         &dev_attr_wakeup_max_time_ms.attr,
     589                 :            :         &dev_attr_wakeup_last_time_ms.attr,
     590                 :            : #ifdef CONFIG_PM_AUTOSLEEP
     591                 :            :         &dev_attr_wakeup_prevent_sleep_time_ms.attr,
     592                 :            : #endif
     593                 :            : #endif
     594                 :            :         NULL,
     595                 :            : };
     596                 :            : static const struct attribute_group pm_wakeup_attr_group = {
     597                 :            :         .name   = power_group_name,
     598                 :            :         .attrs  = wakeup_attrs,
     599                 :            : };
     600                 :            : 
     601                 :            : static struct attribute *runtime_attrs[] = {
     602                 :            : #ifndef CONFIG_PM_ADVANCED_DEBUG
     603                 :            :         &dev_attr_runtime_status.attr,
     604                 :            : #endif
     605                 :            :         &dev_attr_control.attr,
     606                 :            :         &dev_attr_runtime_suspended_time.attr,
     607                 :            :         &dev_attr_runtime_active_time.attr,
     608                 :            :         &dev_attr_autosuspend_delay_ms.attr,
     609                 :            :         NULL,
     610                 :            : };
     611                 :            : static const struct attribute_group pm_runtime_attr_group = {
     612                 :            :         .name   = power_group_name,
     613                 :            :         .attrs  = runtime_attrs,
     614                 :            : };
     615                 :            : 
     616                 :            : static struct attribute *pm_qos_resume_latency_attrs[] = {
     617                 :            :         &dev_attr_pm_qos_resume_latency_us.attr,
     618                 :            :         NULL,
     619                 :            : };
     620                 :            : static const struct attribute_group pm_qos_resume_latency_attr_group = {
     621                 :            :         .name   = power_group_name,
     622                 :            :         .attrs  = pm_qos_resume_latency_attrs,
     623                 :            : };
     624                 :            : 
     625                 :            : static struct attribute *pm_qos_latency_tolerance_attrs[] = {
     626                 :            :         &dev_attr_pm_qos_latency_tolerance_us.attr,
     627                 :            :         NULL,
     628                 :            : };
     629                 :            : static const struct attribute_group pm_qos_latency_tolerance_attr_group = {
     630                 :            :         .name   = power_group_name,
     631                 :            :         .attrs  = pm_qos_latency_tolerance_attrs,
     632                 :            : };
     633                 :            : 
     634                 :            : static struct attribute *pm_qos_flags_attrs[] = {
     635                 :            :         &dev_attr_pm_qos_no_power_off.attr,
     636                 :            :         NULL,
     637                 :            : };
     638                 :            : static const struct attribute_group pm_qos_flags_attr_group = {
     639                 :            :         .name   = power_group_name,
     640                 :            :         .attrs  = pm_qos_flags_attrs,
     641                 :            : };
     642                 :            : 
     643                 :          3 : int dpm_sysfs_add(struct device *dev)
     644                 :            : {
     645                 :            :         int rc;
     646                 :            : 
     647                 :            :         /* No need to create PM sysfs if explicitly disabled. */
     648                 :          3 :         if (device_pm_not_required(dev))
     649                 :            :                 return 0;
     650                 :            : 
     651                 :          3 :         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
     652                 :          3 :         if (rc)
     653                 :            :                 return rc;
     654                 :            : 
     655                 :          3 :         if (pm_runtime_callbacks_present(dev)) {
     656                 :          3 :                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
     657                 :          3 :                 if (rc)
     658                 :            :                         goto err_out;
     659                 :            :         }
     660                 :          3 :         if (device_can_wakeup(dev)) {
     661                 :          3 :                 rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
     662                 :          3 :                 if (rc)
     663                 :            :                         goto err_runtime;
     664                 :            :         }
     665                 :          3 :         if (dev->power.set_latency_tolerance) {
     666                 :          0 :                 rc = sysfs_merge_group(&dev->kobj,
     667                 :            :                                        &pm_qos_latency_tolerance_attr_group);
     668                 :          0 :                 if (rc)
     669                 :            :                         goto err_wakeup;
     670                 :            :         }
     671                 :            :         rc = pm_wakeup_source_sysfs_add(dev);
     672                 :            :         if (rc)
     673                 :            :                 goto err_latency;
     674                 :            :         return 0;
     675                 :            : 
     676                 :            :  err_latency:
     677                 :            :         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
     678                 :            :  err_wakeup:
     679                 :          0 :         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
     680                 :            :  err_runtime:
     681                 :          0 :         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
     682                 :            :  err_out:
     683                 :          0 :         sysfs_remove_group(&dev->kobj, &pm_attr_group);
     684                 :          0 :         return rc;
     685                 :            : }
     686                 :            : 
     687                 :          0 : int wakeup_sysfs_add(struct device *dev)
     688                 :            : {
     689                 :          0 :         return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
     690                 :            : }
     691                 :            : 
     692                 :          0 : void wakeup_sysfs_remove(struct device *dev)
     693                 :            : {
     694                 :          0 :         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
     695                 :          0 : }
     696                 :            : 
     697                 :          3 : int pm_qos_sysfs_add_resume_latency(struct device *dev)
     698                 :            : {
     699                 :          3 :         return sysfs_merge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
     700                 :            : }
     701                 :            : 
     702                 :          3 : void pm_qos_sysfs_remove_resume_latency(struct device *dev)
     703                 :            : {
     704                 :          3 :         sysfs_unmerge_group(&dev->kobj, &pm_qos_resume_latency_attr_group);
     705                 :          3 : }
     706                 :            : 
     707                 :          3 : int pm_qos_sysfs_add_flags(struct device *dev)
     708                 :            : {
     709                 :          3 :         return sysfs_merge_group(&dev->kobj, &pm_qos_flags_attr_group);
     710                 :            : }
     711                 :            : 
     712                 :          3 : void pm_qos_sysfs_remove_flags(struct device *dev)
     713                 :            : {
     714                 :          3 :         sysfs_unmerge_group(&dev->kobj, &pm_qos_flags_attr_group);
     715                 :          3 : }
     716                 :            : 
     717                 :          0 : int pm_qos_sysfs_add_latency_tolerance(struct device *dev)
     718                 :            : {
     719                 :          0 :         return sysfs_merge_group(&dev->kobj,
     720                 :            :                                  &pm_qos_latency_tolerance_attr_group);
     721                 :            : }
     722                 :            : 
     723                 :          0 : void pm_qos_sysfs_remove_latency_tolerance(struct device *dev)
     724                 :            : {
     725                 :          0 :         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
     726                 :          0 : }
     727                 :            : 
     728                 :          0 : void rpm_sysfs_remove(struct device *dev)
     729                 :            : {
     730                 :          3 :         sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
     731                 :          0 : }
     732                 :            : 
     733                 :          3 : void dpm_sysfs_remove(struct device *dev)
     734                 :            : {
     735                 :          3 :         if (device_pm_not_required(dev))
     736                 :          3 :                 return;
     737                 :          3 :         sysfs_unmerge_group(&dev->kobj, &pm_qos_latency_tolerance_attr_group);
     738                 :          3 :         dev_pm_qos_constraints_destroy(dev);
     739                 :            :         rpm_sysfs_remove(dev);
     740                 :          3 :         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
     741                 :          3 :         sysfs_remove_group(&dev->kobj, &pm_attr_group);
     742                 :            : }
    

Generated by: LCOV version 1.14