]> Git Repo - J-linux.git/blobdiff - drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c
projects / J-linux.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge tag 'linux_kselftest-kunit-6.7-rc1' of git://git.kernel.org/pub/scm/linux/kerne...
[J-linux.git] / drivers / gpu / drm / amd / amdgpu / amdgpu_psp.c
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c
index 429ef212c1f25b4865953083ef32196f0e3628a6..648bd5e12830bce18a87afd496fea17fd7bf15de 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c
@@ -100,7 +100,7 @@ static void psp_check_pmfw_centralized_cstate_management(struct psp_context *psp
                return;
        }
 
-       switch (adev->ip_versions[MP0_HWIP][0]) {
+       switch (amdgpu_ip_version(adev, MP0_HWIP, 0)) {
        case IP_VERSION(11, 0, 0):
        case IP_VERSION(11, 0, 4):
        case IP_VERSION(11, 0, 5):
@@ -128,7 +128,7 @@ static int psp_init_sriov_microcode(struct psp_context *psp)
 
        amdgpu_ucode_ip_version_decode(adev, MP0_HWIP, ucode_prefix, sizeof(ucode_prefix));
 
-       switch (adev->ip_versions[MP0_HWIP][0]) {
+       switch (amdgpu_ip_version(adev, MP0_HWIP, 0)) {
        case IP_VERSION(9, 0, 0):
        case IP_VERSION(11, 0, 7):
        case IP_VERSION(11, 0, 9):
@@ -162,7 +162,7 @@ static int psp_early_init(void *handle)
        struct amdgpu_device *adev = (struct amdgpu_device *)handle;
        struct psp_context *psp = &adev->psp;
 
-       switch (adev->ip_versions[MP0_HWIP][0]) {
+       switch (amdgpu_ip_version(adev, MP0_HWIP, 0)) {
        case IP_VERSION(9, 0, 0):
                psp_v3_1_set_psp_funcs(psp);
                psp->autoload_supported = false;
@@ -334,7 +334,7 @@ static bool psp_get_runtime_db_entry(struct amdgpu_device *adev,
        bool ret = false;
        int i;
 
-       if (adev->ip_versions[MP0_HWIP][0] == IP_VERSION(13, 0, 6))
+       if (amdgpu_ip_version(adev, MP0_HWIP, 0) == IP_VERSION(13, 0, 6))
                return false;
 
        db_header_pos = adev->gmc.mc_vram_size - PSP_RUNTIME_DB_OFFSET;
@@ -413,7 +413,7 @@ static int psp_sw_init(void *handle)
 
        adev->psp.xgmi_context.supports_extended_data =
                !adev->gmc.xgmi.connected_to_cpu &&
-                       adev->ip_versions[MP0_HWIP][0] == IP_VERSION(13, 0, 2);
+               amdgpu_ip_version(adev, MP0_HWIP, 0) == IP_VERSION(13, 0, 2);
 
        memset(&scpm_entry, 0, sizeof(scpm_entry));
        if ((psp_get_runtime_db_entry(adev,
@@ -773,7 +773,7 @@ static int psp_load_toc(struct psp_context *psp,
 
 static bool psp_boottime_tmr(struct psp_context *psp)
 {
-       switch (psp->adev->ip_versions[MP0_HWIP][0]) {
+       switch (amdgpu_ip_version(psp->adev, MP0_HWIP, 0)) {
        case IP_VERSION(13, 0, 6):
                return true;
        default:
@@ -828,7 +828,7 @@ static int psp_tmr_init(struct psp_context *psp)
 
 static bool psp_skip_tmr(struct psp_context *psp)
 {
-       switch (psp->adev->ip_versions[MP0_HWIP][0]) {
+       switch (amdgpu_ip_version(psp->adev, MP0_HWIP, 0)) {
        case IP_VERSION(11, 0, 9):
        case IP_VERSION(11, 0, 7):
        case IP_VERSION(13, 0, 2):
@@ -1215,8 +1215,8 @@ int psp_xgmi_terminate(struct psp_context *psp)
        struct amdgpu_device *adev = psp->adev;
 
        /* XGMI TA unload currently is not supported on Arcturus/Aldebaran A+A */
-       if (adev->ip_versions[MP0_HWIP][0] == IP_VERSION(11, 0, 4) ||
-           (adev->ip_versions[MP0_HWIP][0] == IP_VERSION(13, 0, 2) &&
+       if (amdgpu_ip_version(adev, MP0_HWIP, 0) == IP_VERSION(11, 0, 4) ||
+           (amdgpu_ip_version(adev, MP0_HWIP, 0) == IP_VERSION(13, 0, 2) &&
             adev->gmc.xgmi.connected_to_cpu))
                return 0;
 
@@ -1267,6 +1267,8 @@ invoke:
        xgmi_cmd->cmd_id = TA_COMMAND_XGMI__INITIALIZE;
 
        ret = psp_xgmi_invoke(psp, xgmi_cmd->cmd_id);
+       /* note down the capbility flag for XGMI TA */
+       psp->xgmi_context.xgmi_ta_caps = xgmi_cmd->caps_flag;
 
        return ret;
 }
@@ -1313,9 +1315,11 @@ int psp_xgmi_get_node_id(struct psp_context *psp, uint64_t *node_id)
 
 static bool psp_xgmi_peer_link_info_supported(struct psp_context *psp)
 {
-       return (psp->adev->ip_versions[MP0_HWIP][0] == IP_VERSION(13, 0, 2) &&
+       return (amdgpu_ip_version(psp->adev, MP0_HWIP, 0) ==
+                       IP_VERSION(13, 0, 2) &&
                psp->xgmi_context.context.bin_desc.fw_version >= 0x2000000b) ||
-               psp->adev->ip_versions[MP0_HWIP][0] >= IP_VERSION(13, 0, 6);
+              amdgpu_ip_version(psp->adev, MP0_HWIP, 0) >=
+                      IP_VERSION(13, 0, 6);
 }
 
 /*
@@ -1386,7 +1390,7 @@ int psp_xgmi_get_topology_info(struct psp_context *psp,
 
        /* Fill in the shared memory with topology information as input */
        topology_info_input = &xgmi_cmd->xgmi_in_message.get_topology_info;
-       xgmi_cmd->cmd_id = TA_COMMAND_XGMI__GET_GET_TOPOLOGY_INFO;
+       xgmi_cmd->cmd_id = TA_COMMAND_XGMI__GET_TOPOLOGY_INFO;
        topology_info_input->num_nodes = number_devices;
 
        for (i = 0; i < topology_info_input->num_nodes; i++) {
@@ -1397,7 +1401,7 @@ int psp_xgmi_get_topology_info(struct psp_context *psp,
        }
 
        /* Invoke xgmi ta to get the topology information */
-       ret = psp_xgmi_invoke(psp, TA_COMMAND_XGMI__GET_GET_TOPOLOGY_INFO);
+       ret = psp_xgmi_invoke(psp, TA_COMMAND_XGMI__GET_TOPOLOGY_INFO);
        if (ret)
                return ret;
 
@@ -1422,26 +1426,53 @@ int psp_xgmi_get_topology_info(struct psp_context *psp,
 
        /* Invoke xgmi ta again to get the link information */
        if (psp_xgmi_peer_link_info_supported(psp)) {
-               struct ta_xgmi_cmd_get_peer_link_info_output *link_info_output;
+               struct ta_xgmi_cmd_get_peer_link_info *link_info_output;
+               struct ta_xgmi_cmd_get_extend_peer_link_info *link_extend_info_output;
                bool requires_reflection =
-                       (psp->xgmi_context.supports_extended_data && get_extended_data) ||
-                               psp->adev->ip_versions[MP0_HWIP][0] == IP_VERSION(13, 0, 6);
+                       (psp->xgmi_context.supports_extended_data &&
+                        get_extended_data) ||
+                       amdgpu_ip_version(psp->adev, MP0_HWIP, 0) ==
+                               IP_VERSION(13, 0, 6);
+               bool ta_port_num_support = psp->xgmi_context.xgmi_ta_caps &
+                                               EXTEND_PEER_LINK_INFO_CMD_FLAG;
+
+               /* popluate the shared output buffer rather than the cmd input buffer
+                * with node_ids as the input for GET_PEER_LINKS command execution.
+                * This is required for GET_PEER_LINKS per xgmi ta implementation.
+                * The same requirement for GET_EXTEND_PEER_LINKS command.
+                */
+               if (ta_port_num_support) {
+                       link_extend_info_output = &xgmi_cmd->xgmi_out_message.get_extend_link_info;
+
+                       for (i = 0; i < topology->num_nodes; i++)
+                               link_extend_info_output->nodes[i].node_id = topology->nodes[i].node_id;
 
-               xgmi_cmd->cmd_id = TA_COMMAND_XGMI__GET_PEER_LINKS;
+                       link_extend_info_output->num_nodes = topology->num_nodes;
+                       xgmi_cmd->cmd_id = TA_COMMAND_XGMI__GET_EXTEND_PEER_LINKS;
+               } else {
+                       link_info_output = &xgmi_cmd->xgmi_out_message.get_link_info;
 
-               ret = psp_xgmi_invoke(psp, TA_COMMAND_XGMI__GET_PEER_LINKS);
+                       for (i = 0; i < topology->num_nodes; i++)
+                               link_info_output->nodes[i].node_id = topology->nodes[i].node_id;
+
+                       link_info_output->num_nodes = topology->num_nodes;
+                       xgmi_cmd->cmd_id = TA_COMMAND_XGMI__GET_PEER_LINKS;
+               }
 
+               ret = psp_xgmi_invoke(psp, xgmi_cmd->cmd_id);
                if (ret)
                        return ret;
 
-               link_info_output = &xgmi_cmd->xgmi_out_message.get_link_info;
                for (i = 0; i < topology->num_nodes; i++) {
+                       uint8_t node_num_links = ta_port_num_support ?
+                               link_extend_info_output->nodes[i].num_links : link_info_output->nodes[i].num_links;
                        /* accumulate num_links on extended data */
-                       topology->nodes[i].num_links = get_extended_data ?
-                                       topology->nodes[i].num_links +
-                                                       link_info_output->nodes[i].num_links :
-                                       ((requires_reflection && topology->nodes[i].num_links) ? topology->nodes[i].num_links :
-                                        link_info_output->nodes[i].num_links);
+                       if (get_extended_data) {
+                               topology->nodes[i].num_links = topology->nodes[i].num_links + node_num_links;
+                       } else {
+                               topology->nodes[i].num_links = (requires_reflection && topology->nodes[i].num_links) ?
+                                                               topology->nodes[i].num_links : node_num_links;
+                       }
 
                        /* reflect the topology information for bi-directionality */
                        if (requires_reflection && topology->nodes[i].num_hops)
@@ -2390,6 +2421,27 @@ static int psp_get_fw_type(struct amdgpu_firmware_info *ucode,
        case AMDGPU_UCODE_ID_CP_RS64_MEC_P3_STACK:
                *type = GFX_FW_TYPE_RS64_MEC_P3_STACK;
                break;
+       case AMDGPU_UCODE_ID_VPE_CTX:
+               *type = GFX_FW_TYPE_VPEC_FW1;
+               break;
+       case AMDGPU_UCODE_ID_VPE_CTL:
+               *type = GFX_FW_TYPE_VPEC_FW2;
+               break;
+       case AMDGPU_UCODE_ID_VPE:
+               *type = GFX_FW_TYPE_VPE;
+               break;
+       case AMDGPU_UCODE_ID_UMSCH_MM_UCODE:
+               *type = GFX_FW_TYPE_UMSCH_UCODE;
+               break;
+       case AMDGPU_UCODE_ID_UMSCH_MM_DATA:
+               *type = GFX_FW_TYPE_UMSCH_DATA;
+               break;
+       case AMDGPU_UCODE_ID_UMSCH_MM_CMD_BUFFER:
+               *type = GFX_FW_TYPE_UMSCH_CMD_BUFFER;
+               break;
+       case AMDGPU_UCODE_ID_P2S_TABLE:
+               *type = GFX_FW_TYPE_P2S_TABLE;
+               break;
        case AMDGPU_UCODE_ID_MAXIMUM:
        default:
                return -EINVAL;
@@ -2481,6 +2533,31 @@ int psp_execute_ip_fw_load(struct psp_context *psp,
        return ret;
 }
 
+static int psp_load_p2s_table(struct psp_context *psp)
+{
+       int ret;
+       struct amdgpu_device *adev = psp->adev;
+       struct amdgpu_firmware_info *ucode =
+               &adev->firmware.ucode[AMDGPU_UCODE_ID_P2S_TABLE];
+
+       if (adev->in_runpm && (adev->pm.rpm_mode == AMDGPU_RUNPM_BACO))
+               return 0;
+
+       if (amdgpu_ip_version(adev, MP0_HWIP, 0) == IP_VERSION(13, 0, 6)) {
+               uint32_t supp_vers = adev->flags & AMD_IS_APU ? 0x0036013D :
+                                                               0x0036003C;
+               if (psp->sos.fw_version < supp_vers)
+                       return 0;
+       }
+
+       if (!ucode->fw || amdgpu_sriov_vf(psp->adev))
+               return 0;
+
+       ret = psp_execute_ip_fw_load(psp, ucode);
+
+       return ret;
+}
+
 static int psp_load_smu_fw(struct psp_context *psp)
 {
        int ret;
@@ -2499,10 +2576,9 @@ static int psp_load_smu_fw(struct psp_context *psp)
        if (!ucode->fw || amdgpu_sriov_vf(psp->adev))
                return 0;
 
-       if ((amdgpu_in_reset(adev) &&
-            ras && adev->ras_enabled &&
-            (adev->ip_versions[MP0_HWIP][0] == IP_VERSION(11, 0, 4) ||
-             adev->ip_versions[MP0_HWIP][0] == IP_VERSION(11, 0, 2)))) {
+       if ((amdgpu_in_reset(adev) && ras && adev->ras_enabled &&
+            (amdgpu_ip_version(adev, MP0_HWIP, 0) == IP_VERSION(11, 0, 4) ||
+             amdgpu_ip_version(adev, MP0_HWIP, 0) == IP_VERSION(11, 0, 2)))) {
                ret = amdgpu_dpm_set_mp1_state(adev, PP_MP1_STATE_UNLOAD);
                if (ret)
                        DRM_WARN("Failed to set MP1 state prepare for reload\n");
@@ -2522,6 +2598,9 @@ static bool fw_load_skip_check(struct psp_context *psp,
        if (!ucode->fw || !ucode->ucode_size)
                return true;
 
+       if (ucode->ucode_id == AMDGPU_UCODE_ID_P2S_TABLE)
+               return true;
+
        if (ucode->ucode_id == AMDGPU_UCODE_ID_SMC &&
            (psp_smu_reload_quirk(psp) ||
             psp->autoload_supported ||
@@ -2570,6 +2649,9 @@ static int psp_load_non_psp_fw(struct psp_context *psp)
                        return ret;
        }
 
+       /* Load P2S table first if it's available */
+       psp_load_p2s_table(psp);
+
        for (i = 0; i < adev->firmware.max_ucodes; i++) {
                ucode = &adev->firmware.ucode[i];
 
@@ -2585,9 +2667,12 @@ static int psp_load_non_psp_fw(struct psp_context *psp)
                        continue;
 
                if (psp->autoload_supported &&
-                   (adev->ip_versions[MP0_HWIP][0] == IP_VERSION(11, 0, 7) ||
-                    adev->ip_versions[MP0_HWIP][0] == IP_VERSION(11, 0, 11) ||
-                    adev->ip_versions[MP0_HWIP][0] == IP_VERSION(11, 0, 12)) &&
+                   (amdgpu_ip_version(adev, MP0_HWIP, 0) ==
+                            IP_VERSION(11, 0, 7) ||
+                    amdgpu_ip_version(adev, MP0_HWIP, 0) ==
+                            IP_VERSION(11, 0, 11) ||
+                    amdgpu_ip_version(adev, MP0_HWIP, 0) ==
+                            IP_VERSION(11, 0, 12)) &&
                    (ucode->ucode_id == AMDGPU_UCODE_ID_SDMA1 ||
                     ucode->ucode_id == AMDGPU_UCODE_ID_SDMA2 ||
                     ucode->ucode_id == AMDGPU_UCODE_ID_SDMA3))
@@ -3128,7 +3213,7 @@ static int psp_init_sos_base_fw(struct amdgpu_device *adev)
                le32_to_cpu(sos_hdr->header.ucode_array_offset_bytes);
 
        if (adev->gmc.xgmi.connected_to_cpu ||
-           (adev->ip_versions[MP0_HWIP][0] != IP_VERSION(13, 0, 2))) {
+           (amdgpu_ip_version(adev, MP0_HWIP, 0) != IP_VERSION(13, 0, 2))) {
                adev->psp.sos.fw_version = le32_to_cpu(sos_hdr->header.ucode_version);
                adev->psp.sos.feature_version = le32_to_cpu(sos_hdr->sos.fw_version);
 
Empty description
This page took 0.039513 seconds and 4 git commands to generate.