drm/amd/pm: consistent approach for smartshift

create smartshift sysfs attributes from dGPU device even
on smartshift 1.0 platform to be consistent. Do not populate
the attributes on platforms that have APU only but not dGPU
or vice versa.

V2:
 avoid checking for the number of VGA/DISPLAY devices (Lijo)
 move code to read from dGPU or APU into a function and reuse (Lijo)

Suggested-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Sathishkumar S <sathishkumar.sundararaju@amd.com>
Acked-by: Alex Deucher <alexander.deucher@amd.com>
Reviewed-by: Lijo Lazar <lijo.lazar@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/pm/amdgpu_pm.c b/drivers/gpu/drm/amd/pm/amdgpu_pm.c
index d3228216b2daa4294e0edeb8be7fe7ba184bbef1..5e318b3f6c0fe0d3099a5318d933b30561ae5769 100644 (file)
--- a/drivers/gpu/drm/amd/pm/amdgpu_pm.c
+++ b/drivers/gpu/drm/amd/pm/amdgpu_pm.c
@@ -1734,22 +1734,11 @@ out:
        return size;
 }
 
-/**
- * DOC: smartshift_apu_power
- *
- * The amdgpu driver provides a sysfs API for reporting APU power
- * share if it supports smartshift. The value is expressed as
- * the proportion of stapm limit where stapm limit is the total APU
- * power limit. The result is in percentage. If APU power is 130% of
- * STAPM, then APU is using 30% of the dGPU's headroom.
- */
-
-static ssize_t amdgpu_get_smartshift_apu_power(struct device *dev, struct device_attribute *attr,
-                                              char *buf)
+static int amdgpu_device_read_powershift(struct amdgpu_device *adev,
+                                               uint32_t *ss_power, bool dgpu_share)
 {
-       struct drm_device *ddev = dev_get_drvdata(dev);
-       struct amdgpu_device *adev = drm_to_adev(ddev);
-       uint32_t ss_power, size;
+       struct drm_device *ddev = adev_to_drm(adev);
+       uint32_t size;
        int r = 0;
 
        if (amdgpu_in_reset(adev))
@@ -1763,61 +1752,77 @@ static ssize_t amdgpu_get_smartshift_apu_power(struct device *dev, struct device
                return r;
        }
 
-       r = amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_SS_APU_SHARE,
-                                  (void *)&ss_power, &size);
-       if (r)
-               goto out;
-
-       r = sysfs_emit(buf, "%u%%\n", ss_power);
+       if (dgpu_share)
+               r = amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_SS_DGPU_SHARE,
+                                  (void *)ss_power, &size);
+       else
+               r = amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_SS_APU_SHARE,
+                                  (void *)ss_power, &size);
 
-out:
        pm_runtime_mark_last_busy(ddev->dev);
        pm_runtime_put_autosuspend(ddev->dev);
        return r;
 }
 
-/**
- * DOC: smartshift_dgpu_power
- *
- * The amdgpu driver provides a sysfs API for reporting the dGPU power
- * share if the device is in HG and supports smartshift. The value
- * is expressed as the proportion of stapm limit where stapm limit
- * is the total APU power limit. The value is in percentage. If dGPU
- * power is 20% higher than STAPM power(120%), it's using 20% of the
- * APU's power headroom.
- */
-
-static ssize_t amdgpu_get_smartshift_dgpu_power(struct device *dev, struct device_attribute *attr,
-                                               char *buf)
+static int amdgpu_show_powershift_percent(struct device *dev,
+                                       char *buf, bool dgpu_share)
 {
        struct drm_device *ddev = dev_get_drvdata(dev);
        struct amdgpu_device *adev = drm_to_adev(ddev);
-       uint32_t ss_power, size;
-       int r = 0;
-
-       if (amdgpu_in_reset(adev))
-               return -EPERM;
-       if (adev->in_suspend && !adev->in_runpm)
-               return -EPERM;
-
-       r = pm_runtime_get_sync(ddev->dev);
-       if (r < 0) {
-               pm_runtime_put_autosuspend(ddev->dev);
-               return r;
+       uint32_t ss_power;
+       int r = 0, i;
+
+       r = amdgpu_device_read_powershift(adev, &ss_power, dgpu_share);
+       if (r == -EOPNOTSUPP) {
+               /* sensor not available on dGPU, try to read from APU */
+               adev = NULL;
+               mutex_lock(&mgpu_info.mutex);
+               for (i = 0; i < mgpu_info.num_gpu; i++) {
+                       if (mgpu_info.gpu_ins[i].adev->flags & AMD_IS_APU) {
+                               adev = mgpu_info.gpu_ins[i].adev;
+                               break;
+                       }
+               }
+               mutex_unlock(&mgpu_info.mutex);
+               if (adev)
+                       r = amdgpu_device_read_powershift(adev, &ss_power, dgpu_share);
        }
 
-       r = amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_SS_DGPU_SHARE,
-                                  (void *)&ss_power, &size);
+       if (!r)
+               r = sysfs_emit(buf, "%u%%\n", ss_power);
 
-       if (r)
-               goto out;
+       return r;
+}
+/**
+ * DOC: smartshift_apu_power
+ *
+ * The amdgpu driver provides a sysfs API for reporting APU power
+ * shift in percentage if platform supports smartshift. Value 0 means that
+ * there is no powershift and values between [1-100] means that the power
+ * is shifted to APU, the percentage of boost is with respect to APU power
+ * limit on the platform.
+ */
 
-       r = sysfs_emit(buf, "%u%%\n", ss_power);
+static ssize_t amdgpu_get_smartshift_apu_power(struct device *dev, struct device_attribute *attr,
+                                              char *buf)
+{
+       return amdgpu_show_powershift_percent(dev, buf, false);
+}
 
-out:
-       pm_runtime_mark_last_busy(ddev->dev);
-       pm_runtime_put_autosuspend(ddev->dev);
-       return r;
+/**
+ * DOC: smartshift_dgpu_power
+ *
+ * The amdgpu driver provides a sysfs API for reporting dGPU power
+ * shift in percentage if platform supports smartshift. Value 0 means that
+ * there is no powershift and values between [1-100] means that the power is
+ * shifted to dGPU, the percentage of boost is with respect to dGPU power
+ * limit on the platform.
+ */
+
+static ssize_t amdgpu_get_smartshift_dgpu_power(struct device *dev, struct device_attribute *attr,
+                                               char *buf)
+{
+       return amdgpu_show_powershift_percent(dev, buf, true);
 }
 
 /**
@@ -1884,18 +1889,7 @@ out:
 static int ss_power_attr_update(struct amdgpu_device *adev, struct amdgpu_device_attr *attr,
                                uint32_t mask, enum amdgpu_device_attr_states *states)
 {
-       uint32_t ss_power, size;
-
-       if (!amdgpu_acpi_is_power_shift_control_supported())
-               *states = ATTR_STATE_UNSUPPORTED;
-       else if ((adev->flags & AMD_IS_PX) &&
-                !amdgpu_device_supports_smart_shift(adev_to_drm(adev)))
-               *states = ATTR_STATE_UNSUPPORTED;
-       else if (amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_SS_APU_SHARE,
-                (void *)&ss_power, &size))
-               *states = ATTR_STATE_UNSUPPORTED;
-       else if (amdgpu_dpm_read_sensor(adev, AMDGPU_PP_SENSOR_SS_DGPU_SHARE,
-                (void *)&ss_power, &size))
+       if (!amdgpu_device_supports_smart_shift(adev_to_drm(adev)))
                *states = ATTR_STATE_UNSUPPORTED;
 
        return 0;