drm/amdkfd: add gpu compute cores io links for gfx9.4.3

The PSP TA will only provide xGMI topology info for links between GPU
sockets so links between partitions from different sockets will be
hardcoded as 3 xGMI hops with 1 hops weighted as xGMI and 2 hops
weighted with a new intra-socket weight to indicate the longest
possible distance.

If the link between a partition and the CPU is non-PCIe, then assume
the CPU (CCDs) is located within the same socket as the partition
and represent the link as an intra-socket weighted single hop XGMI link
with memory bandwidth.

Links between partitions within a single socket will be abstracted as
single hop xGMI links weighted with the new intra-socket weight and
will have memory bandwidth.

Finally, use the unused function bits in the location ID to represent the
coordinates of the compute partition within its socket.

A follow on patch will resolve the requirement for GPU socket xGMI
link representation sometime later.

Signed-off-by: Jonathan Kim <jonathan.kim@amd.com>
Reviewed-by: Felix Kuehling <felix.kuehling@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
index f5aebba..dc93a67 100644 (file)
--- a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
@@ -1166,7 +1166,7 @@ static int kfd_parse_subtype_iolink(struct crat_subtype_iolink *iolink,
                        if (props->iolink_type == CRAT_IOLINK_TYPE_PCIEXPRESS)
                                props->weight = 20;
                        else if (props->iolink_type == CRAT_IOLINK_TYPE_XGMI)
-                               props->weight = 15 * iolink->num_hops_xgmi;
+                               props->weight = iolink->weight_xgmi;
                        else
                                props->weight = node_distance(id_from, id_to);
 
@@ -1972,6 +1972,9 @@ static void kfd_find_numa_node_in_srat(struct kfd_node *kdev)
 }
 #endif
 
