Commit f14a323d authored by Kevin Wang's avatar Kevin Wang Committed by Alex Deucher
Browse files

drm/amd/powerplay: implement update enabled feature state to smc for smu11 



change:
1.when enable smu feature, the feature id will store sw-bitmap and smu
controller.
2.add feature mutex lock to protect feature bitmap changed when update
feature enabled state.

Signed-off-by: default avatarKevin Wang <kevin1.wang@amd.com>
Reviewed-by: default avatarHuang Rui <ray.huang@amd.com>
Acked-by: default avatarAlex Deucher <alexander.deucher@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent 15074186

drivers/gpu/drm/amd/powerplay/amdgpu_smu.c

+41 −4
Original line number Diff line number Diff line
@@ -170,16 +170,20 @@ int smu_feature_init_dpm(struct smu_context *smu) 
	int ret = 0;

	uint32_t unallowed_feature_mask[SMU_FEATURE_MAX/32];



	mutex_lock(&feature->mutex);

	bitmap_fill(feature->allowed, SMU_FEATURE_MAX);

	mutex_unlock(&feature->mutex);



	ret = smu_get_unallowed_feature_mask(smu, unallowed_feature_mask,

					     SMU_FEATURE_MAX/32);

	if (ret)

		return ret;



	mutex_lock(&feature->mutex);

	bitmap_andnot(feature->allowed, feature->allowed,

		      (unsigned long *)unallowed_feature_mask,

		      feature->feature_num);

	mutex_unlock(&feature->mutex);



	return ret;

}
@@ -187,38 +191,70 @@ int smu_feature_init_dpm(struct smu_context *smu) 
int smu_feature_is_enabled(struct smu_context *smu, int feature_id)

{

	struct smu_feature *feature = &smu->smu_feature;

	int ret = 0;



	WARN_ON(feature_id > feature->feature_num);

	return test_bit(feature_id, feature->enabled);



	mutex_lock(&feature->mutex);

	ret = test_bit(feature_id, feature->enabled);

	mutex_unlock(&feature->mutex);



	return ret;

}



int smu_feature_set_enabled(struct smu_context *smu, int feature_id, bool enable)

{

	struct smu_feature *feature = &smu->smu_feature;

	int ret = 0;



	WARN_ON(feature_id > feature->feature_num);



	mutex_lock(&feature->mutex);

	ret = smu_feature_update_enable_state(smu, feature_id, enable);

	if (ret)

		goto failed;



	if (enable)

		test_and_set_bit(feature_id, feature->enabled);

	else

		test_and_clear_bit(feature_id, feature->enabled);

	return 0;



failed:

	mutex_unlock(&feature->mutex);



	return ret;

}



int smu_feature_is_supported(struct smu_context *smu, int feature_id)

{

	struct smu_feature *feature = &smu->smu_feature;

	int ret = 0;



	WARN_ON(feature_id > feature->feature_num);

	return test_bit(feature_id, feature->supported);



	mutex_lock(&feature->mutex);

	ret = test_bit(feature_id, feature->supported);

	mutex_unlock(&feature->mutex);



	return ret;

}



int smu_feature_set_supported(struct smu_context *smu, int feature_id,

			      bool enable)

{

	struct smu_feature *feature = &smu->smu_feature;

	int ret = 0;



	WARN_ON(feature_id > feature->feature_num);



	mutex_unlock(&feature->mutex);

	if (enable)

		test_and_set_bit(feature_id, feature->supported);

	else

		test_and_clear_bit(feature_id, feature->supported);

	return 0;

	mutex_unlock(&feature->mutex);



	return ret;

}



static int smu_set_funcs(struct amdgpu_device *adev)
@@ -326,6 +362,7 @@ static int smu_sw_init(void *handle) 


	smu->pool_size = adev->pm.smu_prv_buffer_size;

	smu->smu_feature.feature_num = SMU_FEATURE_MAX;

	mutex_init(&smu->smu_feature.mutex);

	bitmap_zero(smu->smu_feature.supported, SMU_FEATURE_MAX);

	bitmap_zero(smu->smu_feature.enabled, SMU_FEATURE_MAX);

	bitmap_zero(smu->smu_feature.allowed, SMU_FEATURE_MAX);

drivers/gpu/drm/amd/powerplay/inc/amdgpu_smu.h

