From: YiPeng Chai <[email protected]>

The socket ID parsed from ACA IPID always corresponds to the current
socket and never references another socket. Therefore, there is no
need to maintain per-socket storage for remote sockets — a single
socket is sufficient to store all ACA RAS error information for each
GPU device.

Signed-off-by: YiPeng Chai <[email protected]>
Reviewed-by: Hawking Zhang <[email protected]>
Signed-off-by: Alex Deucher <[email protected]>
---
 drivers/gpu/drm/amd/ras/core/aca.c            | 100 ++++++++----------
 drivers/gpu/drm/amd/ras/core/aca.h            |   4 +-
 drivers/gpu/drm/amd/ras/core/ras.h            |   1 -
 .../gpu/drm/amd/ras/ras_mgr/amdgpu_ras_mgr.c  |   4 -
 .../gpu/drm/amd/ras/ras_mgr/amdgpu_ras_sys.c  |   3 +
 5 files changed, 49 insertions(+), 63 deletions(-)

diff --git a/drivers/gpu/drm/amd/ras/core/aca.c 
b/drivers/gpu/drm/amd/ras/core/aca.c
index a2529645af098..60a435ae92c9a 100644
--- a/drivers/gpu/drm/amd/ras/core/aca.c
+++ b/drivers/gpu/drm/amd/ras/core/aca.c
@@ -189,27 +189,36 @@ static int aca_parse_bank(struct ras_core_context 
*ras_core,
 static int aca_check_block_ecc_info(struct ras_core_context *ras_core,
                        struct aca_block *aca_blk, struct aca_ecc_info *info)
 {
-       if (info->socket_id >= aca_blk->ecc.socket_num_per_node) {
+       struct device_system_info dev_info = {0};
+       int ret;
+
+       ret = ras_core_get_device_system_info(ras_core, &dev_info);
+       if (ret) {
+               RAS_DEV_ERR(ras_core->dev, "Failed to get system device 
info.\n");
+               return ret;
+       }
+
+       if (info->socket_id != dev_info.socket_id) {
                RAS_DEV_ERR(ras_core->dev,
-                       "Socket id (%d) is out of config! max:%u\n",
-                       info->socket_id, aca_blk->ecc.socket_num_per_node);
-               return -ENODATA;
+                       "Bank socket id (%d) does not match device socket 
id:%u\n",
+                       info->socket_id, dev_info.socket_id);
+               return -ENXIO;
        }
 
-       if (info->die_id >= aca_blk->ecc.socket[info->socket_id].aid_num) {
+       if (info->die_id >= aca_blk->ecc.socket.aid_num) {
                RAS_DEV_ERR(ras_core->dev,
                        "Die id (%d) is out of config! max:%u\n",
-                       info->die_id, 
aca_blk->ecc.socket[info->socket_id].aid_num);
+                       info->die_id, aca_blk->ecc.socket.aid_num);
                return -ENODATA;
        }
 
        if ((aca_blk->blk_info->ras_block_id == RAS_BLOCK_ID__GFX) && 
info->xcd_valid &&
            (info->xcd_id >=
-                
aca_blk->ecc.socket[info->socket_id].aid[info->die_id].xcd.xcd_num)) {
+                aca_blk->ecc.socket.aid[info->die_id].xcd.xcd_num)) {
                RAS_DEV_ERR(ras_core->dev,
                        "Xcd id (%d) is out of config! max:%u\n",
                        info->xcd_id,
-                       
aca_blk->ecc.socket[info->socket_id].aid[info->die_id].xcd.xcd_num);
+                       aca_blk->ecc.socket.aid[info->die_id].xcd.xcd_num);
                return -ENODATA;
        }
 
@@ -232,7 +241,7 @@ static int aca_log_bad_bank(struct ras_core_context 
*ras_core,
                return ret;
 
        mutex_lock(&ras_core->ras_aca.aca_lock);
-       aid_ecc = &aca_blk->ecc.socket[info->socket_id].aid[info->die_id];
+       aid_ecc = &aca_blk->ecc.socket.aid[info->die_id];
        ecc_err = &aid_ecc->ecc_err;
 
        if ((aca_blk->blk_info->ras_block_id == RAS_BLOCK_ID__GFX) &&
@@ -268,7 +277,7 @@ static int aca_log_bad_bank(struct ras_core_context 
*ras_core,
 
        aca_report_ecc_info(ras_core,
                bank->seq_no, aca_blk->blk_info->ras_block_id, info->socket_id, 
info->die_id,
-               &aca_blk->ecc.socket[info->socket_id].aid[info->die_id], 
bank_ecc);
+               &aca_blk->ecc.socket.aid[info->die_id], bank_ecc);
 
        return 0;
 }
@@ -452,16 +461,13 @@ int ras_aca_clear_all_blocks_ecc_count(struct 
ras_core_context *ras_core)
 {
        struct aca_block *aca_blk;
        enum ras_block_id blk;
-       int skt;
 
        mutex_lock(&ras_core->ras_aca.aca_lock);
        for (blk = RAS_BLOCK_ID__UMC; blk < RAS_BLOCK_ID__LAST; blk++) {
                aca_blk = ras_aca_get_block_handle(ras_core, blk);
-               if (aca_blk) {
-                       for (skt = 0; skt < aca_blk->ecc.socket_num_per_node; 
skt++)
-                               __clear_block_socket_ecc_count(ras_core,
-                                               blk, &aca_blk->ecc.socket[skt]);
-               }
+               if (aca_blk)
+                       __clear_block_socket_ecc_count(ras_core,
+                                               blk, &aca_blk->ecc.socket);
        }
        mutex_unlock(&ras_core->ras_aca.aca_lock);
 
@@ -471,29 +477,27 @@ int ras_aca_clear_all_blocks_ecc_count(struct 
ras_core_context *ras_core)
 int ras_aca_clear_block_new_ecc_count(struct ras_core_context *ras_core, u32 
blk)
 {
        struct aca_block *aca_blk;
-       int skt, aid, xcd;
+       int aid, xcd;
        struct aca_ecc_count *ecc_err;
        struct aca_aid_ecc  *aid_ecc;
 
        mutex_lock(&ras_core->ras_aca.aca_lock);
        aca_blk = ras_aca_get_block_handle(ras_core, blk);
-       for (skt = 0; skt < aca_blk->ecc.socket_num_per_node; skt++) {
-               for (aid = 0; aid < aca_blk->ecc.socket[skt].aid_num; aid++) {
-                       aid_ecc = &aca_blk->ecc.socket[skt].aid[aid];
-                       if (blk == RAS_BLOCK_ID__GFX) {
-                               for (xcd = 0; xcd < aid_ecc->xcd.xcd_num; 
xcd++) {
-                                       ecc_err = 
&aid_ecc->xcd.xcd[xcd].ecc_err;
-                                       ecc_err->new_ce_count = 0;
-                                       ecc_err->new_ue_count = 0;
-                                       ecc_err->new_de_count = 0;
-                               }
+       for (aid = 0; aid < aca_blk->ecc.socket.aid_num; aid++) {
+               aid_ecc = &aca_blk->ecc.socket.aid[aid];
+               if (blk == RAS_BLOCK_ID__GFX) {
+                       for (xcd = 0; xcd < aid_ecc->xcd.xcd_num; xcd++) {
+                               ecc_err = &aid_ecc->xcd.xcd[xcd].ecc_err;
+                               ecc_err->new_ce_count = 0;
+                               ecc_err->new_ue_count = 0;
+                               ecc_err->new_de_count = 0;
                        }
-
-                       ecc_err = &aid_ecc->ecc_err;
-                       ecc_err->new_ce_count = 0;
-                       ecc_err->new_ue_count = 0;
-                       ecc_err->new_de_count = 0;
                }
+
+               ecc_err = &aid_ecc->ecc_err;
+               ecc_err->new_ce_count = 0;
+               ecc_err->new_ue_count = 0;
+               ecc_err->new_de_count = 0;
        }
        mutex_unlock(&ras_core->ras_aca.aca_lock);
 
@@ -551,9 +555,7 @@ int ras_aca_get_block_ecc_count(struct ras_core_context 
*ras_core,
 {
        struct ras_ecc_count *err_data = (struct ras_ecc_count *)data;
        struct aca_block *aca_blk;
-       struct aca_ecc_count skt_ecc;
        struct aca_ecc_count ecc;
-       u32 skt;
 
        if (blk >= RAS_BLOCK_ID__LAST)
                return -EINVAL;
@@ -565,13 +567,7 @@ int ras_aca_get_block_ecc_count(struct ras_core_context 
*ras_core,
        memset(&ecc, 0, sizeof(ecc));
 
        mutex_lock(&ras_core->ras_aca.aca_lock);
-       for (skt = 0; skt < aca_blk->ecc.socket_num_per_node; skt++) {
-               memset(&skt_ecc, 0, sizeof(skt_ecc));
-               __get_block_socket_ecc_count(ras_core, blk,
-                               &aca_blk->ecc.socket[skt], &skt_ecc);
-
-               _add_ecc_count(&ecc, &skt_ecc);
-       }
+       __get_block_socket_ecc_count(ras_core, blk, &aca_blk->ecc.socket, &ecc);
 
        err_data->new_ce_count = ecc.new_ce_count;
        err_data->total_ce_count = ecc.total_ce_count;
@@ -589,21 +585,18 @@ int ras_aca_sw_init(struct ras_core_context *ras_core)
        struct ras_aca *ras_aca = &ras_core->ras_aca;
        struct ras_aca_config *aca_cfg = &ras_core->config->aca_cfg;
        struct aca_block *aca_blk;
-       uint32_t socket_num_per_node;
        uint32_t aid_num_per_socket;
        uint32_t xcd_num_per_aid;
-       int blk, skt, aid;
+       int blk, aid;
 
-       socket_num_per_node = aca_cfg->socket_num_per_node;
        aid_num_per_socket = aca_cfg->aid_num_per_socket;
        xcd_num_per_aid = aca_cfg->xcd_num_per_aid;
 
        if (!xcd_num_per_aid || !aid_num_per_socket ||
-               (socket_num_per_node > MAX_SOCKET_NUM_PER_NODE) ||
            (aid_num_per_socket > MAX_AID_NUM_PER_SOCKET) ||
            (xcd_num_per_aid > MAX_XCD_NUM_PER_AID)) {
-               RAS_DEV_ERR(ras_core->dev, "Invalid ACA system configuration: 
%d, %d, %d\n",
-                       socket_num_per_node, aid_num_per_socket, 
xcd_num_per_aid);
+               RAS_DEV_ERR(ras_core->dev, "Invalid ACA system configuration: 
%d, %d\n",
+                       aid_num_per_socket, xcd_num_per_aid);
                return -EINVAL;
        }
 
@@ -615,14 +608,11 @@ int ras_aca_sw_init(struct ras_core_context *ras_core)
 
        for (blk = 0; blk < RAS_BLOCK_ID__LAST; blk++) {
                aca_blk = &ras_aca->aca_blk[blk];
-               aca_blk->ecc.socket_num_per_node = socket_num_per_node;
-               for (skt = 0; skt < aca_blk->ecc.socket_num_per_node; skt++) {
-                       aca_blk->ecc.socket[skt].aid_num = aid_num_per_socket;
-                       if (blk == RAS_BLOCK_ID__GFX) {
-                               for (aid = 0; aid < 
aca_blk->ecc.socket[skt].aid_num; aid++)
-                                       
aca_blk->ecc.socket[skt].aid[aid].xcd.xcd_num =
-                                                               xcd_num_per_aid;
-                       }
+               aca_blk->ecc.socket.aid_num = aid_num_per_socket;
+               if (blk == RAS_BLOCK_ID__GFX) {
+                       for (aid = 0; aid < aca_blk->ecc.socket.aid_num; aid++)
+                               aca_blk->ecc.socket.aid[aid].xcd.xcd_num =
+                                                       xcd_num_per_aid;
                }
        }
 
diff --git a/drivers/gpu/drm/amd/ras/core/aca.h 
b/drivers/gpu/drm/amd/ras/core/aca.h
index b19b6e7089f28..22b12a036754e 100644
--- a/drivers/gpu/drm/amd/ras/core/aca.h
+++ b/drivers/gpu/drm/amd/ras/core/aca.h
@@ -26,7 +26,6 @@
 #define __ACA_H__
 #include "ras.h"
 
-#define MAX_SOCKET_NUM_PER_NODE 8
 #define MAX_AID_NUM_PER_SOCKET 4
 #define MAX_XCD_NUM_PER_AID 4
 
@@ -119,8 +118,7 @@ struct aca_socket_ecc {
 };
 
 struct aca_block_ecc {
-       struct aca_socket_ecc socket[MAX_SOCKET_NUM_PER_NODE];
-       u32 socket_num_per_node;
+       struct aca_socket_ecc socket;
 };
 
 struct aca_bank_hw_ops {
diff --git a/drivers/gpu/drm/amd/ras/core/ras.h 
b/drivers/gpu/drm/amd/ras/core/ras.h
index 38ab1aa9be0f9..9c830b803e834 100644
--- a/drivers/gpu/drm/amd/ras/core/ras.h
+++ b/drivers/gpu/drm/amd/ras/core/ras.h
@@ -323,7 +323,6 @@ struct ras_bank_ecc_node {
 };
 
 struct ras_aca_config {
-       u32 socket_num_per_node;
        u32 aid_num_per_socket;
        u32 xcd_num_per_aid;
 };
diff --git a/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_mgr.c 
b/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_mgr.c
index 34b4b3345259a..0e41c005a1ea2 100644
--- a/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_mgr.c
+++ b/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_mgr.c
@@ -35,11 +35,9 @@
 #include "amdgpu_ras_nbio_v7_9.h"
 #include "amdgpu_ras_mce.h"
 
-#define MAX_SOCKET_NUM_PER_NODE_GFX9    8
 #define MAX_AID_NUM_PER_SOCKET_GFX9     4
 #define MAX_XCD_NUM_PER_AID_GFX9        2
 
-#define MAX_SOCKET_NUM_PER_NODE_GFX12   4
 #define MAX_AID_NUM_PER_SOCKET_GFX12    2
 #define MAX_XCD_NUM_PER_AID_GFX12       4
 
@@ -92,12 +90,10 @@ static int amdgpu_ras_mgr_init_aca_config(struct 
amdgpu_device *adev,
        case IP_VERSION(9, 4, 3):
        case IP_VERSION(9, 4, 4):
        case IP_VERSION(9, 5, 0):
-               aca_cfg->socket_num_per_node = MAX_SOCKET_NUM_PER_NODE_GFX9;
                aca_cfg->aid_num_per_socket = MAX_AID_NUM_PER_SOCKET_GFX9;
                aca_cfg->xcd_num_per_aid = MAX_XCD_NUM_PER_AID_GFX9;
                break;
        case IP_VERSION(12, 1, 0):
-               aca_cfg->socket_num_per_node = MAX_SOCKET_NUM_PER_NODE_GFX12;
                aca_cfg->aid_num_per_socket = MAX_AID_NUM_PER_SOCKET_GFX12;
                aca_cfg->xcd_num_per_aid = MAX_XCD_NUM_PER_AID_GFX12;
                break;
diff --git a/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_sys.c 
b/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_sys.c
index 7bc827cc8e9fc..afb539f068c2d 100644
--- a/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_sys.c
+++ b/drivers/gpu/drm/amd/ras/ras_mgr/amdgpu_ras_sys.c
@@ -212,6 +212,9 @@ static int amdgpu_ras_sys_get_device_system_info(struct 
ras_core_context *ras_co
 {
        struct amdgpu_device *adev = (struct amdgpu_device *)ras_core->dev;
 
+       if (!adev->smuio.funcs || !adev->smuio.funcs->get_socket_id)
+               return -ENOENT;
+
        dev_info->device_id = adev->pdev->device;
        dev_info->vendor_id = adev->pdev->vendor;
        dev_info->socket_id = adev->smuio.funcs->get_socket_id(adev);
-- 
2.55.0

Reply via email to