+#define KFD_CRAT_INTRA_SOCKET_WEIGHT   13
+#define KFD_CRAT_XGMI_WEIGHT           15
+
 /* kfd_fill_gpu_direct_io_link - Fill in direct io link from GPU
  * to its NUMA node
  *     @avail_size: Available size in the memory
@@ -2003,6 +2006,12 @@ static int kfd_fill_gpu_direct_io_link_to_cpu(int *avail_size,
         * TODO: Fill-in other fields of iolink subtype
         */
        if (kdev->adev->gmc.xgmi.connected_to_cpu) {
+               bool ext_cpu = KFD_GC_VERSION(kdev) != IP_VERSION(9, 4, 3);
+               int mem_bw = 819200, weight = ext_cpu ? KFD_CRAT_XGMI_WEIGHT :
+                                                       KFD_CRAT_INTRA_SOCKET_WEIGHT;
+               uint32_t bandwidth = ext_cpu ? amdgpu_amdkfd_get_xgmi_bandwidth_mbytes(
+                                                       kdev->adev, NULL, true) : mem_bw;
+
                /*
                 * with host gpu xgmi link, host can access gpu memory whether
                 * or not pcie bar type is large, so always create bidirectional
@@ -2010,14 +2019,9 @@ static int kfd_fill_gpu_direct_io_link_to_cpu(int *avail_size,
                 */
                sub_type_hdr->flags |= CRAT_IOLINK_FLAGS_BI_DIRECTIONAL;
                sub_type_hdr->io_interface_type = CRAT_IOLINK_TYPE_XGMI;
-               sub_type_hdr->num_hops_xgmi = 1;
-               if (KFD_GC_VERSION(kdev) == IP_VERSION(9, 4, 2)) {
-                       sub_type_hdr->minimum_bandwidth_mbs =
-                                       amdgpu_amdkfd_get_xgmi_bandwidth_mbytes(
-                                                       kdev->adev, NULL, true);
-                       sub_type_hdr->maximum_bandwidth_mbs =
-                                       sub_type_hdr->minimum_bandwidth_mbs;
-               }
+               sub_type_hdr->weight_xgmi = weight;
+               sub_type_hdr->minimum_bandwidth_mbs = bandwidth;
+               sub_type_hdr->maximum_bandwidth_mbs = bandwidth;
        } else {
                sub_type_hdr->io_interface_type = CRAT_IOLINK_TYPE_PCIEXPRESS;
                sub_type_hdr->minimum_bandwidth_mbs =
@@ -2050,6 +2054,8 @@ static int kfd_fill_gpu_xgmi_link_to_gpu(int *avail_size,
                        uint32_t proximity_domain_from,
                        uint32_t proximity_domain_to)
 {
+       bool use_ta_info = kdev->kfd->num_nodes == 1;
+
        *avail_size -= sizeof(struct crat_subtype_iolink);
        if (*avail_size < 0)
                return -ENOMEM;
@@ -2064,12 +2070,25 @@ static int kfd_fill_gpu_xgmi_link_to_gpu(int *avail_size,
        sub_type_hdr->io_interface_type = CRAT_IOLINK_TYPE_XGMI;
        sub_type_hdr->proximity_domain_from = proximity_domain_from;
        sub_type_hdr->proximity_domain_to = proximity_domain_to;
-       sub_type_hdr->num_hops_xgmi =
-               amdgpu_amdkfd_get_xgmi_hops_count(kdev->adev, peer_kdev->adev);
-       sub_type_hdr->maximum_bandwidth_mbs =
-               amdgpu_amdkfd_get_xgmi_bandwidth_mbytes(kdev->adev, peer_kdev->adev, false);
-       sub_type_hdr->minimum_bandwidth_mbs = sub_type_hdr->maximum_bandwidth_mbs ?
-               amdgpu_amdkfd_get_xgmi_bandwidth_mbytes(kdev->adev, NULL, true) : 0;
+
+       if (use_ta_info) {
+               sub_type_hdr->weight_xgmi = KFD_CRAT_XGMI_WEIGHT *
+                       amdgpu_amdkfd_get_xgmi_hops_count(kdev->adev, peer_kdev->adev);
+               sub_type_hdr->maximum_bandwidth_mbs =
+                       amdgpu_amdkfd_get_xgmi_bandwidth_mbytes(kdev->adev,
+                                                       peer_kdev->adev, false);
+               sub_type_hdr->minimum_bandwidth_mbs = sub_type_hdr->maximum_bandwidth_mbs ?
+                       amdgpu_amdkfd_get_xgmi_bandwidth_mbytes(kdev->adev, NULL, true) : 0;
+       } else {
+               bool is_single_hop = kdev->kfd == peer_kdev->kfd;
+               int weight = is_single_hop ? KFD_CRAT_INTRA_SOCKET_WEIGHT :
+                       (2 * KFD_CRAT_INTRA_SOCKET_WEIGHT) + KFD_CRAT_XGMI_WEIGHT;
+               int mem_bw = 819200;
+
+               sub_type_hdr->weight_xgmi = weight;
+               sub_type_hdr->maximum_bandwidth_mbs = is_single_hop ? mem_bw : 0;
+               sub_type_hdr->minimum_bandwidth_mbs = is_single_hop ? mem_bw : 0;
+       }
 
        return 0;
 }

diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_crat.h b/drivers/gpu/drm/amd/amdkfd/kfd_crat.h
index 3d0e533..fc71938 100644 (file)
--- a/drivers/gpu/drm/amd/amdkfd/kfd_crat.h
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_crat.h
@@ -275,7 +275,7 @@ struct crat_subtype_iolink {
        uint32_t        maximum_bandwidth_mbs;
        uint32_t        recommended_transfer_size;
        uint8_t         reserved2[CRAT_IOLINK_RESERVED_LENGTH - 1];
-       uint8_t         num_hops_xgmi;
+       uint8_t         weight_xgmi;
 };
 
 /*

diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device.c b/drivers/gpu/drm/amd/amdkfd/kfd_device.c
index ec5f85f..971a3aa 100644 (file)
--- a/drivers/gpu/drm/amd/amdkfd/kfd_device.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_device.c
@@ -702,6 +702,14 @@ bool kgd2kfd_device_init(struct kfd_dev *kfd,
        if (amdgpu_use_xgmi_p2p)
                kfd->hive_id = kfd->adev->gmc.xgmi.hive_id;
 
+       /*
+        * For GFX9.4.3, the KFD abstracts all partitions within a socket as
+        * xGMI connected in the topology so assign a unique hive id per
+        * device based on the pci device location if device is in PCIe mode.
+        */
+       if (!kfd->hive_id && (KFD_GC_VERSION(kfd) == IP_VERSION(9, 4, 3)) && kfd->num_nodes > 1)
+               kfd->hive_id = pci_dev_id(kfd->adev->pdev);
+
        kfd->noretry = kfd->adev->gmc.noretry;
 
        /* If CRAT is broken, won't set iommu enabled */

diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_topology.c b/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
index 6d958bf..d3e7034 100644 (file)
--- a/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
@@ -1926,7 +1926,11 @@ int kfd_topology_add_device(struct kfd_node *gpu)
        dev->node_props.capability |=
                ((dev->gpu->adev->rev_id << HSA_CAP_ASIC_REVISION_SHIFT) &
                        HSA_CAP_ASIC_REVISION_MASK);
+
        dev->node_props.location_id = pci_dev_id(gpu->adev->pdev);
+       if (KFD_GC_VERSION(dev->gpu->kfd) == IP_VERSION(9, 4, 3))
+               dev->node_props.location_id |= dev->gpu->node_id;
+
        dev->node_props.domain = pci_domain_nr(gpu->adev->pdev->bus);
        dev->node_props.max_engine_clk_fcompute =
                amdgpu_amdkfd_get_max_engine_clock_in_mhz(dev->gpu->adev);