This patch series introduces the Qualcomm DSP Accelerator (QDA) driver, a DRM-based accelerator driver for Qualcomm DSPs. The driver provides a standardized interface for offloading computational tasks to DSPs found on Qualcomm SoCs, supporting all DSP domains.
The QDA driver implements the FastRPC protocol over the DRM accel subsystem. It uses the same device-tree node structure as the existing fastrpc driver in drivers/misc/. The approach for binding the QDA driver to device-tree nodes while coexisting with the fastrpc driver is an open item described below. v1: https://lore.kernel.org/all/[email protected]/ RFC: https://lore.kernel.org/dri-devel/[email protected]/T/ Changes since v1 ================ The v1 review raised two architectural objections and one correctness issue; all three are resolved in v2: * Christian König (dma-buf maintainer) pointed out that the imported- buffer path silently assumed the IOMMU maps every buffer as a single contiguous range, which is not guaranteed. v2 walks the scatterlist and cleanly rejects non-contiguous imports; contiguous imports (e.g. CMA DMA-buf heap) are accepted. (patch 11) * Dmitry Baryshkov objected to three different buffer-passing formats in the invoke IOCTL (DMA-BUF fd, direct/inline, DMA handle). v2 passes only GEM handles; userspace imports any fd to a GEM handle with DRM_IOCTL_PRIME_FD_TO_HANDLE before invoking. Packing and overlap handling are left to userspace. (patch 12) * The memory manager (patch 07) used a fixed 16-entry array without justification and leaked the device descriptor on teardown. v2 allocates the array from the DT context-bank count (as Dmitry suggested) and frees it correctly. User-space staging branch ========================= https://github.com/qualcomm/fastrpc/tree/accel/staging Key Features ============ * Standard DRM accelerator interface via /dev/accel/accelN * GEM-based buffer management with DMA-BUF import (PRIME) * IOMMU-based memory isolation using per-process context banks * FastRPC protocol implementation for DSP communication * RPMsg transport layer for reliable message passing * Support for all DSP domains (ADSP, CDSP, SDSP, GDSP) * DRM IOCTL interface for DSP session management, buffer allocation, and remote procedure invocation Architecture ============ 1. DRM Accelerator Framework Integration The driver registers as a DRM accel device, exposing a standard /dev/accel/accelN character device node. This provides established DRM infrastructure for device management, file operations, and IOCTL dispatch. 2. Memory Management Buffers are managed as GEM objects with PRIME support for DMA-BUF import. This enables buffer sharing with other DRM drivers (GPU, camera, video) using standard kernel mechanisms. Only contiguous imports are accepted; the driver verifies contiguity at import time rather than assuming it. 3. IOMMU Context Bank Management IOMMU context banks (CBs) are represented as proper struct device instances on a custom virtual bus (qda-compute-cb). Each CB device is registered with the IOMMU subsystem and receives its own IOMMU domain, enabling per-session address space isolation. The custom bus was introduced because IOMMU context banks are synthetic constructs — not real platform devices — and to ensure CB device lifetime is strictly subordinate to the parent QDA device. See also: https://lore.kernel.org/all/[email protected]/ 4. Memory Manager Architecture The memory manager maintains a registry of IOMMU devices in an array sized to the number of context banks described in the device tree, and coordinates per-process device assignment with reference- counted lifetime management. The DMA-coherent backend allocates buffers with SID-prefixed DMA addresses for DSP firmware compatibility. 5. Transport Layer RPMsg communication is handled in a dedicated transport layer (qda_rpmsg.c), separate from the core DRM driver logic. 6. Code Organization The driver is organized across multiple files (~4800 lines total): * qda_drv.c: Core driver and DRM integration * qda_rpmsg.c: RPMsg transport layer * qda_cb.c: Context bank device management * qda_compute_bus.c: Custom virtual bus for CB devices * qda_gem.c: GEM object management * qda_prime.c: DMA-BUF import (PRIME) * qda_memory_manager.c: IOMMU device registry and allocation * qda_memory_dma.c: DMA-coherent allocation backend * qda_fastrpc.c: FastRPC protocol implementation * qda_ioctl.c: IOCTL dispatch 7. UAPI Design The driver exposes DRM-style IOCTLs defined in include/uapi/drm/qda_accel.h, following DRM UAPI conventions (__u32/__u64 types, C++ guard, GPL-2.0-only WITH Linux-syscall-note). Buffer arguments are identified by GEM handles; the driver never accepts DMA-BUF fds directly in any IOCTL. Patch Series Organization ========================== Patch 01: MAINTAINERS entry Patch 02: Driver documentation (Documentation/accel/qda/) Patches 03-04: Core driver skeleton and compute bus Patch 05: iommu: Register qda-compute-cb bus with IOMMU subsystem Patches 06-07: CB device enumeration and memory manager Patch 08: QUERY IOCTL and UAPI header Patches 09-11: GEM buffer management and PRIME import Patches 12-15: FastRPC protocol (invoke, session create/release, map/unmap) Open Items =========== 1. Device-Tree Compatible String The QDA driver uses the same device-tree node structure and properties as the existing fastrpc driver in drivers/misc/. A mechanism is needed to allow the QDA driver to bind to its device node independently of the fastrpc driver. The intended coexistence model is: platforms that require the complete fastrpc feature set continue to use "qcom,fastrpc"; new platforms where QDA's feature set is sufficient use a QDA-specific compatible string. New feature development is directed toward QDA. The options under consideration are: a) Add a new "qcom,qda" compatible string to the existing qcom,fastrpc.yaml binding, since the DT node structure and properties are identical. b) Introduce a separate qcom,qda.yaml binding that references or inherits the fastrpc binding properties. Seeking guidance from DT binding maintainers on the preferred approach. 2. Privilege Level Management Currently, daemon processes and user processes have the same access level as both use the same accel device node. Daemons attach to privileged DSP protection domains and require higher privilege levels for system-level operations. Seeking guidance on the best approach: separate device nodes, capability-based checks, or DRM master/authentication mechanisms. 3. Audio and Sensors PD Support The current series does not handle Audio PD and Sensors PD functionalities. These specialized protection domains require additional support for real-time constraints and power management. Interface Compatibility ======================== The QDA driver uses the same device-tree node structure and child node layout (including "qcom,fastrpc-compute-cb" child nodes) as the existing fastrpc driver. The underlying FastRPC protocol and DSP firmware interface are compatible with the existing fastrpc driver, ensuring that DSP firmware and libraries continue to work without modification. References ========== Previous discussions on this migration: - https://lkml.org/lkml/2024/6/24/479 - https://lkml.org/lkml/2024/6/21/1252 Testing ======= The driver has been tested on Qualcomm platforms with: - Basic FastRPC attach/release operations - DSP process creation and initialization - Memory mapping/unmapping operations - Dynamic invocation with various buffer types - GEM buffer allocation and mmap - PRIME buffer import from other subsystems (contiguous buffers) Signed-off-by: Ekansh Gupta <[email protected]> --- Ekansh Gupta (15): MAINTAINERS: Add entry for Qualcomm DSP Accelerator (QDA) driver accel/qda: Add QDA driver documentation accel/qda: Add initial QDA DRM accelerator driver accel/qda: Add compute bus for QDA context banks iommu: Add QDA compute context bank bus to iommu_buses accel/qda: Create compute context bank devices on QDA compute bus accel/qda: Add memory manager for CB devices accel/qda: Add QUERY IOCTL and QDA UAPI header accel/qda: Add DMA-backed GEM objects and memory manager integration accel/qda: Add GEM_CREATE and GEM_MMAP_OFFSET IOCTLs accel/qda: Add PRIME DMA-BUF import support accel/qda: Add FastRPC invocation support accel/qda: Add DSP process creation and release accel/qda: Add remote memory mapping to DSP address space accel/qda: Add remote memory unmap from DSP address space Documentation/accel/index.rst | 1 + Documentation/accel/qda/index.rst | 13 + Documentation/accel/qda/qda.rst | 191 ++++++ MAINTAINERS | 11 + drivers/accel/Kconfig | 1 + drivers/accel/Makefile | 2 + drivers/accel/qda/Kconfig | 34 ++ drivers/accel/qda/Makefile | 19 + drivers/accel/qda/qda_cb.c | 125 ++++ drivers/accel/qda/qda_cb.h | 32 + drivers/accel/qda/qda_compute_bus.c | 80 +++ drivers/accel/qda/qda_drv.c | 144 +++++ drivers/accel/qda/qda_drv.h | 90 +++ drivers/accel/qda/qda_fastrpc.c | 1009 ++++++++++++++++++++++++++++++++ drivers/accel/qda/qda_fastrpc.h | 367 ++++++++++++ drivers/accel/qda/qda_gem.c | 155 +++++ drivers/accel/qda/qda_gem.h | 60 ++ drivers/accel/qda/qda_ioctl.c | 290 +++++++++ drivers/accel/qda/qda_ioctl.h | 19 + drivers/accel/qda/qda_memory_dma.c | 82 +++ drivers/accel/qda/qda_memory_dma.h | 17 + drivers/accel/qda/qda_memory_manager.c | 369 ++++++++++++ drivers/accel/qda/qda_memory_manager.h | 85 +++ drivers/accel/qda/qda_prime.c | 167 ++++++ drivers/accel/qda/qda_prime.h | 18 + drivers/accel/qda/qda_rpmsg.c | 201 +++++++ drivers/accel/qda/qda_rpmsg.h | 26 + drivers/iommu/iommu.c | 4 + include/linux/qda_compute_bus.h | 33 ++ include/uapi/drm/qda_accel.h | 242 ++++++++ 30 files changed, 3887 insertions(+) --- base-commit: 5f07a0db7088b4ef4b9a48069a93b9f3e1a33379 change-id: 20260817-qda-v2-78e2d1f10529 Best regards, -- Ekansh Gupta <[email protected]>
