drm/amdgpu: use new flag to handle different firmware loading method

This patch introduces a new flag named "amdgpu_firmware_load_type" to
handle different firmware loading method. Since Vega10, there are
three ways to load firmware. It would be better to use a flag and a
fw_load_type kernel parameter to configure it.

Acked-by: Christian König <christian.koenig@amd.com>
Signed-off-by: Huang Rui <ray.huang@amd.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

10 files changed, 90 insertions, 20 deletions

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
index a7108ba94794..c83d7bd5b712 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
@@ -81,7 +81,7 @@ extern int amdgpu_pcie_gen2;
 extern int amdgpu_msi;
 extern int amdgpu_lockup_timeout;
 extern int amdgpu_dpm;
-extern int amdgpu_smc_load_fw;
+extern int amdgpu_fw_load_type;
 extern int amdgpu_aspm;
 extern int amdgpu_runtime_pm;
 extern unsigned amdgpu_ip_block_mask;
@@ -1063,9 +1063,15 @@ struct amdgpu_sdma {
 /*
  * Firmware
  */
+enum amdgpu_firmware_load_type {
+        AMDGPU_FW_LOAD_DIRECT = 0,
+        AMDGPU_FW_LOAD_SMU,
+        AMDGPU_FW_LOAD_PSP,
+};
+
 struct amdgpu_firmware {
         struct amdgpu_firmware_info ucode[AMDGPU_UCODE_ID_MAXIMUM];
-        bool smu_load;
+        enum amdgpu_firmware_load_type load_type;
         struct amdgpu_bo *fw_buf;
         unsigned int fw_size;
 };
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
index 778d16f835ab..7292f4e7bb1a 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
@@ -80,7 +80,7 @@ int amdgpu_pcie_gen2 = -1;
 int amdgpu_msi = -1;
 int amdgpu_lockup_timeout = 0;
 int amdgpu_dpm = -1;
-int amdgpu_smc_load_fw = 1;
+int amdgpu_fw_load_type = -1;
 int amdgpu_aspm = -1;
 int amdgpu_runtime_pm = -1;
 unsigned amdgpu_ip_block_mask = 0xffffffff;
@@ -140,8 +140,8 @@ module_param_named(lockup_timeout, amdgpu_lockup_timeout, int, 0444);
 MODULE_PARM_DESC(dpm, "DPM support (1 = enable, 0 = disable, -1 = auto)");
 module_param_named(dpm, amdgpu_dpm, int, 0444);
 
-MODULE_PARM_DESC(smc_load_fw, "SMC firmware loading(1 = enable, 0 = disable)");
-module_param_named(smc_load_fw, amdgpu_smc_load_fw, int, 0444);
+MODULE_PARM_DESC(fw_load_type, "firmware loading type (0 = direct, 1 = SMU, 2 = PSP, -1 = auto)");
+module_param_named(fw_load_type, amdgpu_fw_load_type, int, 0444);
 
 MODULE_PARM_DESC(aspm, "ASPM support (1 = enable, 0 = disable, -1 = auto)");
 module_param_named(aspm, amdgpu_aspm, int, 0444);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c
index d56d200a3646..96a5113b948f 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c
@@ -163,7 +163,7 @@ static int amdgpu_pp_hw_init(void *handle)
         int ret = 0;
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
-        if (adev->pp_enabled && adev->firmware.smu_load)
+        if (adev->pp_enabled && adev->firmware.load_type == AMDGPU_FW_LOAD_SMU)
                 amdgpu_ucode_init_bo(adev);
 
         if (adev->powerplay.ip_funcs->hw_init)
@@ -190,7 +190,7 @@ static int amdgpu_pp_hw_fini(void *handle)
                 ret = adev->powerplay.ip_funcs->hw_fini(
                                         adev->powerplay.pp_handle);
 
-        if (adev->pp_enabled && adev->firmware.smu_load)
+        if (adev->pp_enabled && adev->firmware.load_type == AMDGPU_FW_LOAD_SMU)
                 amdgpu_ucode_fini_bo(adev);
 
         return ret;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c
index be16377128c3..73c3e664d99a 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c
@@ -217,6 +217,49 @@ bool amdgpu_ucode_hdr_version(union amdgpu_firmware_header *hdr,
         return true;
 }
 
+enum amdgpu_firmware_load_type
+amdgpu_ucode_get_load_type(struct amdgpu_device *adev, int load_type)
+{
+        switch (adev->asic_type) {
+#ifdef CONFIG_DRM_AMDGPU_SI
+        case CHIP_TAHITI:
+        case CHIP_PITCAIRN:
+        case CHIP_VERDE:
+        case CHIP_OLAND:
+                return AMDGPU_FW_LOAD_DIRECT;
+#endif
+#ifdef CONFIG_DRM_AMDGPU_CIK
+        case CHIP_BONAIRE:
+        case CHIP_KAVERI:
+        case CHIP_KABINI:
+        case CHIP_HAWAII:
+        case CHIP_MULLINS:
+                return AMDGPU_FW_LOAD_DIRECT;
+#endif
+        case CHIP_TOPAZ:
+        case CHIP_TONGA:
+        case CHIP_FIJI:
+        case CHIP_CARRIZO:
+        case CHIP_STONEY:
+        case CHIP_POLARIS10:
+        case CHIP_POLARIS11:
+        case CHIP_POLARIS12:
+                if (!load_type)
+                        return AMDGPU_FW_LOAD_DIRECT;
+                else
+                        return AMDGPU_FW_LOAD_SMU;
+        case CHIP_VEGA10:
+                if (!load_type)
+                        return AMDGPU_FW_LOAD_DIRECT;
+                else
+                        return AMDGPU_FW_LOAD_PSP;
+        default:
+                DRM_ERROR("Unknow firmware load type\n");
+        }
+
+        return AMDGPU_FW_LOAD_DIRECT;
+}
+
 static int amdgpu_ucode_init_single_fw(struct amdgpu_firmware_info *ucode,
                                 uint64_t mc_addr, void *kptr)
 {
@@ -273,7 +316,7 @@ int amdgpu_ucode_init_bo(struct amdgpu_device *adev)
         uint64_t fw_mc_addr;
         void *fw_buf_ptr = NULL;
         uint64_t fw_offset = 0;
-        int i, err;
+        int i, err, max;
         struct amdgpu_firmware_info *ucode = NULL;
         const struct common_firmware_header *header = NULL;
 
@@ -306,7 +349,16 @@ int amdgpu_ucode_init_bo(struct amdgpu_device *adev)
 
         amdgpu_bo_unreserve(*bo);
 
-        for (i = 0; i < AMDGPU_UCODE_ID_MAXIMUM; i++) {
+        /*
+         * if SMU loaded firmware, it needn't add SMC, UVD, and VCE
+         * ucode info here
+         */
+        if (adev->firmware.load_type != AMDGPU_FW_LOAD_PSP)
+                max = AMDGPU_UCODE_ID_MAXIMUM - 3;
+        else
+                max = AMDGPU_UCODE_ID_MAXIMUM;
+
+        for (i = 0; i < max; i++) {
                 ucode = &adev->firmware.ucode[i];
                 if (ucode->fw) {
                         header = (const struct common_firmware_header *)ucode->fw->data;
@@ -331,7 +383,8 @@ failed_pin:
 failed_reserve:
         amdgpu_bo_unref(bo);
 failed:
-        adev->firmware.smu_load = false;
+        if (err)
+                adev->firmware.load_type = AMDGPU_FW_LOAD_DIRECT;
 
         return err;
 }
@@ -340,8 +393,14 @@ int amdgpu_ucode_fini_bo(struct amdgpu_device *adev)
 {
         int i;
         struct amdgpu_firmware_info *ucode = NULL;
+        int max;
+
+        if (adev->firmware.load_type != AMDGPU_FW_LOAD_PSP)
+                max = AMDGPU_UCODE_ID_MAXIMUM - 3;
+        else
+                max = AMDGPU_UCODE_ID_MAXIMUM;
 
-        for (i = 0; i < AMDGPU_UCODE_ID_MAXIMUM; i++) {
+        for (i = 0; i < max; i++) {
                 ucode = &adev->firmware.ucode[i];
                 if (ucode->fw) {
                         ucode->mc_addr = 0;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h
index 19a584cd4527..2b212b04ce54 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h
@@ -176,4 +176,7 @@ bool amdgpu_ucode_hdr_version(union amdgpu_firmware_header *hdr,
 int amdgpu_ucode_init_bo(struct amdgpu_device *adev);
 int amdgpu_ucode_fini_bo(struct amdgpu_device *adev);
 
+enum amdgpu_firmware_load_type
+amdgpu_ucode_get_load_type(struct amdgpu_device *adev, int load_type);
+
 #endif
diff --git a/drivers/gpu/drm/amd/amdgpu/cik.c b/drivers/gpu/drm/amd/amdgpu/cik.c
index dbaedb4f2a6b..9d33e5641419 100644
--- a/drivers/gpu/drm/amd/amdgpu/cik.c
+++ b/drivers/gpu/drm/amd/amdgpu/cik.c
@@ -1785,6 +1785,8 @@ static int cik_common_early_init(void *handle)
                 return -EINVAL;
         }
 
+        adev->firmware.load_type = amdgpu_ucode_get_load_type(adev, amdgpu_fw_load_type);
+
         amdgpu_get_pcie_info(adev);
 
         return 0;
diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
index 1e177cd9b46b..423ed68c2e52 100644
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
@@ -1040,7 +1040,7 @@ static int gfx_v8_0_init_microcode(struct amdgpu_device *adev)
                 }
         }
 
-        if (adev->firmware.smu_load) {
+        if (adev->firmware.load_type == AMDGPU_FW_LOAD_SMU) {
                 info = &adev->firmware.ucode[AMDGPU_UCODE_ID_CP_PFP];
                 info->ucode_id = AMDGPU_UCODE_ID_CP_PFP;
                 info->fw = adev->gfx.pfp_fw;
@@ -4253,7 +4253,7 @@ static int gfx_v8_0_rlc_resume(struct amdgpu_device *adev)
         gfx_v8_0_init_pg(adev);
 
         if (!adev->pp_enabled) {
-                if (!adev->firmware.smu_load) {
+                if (adev->firmware.load_type != AMDGPU_FW_LOAD_SMU) {
                         /* legacy rlc firmware loading */
                         r = gfx_v8_0_rlc_load_microcode(adev);
                         if (r)
@@ -5269,7 +5269,7 @@ static int gfx_v8_0_cp_resume(struct amdgpu_device *adev)
                 gfx_v8_0_enable_gui_idle_interrupt(adev, false);
 
         if (!adev->pp_enabled) {
-                if (!adev->firmware.smu_load) {
+                if (adev->firmware.load_type != AMDGPU_FW_LOAD_SMU) {
                         /* legacy firmware loading */
                         r = gfx_v8_0_cp_gfx_load_microcode(adev);
                         if (r)
diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c b/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c
index 1a4b351f350b..182de5dc2081 100644
--- a/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c
+++ b/drivers/gpu/drm/amd/amdgpu/sdma_v2_4.c
@@ -158,7 +158,7 @@ static int sdma_v2_4_init_microcode(struct amdgpu_device *adev)
                 if (adev->sdma.instance[i].feature_version >= 20)
                         adev->sdma.instance[i].burst_nop = true;
 
-                if (adev->firmware.smu_load) {
+                if (adev->firmware.load_type == AMDGPU_FW_LOAD_SMU) {
                         info = &adev->firmware.ucode[AMDGPU_UCODE_ID_SDMA0 + i];
                         info->ucode_id = AMDGPU_UCODE_ID_SDMA0 + i;
                         info->fw = adev->sdma.instance[i].fw;
@@ -562,7 +562,7 @@ static int sdma_v2_4_start(struct amdgpu_device *adev)
         int r;
 
         if (!adev->pp_enabled) {
-                if (!adev->firmware.smu_load) {
+                if (adev->firmware.load_type != AMDGPU_FW_LOAD_SMU) {
                         r = sdma_v2_4_load_microcode(adev);
                         if (r)
                                 return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c b/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c
index 5f7812d1c90d..5be84df27cad 100644
--- a/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/sdma_v3_0.c
@@ -310,7 +310,7 @@ static int sdma_v3_0_init_microcode(struct amdgpu_device *adev)
                 if (adev->sdma.instance[i].feature_version >= 20)
                         adev->sdma.instance[i].burst_nop = true;
 
-                if (adev->firmware.smu_load) {
+                if (adev->firmware.load_type == AMDGPU_FW_LOAD_SMU) {
                         info = &adev->firmware.ucode[AMDGPU_UCODE_ID_SDMA0 + i];
                         info->ucode_id = AMDGPU_UCODE_ID_SDMA0 + i;
                         info->fw = adev->sdma.instance[i].fw;
@@ -771,7 +771,7 @@ static int sdma_v3_0_start(struct amdgpu_device *adev)
         int r, i;
 
         if (!adev->pp_enabled) {
-                if (!adev->firmware.smu_load) {
+                if (adev->firmware.load_type != AMDGPU_FW_LOAD_SMU) {
                         r = sdma_v3_0_load_microcode(adev);
                         if (r)
                                 return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/vi.c b/drivers/gpu/drm/amd/amdgpu/vi.c
index 1ff36724fb2a..1fe654e8cb7f 100644
--- a/drivers/gpu/drm/amd/amdgpu/vi.c
+++ b/drivers/gpu/drm/amd/amdgpu/vi.c
@@ -1117,8 +1117,8 @@ static int vi_common_early_init(void *handle)
                 return -EINVAL;
         }
 
-        if (amdgpu_smc_load_fw && smc_enabled)
-                adev->firmware.smu_load = true;
+        /* vi use smc load by default */
+        adev->firmware.load_type = amdgpu_ucode_get_load_type(adev, amdgpu_fw_load_type);
 
         amdgpu_get_pcie_info(adev);