Commit 0c0dd100 authored by Lijo Lazar's avatar Lijo Lazar Committed by Alex Deucher
Browse files

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: default avatarLijo Lazar <lijo.lazar@amd.com>
Reviewed-by: default avatarAsad Kamal <asad.kamal@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent 34d65997

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c

+11 −9
Original line number Diff line number Diff line
@@ -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);

drivers/gpu/drm/amd/pm/swsmu/inc/amdgpu_smu.h

+7 −7
Original line number Diff line number Diff line
@@ -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,

drivers/gpu/drm/amd/pm/swsmu/smu13/smu_v13_0_12_ppt.c

+25 −24
Original line number Diff line number Diff line
@@ -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,

	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,

	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;

}