On Tue, Feb 24, 2026 at 12:39:06AM +0530, Ekansh Gupta wrote:
> Add PRIME dma-buf import support for QDA GEM buffer objects and integrate
> it with the existing per-process memory manager and IOMMU device model.
>
> The implementation extends qda_gem_obj to represent imported dma-bufs,
> including dma_buf references, attachment state, scatter-gather tables
> and an imported DMA address used for DSP-facing book-keeping. The
> qda_gem_prime_import() path handles reimports of buffers originally
> exported by QDA as well as imports of external dma-bufs, attaching them
> to the assigned IOMMU device and mapping them through the memory manager
> for DSP access. The GEM free path is updated to unmap and detach
> imported buffers while preserving the existing behaviour for locally
> allocated memory.
>
> The PRIME fd-to-handle path is implemented in qda_prime_fd_to_handle(),
> which records the calling drm_file in a driver-private import context
> before invoking the core DRM helpers. The GEM import callback retrieves
> this context to ensure that an IOMMU device is assigned to the process
> and that imported buffers follow the same per-process IOMMU selection
> rules as natively allocated GEM objects.
>
> This patch prepares the driver for interoperable buffer sharing between
> QDA and other dma-buf capable subsystems while keeping IOMMU mapping and
> lifetime handling consistent with the existing GEM allocation flow.
>
> Signed-off-by: Ekansh Gupta <[email protected]>
> ---
> drivers/accel/qda/Makefile | 1 +
> drivers/accel/qda/qda_drv.c | 8 ++
> drivers/accel/qda/qda_drv.h | 4 +
> drivers/accel/qda/qda_gem.c | 60 +++++++---
> drivers/accel/qda/qda_gem.h | 10 ++
> drivers/accel/qda/qda_ioctl.c | 7 ++
> drivers/accel/qda/qda_ioctl.h | 15 +++
> drivers/accel/qda/qda_memory_manager.c | 42 ++++++-
> drivers/accel/qda/qda_memory_manager.h | 14 +++
> drivers/accel/qda/qda_prime.c | 194
> +++++++++++++++++++++++++++++++++
> drivers/accel/qda/qda_prime.h | 43 ++++++++
> 11 files changed, 377 insertions(+), 21 deletions(-)
>
> diff --git a/drivers/accel/qda/Makefile b/drivers/accel/qda/Makefile
> index 88c324fa382c..8286f5279748 100644
> --- a/drivers/accel/qda/Makefile
> +++ b/drivers/accel/qda/Makefile
> @@ -13,5 +13,6 @@ qda-y := \
> qda_ioctl.o \
> qda_gem.o \
> qda_memory_dma.o \
> + qda_prime.o \
>
> obj-$(CONFIG_DRM_ACCEL_QDA_COMPUTE_BUS) += qda_compute_bus.o
> diff --git a/drivers/accel/qda/qda_drv.c b/drivers/accel/qda/qda_drv.c
> index 0dd0e2bb2c0f..4adee00b1f2c 100644
> --- a/drivers/accel/qda/qda_drv.c
> +++ b/drivers/accel/qda/qda_drv.c
> @@ -10,9 +10,11 @@
> #include <drm/drm_gem.h>
> #include <drm/drm_ioctl.h>
> #include <drm/qda_accel.h>
> +#include <drm/drm_prime.h>
>
> #include "qda_drv.h"
> #include "qda_gem.h"
> +#include "qda_prime.h"
> #include "qda_ioctl.h"
> #include "qda_rpmsg.h"
>
> @@ -166,6 +168,8 @@ static struct drm_driver qda_drm_driver = {
> .postclose = qda_postclose,
> .ioctls = qda_ioctls,
> .num_ioctls = ARRAY_SIZE(qda_ioctls),
> + .gem_prime_import = qda_gem_prime_import,
> + .prime_fd_to_handle = qda_ioctl_prime_fd_to_handle,
> .name = DRIVER_NAME,
> .desc = "Qualcomm DSP Accelerator Driver",
> };
> @@ -174,6 +178,7 @@ static void cleanup_drm_private(struct qda_dev *qdev)
> {
> if (qdev->drm_priv) {
> qda_dbg(qdev, "Cleaning up DRM private data\n");
> + mutex_destroy(&qdev->drm_priv->import_lock);
> kfree(qdev->drm_priv);
> }
> }
> @@ -240,6 +245,9 @@ static int init_drm_private(struct qda_dev *qdev)
> if (!qdev->drm_priv)
> return -ENOMEM;
>
> + mutex_init(&qdev->drm_priv->import_lock);
> + qdev->drm_priv->current_import_file_priv = NULL;
> +
> qda_dbg(qdev, "DRM private data initialized successfully\n");
> return 0;
> }
> diff --git a/drivers/accel/qda/qda_drv.h b/drivers/accel/qda/qda_drv.h
> index 8a2cd474958b..bb0dd7e284c6 100644
> --- a/drivers/accel/qda/qda_drv.h
> +++ b/drivers/accel/qda/qda_drv.h
> @@ -64,6 +64,10 @@ struct qda_drm_priv {
> struct qda_memory_manager *iommu_mgr;
> /* Back-pointer to qda_dev */
> struct qda_dev *qdev;
> + /* Lock protecting import context */
> + struct mutex import_lock;
> + /* Current file_priv during prime import */
> + struct drm_file *current_import_file_priv;
> };
>
> /* struct qda_dev - Main device structure for QDA driver */
> diff --git a/drivers/accel/qda/qda_gem.c b/drivers/accel/qda/qda_gem.c
> index bbd54e2502d3..37279e8b46fe 100644
> --- a/drivers/accel/qda/qda_gem.c
> +++ b/drivers/accel/qda/qda_gem.c
> @@ -8,6 +8,7 @@
> #include "qda_gem.h"
> #include "qda_memory_manager.h"
> #include "qda_memory_dma.h"
> +#include "qda_prime.h"
>
> static int validate_gem_obj_for_mmap(struct qda_gem_obj *qda_gem_obj)
> {
> @@ -15,23 +16,29 @@ static int validate_gem_obj_for_mmap(struct qda_gem_obj
> *qda_gem_obj)
> qda_err(NULL, "Invalid GEM object size\n");
> return -EINVAL;
> }
> - if (!qda_gem_obj->iommu_dev || !qda_gem_obj->iommu_dev->dev) {
> - qda_err(NULL, "Allocated buffer missing IOMMU device\n");
> - return -EINVAL;
> - }
> - if (!qda_gem_obj->iommu_dev->dev) {
> - qda_err(NULL, "Allocated buffer missing IOMMU device\n");
> - return -EINVAL;
> - }
> - if (!qda_gem_obj->virt) {
> - qda_err(NULL, "Allocated buffer missing virtual address\n");
> - return -EINVAL;
> - }
> - if (qda_gem_obj->dma_addr == 0) {
> - qda_err(NULL, "Allocated buffer missing DMA address\n");
> - return -EINVAL;
> + if (qda_gem_obj->is_imported) {
> + if (!qda_gem_obj->sgt) {
> + qda_err(NULL, "Imported buffer missing sgt\n");
> + return -EINVAL;
> + }
> + if (!qda_gem_obj->iommu_dev || !qda_gem_obj->iommu_dev->dev) {
> + qda_err(NULL, "Imported buffer missing IOMMU device\n");
> + return -EINVAL;
> + }
> + } else {
> + if (!qda_gem_obj->iommu_dev || !qda_gem_obj->iommu_dev->dev) {
> + qda_err(NULL, "Allocated buffer missing IOMMU
> device\n");
> + return -EINVAL;
> + }
> + if (!qda_gem_obj->virt) {
> + qda_err(NULL, "Allocated buffer missing virtual
> address\n");
> + return -EINVAL;
> + }
> + if (qda_gem_obj->dma_addr == 0) {
> + qda_err(NULL, "Allocated buffer missing DMA address\n");
> + return -EINVAL;
> + }
> }
> -
> return 0;
> }
>
> @@ -60,9 +67,21 @@ void qda_gem_free_object(struct drm_gem_object *gem_obj)
> struct qda_gem_obj *qda_gem_obj = to_qda_gem_obj(gem_obj);
> struct qda_drm_priv *drm_priv = get_drm_priv_from_device(gem_obj->dev);
>
> - if (qda_gem_obj->virt) {
> - if (drm_priv && drm_priv->iommu_mgr)
> + if (qda_gem_obj->is_imported) {
> + if (qda_gem_obj->attachment && qda_gem_obj->sgt)
> +
> dma_buf_unmap_attachment_unlocked(qda_gem_obj->attachment,
> + qda_gem_obj->sgt,
> DMA_BIDIRECTIONAL);
> + if (qda_gem_obj->attachment)
> + dma_buf_detach(qda_gem_obj->dma_buf,
> qda_gem_obj->attachment);
> + if (qda_gem_obj->dma_buf)
> + dma_buf_put(qda_gem_obj->dma_buf);
> + if (qda_gem_obj->iommu_dev && drm_priv && drm_priv->iommu_mgr)
> qda_memory_manager_free(drm_priv->iommu_mgr,
> qda_gem_obj);
> + } else {
> + if (qda_gem_obj->virt) {
> + if (drm_priv && drm_priv->iommu_mgr)
> + qda_memory_manager_free(drm_priv->iommu_mgr,
> qda_gem_obj);
> + }
> }
>
> drm_gem_object_release(gem_obj);
> @@ -174,6 +193,11 @@ struct drm_gem_object *qda_gem_create_object(struct
> drm_device *drm_dev,
> qda_gem_obj = qda_gem_alloc_object(drm_dev, aligned_size);
> if (IS_ERR(qda_gem_obj))
> return (struct drm_gem_object *)qda_gem_obj;
> + qda_gem_obj->is_imported = false;
> + qda_gem_obj->dma_buf = NULL;
> + qda_gem_obj->attachment = NULL;
> + qda_gem_obj->sgt = NULL;
> + qda_gem_obj->imported_dma_addr = 0;
>
> ret = qda_memory_manager_alloc(iommu_mgr, qda_gem_obj, file_priv);
> if (ret) {
> diff --git a/drivers/accel/qda/qda_gem.h b/drivers/accel/qda/qda_gem.h
> index cbd5d0a58fa4..3566c5b2ad88 100644
> --- a/drivers/accel/qda/qda_gem.h
> +++ b/drivers/accel/qda/qda_gem.h
> @@ -31,6 +31,16 @@ struct qda_gem_obj {
> size_t size;
> /* IOMMU device that performed the allocation */
> struct qda_iommu_device *iommu_dev;
> + /* True if buffer is imported, false if allocated */
> + bool is_imported;
> + /* Reference to imported dma_buf */
> + struct dma_buf *dma_buf;
> + /* DMA buf attachment */
> + struct dma_buf_attachment *attachment;
> + /* Scatter-gather table */
> + struct sg_table *sgt;
> + /* DMA address of imported buffer */
> + dma_addr_t imported_dma_addr;
> };
>
> /*
> diff --git a/drivers/accel/qda/qda_ioctl.c b/drivers/accel/qda/qda_ioctl.c
> index ef3c9c691cb7..d91983048d6c 100644
> --- a/drivers/accel/qda/qda_ioctl.c
> +++ b/drivers/accel/qda/qda_ioctl.c
> @@ -5,6 +5,7 @@
> #include <drm/qda_accel.h>
> #include "qda_drv.h"
> #include "qda_ioctl.h"
> +#include "qda_prime.h"
>
> static int qda_validate_and_get_context(struct drm_device *dev, struct
> drm_file *file_priv,
> struct qda_dev **qdev, struct qda_user
> **qda_user)
> @@ -78,3 +79,9 @@ int qda_ioctl_gem_mmap_offset(struct drm_device *dev, void
> *data, struct drm_fil
> drm_gem_object_put(gem_obj);
> return ret;
> }
> +
> +int qda_ioctl_prime_fd_to_handle(struct drm_device *dev, struct drm_file
> *file_priv, int prime_fd,
> + u32 *handle)
> +{
> + return qda_prime_fd_to_handle(dev, file_priv, prime_fd, handle);
> +}
> diff --git a/drivers/accel/qda/qda_ioctl.h b/drivers/accel/qda/qda_ioctl.h
> index 6bf3bcd28c0e..d454256f5fc5 100644
> --- a/drivers/accel/qda/qda_ioctl.h
> +++ b/drivers/accel/qda/qda_ioctl.h
> @@ -23,4 +23,19 @@
> */
> int qda_ioctl_query(struct drm_device *dev, void *data, struct drm_file
> *file_priv);
>
> +/**
> + * qda_ioctl_prime_fd_to_handle - IOCTL handler for PRIME FD to handle
> conversion
> + * @dev: DRM device structure
> + * @file_priv: DRM file private data
> + * @prime_fd: File descriptor of the PRIME buffer
> + * @handle: Output parameter for the GEM handle
> + *
> + * This IOCTL handler converts a PRIME file descriptor to a GEM handle.
> + * It serves as both the DRM driver callback and can be used directly.
> + *
> + * Return: 0 on success, negative error code on failure
> + */
> +int qda_ioctl_prime_fd_to_handle(struct drm_device *dev, struct drm_file
> *file_priv,
> + int prime_fd, u32 *handle);
> +
> #endif /* _QDA_IOCTL_H */
> diff --git a/drivers/accel/qda/qda_memory_manager.c
> b/drivers/accel/qda/qda_memory_manager.c
> index e225667557ee..3fd20f17c57b 100644
> --- a/drivers/accel/qda/qda_memory_manager.c
> +++ b/drivers/accel/qda/qda_memory_manager.c
> @@ -154,8 +154,8 @@ static struct qda_iommu_device
> *get_process_iommu_device(struct qda_memory_manag
> return qda_priv->assigned_iommu_dev;
> }
>
> -static int qda_memory_manager_assign_device(struct qda_memory_manager
> *mem_mgr,
> - struct drm_file *file_priv)
> +int qda_memory_manager_assign_device(struct qda_memory_manager *mem_mgr,
> + struct drm_file *file_priv)
> {
> struct qda_file_priv *qda_priv;
> struct qda_iommu_device *selected_dev = NULL;
> @@ -223,6 +223,35 @@ static struct qda_iommu_device
> *get_or_assign_iommu_device(struct qda_memory_man
> return NULL;
> }
>
> +static int qda_memory_manager_map_imported(struct qda_memory_manager
> *mem_mgr,
> + struct qda_gem_obj *gem_obj,
> + struct qda_iommu_device *iommu_dev)
> +{
> + struct scatterlist *sg;
> + dma_addr_t dma_addr;
> + int ret = 0;
> +
> + if (!gem_obj->is_imported || !gem_obj->sgt || !iommu_dev) {
> + qda_err(NULL, "Invalid parameters for imported buffer
> mapping\n");
> + return -EINVAL;
> + }
> +
> + gem_obj->iommu_dev = iommu_dev;
> +
> + sg = gem_obj->sgt->sgl;
> + if (sg) {
> + dma_addr = sg_dma_address(sg);
> + dma_addr += ((u64)iommu_dev->sid << 32);
> +
> + gem_obj->imported_dma_addr = dma_addr;
> + } else {
> + qda_err(NULL, "Invalid scatter-gather list for imported
> buffer\n");
> + ret = -EINVAL;
> + }
> +
> + return ret;
> +}
> +
> int qda_memory_manager_alloc(struct qda_memory_manager *mem_mgr, struct
> qda_gem_obj *gem_obj,
> struct drm_file *file_priv)
> {
> @@ -248,7 +277,10 @@ int qda_memory_manager_alloc(struct qda_memory_manager
> *mem_mgr, struct qda_gem_
> return -ENOMEM;
> }
>
> - ret = qda_dma_alloc(selected_dev, gem_obj, size);
> + if (gem_obj->is_imported)
> + ret = qda_memory_manager_map_imported(mem_mgr, gem_obj,
> selected_dev);
> + else
> + ret = qda_dma_alloc(selected_dev, gem_obj, size);
>
> if (ret) {
> qda_err(NULL, "Allocation failed: size=%zu, device_id=%u,
> ret=%d\n",
> @@ -268,6 +300,10 @@ void qda_memory_manager_free(struct qda_memory_manager
> *mem_mgr, struct qda_gem_
> return;
> }
>
> + if (gem_obj->is_imported) {
> + qda_dbg(NULL, "Freed imported buffer tracking (no DMA free
> needed)\n");
> + return;
> + }
> qda_dma_free(gem_obj);
> }
>
> diff --git a/drivers/accel/qda/qda_memory_manager.h
> b/drivers/accel/qda/qda_memory_manager.h
> index bac44284ef98..f6c7963cec42 100644
> --- a/drivers/accel/qda/qda_memory_manager.h
> +++ b/drivers/accel/qda/qda_memory_manager.h
> @@ -106,6 +106,20 @@ int qda_memory_manager_register_device(struct
> qda_memory_manager *mem_mgr,
> void qda_memory_manager_unregister_device(struct qda_memory_manager *mem_mgr,
> struct qda_iommu_device *iommu_dev);
>
> +/**
> + * qda_memory_manager_assign_device() - Assign an IOMMU device to a process
> + * @mem_mgr: Pointer to memory manager
> + * @file_priv: DRM file private data for process association
> + *
> + * Assigns an IOMMU device to the calling process. If the process already has
> + * a device assigned, returns success. If another file descriptor from the
> same
> + * PID has a device, reuses it. Otherwise, finds an available device and
> assigns it.
> + *
> + * Return: 0 on success, negative error code on failure
> + */
> +int qda_memory_manager_assign_device(struct qda_memory_manager *mem_mgr,
> + struct drm_file *file_priv);
> +
> /**
> * qda_memory_manager_alloc() - Allocate memory for a GEM object
> * @mem_mgr: Pointer to memory manager
> diff --git a/drivers/accel/qda/qda_prime.c b/drivers/accel/qda/qda_prime.c
> new file mode 100644
> index 000000000000..3d23842e48bb
> --- /dev/null
> +++ b/drivers/accel/qda/qda_prime.c
> @@ -0,0 +1,194 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
> +#include <drm/drm_gem.h>
> +#include <drm/drm_prime.h>
> +#include <linux/slab.h>
> +#include <linux/dma-mapping.h>
> +#include "qda_drv.h"
> +#include "qda_gem.h"
> +#include "qda_prime.h"
> +#include "qda_memory_manager.h"
> +
> +static struct drm_gem_object *check_own_buffer(struct drm_device *dev,
> struct dma_buf *dma_buf)
> +{
> + if (dma_buf->priv) {
> + struct drm_gem_object *existing_gem = dma_buf->priv;
Randomly looking at your driver — you’ve broken the dma-buf cross-driver
contract here. How do you know dma_buf->priv is a struct drm_gem_object?
You don’t, because that is assigned by the exporter, and userspace could
pass in a dma-buf from another device and blow up your driver.
I think you just want to call drm_gem_is_prime_exported_dma_buf() here
before doing anything.
The rest of this dma-buf code also looks highly questionable. I’d study
how other drivers implement their dma-buf paths and use those as a
reference to improve yours.
Matt
> +
> + if (existing_gem->dev == dev) {
> + struct qda_gem_obj *existing_qda_gem =
> to_qda_gem_obj(existing_gem);
> +
> + if (!existing_qda_gem->is_imported) {
> + drm_gem_object_get(existing_gem);
> + return existing_gem;
> + }
> + }
> + }
> + return NULL;
> +}
> +
> +static struct qda_iommu_device *get_iommu_device_for_import(struct
> qda_drm_priv *drm_priv,
> + struct drm_file
> **file_priv_out,
> + struct qda_dev
> *qdev)
> +{
> + struct drm_file *file_priv;
> + struct qda_file_priv *qda_file_priv;
> + struct qda_iommu_device *iommu_dev = NULL;
> + int ret;
> +
> + file_priv = drm_priv->current_import_file_priv;
> + *file_priv_out = file_priv;
> +
> + if (!file_priv || !file_priv->driver_priv)
> + return NULL;
> +
> + qda_file_priv = (struct qda_file_priv *)file_priv->driver_priv;
> + iommu_dev = qda_file_priv->assigned_iommu_dev;
> +
> + if (!iommu_dev) {
> + ret = qda_memory_manager_assign_device(drm_priv->iommu_mgr,
> file_priv);
> + if (ret) {
> + qda_err(qdev, "Failed to assign IOMMU device: %d\n",
> ret);
> + return NULL;
> + }
> +
> + iommu_dev = qda_file_priv->assigned_iommu_dev;
> + }
> +
> + return iommu_dev;
> +}
> +
> +static int setup_dma_buf_mapping(struct qda_gem_obj *qda_gem_obj, struct
> dma_buf *dma_buf,
> + struct device *attach_dev, struct qda_dev
> *qdev)
> +{
> + struct dma_buf_attachment *attachment;
> + struct sg_table *sgt;
> + int ret;
> +
> + attachment = dma_buf_attach(dma_buf, attach_dev);
> + if (IS_ERR(attachment)) {
> + ret = PTR_ERR(attachment);
> + qda_err(qdev, "Failed to attach dma_buf: %d\n", ret);
> + return ret;
> + }
> + qda_gem_obj->attachment = attachment;
> +
> + sgt = dma_buf_map_attachment_unlocked(attachment, DMA_BIDIRECTIONAL);
> + if (IS_ERR(sgt)) {
> + ret = PTR_ERR(sgt);
> + qda_err(qdev, "Failed to map dma_buf attachment: %d\n", ret);
> + dma_buf_detach(dma_buf, attachment);
> + return ret;
> + }
> + qda_gem_obj->sgt = sgt;
> +
> + return 0;
> +}
> +
> +struct drm_gem_object *qda_gem_prime_import(struct drm_device *dev, struct
> dma_buf *dma_buf)
> +{
> + struct qda_drm_priv *drm_priv;
> + struct qda_gem_obj *qda_gem_obj;
> + struct drm_file *file_priv;
> + struct qda_iommu_device *iommu_dev;
> + struct qda_dev *qdev;
> + struct drm_gem_object *existing_gem;
> + size_t aligned_size;
> + int ret;
> +
> + drm_priv = get_drm_priv_from_device(dev);
> + if (!drm_priv || !drm_priv->iommu_mgr) {
> + qda_err(NULL, "Invalid drm_priv or iommu_mgr\n");
> + return ERR_PTR(-EINVAL);
> + }
> +
> + qdev = drm_priv->qdev;
> +
> + existing_gem = check_own_buffer(dev, dma_buf);
> + if (existing_gem)
> + return existing_gem;
> +
> + iommu_dev = get_iommu_device_for_import(drm_priv, &file_priv, qdev);
> + if (!iommu_dev || !iommu_dev->dev) {
> + qda_err(qdev, "No IOMMU device assigned for prime import\n");
> + return ERR_PTR(-ENODEV);
> + }
> +
> + qda_dbg(qdev, "Using IOMMU device %u for prime import\n",
> iommu_dev->id);
> +
> + aligned_size = PAGE_ALIGN(dma_buf->size);
> + qda_gem_obj = qda_gem_alloc_object(dev, aligned_size);
> + if (IS_ERR(qda_gem_obj))
> + return (struct drm_gem_object *)qda_gem_obj;
> +
> + qda_gem_obj->is_imported = true;
> + qda_gem_obj->dma_buf = dma_buf;
> + qda_gem_obj->virt = NULL;
> + qda_gem_obj->dma_addr = 0;
> + qda_gem_obj->imported_dma_addr = 0;
> + qda_gem_obj->iommu_dev = iommu_dev;
> +
> + get_dma_buf(dma_buf);
> +
> + ret = setup_dma_buf_mapping(qda_gem_obj, dma_buf, iommu_dev->dev, qdev);
> + if (ret)
> + goto err_put_dma_buf;
> +
> + ret = qda_memory_manager_alloc(drm_priv->iommu_mgr, qda_gem_obj,
> file_priv);
> + if (ret) {
> + qda_err(qdev, "Failed to allocate IOMMU mapping: %d\n", ret);
> + goto err_unmap;
> + }
> +
> + qda_dbg(qdev, "Prime import completed successfully size=%zu\n",
> aligned_size);
> + return &qda_gem_obj->base;
> +
> +err_unmap:
> + dma_buf_unmap_attachment_unlocked(qda_gem_obj->attachment,
> + qda_gem_obj->sgt, DMA_BIDIRECTIONAL);
> + dma_buf_detach(dma_buf, qda_gem_obj->attachment);
> +err_put_dma_buf:
> + dma_buf_put(dma_buf);
> + qda_gem_cleanup_object(qda_gem_obj);
> + return ERR_PTR(ret);
> +}
> +
> +int qda_prime_fd_to_handle(struct drm_device *dev, struct drm_file
> *file_priv,
> + int prime_fd, u32 *handle)
> +{
> + struct qda_drm_priv *drm_priv;
> + struct qda_dev *qdev;
> + int ret;
> +
> + drm_priv = get_drm_priv_from_device(dev);
> + if (!drm_priv) {
> + qda_dbg(NULL, "Failed to get drm_priv from device\n");
> + return -EINVAL;
> + }
> +
> + qdev = drm_priv->qdev;
> +
> + if (file_priv && file_priv->driver_priv) {
> + struct qda_file_priv *qda_file_priv;
> +
> + qda_file_priv = (struct qda_file_priv *)file_priv->driver_priv;
> + } else {
> + qda_dbg(qdev, "Called with NULL file_priv or driver_priv\n");
> + }
> +
> + mutex_lock(&drm_priv->import_lock);
> + drm_priv->current_import_file_priv = file_priv;
> +
> + ret = drm_gem_prime_fd_to_handle(dev, file_priv, prime_fd, handle);
> +
> + drm_priv->current_import_file_priv = NULL;
> + mutex_unlock(&drm_priv->import_lock);
> +
> + if (!ret)
> + qda_dbg(qdev, "Completed with ret=%d, handle=%u\n", ret,
> *handle);
> + else
> + qda_dbg(qdev, "Completed with ret=%d\n", ret);
> +
> + return ret;
> +}
> +
> +MODULE_IMPORT_NS("DMA_BUF");
> diff --git a/drivers/accel/qda/qda_prime.h b/drivers/accel/qda/qda_prime.h
> new file mode 100644
> index 000000000000..939902454dcd
> --- /dev/null
> +++ b/drivers/accel/qda/qda_prime.h
> @@ -0,0 +1,43 @@
> +/* SPDX-License-Identifier: GPL-2.0-only */
> +/*
> + * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
> + */
> +
> +#ifndef _QDA_PRIME_H
> +#define _QDA_PRIME_H
> +
> +#include <drm/drm_device.h>
> +#include <drm/drm_file.h>
> +#include <drm/drm_gem.h>
> +#include <linux/dma-buf.h>
> +
> +/**
> + * qda_gem_prime_import - Import a DMA-BUF as a GEM object
> + * @dev: DRM device structure
> + * @dma_buf: DMA-BUF to import
> + *
> + * This function imports an external DMA-BUF into the QDA driver as a GEM
> + * object. It handles both re-imports of buffers originally from this driver
> + * and imports of external buffers from other drivers.
> + *
> + * Return: Pointer to the imported GEM object on success, ERR_PTR on failure
> + */
> +struct drm_gem_object *qda_gem_prime_import(struct drm_device *dev, struct
> dma_buf *dma_buf);
> +
> +/**
> + * qda_prime_fd_to_handle - Core implementation for PRIME FD to GEM handle
> conversion
> + * @dev: DRM device structure
> + * @file_priv: DRM file private data
> + * @prime_fd: File descriptor of the PRIME buffer
> + * @handle: Output parameter for the GEM handle
> + *
> + * This core function sets up the necessary context before calling the
> + * DRM framework's prime FD to handle conversion. It ensures proper IOMMU
> + * device assignment and tracking for the import operation.
> + *
> + * Return: 0 on success, negative error code on failure
> + */
> +int qda_prime_fd_to_handle(struct drm_device *dev, struct drm_file
> *file_priv,
> + int prime_fd, u32 *handle);
> +
> +#endif /* _QDA_PRIME_H */
>
> --
> 2.34.1
>
