GPU board and Baseboard temperatures come from system metrics table.
Driver keeps separate metrics table for both. Use the new driver table
structure to represent them.

Signed-off-by: Lijo Lazar <[email protected]>
---
 drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c     | 20 ++++----
 drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h | 14 +++---
 .../drm/amd/pm/swsmu/smu13/smu_v13_0_12_ppt.c | 49 ++++++++++---------
 3 files changed, 43 insertions(+), 40 deletions(-)

diff --git a/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c 
b/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
index d0806deb9ce9..fd926552ac6f 100644
--- a/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
+++ b/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
@@ -3891,8 +3891,9 @@ static ssize_t smu_sys_get_temp_metrics(void *handle, 
enum smu_temp_metric_type
 {
        struct smu_context *smu = handle;
        struct smu_table_context *smu_table = &smu->smu_table;
-       struct smu_table *tables = smu_table->tables;
-       enum smu_table_id table_id;
+       struct smu_driver_table *driver_tables = smu_table->driver_tables;
+       enum smu_driver_table_id table_id;
+       struct smu_driver_table *temp_table;
 
        if (!smu->pm_enabled || !smu->adev->pm.dpm_enabled)
                return -EOPNOTSUPP;
@@ -3902,17 +3903,18 @@ static ssize_t smu_sys_get_temp_metrics(void *handle, 
enum smu_temp_metric_type
 
        table_id = smu_metrics_get_temp_table_id(type);
 
-       if (table_id == SMU_TABLE_COUNT)
+       if (table_id == SMU_DRIVER_TABLE_COUNT)
                return -EINVAL;
 
+       temp_table = &driver_tables[table_id];
+
        /* If the request is to get size alone, return the cached table size */
-       if (!table && tables[table_id].cache.size)
-               return tables[table_id].cache.size;
+       if (!table && temp_table->cache.size)
+               return temp_table->cache.size;
 
-       if (smu_table_cache_is_valid(&tables[table_id])) {
-               memcpy(table, tables[table_id].cache.buffer,
-                      tables[table_id].cache.size);
-               return tables[table_id].cache.size;
+       if (smu_driver_table_is_valid(temp_table)) {
+               memcpy(table, temp_table->cache.buffer, temp_table->cache.size);
+               return temp_table->cache.size;
        }
 
        return smu->smu_temp.temp_funcs->get_temp_metrics(smu, type, table);
diff --git a/drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h 
b/drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h
index 3b8bd8c9827a..03ecbeefa67b 100644
--- a/drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h
+++ b/drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h
@@ -273,6 +273,8 @@ struct smu_table {
 
 enum smu_driver_table_id {
        SMU_DRIVER_TABLE_GPU_METRICS = 0,
+       SMU_DRIVER_TABLE_GPUBOARD_TEMP_METRICS,
+       SMU_DRIVER_TABLE_BASEBOARD_TEMP_METRICS,
        SMU_DRIVER_TABLE_COUNT,
 };
 
@@ -344,8 +346,6 @@ enum smu_table_id {
        SMU_TABLE_ECCINFO,
        SMU_TABLE_COMBO_PPTABLE,
        SMU_TABLE_WIFIBAND,
-       SMU_TABLE_GPUBOARD_TEMP_METRICS,
-       SMU_TABLE_BASEBOARD_TEMP_METRICS,
        SMU_TABLE_PMFW_SYSTEM_METRICS,
        SMU_TABLE_COUNT,
 };
@@ -1691,19 +1691,19 @@ typedef struct {
 struct smu_dpm_policy *smu_get_pm_policy(struct smu_context *smu,
                                         enum pp_pm_policy p_type);
 
-static inline enum smu_table_id
+static inline enum smu_driver_table_id
 smu_metrics_get_temp_table_id(enum smu_temp_metric_type type)
 {
        switch (type) {
        case SMU_TEMP_METRIC_BASEBOARD:
-               return SMU_TABLE_BASEBOARD_TEMP_METRICS;
+               return SMU_DRIVER_TABLE_BASEBOARD_TEMP_METRICS;
        case SMU_TEMP_METRIC_GPUBOARD:
-               return SMU_TABLE_GPUBOARD_TEMP_METRICS;
+               return SMU_DRIVER_TABLE_GPUBOARD_TEMP_METRICS;
        default:
-               return SMU_TABLE_COUNT;
+               return SMU_DRIVER_TABLE_COUNT;
        }
 
-       return SMU_TABLE_COUNT;
+       return SMU_DRIVER_TABLE_COUNT;
 }
 
 static inline void smu_table_cache_update_time(struct smu_table *table,
diff --git a/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_12_ppt.c 
b/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_12_ppt.c
index 07bee1f32f54..91a17db7912b 100644
--- a/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_12_ppt.c
+++ b/drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_12_ppt.c
@@ -156,9 +156,6 @@ int smu_v13_0_12_tables_init(struct smu_context *smu)
 {
        struct amdgpu_baseboard_temp_metrics_v1_0 *baseboard_temp_metrics;
        struct amdgpu_gpuboard_temp_metrics_v1_0 *gpuboard_temp_metrics;
-       struct smu_table_context *smu_table = &smu->smu_table;
-       struct smu_table *tables = smu_table->tables;
-       struct smu_table_cache *cache;
        int ret;
 
        ret = smu_table_cache_init(smu, SMU_TABLE_PMFW_SYSTEM_METRICS,
@@ -167,25 +164,28 @@ int smu_v13_0_12_tables_init(struct smu_context *smu)
        if (ret)
                return ret;
 
-       ret = smu_table_cache_init(smu, SMU_TABLE_BASEBOARD_TEMP_METRICS,
-                                  sizeof(*baseboard_temp_metrics), 50);
+       ret = smu_driver_table_init(smu,
+                                   SMU_DRIVER_TABLE_BASEBOARD_TEMP_METRICS,
+                                   sizeof(*baseboard_temp_metrics), 50);
        if (ret)
                return ret;
        /* Initialize base board temperature metrics */
-       cache = &(tables[SMU_TABLE_BASEBOARD_TEMP_METRICS].cache);
-       baseboard_temp_metrics =
-               (struct amdgpu_baseboard_temp_metrics_v1_0 *) cache->buffer;
+       baseboard_temp_metrics = (struct amdgpu_baseboard_temp_metrics_v1_0 *)
+               smu_driver_table_ptr(smu,
+                                    SMU_DRIVER_TABLE_BASEBOARD_TEMP_METRICS);
        smu_cmn_init_baseboard_temp_metrics(baseboard_temp_metrics, 1, 0);
        /* Initialize GPU board temperature metrics */
-       ret = smu_table_cache_init(smu, SMU_TABLE_GPUBOARD_TEMP_METRICS,
-                                  sizeof(*gpuboard_temp_metrics), 50);
+       ret = smu_driver_table_init(smu, SMU_DRIVER_TABLE_GPUBOARD_TEMP_METRICS,
+                                   sizeof(*gpuboard_temp_metrics), 50);
        if (ret) {
                smu_table_cache_fini(smu, SMU_TABLE_PMFW_SYSTEM_METRICS);
-               smu_table_cache_fini(smu, SMU_TABLE_BASEBOARD_TEMP_METRICS);
+               smu_driver_table_fini(smu,
+                                     SMU_DRIVER_TABLE_BASEBOARD_TEMP_METRICS);
                return ret;
        }
-       cache = &(tables[SMU_TABLE_GPUBOARD_TEMP_METRICS].cache);
-       gpuboard_temp_metrics = (struct amdgpu_gpuboard_temp_metrics_v1_0 
*)cache->buffer;
+       gpuboard_temp_metrics = (struct amdgpu_gpuboard_temp_metrics_v1_0 *)
+               smu_driver_table_ptr(smu,
+                                    SMU_DRIVER_TABLE_GPUBOARD_TEMP_METRICS);
        smu_cmn_init_gpuboard_temp_metrics(gpuboard_temp_metrics, 1, 0);
 
        return 0;
@@ -193,8 +193,8 @@ int smu_v13_0_12_tables_init(struct smu_context *smu)
 
 void smu_v13_0_12_tables_fini(struct smu_context *smu)
 {
-       smu_table_cache_fini(smu, SMU_TABLE_BASEBOARD_TEMP_METRICS);
-       smu_table_cache_fini(smu, SMU_TABLE_GPUBOARD_TEMP_METRICS);
+       smu_driver_table_fini(smu, SMU_DRIVER_TABLE_BASEBOARD_TEMP_METRICS);
+       smu_driver_table_fini(smu, SMU_DRIVER_TABLE_GPUBOARD_TEMP_METRICS);
        smu_table_cache_fini(smu, SMU_TABLE_PMFW_SYSTEM_METRICS);
 }
 
@@ -686,8 +686,8 @@ static ssize_t smu_v13_0_12_get_temp_metrics(struct 
smu_context *smu,
        struct amdgpu_gpuboard_temp_metrics_v1_0 *gpuboard_temp_metrics;
        struct smu_table_context *smu_table = &smu->smu_table;
        struct smu_table *tables = smu_table->tables;
+       enum smu_driver_table_id table_id;
        SystemMetricsTable_t *metrics;
-       struct smu_table *data_table;
        struct smu_table *sys_table;
        int ret, sensor_type;
        u32 idx, sensors;
@@ -695,18 +695,16 @@ static ssize_t smu_v13_0_12_get_temp_metrics(struct 
smu_context *smu,
 
        if (type == SMU_TEMP_METRIC_BASEBOARD) {
                /* Initialize base board temperature metrics */
-               data_table =
-                       
&smu->smu_table.tables[SMU_TABLE_BASEBOARD_TEMP_METRICS];
+               table_id = SMU_DRIVER_TABLE_BASEBOARD_TEMP_METRICS;
                baseboard_temp_metrics =
                        (struct amdgpu_baseboard_temp_metrics_v1_0 *)
-                               data_table->cache.buffer;
+                               smu_driver_table_ptr(smu, table_id);
                size = sizeof(*baseboard_temp_metrics);
        } else {
-               data_table =
-                       &smu->smu_table.tables[SMU_TABLE_GPUBOARD_TEMP_METRICS];
+               table_id = SMU_DRIVER_TABLE_GPUBOARD_TEMP_METRICS;
                gpuboard_temp_metrics =
                        (struct amdgpu_gpuboard_temp_metrics_v1_0 *)
-                               data_table->cache.buffer;
+                               smu_driver_table_ptr(smu, table_id);
                size = sizeof(*baseboard_temp_metrics);
        }
 
@@ -716,7 +714,7 @@ static ssize_t smu_v13_0_12_get_temp_metrics(struct 
smu_context *smu,
 
        sys_table = &tables[SMU_TABLE_PMFW_SYSTEM_METRICS];
        metrics = (SystemMetricsTable_t *)sys_table->cache.buffer;
-       smu_table_cache_update_time(data_table, jiffies);
+       smu_driver_table_update_cache_time(smu, table_id);
 
        if (type == SMU_TEMP_METRIC_GPUBOARD) {
                gpuboard_temp_metrics->accumulation_counter = 
metrics->AccumulationCounter;
@@ -762,7 +760,10 @@ static ssize_t smu_v13_0_12_get_temp_metrics(struct 
smu_context *smu,
                }
        }
 
-       memcpy(table, data_table->cache.buffer, size);
+       if (type == SMU_TEMP_METRIC_BASEBOARD)
+               memcpy(table, baseboard_temp_metrics, size);
+       else
+               memcpy(table, gpuboard_temp_metrics, size);
 
        return size;
 }
-- 
2.49.0

Reply via email to