drm/amd: consolidate TA shared memory structures

[linux-2.6-microblaze.git] / drivers / base / power / sysfs.c

diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index c7b2481..a1474fb 100644 (file)
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -101,8 +101,8 @@ static const char ctrl_on[] = "on";
 static ssize_t control_show(struct device *dev, struct device_attribute *attr,
                            char *buf)
 {
-       return sprintf(buf, "%s\n",
-                               dev->power.runtime_auto ? ctrl_auto : ctrl_on);
+       return sysfs_emit(buf, "%s\n",
+                         dev->power.runtime_auto ? ctrl_auto : ctrl_on);
 }
 
 static ssize_t control_store(struct device * dev, struct device_attribute *attr,
@@ -122,67 +122,71 @@ static ssize_t control_store(struct device * dev, struct device_attribute *attr,
 static DEVICE_ATTR_RW(control);
 
 static ssize_t runtime_active_time_show(struct device *dev,
-                               struct device_attribute *attr, char *buf)
+                                       struct device_attribute *attr,
+                                       char *buf)
 {
-       int ret;
        u64 tmp = pm_runtime_active_time(dev);
+
        do_div(tmp, NSEC_PER_MSEC);
-       ret = sprintf(buf, "%llu\n", tmp);
-       return ret;
+
+       return sysfs_emit(buf, "%llu\n", tmp);
 }
 
 static DEVICE_ATTR_RO(runtime_active_time);
 
 static ssize_t runtime_suspended_time_show(struct device *dev,
-                               struct device_attribute *attr, char *buf)
+                                          struct device_attribute *attr,
+                                          char *buf)
 {
-       int ret;
        u64 tmp = pm_runtime_suspended_time(dev);
+
        do_div(tmp, NSEC_PER_MSEC);
-       ret = sprintf(buf, "%llu\n", tmp);
-       return ret;
+
+       return sysfs_emit(buf, "%llu\n", tmp);
 }
 
 static DEVICE_ATTR_RO(runtime_suspended_time);
 
 static ssize_t runtime_status_show(struct device *dev,
-                               struct device_attribute *attr, char *buf)
+                                  struct device_attribute *attr, char *buf)
 {
-       const char *p;
+       const char *output;
 
        if (dev->power.runtime_error) {
-               p = "error\n";
+               output = "error";
        } else if (dev->power.disable_depth) {
-               p = "unsupported\n";
+               output = "unsupported";
        } else {
                switch (dev->power.runtime_status) {
                case RPM_SUSPENDED:
-                       p = "suspended\n";
+                       output = "suspended";
                        break;
                case RPM_SUSPENDING:
-                       p = "suspending\n";
+                       output = "suspending";
                        break;
                case RPM_RESUMING:
-                       p = "resuming\n";
+                       output = "resuming";
                        break;
                case RPM_ACTIVE:
-                       p = "active\n";
+                       output = "active";
                        break;
                default:
                        return -EIO;
                }
        }
-       return sprintf(buf, p);
+       return sysfs_emit(buf, "%s\n", output);
 }
 
 static DEVICE_ATTR_RO(runtime_status);
 
 static ssize_t autosuspend_delay_ms_show(struct device *dev,
-               struct device_attribute *attr, char *buf)
+                                        struct device_attribute *attr,
+                                        char *buf)
 {
        if (!dev->power.use_autosuspend)
                return -EIO;
-       return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
+
+       return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay);
 }
 
 static ssize_t autosuspend_delay_ms_store(struct device *dev,
@@ -211,11 +215,11 @@ static ssize_t pm_qos_resume_latency_us_show(struct device *dev,
        s32 value = dev_pm_qos_requested_resume_latency(dev);
 
        if (value == 0)
-               return sprintf(buf, "n/a\n");
+               return sysfs_emit(buf, "n/a\n");
        if (value == PM_QOS_RESUME_LATENCY_NO_CONSTRAINT)
                value = 0;
 
-       return sprintf(buf, "%d\n", value);
+       return sysfs_emit(buf, "%d\n", value);
 }
 
 static ssize_t pm_qos_resume_latency_us_store(struct device *dev,
@@ -255,11 +259,11 @@ static ssize_t pm_qos_latency_tolerance_us_show(struct device *dev,
        s32 value = dev_pm_qos_get_user_latency_tolerance(dev);
 
        if (value < 0)
-               return sprintf(buf, "auto\n");
+               return sysfs_emit(buf, "%s\n", "auto");
        if (value == PM_QOS_LATENCY_ANY)
-               return sprintf(buf, "any\n");
+               return sysfs_emit(buf, "%s\n", "any");
 
-       return sprintf(buf, "%d\n", value);
+       return sysfs_emit(buf, "%d\n", value);
 }
 
 static ssize_t pm_qos_latency_tolerance_us_store(struct device *dev,
@@ -291,8 +295,8 @@ static ssize_t pm_qos_no_power_off_show(struct device *dev,
                                        struct device_attribute *attr,
                                        char *buf)
 {
-       return sprintf(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
-                                       & PM_QOS_FLAG_NO_POWER_OFF));
+       return sysfs_emit(buf, "%d\n", !!(dev_pm_qos_requested_flags(dev)
+                                         & PM_QOS_FLAG_NO_POWER_OFF));
 }
 
 static ssize_t pm_qos_no_power_off_store(struct device *dev,
@@ -320,9 +324,9 @@ static const char _disabled[] = "disabled";
 static ssize_t wakeup_show(struct device *dev, struct device_attribute *attr,
                           char *buf)
 {
-       return sprintf(buf, "%s\n", device_can_wakeup(dev)
-               ? (device_may_wakeup(dev) ? _enabled : _disabled)
-               : "");
+       return sysfs_emit(buf, "%s\n", device_can_wakeup(dev)
+                         ? (device_may_wakeup(dev) ? _enabled : _disabled)
+                         : "");
 }
 
 static ssize_t wakeup_store(struct device *dev, struct device_attribute *attr,
@@ -345,7 +349,7 @@ static DEVICE_ATTR_RW(wakeup);
 static ssize_t wakeup_count_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
-       unsigned long count = 0;
+       unsigned long count;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -354,7 +358,10 @@ static ssize_t wakeup_count_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lu\n", count);
 }
 
 static DEVICE_ATTR_RO(wakeup_count);
@@ -363,7 +370,7 @@ static ssize_t wakeup_active_count_show(struct device *dev,
                                        struct device_attribute *attr,
                                        char *buf)
 {
-       unsigned long count = 0;
+       unsigned long count;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -372,7 +379,10 @@ static ssize_t wakeup_active_count_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lu\n", count);
 }
 
 static DEVICE_ATTR_RO(wakeup_active_count);
@@ -381,7 +391,7 @@ static ssize_t wakeup_abort_count_show(struct device *dev,
                                       struct device_attribute *attr,
                                       char *buf)
 {
-       unsigned long count = 0;
+       unsigned long count;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -390,7 +400,10 @@ static ssize_t wakeup_abort_count_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lu\n", count);
 }
 
 static DEVICE_ATTR_RO(wakeup_abort_count);
@@ -399,7 +412,7 @@ static ssize_t wakeup_expire_count_show(struct device *dev,
                                        struct device_attribute *attr,
                                        char *buf)
 {
-       unsigned long count = 0;
+       unsigned long count;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -408,7 +421,10 @@ static ssize_t wakeup_expire_count_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lu\n", count);
 }
 
 static DEVICE_ATTR_RO(wakeup_expire_count);
@@ -416,7 +432,7 @@ static DEVICE_ATTR_RO(wakeup_expire_count);
 static ssize_t wakeup_active_show(struct device *dev,
                                  struct device_attribute *attr, char *buf)
 {
-       unsigned int active = 0;
+       unsigned int active;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -425,7 +441,10 @@ static ssize_t wakeup_active_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%u\n", active);
 }
 
 static DEVICE_ATTR_RO(wakeup_active);
@@ -434,7 +453,7 @@ static ssize_t wakeup_total_time_ms_show(struct device *dev,
                                         struct device_attribute *attr,
                                         char *buf)
 {
-       s64 msec = 0;
+       s64 msec;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -443,7 +462,10 @@ static ssize_t wakeup_total_time_ms_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lld\n", msec);
 }
 
 static DEVICE_ATTR_RO(wakeup_total_time_ms);
@@ -451,7 +473,7 @@ static DEVICE_ATTR_RO(wakeup_total_time_ms);
 static ssize_t wakeup_max_time_ms_show(struct device *dev,
                                       struct device_attribute *attr, char *buf)
 {
-       s64 msec = 0;
+       s64 msec;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -460,7 +482,10 @@ static ssize_t wakeup_max_time_ms_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lld\n", msec);
 }
 
 static DEVICE_ATTR_RO(wakeup_max_time_ms);
@@ -469,7 +494,7 @@ static ssize_t wakeup_last_time_ms_show(struct device *dev,
                                        struct device_attribute *attr,
                                        char *buf)
 {
-       s64 msec = 0;
+       s64 msec;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -478,7 +503,10 @@ static ssize_t wakeup_last_time_ms_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lld\n", msec);
 }
 
 static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
@@ -496,7 +524,7 @@ static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
                                                 struct device_attribute *attr,
                                                 char *buf)
 {
-       s64 msec = 0;
+       s64 msec;
        bool enabled = false;
 
        spin_lock_irq(&dev->power.lock);
@@ -505,7 +533,10 @@ static ssize_t wakeup_prevent_sleep_time_ms_show(struct device *dev,
                enabled = true;
        }
        spin_unlock_irq(&dev->power.lock);
-       return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
+
+       if (!enabled)
+               return sysfs_emit(buf, "\n");
+       return sysfs_emit(buf, "%lld\n", msec);
 }
 
 static DEVICE_ATTR_RO(wakeup_prevent_sleep_time_ms);
@@ -522,7 +553,7 @@ static inline int dpm_sysfs_wakeup_change_owner(struct device *dev, kuid_t kuid,
 static ssize_t runtime_usage_show(struct device *dev,
                                  struct device_attribute *attr, char *buf)
 {
-       return sprintf(buf, "%d\n", atomic_read(&dev->power.usage_count));
+       return sysfs_emit(buf, "%d\n", atomic_read(&dev->power.usage_count));
 }
 static DEVICE_ATTR_RO(runtime_usage);
 
@@ -530,21 +561,26 @@ static ssize_t runtime_active_kids_show(struct device *dev,
                                        struct device_attribute *attr,
                                        char *buf)
 {
-       return sprintf(buf, "%d\n", dev->power.ignore_children ?
-               0 : atomic_read(&dev->power.child_count));
+       return sysfs_emit(buf, "%d\n", dev->power.ignore_children ?
+                         0 : atomic_read(&dev->power.child_count));
 }
 static DEVICE_ATTR_RO(runtime_active_kids);
 
 static ssize_t runtime_enabled_show(struct device *dev,
                                    struct device_attribute *attr, char *buf)
 {
-       if (dev->power.disable_depth && (dev->power.runtime_auto == false))
-               return sprintf(buf, "disabled & forbidden\n");
-       if (dev->power.disable_depth)
-               return sprintf(buf, "disabled\n");
-       if (dev->power.runtime_auto == false)
-               return sprintf(buf, "forbidden\n");
-       return sprintf(buf, "enabled\n");
+       const char *output;
+
+       if (dev->power.disable_depth && !dev->power.runtime_auto)
+               output = "disabled & forbidden";
+       else if (dev->power.disable_depth)
+               output = "disabled";
+       else if (!dev->power.runtime_auto)
+               output = "forbidden";
+       else
+               output = "enabled";
+
+       return sysfs_emit(buf, "%s\n", output);
 }
 static DEVICE_ATTR_RO(runtime_enabled);
 
@@ -552,9 +588,9 @@ static DEVICE_ATTR_RO(runtime_enabled);
 static ssize_t async_show(struct device *dev, struct device_attribute *attr,
                          char *buf)
 {
-       return sprintf(buf, "%s\n",
-                       device_async_suspend_enabled(dev) ?
-                               _enabled : _disabled);
+       return sysfs_emit(buf, "%s\n",
+                         device_async_suspend_enabled(dev) ?
+                         _enabled : _disabled);
 }
 
 static ssize_t async_store(struct device *dev, struct device_attribute *attr,