projects / linux-block.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge tag 'amd-drm-next-6.3-2023-01-13' of https://gitlab.freedesktop.org/agd5f/linux...
[linux-block.git] / drivers / gpu / drm / amd / display / amdgpu_dm / amdgpu_dm.c
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index cabe02cb307c134aafcfb1584adc3914a41f3d4d..4300ce98ce8d88c57c0eb21d0ab66d767c23defd 100644 (file)
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -1883,25 +1883,17 @@ static int load_dmcu_fw(struct amdgpu_device *adev)
                return 0;
        }
 
-       r = request_firmware_direct(&adev->dm.fw_dmcu, fw_name_dmcu, adev->dev);
-       if (r == -ENOENT) {
+       r = amdgpu_ucode_request(adev, &adev->dm.fw_dmcu, fw_name_dmcu);
+       if (r == -ENODEV) {
                /* DMCU firmware is not necessary, so don't raise a fuss if it's missing */
                DRM_DEBUG_KMS("dm: DMCU firmware not found\n");
                adev->dm.fw_dmcu = NULL;
                return 0;
        }
-       if (r) {
-               dev_err(adev->dev, "amdgpu_dm: Can't load firmware \"%s\"\n",
-                       fw_name_dmcu);
-               return r;
-       }
-
-       r = amdgpu_ucode_validate(adev->dm.fw_dmcu);
        if (r) {
                dev_err(adev->dev, "amdgpu_dm: Can't validate firmware \"%s\"\n",
                        fw_name_dmcu);
-               release_firmware(adev->dm.fw_dmcu);
-               adev->dm.fw_dmcu = NULL;
+               amdgpu_ucode_release(&adev->dm.fw_dmcu);
                return r;
        }
 
@@ -1947,7 +1939,6 @@ static int dm_dmub_sw_init(struct amdgpu_device *adev)
        struct dmub_srv_fb_info *fb_info;
        struct dmub_srv *dmub_srv;
        const struct dmcub_firmware_header_v1_0 *hdr;
-       const char *fw_name_dmub;
        enum dmub_asic dmub_asic;
        enum dmub_status status;
        int r;
@@ -1955,73 +1946,46 @@ static int dm_dmub_sw_init(struct amdgpu_device *adev)
        switch (adev->ip_versions[DCE_HWIP][0]) {
        case IP_VERSION(2, 1, 0):
                dmub_asic = DMUB_ASIC_DCN21;
-               fw_name_dmub = FIRMWARE_RENOIR_DMUB;
-               if (ASICREV_IS_GREEN_SARDINE(adev->external_rev_id))
-                       fw_name_dmub = FIRMWARE_GREEN_SARDINE_DMUB;
                break;
        case IP_VERSION(3, 0, 0):
-               if (adev->ip_versions[GC_HWIP][0] == IP_VERSION(10, 3, 0)) {
+               if (adev->ip_versions[GC_HWIP][0] == IP_VERSION(10, 3, 0))
                        dmub_asic = DMUB_ASIC_DCN30;
-                       fw_name_dmub = FIRMWARE_SIENNA_CICHLID_DMUB;
-               } else {
+               else
                        dmub_asic = DMUB_ASIC_DCN30;
-                       fw_name_dmub = FIRMWARE_NAVY_FLOUNDER_DMUB;
-               }
                break;
        case IP_VERSION(3, 0, 1):
                dmub_asic = DMUB_ASIC_DCN301;
-               fw_name_dmub = FIRMWARE_VANGOGH_DMUB;
                break;
        case IP_VERSION(3, 0, 2):
                dmub_asic = DMUB_ASIC_DCN302;
-               fw_name_dmub = FIRMWARE_DIMGREY_CAVEFISH_DMUB;
                break;
        case IP_VERSION(3, 0, 3):
                dmub_asic = DMUB_ASIC_DCN303;
-               fw_name_dmub = FIRMWARE_BEIGE_GOBY_DMUB;
                break;
        case IP_VERSION(3, 1, 2):
        case IP_VERSION(3, 1, 3):
                dmub_asic = (adev->external_rev_id == YELLOW_CARP_B0) ? DMUB_ASIC_DCN31B : DMUB_ASIC_DCN31;
-               fw_name_dmub = FIRMWARE_YELLOW_CARP_DMUB;
                break;
        case IP_VERSION(3, 1, 4):
                dmub_asic = DMUB_ASIC_DCN314;
-               fw_name_dmub = FIRMWARE_DCN_314_DMUB;
                break;
        case IP_VERSION(3, 1, 5):
                dmub_asic = DMUB_ASIC_DCN315;
-               fw_name_dmub = FIRMWARE_DCN_315_DMUB;
                break;
        case IP_VERSION(3, 1, 6):
                dmub_asic = DMUB_ASIC_DCN316;
-               fw_name_dmub = FIRMWARE_DCN316_DMUB;
                break;
        case IP_VERSION(3, 2, 0):
                dmub_asic = DMUB_ASIC_DCN32;
-               fw_name_dmub = FIRMWARE_DCN_V3_2_0_DMCUB;
                break;
        case IP_VERSION(3, 2, 1):
                dmub_asic = DMUB_ASIC_DCN321;
-               fw_name_dmub = FIRMWARE_DCN_V3_2_1_DMCUB;
                break;
        default:
                /* ASIC doesn't support DMUB. */
                return 0;
        }
 
-       r = request_firmware_direct(&adev->dm.dmub_fw, fw_name_dmub, adev->dev);
-       if (r) {
-               DRM_ERROR("DMUB firmware loading failed: %d\n", r);
-               return 0;
-       }
-
-       r = amdgpu_ucode_validate(adev->dm.dmub_fw);
-       if (r) {
-               DRM_ERROR("Couldn't validate DMUB firmware: %d\n", r);
-               return 0;
-       }
-
        hdr = (const struct dmcub_firmware_header_v1_0 *)adev->dm.dmub_fw->data;
        adev->dm.dmcub_fw_version = le32_to_cpu(hdr->header.ucode_version);
 
@@ -2145,11 +2109,8 @@ static int dm_sw_fini(void *handle)
                adev->dm.dmub_srv = NULL;
        }
 