+4 −0
Original line number Diff line number Diff line
@@ -340,6 +340,7 @@ struct smu_feature 
	DECLARE_BITMAP(supported, SMU_FEATURE_MAX);

	DECLARE_BITMAP(allowed, SMU_FEATURE_MAX);

	DECLARE_BITMAP(enabled, SMU_FEATURE_MAX);

	struct mutex mutex;

};



struct smu_clocks {
@@ -469,6 +470,7 @@ struct smu_funcs 
	int (*get_enabled_mask)(struct smu_context *smu, uint32_t *feature_mask, uint32_t num);

	int (*enable_all_mask)(struct smu_context *smu);

	int (*disable_all_mask)(struct smu_context *smu);

	int (*update_feature_enable_state)(struct smu_context *smu, uint32_t feature_id, bool enabled);

	int (*notify_display_change)(struct smu_context *smu);

	int (*get_power_limit)(struct smu_context *smu);

	int (*get_current_clk_freq)(struct smu_context *smu, uint32_t clk_id, uint32_t *value);
@@ -580,6 +582,8 @@ struct smu_funcs 
	((smu)->funcs->enable_all_mask? (smu)->funcs->enable_all_mask((smu)) : 0)

#define smu_feature_disable_all(smu) \

	((smu)->funcs->disable_all_mask? (smu)->funcs->disable_all_mask((smu)) : 0)

#define smu_feature_update_enable_state(smu, feature_id, enabled) \

	((smu)->funcs->update_feature_enable_state? (smu)->funcs->update_feature_enable_state((smu), (feature_id), (enabled)) : 0)

#define smu_notify_display_change(smu) \

	((smu)->funcs->notify_display_change? (smu)->funcs->notify_display_change((smu)) : 0)

#define smu_store_powerplay_table(smu) \

drivers/gpu/drm/amd/powerplay/smu_v11_0.c

+44 −3
Original line number Diff line number Diff line
@@ -615,27 +615,67 @@ static int smu_v11_0_init_display(struct smu_context *smu) 
	return ret;

}



static int smu_v11_0_update_feature_enable_state(struct smu_context *smu, uint32_t feature_id, bool enabled)

{

	uint32_t feature_low = 0, feature_high = 0;

	int ret = 0;



	if (feature_id >= 0 && feature_id < 31)

		feature_low = (1 << feature_id);

	else if (feature_id > 31 && feature_id < 63)

		feature_high = (1 << feature_id);

	else

		return -EINVAL;



	if (enabled) {

		ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesLow,

						  feature_low);

		if (ret)

			return ret;

		ret = smu_send_smc_msg_with_param(smu, SMU_MSG_EnableSmuFeaturesHigh,

						  feature_high);

		if (ret)

			return ret;



	} else {

		ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesLow,

						  feature_low);

		if (ret)

			return ret;

		ret = smu_send_smc_msg_with_param(smu, SMU_MSG_DisableSmuFeaturesHigh,

						  feature_high);

		if (ret)

			return ret;



	}



	return ret;

}



static int smu_v11_0_set_allowed_mask(struct smu_context *smu)

{

	struct smu_feature *feature = &smu->smu_feature;

	int ret = 0;

	uint32_t feature_mask[2];



	mutex_lock(&feature->mutex);

	if (bitmap_empty(feature->allowed, SMU_FEATURE_MAX) || feature->feature_num < 64)

		return -EINVAL;

		goto failed;



	bitmap_copy((unsigned long *)feature_mask, feature->allowed, 64);



	ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskHigh,

					  feature_mask[1]);

	if (ret)

		return ret;

		goto failed;



	ret = smu_send_smc_msg_with_param(smu, SMU_MSG_SetAllowedFeaturesMaskLow,

					  feature_mask[0]);

	if (ret)

		return ret;

		goto failed;



failed:

	mutex_unlock(&feature->mutex);

	return ret;

}
@@ -1578,6 +1618,7 @@ static const struct smu_funcs smu_v11_0_funcs = { 
	.get_enabled_mask = smu_v11_0_get_enabled_mask,

	.enable_all_mask = smu_v11_0_enable_all_mask,

	.disable_all_mask = smu_v11_0_disable_all_mask,

	.update_feature_enable_state = smu_v11_0_update_feature_enable_state,

	.notify_display_change = smu_v11_0_notify_display_change,

	.get_power_limit = smu_v11_0_get_power_limit,

	.get_current_clk_freq = smu_v11_0_get_current_clk_freq,

CRA Git | Maintained and supported by SUSTech CRA and CCSE