drm/amd/pm: Use driver table for board temperature

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 <lijo.lazar@amd.com>
Reviewed-by: Asad Kamal <asad.kamal@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c b/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
index 52d5683..39f9031 100644 (file)
--- a/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
+++ b/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
@@ -3864,8 +3864,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;
@@ -3875,17 +3876,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 6b803b0..24cf25d 100644 (file)
--- 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,
 };
 
@@ -375,8 +377,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,
 };
@@ -1722,19 +1722,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 07bee1f..91a17db 100644 (file)
--- 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;
 }