On 2/24/2026 2:22 PM, Matthew Brost wrote:
> 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
I had this concern while developing this patch but I was not able to find the
right way
to handle this. I'll look into drm_gem_is_prime_exported_dma_buf() and see if
it fits
here. For the rest of the dma-buf, the mapping part is something where I could
not see my
requirements on any other driver(mapping to iommu device), so I might be trying
to
implement something new here. That being said, I'll go through some more
drivers and
check if my dma-buf could be improved.
Thanks for the review and your suggestion, 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
>>
