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 52d568379fd04aa11270da076d0a0ae79032f900..39f90317b5d7b3e5d554c0919c9ca171f5a36c13 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 6b803b0213e097a57559e6e82d58929ffe85b2b0..24cf25d0606b154a47c69b7475050f8ccca0cfc7 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 07bee1f32f54f1512d851fa00c27096e37575157..91a17db7912be301d9e9267bf19d2c368668783b 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;
 }