-       release_firmware(adev->dm.dmub_fw);
-       adev->dm.dmub_fw = NULL;
-
-       release_firmware(adev->dm.fw_dmcu);
-       adev->dm.fw_dmcu = NULL;
+       amdgpu_ucode_release(&adev->dm.dmub_fw);
+       amdgpu_ucode_release(&adev->dm.fw_dmcu);
 
        return 0;
 }
@@ -4518,6 +4479,61 @@ DEVICE_ATTR_WO(s3_debug);
 
 #endif
 
+static int dm_init_microcode(struct amdgpu_device *adev)
+{
+       char *fw_name_dmub;
+       int r;
+
+       switch (adev->ip_versions[DCE_HWIP][0]) {
+       case IP_VERSION(2, 1, 0):
+               fw_name_dmub = FIRMWARE_RENOIR_DMUB;
+               if (ASICREV_IS_GREEN_SARDINE(adev->external_rev_id))
+                       fw_name_dmub = FIRMWARE_GREEN_SARDINE_DMUB;
+               break;
+       case IP_VERSION(3, 0, 0):
+               if (adev->ip_versions[GC_HWIP][0] == IP_VERSION(10, 3, 0))
+                       fw_name_dmub = FIRMWARE_SIENNA_CICHLID_DMUB;
+               else
+                       fw_name_dmub = FIRMWARE_NAVY_FLOUNDER_DMUB;
+               break;
+       case IP_VERSION(3, 0, 1):
+               fw_name_dmub = FIRMWARE_VANGOGH_DMUB;
+               break;
+       case IP_VERSION(3, 0, 2):
+               fw_name_dmub = FIRMWARE_DIMGREY_CAVEFISH_DMUB;
+               break;
+       case IP_VERSION(3, 0, 3):
+               fw_name_dmub = FIRMWARE_BEIGE_GOBY_DMUB;
+               break;
+       case IP_VERSION(3, 1, 2):
+       case IP_VERSION(3, 1, 3):
+               fw_name_dmub = FIRMWARE_YELLOW_CARP_DMUB;
+               break;
+       case IP_VERSION(3, 1, 4):
+               fw_name_dmub = FIRMWARE_DCN_314_DMUB;
+               break;
+       case IP_VERSION(3, 1, 5):
+               fw_name_dmub = FIRMWARE_DCN_315_DMUB;
+               break;
+       case IP_VERSION(3, 1, 6):
+               fw_name_dmub = FIRMWARE_DCN316_DMUB;
+               break;
+       case IP_VERSION(3, 2, 0):
+               fw_name_dmub = FIRMWARE_DCN_V3_2_0_DMCUB;
+               break;
+       case IP_VERSION(3, 2, 1):
+               fw_name_dmub = FIRMWARE_DCN_V3_2_1_DMCUB;
+               break;
+       default:
+               /* ASIC doesn't support DMUB. */
+               return 0;
+       }
+       r = amdgpu_ucode_request(adev, &adev->dm.dmub_fw, fw_name_dmub);
+       if (r)
+               DRM_ERROR("DMUB firmware loading failed: %d\n", r);
+       return r;
+}
+
 static int dm_early_init(void *handle)
 {
        struct amdgpu_device *adev = (struct amdgpu_device *)handle;
@@ -4650,7 +4666,7 @@ static int dm_early_init(void *handle)
 #endif
        adev->dc_enabled = true;
 
-       return 0;
+       return dm_init_microcode(adev);
 }
 
 static bool modereset_required(struct drm_crtc_state *crtc_state)
@@ -7428,7 +7444,7 @@ static bool is_content_protection_different(struct drm_crtc_state *new_crtc_stat
                        new_conn_state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
                        pr_debug("[HDCP_DM] ENABLED->DESIRED & mode_changed %s :true\n", __func__);
                        return true;
-               };
+               }
                new_conn_state->content_protection = DRM_MODE_CONTENT_PROTECTION_ENABLED;
                pr_debug("[HDCP_DM] ENABLED -> DESIRED %s :false\n", __func__);
                return false;
@@ -7482,11 +7498,11 @@ static bool is_content_protection_different(struct drm_crtc_state *new_crtc_stat
                                pr_debug("[HDCP_DM] DESIRED->DESIRED or ENABLE->ENABLE mode_change %s :true\n",
                                        __func__);
                                return true;
-                       };
+                       }
                        pr_debug("[HDCP_DM] DESIRED->DESIRED & ENABLE->ENABLE %s :false\n",
                                __func__);
                        return false;
-               };
+               }
 
                pr_debug("[HDCP_DM] UNDESIRED->UNDESIRED %s :false\n", __func__);
                return false;
Linux 6.x block layer and io_uring tree(s)