On Mon, Nov 16, 2026 at 11:26 AM Siwei He <[email protected]> wrote:
>
> Add AMDGPU_INFO_CU_BITMAP, returning struct drm_amdgpu_info_cu_bitmap:
> a header carrying num_xcc, num_se, num_sa and xcc_mask, followed by a
> flexible array of num_xcc * num_se * num_sa active CU masks in un-folded
> [xcc][se][sa] order, indexed bitmap[(xcc * num_se + se) * num_sa + sa].

Please provide a link to the proposed userspace which will use this
new interface.

Alex

>
> Signed-off-by: Siwei He <[email protected]>
> ---
>  drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c | 69 +++++++++++++++++++++++++
>  drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.h |  2 +
>  drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c | 50 ++++++++++++++++++
>  include/uapi/drm/amdgpu_drm.h           | 32 ++++++++++++
>  4 files changed, 153 insertions(+)
>
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c 
> b/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c
> index 0ae6e990c310..7a0a1d5542ee 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.c
> @@ -2050,6 +2050,75 @@ static ssize_t amdgpu_gfx_get_gfx_reset_mask(struct 
> device *dev,
>         return amdgpu_show_reset_mask(buf, adev->gfx.gfx_supported_reset);
>  }
>
> +/**
> + * amdgpu_gfx_get_cu_bitmap - un-fold the active CU bitmap for a set of XCCs
> + *
> + * @adev: amdgpu_device pointer
> + * @inst_mask: mask of logical GC (XCC) instances to report
> + * @out: destination, filled in [xcc][se][sa] row-major order
> + * @max_entries: capacity of @out, in u32 entries
> + *
> + * XCCs are written in ascending set-bit order of @inst_mask, densely packed,
> + * so entry (xcc * num_se + se) * num_sa + sa holds shader array @sa of
> + * shader engine @se on the @xcc'th set bit of @inst_mask.
> + *
> + * Returns the number of XCCs written, or a negative error code.
> + */
> +int amdgpu_gfx_get_cu_bitmap(struct amdgpu_device *adev, u32 inst_mask,
> +                            u32 *out, u32 max_entries)
> +{
> +       struct amdgpu_gfx_config *config = &adev->gfx.config;
> +       u32 gc_version = amdgpu_ip_version(adev, GC_HWIP, 0);
> +       u32 num_se, num_sa, sh_mul, se, sa, n = 0;
> +       int xcc;
> +
> +       /* cu_info.bitmap[] only has AMDGPU_MAX_GC_INSTANCES slots */
> +       inst_mask &= GENMASK(AMDGPU_MAX_GC_INSTANCES - 1, 0);
> +       if (!inst_mask)
> +               return -ENODEV;
> +
> +       num_se = config->max_shader_engines;
> +       num_sa = config->max_sh_per_se;
> +       if (!num_se || !num_sa)
> +               return -ENODEV;
> +
> +       if (hweight32(inst_mask) * num_se * num_sa > max_entries)
> +               return -EINVAL;
> +
> +       /* gfx11/gfx12_0 fold SE4-7 into shader array columns 2 and 3 */
> +       sh_mul = (gc_version >= IP_VERSION(11, 0, 0) &&
> +                 gc_version < IP_VERSION(13, 0, 0)) ? 2 : 1;
> +
> +       /*
> +        * cu_info.bitmap[] stores a [4][4] tile per XCC, and the IP backend
> +        * packed (se, sa) into it with the fold above. The row index se % 4 
> is
> +        * in range by construction; the column must both stay inside the tile
> +        * and not alias another shader engine's slot. Shader engines 4 apart
> +        * share a row and are separated by sh_mul columns, so num_sa > sh_mul
> +        * overlaps them. A topology failing either test lost data when the
> +        * backend wrote the tile, and un-folding cannot recover it -- fail
> +        * rather than report some other slot's mask as this shader array's.
> +        */
> +       if ((num_se > 4 && num_sa > sh_mul) ||
> +           (num_sa - 1) + ((num_se - 1) / 4) * sh_mul > 3) {
> +               dev_warn_once(adev->dev,
> +                             "unsupported CU bitmap topology %u SE x %u 
> SA\n",
> +                             num_se, num_sa);
> +               return -EOPNOTSUPP;
> +       }
> +
> +       for_each_inst(xcc, inst_mask) {
> +               for (se = 0; se < num_se; se++)
> +                       for (sa = 0; sa < num_sa; sa++)
> +                               out[(n * num_se + se) * num_sa + sa] =
> +                                       adev->gfx.cu_info.bitmap[xcc]
> +                                               [se % 4][sa + (se / 4) * 
> sh_mul];
> +               n++;
> +       }
> +
> +       return n;
> +}
> +
>  static ssize_t amdgpu_gfx_get_compute_reset_mask(struct device *dev,
>                                                 struct device_attribute *attr,
>                                                 char *buf)
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.h 
> b/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.h
> index 5939e1fb3b24..bd2617dd4c56 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.h
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gfx.h
> @@ -663,6 +663,8 @@ int amdgpu_gfx_poison_consumption_handler(struct 
> amdgpu_device *adev,
>  bool amdgpu_gfx_is_master_xcc(struct amdgpu_device *adev, int xcc_id);
>  int amdgpu_gfx_sysfs_init(struct amdgpu_device *adev);
>  void amdgpu_gfx_sysfs_fini(struct amdgpu_device *adev);
> +int amdgpu_gfx_get_cu_bitmap(struct amdgpu_device *adev, u32 inst_mask,
> +                            u32 *out, u32 max_entries);
>  int amdgpu_gfx_reset_mes_compute(struct amdgpu_device *adev,
>                                  struct amdgpu_ring *ring,
>                                  struct amdgpu_fence *guilty_fence,
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c 
> b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
> index 14a72a406d37..a8ebc85c9b88 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
> @@ -1453,6 +1453,56 @@ int amdgpu_info_ioctl(struct drm_device *dev, void 
> *data, struct drm_file *filp)
>                         return -EINVAL;
>                 }
>         }
> +       case AMDGPU_INFO_CU_BITMAP: {
> +               struct drm_amdgpu_info_cu_bitmap *cu_bitmap;
> +               u32 num_xcc, num_se, num_sa, nent;
> +               size_t sz;
> +
> +               fpriv = (struct amdgpu_fpriv *)filp->driver_priv;
> +
> +               /* scope the reply to the partition this fd was opened 
> against */
> +               if (adev->xcp_mgr && adev->xcp_mgr->num_xcps > 0 &&
> +                   fpriv->xcp_id < adev->xcp_mgr->num_xcps) {
> +                       xcp = &adev->xcp_mgr->xcp[fpriv->xcp_id];
> +                       ret = amdgpu_xcp_get_inst_details(xcp, AMDGPU_XCP_GFX,
> +                                                         &inst_mask);
> +                       if (ret)
> +                               return ret;
> +               } else {
> +                       inst_mask = adev->gfx.xcc_mask ? adev->gfx.xcc_mask : 
> 1;
> +               }
> +
> +               inst_mask &= GENMASK(AMDGPU_MAX_GC_INSTANCES - 1, 0);
> +               num_xcc = hweight32(inst_mask);
> +               num_se = adev->gfx.config.max_shader_engines;
> +               num_sa = adev->gfx.config.max_sh_per_se;
> +               if (!num_xcc || !num_se || !num_sa)
> +                       return -ENODEV;
> +
> +               nent = num_xcc * num_se * num_sa;
> +               sz = struct_size(cu_bitmap, bitmap, nent);
> +
> +               cu_bitmap = kzalloc(sz, GFP_KERNEL);
> +               if (!cu_bitmap)
> +                       return -ENOMEM;
> +
> +               ret = amdgpu_gfx_get_cu_bitmap(adev, inst_mask,
> +                                              cu_bitmap->bitmap, nent);
> +               if (ret < 0) {
> +                       kfree(cu_bitmap);
> +                       return ret;
> +               }
> +
> +               cu_bitmap->num_xcc = ret;
> +               cu_bitmap->num_se = num_se;
> +               cu_bitmap->num_sa = num_sa;
> +               cu_bitmap->xcc_mask = inst_mask;
> +
> +               ret = copy_to_user(out, cu_bitmap, min_t(size_t, size, sz)) ?
> +                             -EFAULT : 0;
> +               kfree(cu_bitmap);
> +               return ret;
> +       }
>         default:
>                 DRM_DEBUG_KMS("Invalid request %d\n", info->query);
>                 return -EINVAL;
> diff --git a/include/uapi/drm/amdgpu_drm.h b/include/uapi/drm/amdgpu_drm.h
> index 29009f6aabde..b726dc511491 100644
> --- a/include/uapi/drm/amdgpu_drm.h
> +++ b/include/uapi/drm/amdgpu_drm.h
> @@ -1289,6 +1289,8 @@ struct drm_amdgpu_cs_chunk_cp_gfx_shadow {
>  #define AMDGPU_INFO_GPUVM_FAULT                        0x23
>  /* query FW object size and alignment */
>  #define AMDGPU_INFO_UQ_FW_AREAS                        0x24
> +/* query the full per-XCC active CU bitmap */
> +#define AMDGPU_INFO_CU_BITMAP                  0x25
>
>  #define AMDGPU_INFO_MMR_SE_INDEX_SHIFT 0
>  #define AMDGPU_INFO_MMR_SE_INDEX_MASK  0xff
> @@ -1363,6 +1365,36 @@ struct drm_amdgpu_info {
>         };
>  };
>
> +/*
> + * Reply to AMDGPU_INFO_CU_BITMAP.
> + *
> + * Reports every XCC visible to the file descriptor in
> + * un-folded [xcc][se][sa] order.
> + *
> + * On a partitioned device the reply covers only the XCCs belonging to the
> + * partition the file descriptor was opened against.
> + *
> + * The reply is variable length and carries no fixed topology limits. Query 
> it
> + * twice: first with return_size = sizeof(struct drm_amdgpu_info_cu_bitmap) 
> to
> + * read the counts, then with return_size large enough for the trailing 
> array.
> + */
> +struct drm_amdgpu_info_cu_bitmap {
> +       /** number of XCC slices described by bitmap[] */
> +       __u32 num_xcc;
> +       /** number of shader engines per XCC */
> +       __u32 num_se;
> +       /** number of shader arrays per shader engine */
> +       __u32 num_sa;
> +       /** mask of logical XCC instances this reply describes */
> +       __u32 xcc_mask;
> +       /**
> +        * active CU mask per shader array, num_xcc * num_se * num_sa entries
> +        * in [xcc][se][sa] row-major order. Index as
> +        * bitmap[(xcc * num_se + se) * num_sa + sa].
> +        */
> +       __u32 bitmap[];
> +};
> +
>  struct drm_amdgpu_info_gds {
>         /** GDS GFX partition size */
>         __u32 gds_gfx_partition_size;
> --
> 2.43.0
>

Reply via email to