On Mon, Dec 04, 2023 at 06:33:04PM +0100, Boris Brezillon wrote:
> This is the last piece missing to expose the driver to the outside
> world.
>
> This is basically a wrapper between the ioctls and the other logical
> blocks.
>
> v3:
> - Add acks for the MIT/GPL2 relicensing
> - Fix 32-bit support
> - Account for panthor_vm and panthor_sched changes
> - Simplify the resv preparation/update logic
> - Use a linked list rather than xarray for list of signals.
> - Simplify panthor_get_uobj_array by returning the newly allocated
> array.
> - Drop the "DOC" for job submission helpers and move the relevant
> comments to panthor_ioctl_group_submit().
> - Add helpers sync_op_is_signal()/sync_op_is_wait().
> - Simplify return type of panthor_submit_ctx_add_sync_signal() and
> panthor_submit_ctx_get_sync_signal().
> - Drop WARN_ON from panthor_submit_ctx_add_job().
> - Fix typos in comments.
>
> Signed-off-by: Boris Brezillon <boris.brezil...@collabora.com>
> Signed-off-by: Steven Price <steven.pr...@arm.com>
> Acked-by: Steven Price <steven.pr...@arm.com> # MIT+GPL2 relicensing,Arm
> Acked-by: Grant Likely <grant.lik...@linaro.org> # MIT+GPL2 relicensing,Linaro
> Acked-by: Boris Brezillon <boris.brezil...@collabora.com> # MIT+GPL2
> relicensing,Collabora
Hello,
Just some small name mismatch spotted here.
Otherwise,
Reviewed-by: Liviu Dudau <liviu.du...@arm.com>
> ---
> drivers/gpu/drm/panthor/panthor_drv.c | 1454 +++++++++++++++++++++++++
> 1 file changed, 1454 insertions(+)
> create mode 100644 drivers/gpu/drm/panthor/panthor_drv.c
>
> diff --git a/drivers/gpu/drm/panthor/panthor_drv.c
> b/drivers/gpu/drm/panthor/panthor_drv.c
> new file mode 100644
> index 000000000000..9447a4e90018
> --- /dev/null
> +++ b/drivers/gpu/drm/panthor/panthor_drv.c
> @@ -0,0 +1,1454 @@
> +// SPDX-License-Identifier: GPL-2.0 or MIT
> +/* Copyright 2018 Marty E. Plummer <hanet...@startmail.com> */
> +/* Copyright 2019 Linaro, Ltd., Rob Herring <r...@kernel.org> */
> +/* Copyright 2019 Collabora ltd. */
> +
> +#include <linux/list.h>
> +#include <linux/module.h>
> +#include <linux/of_platform.h>
> +#include <linux/pagemap.h>
> +#include <linux/pm_runtime.h>
> +
> +#include <drm/drm_drv.h>
> +#include <drm/drm_exec.h>
> +#include <drm/drm_ioctl.h>
> +#include <drm/drm_syncobj.h>
> +#include <drm/drm_utils.h>
> +#include <drm/drm_debugfs.h>
> +#include <drm/gpu_scheduler.h>
> +#include <drm/panthor_drm.h>
> +
> +#include "panthor_sched.h"
> +#include "panthor_device.h"
> +#include "panthor_gem.h"
> +#include "panthor_heap.h"
> +#include "panthor_fw.h"
> +#include "panthor_mmu.h"
> +#include "panthor_gpu.h"
> +#include "panthor_regs.h"
> +
> +/**
> + * DOC: user <-> kernel object copy helpers.
> + */
> +
> +/**
> + * panthor_set_uobj() - Copy kernel object to user object.
> + * @usr_ptr: Users pointer.
> + * @usr_size: Size of the user object.
> + * @min_size: Minimum size for this object.
> + * @kern_size: Size of the kernel object.
> + * @in: Address of the kernel object to copy.
> + *
> + * Helper automating kernel -> user object copies.
> + *
> + * Don't use this function directly, use PANTHOR_UOBJ_SET() instead.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_set_uobj(u64 usr_ptr, u32 usr_size, u32 min_size, u32 kern_size,
> const void *in)
> +{
> + /* User size shouldn't be smaller than the minimal object size. */
> + if (usr_size < min_size)
> + return -EINVAL;
> +
> + if (copy_to_user(u64_to_user_ptr(usr_ptr), in, min_t(u32, usr_size,
> kern_size)))
> + return -EFAULT;
> +
> + /* When the kernel object is smaller than the user object, we fill the
> gap with
> + * zeros.
> + */
> + if (usr_size > kern_size &&
> + clear_user(u64_to_user_ptr(usr_ptr + kern_size), usr_size -
> kern_size)) {
> + return -EFAULT;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * panthor_get_uobj_array() - Copy a user object array into a kernel
> accessible object array.
> + * @in: The object array to copy.
> + * @min_stride: Minimum array stride.
> + * @obj_size: Kernel object size.
> + *
> + * Helper automating user -> kernel object copies.
> + *
> + * Don't use this function directly, use PANTHOR_UOBJ_ARRAY_GET() instead.
Looks like the macro is called PANTHOR_UOBJ_GET_ARRAY().
Best regards,
Liviu
> + *
> + * Return: newly allocated object array or an ERR_PTR on error.
> + */
> +static void *
> +panthor_get_uobj_array(const struct drm_panthor_obj_array *in, u32
> min_stride,
> + u32 obj_size)
> +{
> + int ret = 0;
> + void *out_alloc;
> +
> + /* User stride must be at least the minimum object size, otherwise it
> might
> + * lack useful information.
> + */
> + if (in->stride < min_stride)
> + return ERR_PTR(-EINVAL);
> +
> + if (!in->count)
> + return NULL;
> +
> + out_alloc = kvmalloc_array(in->count, obj_size, GFP_KERNEL);
> + if (!out_alloc)
> + return ERR_PTR(-ENOMEM);
> +
> + if (obj_size == in->stride) {
> + /* Fast path when user/kernel have the same uAPI header
> version. */
> + if (copy_from_user(out_alloc, u64_to_user_ptr(in->array),
> + (unsigned long)obj_size * in->count))
> + ret = -EFAULT;
> + } else {
> + void __user *in_ptr = u64_to_user_ptr(in->array);
> + void *out_ptr = out_alloc;
> +
> + /* If the sizes differ, we need to copy elements one by one. */
> + for (u32 i = 0; i < in->count; i++) {
> + ret = copy_struct_from_user(out_ptr, obj_size, in_ptr,
> in->stride);
> + if (ret)
> + break;
> +
> + out_ptr += obj_size;
> + in_ptr += in->stride;
> + }
> + }
> +
> + if (ret) {
> + kvfree(out_alloc);
> + return ERR_PTR(ret);
> + }
> +
> + return out_alloc;
> +}
> +
> +/**
> + * PANTHOR_UOBJ_MIN_SIZE_INTERNAL() - Get the minimum user object size
> + * @_typename: Object type.
> + * @_last_mandatory_field: Last mandatory field.
> + *
> + * Get the minimum user object size based on the last mandatory field name,
> + * A.K.A, the name of the last field of the structure at the time this
> + * structure was added to the uAPI.
> + *
> + * Don't use directly, use PANTHOR_UOBJ_DECL() instead.
> + */
> +#define PANTHOR_UOBJ_MIN_SIZE_INTERNAL(_typename, _last_mandatory_field) \
> + (offsetof(_typename, _last_mandatory_field) + \
> + sizeof(((_typename *)NULL)->_last_mandatory_field))
> +
> +/**
> + * PANTHOR_UOBJ_DECL() - Declare a new uAPI object whose subject to
> + * evolutions.
> + * @_typename: Object type.
> + * @_last_mandatory_field: Last mandatory field.
> + *
> + * Should be used to extend the PANTHOR_UOBJ_MIN_SIZE() list.
> + */
> +#define PANTHOR_UOBJ_DECL(_typename, _last_mandatory_field) \
> + _typename : PANTHOR_UOBJ_MIN_SIZE_INTERNAL(_typename,
> _last_mandatory_field)
> +
> +/**
> + * PANTHOR_UOBJ_MIN_SIZE() - Get the minimum size of a given uAPI object
> + * @_obj_name: Object to get the minimum size of.
> + *
> + * Don't use this macro directly, it's automatically called by
> + * PANTHOR_UOBJ_{SET,GET_ARRAY}().
> + */
> +#define PANTHOR_UOBJ_MIN_SIZE(_obj_name) \
> + _Generic(_obj_name, \
> + PANTHOR_UOBJ_DECL(struct drm_panthor_gpu_info, tiler_present),
> \
> + PANTHOR_UOBJ_DECL(struct drm_panthor_csif_info, pad), \
> + PANTHOR_UOBJ_DECL(struct drm_panthor_sync_op, timeline_value),
> \
> + PANTHOR_UOBJ_DECL(struct drm_panthor_queue_submit, syncs), \
> + PANTHOR_UOBJ_DECL(struct drm_panthor_queue_create,
> ringbuf_size), \
> + PANTHOR_UOBJ_DECL(struct drm_panthor_vm_bind_op, syncs))
> +
> +/**
> + * PANTHOR_UOBJ_SET() - Copy a kernel object to a user object.
> + * @_dest_usr_ptr: User pointer to copy to.
> + * @_usr_size: Size of the user object.
> + * @_src_obj: Kernel object to copy (not a pointer).
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +#define PANTHOR_UOBJ_SET(_dest_usr_ptr, _usr_size, _src_obj) \
> + panthor_set_uobj(_dest_usr_ptr, _usr_size, \
> + PANTHOR_UOBJ_MIN_SIZE(_src_obj), \
> + sizeof(_src_obj), &(_src_obj))
> +
> +/**
> + * PANTHOR_UOBJ_GET_ARRAY() - Copy a user object array to a kernel accessible
> + * object array.
> + * @_dest_array: Local variable that will hold the newly allocated kernel
> + * object array.
> + * @_uobj_array: The drm_panthor_obj_array object describing the user object
> + * array.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +#define PANTHOR_UOBJ_GET_ARRAY(_dest_array, _uobj_array) \
> + ({ \
> + typeof(_dest_array) _tmp; \
> + _tmp = panthor_get_uobj_array(_uobj_array, \
> +
> PANTHOR_UOBJ_MIN_SIZE((_dest_array)[0]), \
> + sizeof((_dest_array)[0])); \
> + if (!IS_ERR(_tmp)) \
> + _dest_array = _tmp; \
> + PTR_ERR_OR_ZERO(_tmp); \
> + })
> +
> +/**
> + * struct panthor_sync_signal - Represent a synchronization object point to
> attach
> + * our job fence to.
> + *
> + * This structure is here to keep track of fences that are currently bound to
> + * a specific syncobj point.
> + *
> + * At the beginning of a job submission, the fence
> + * is retrieved from the syncobj itself, and can be NULL if no fence was
> attached
> + * to this point.
> + *
> + * At the end, it points to the fence of the last job that had a
> + * %DRM_PANTHOR_SYNC_OP_SIGNAL on this syncobj.
> + *
> + * With jobs being submitted in batches, the fence might change several
> times during
> + * the process, allowing one job to wait on a job that's part of the same
> submission
> + * but appears earlier in the drm_panthor_group_submit::queue_submits array.
> + */
> +struct panthor_sync_signal {
> + /** @node: list_head to track signal ops within a submit operation */
> + struct list_head node;
> +
> + /** @handle: The syncobj handle. */
> + u32 handle;
> +
> + /**
> + * @point: The syncobj point.
> + *
> + * Zero for regular syncobjs, and non-zero for timeline syncobjs.
> + */
> + u64 point;
> +
> + /**
> + * @syncobj: The sync object pointed by @handle.
> + */
> + struct drm_syncobj *syncobj;
> +
> + /**
> + * @chain: Chain object used to link the new fence to an existing
> + * timeline syncobj.
> + *
> + * NULL for regular syncobj, non-NULL for timeline syncobjs.
> + */
> + struct dma_fence_chain *chain;
> +
> + /**
> + * @fence: The fence to assign to the syncobj or syncobj-point.
> + */
> + struct dma_fence *fence;
> +};
> +
> +/**
> + * struct panthor_job_ctx - Job context
> + */
> +struct panthor_job_ctx {
> + /** @job: The job that is about to be submitted to drm_sched. */
> + struct drm_sched_job *job;
> +
> + /** @syncops: Array of sync operations. */
> + struct drm_panthor_sync_op *syncops;
> +
> + /** @syncop_count: Number of sync operations. */
> + u32 syncop_count;
> +};
> +
> +/**
> + * struct panthor_submit_ctx - Submission context
> + *
> + * Anything that's related to a submission (%DRM_IOCTL_PANTHOR_VM_BIND or
> + * %DRM_IOCTL_PANTHOR_GROUP_SUBMIT) is kept here, so we can automate the
> + * initialization and cleanup steps.
> + */
> +struct panthor_submit_ctx {
> + /** @file: DRM file this submission happens on. */
> + struct drm_file *file;
> +
> + /**
> + * @signals: List of struct panthor_sync_signal.
> + *
> + * %DRM_PANTHOR_SYNC_OP_SIGNAL operations will be recorded here,
> + * and %DRM_PANTHOR_SYNC_OP_WAIT will first check if an entry
> + * matching the syncobj+point exists before calling
> + * drm_syncobj_find_fence(). This allows us to describe dependencies
> + * existing between jobs that are part of the same batch.
> + */
> + struct list_head signals;
> +
> + /** @jobs: Array of jobs. */
> + struct panthor_job_ctx *jobs;
> +
> + /** @job_count: Number of entries in the @jobs array. */
> + u32 job_count;
> +
> + /** @exec: drm_exec context used to acquire and prepare resv objects. */
> + struct drm_exec exec;
> +};
> +
> +#define PANTHOR_SYNC_OP_FLAGS_MASK \
> + (DRM_PANTHOR_SYNC_OP_HANDLE_TYPE_MASK | DRM_PANTHOR_SYNC_OP_SIGNAL)
> +
> +static bool sync_op_is_signal(const struct drm_panthor_sync_op *sync_op)
> +{
> + return !!(sync_op->flags & DRM_PANTHOR_SYNC_OP_SIGNAL);
> +}
> +
> +static bool sync_op_is_wait(const struct drm_panthor_sync_op *sync_op)
> +{
> + /* Note that DRM_PANTHOR_SYNC_OP_WAIT == 0 */
> + return !(sync_op->flags & DRM_PANTHOR_SYNC_OP_SIGNAL);
> +}
> +
> +/**
> + * panthor_check_sync_op() - Check drm_panthor_sync_op fields
> + * @sync_op: The sync operation to check.
> + *
> + * Return: 0 on success, -EINVAL otherwise.
> + */
> +static int
> +panthor_check_sync_op(const struct drm_panthor_sync_op *sync_op)
> +{
> + u8 handle_type;
> +
> + if (sync_op->flags & ~PANTHOR_SYNC_OP_FLAGS_MASK)
> + return -EINVAL;
> +
> + handle_type = sync_op->flags & DRM_PANTHOR_SYNC_OP_HANDLE_TYPE_MASK;
> + if (handle_type != DRM_PANTHOR_SYNC_OP_HANDLE_TYPE_SYNCOBJ &&
> + handle_type != DRM_PANTHOR_SYNC_OP_HANDLE_TYPE_TIMELINE_SYNCOBJ)
> + return -EINVAL;
> +
> + if (handle_type == DRM_PANTHOR_SYNC_OP_HANDLE_TYPE_SYNCOBJ &&
> + sync_op->timeline_value != 0)
> + return -EINVAL;
> +
> + return 0;
> +}
> +
> +/**
> + * panthor_sync_signal_free() - Release resources and free a
> panthor_sync_signal object
> + * @sig_sync: Signal object to free.
> + */
> +static void
> +panthor_sync_signal_free(struct panthor_sync_signal *sig_sync)
> +{
> + if (!sig_sync)
> + return;
> +
> + drm_syncobj_put(sig_sync->syncobj);
> + dma_fence_chain_free(sig_sync->chain);
> + dma_fence_put(sig_sync->fence);
> + kfree(sig_sync);
> +}
> +
> +/**
> + * panthor_submit_ctx_add_sync_signal() - Add a signal operation to a submit
> context
> + * @ctx: Context to add the signal operation to.
> + * @handle: Syncobj handle.
> + * @point: Syncobj point.
> + *
> + * Return: 0 on success, otherwise negative error value.
> + */
> +static int
> +panthor_submit_ctx_add_sync_signal(struct panthor_submit_ctx *ctx, u32
> handle, u64 point)
> +{
> + struct panthor_sync_signal *sig_sync;
> + struct dma_fence *cur_fence;
> + int ret;
> +
> + sig_sync = kzalloc(sizeof(*sig_sync), GFP_KERNEL);
> + if (!sig_sync)
> + return -ENOMEM;
> +
> + sig_sync->handle = handle;
> + sig_sync->point = point;
> +
> + if (point > 0) {
> + sig_sync->chain = dma_fence_chain_alloc();
> + if (!sig_sync->chain) {
> + ret = -ENOMEM;
> + goto err_free_sig_sync;
> + }
> + }
> +
> + sig_sync->syncobj = drm_syncobj_find(ctx->file, handle);
> + if (!sig_sync->syncobj) {
> + ret = -EINVAL;
> + goto err_free_sig_sync;
> + }
> +
> + /* Retrieve the current fence attached to that point. It's
> + * perfectly fine to get a NULL fence here, it just means there's
> + * no fence attached to that point yet.
> + */
> + if (!drm_syncobj_find_fence(ctx->file, handle, point, 0, &cur_fence))
> + sig_sync->fence = cur_fence;
> +
> + list_add_tail(&sig_sync->node, &ctx->signals);
> +
> + return 0;
> +
> +err_free_sig_sync:
> + panthor_sync_signal_free(sig_sync);
> + return ret;
> +}
> +
> +/**
> + * panthor_submit_ctx_search_sync_signal() - Search an existing signal
> operation in a
> + * submit context.
> + * @ctx: Context to search the signal operation in.
> + * @handle: Syncobj handle.
> + * @point: Syncobj point.
> + *
> + * Return: A valid panthor_sync_signal object if found, NULL otherwise.
> + */
> +static struct panthor_sync_signal *
> +panthor_submit_ctx_search_sync_signal(struct panthor_submit_ctx *ctx, u32
> handle, u64 point)
> +{
> + struct panthor_sync_signal *sig_sync;
> +
> + list_for_each_entry(sig_sync, &ctx->signals, node) {
> + if (handle == sig_sync->handle && point == sig_sync->point)
> + return sig_sync;
> + }
> +
> + return NULL;
> +}
> +
> +/**
> + * panthor_submit_ctx_add_job() - Add a job to a submit context
> + * @ctx: Context to search the signal operation in.
> + * @idx: Index of the job in the context.
> + * @job: Job to add.
> + * @syncs: Sync operations provided by userspace.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_submit_ctx_add_job(struct panthor_submit_ctx *ctx, u32 idx,
> + struct drm_sched_job *job,
> + const struct drm_panthor_obj_array *syncs)
> +{
> + int ret;
> +
> + ctx->jobs[idx].job = job;
> +
> + ret = PANTHOR_UOBJ_GET_ARRAY(ctx->jobs[idx].syncops, syncs);
> + if (ret)
> + return ret;
> +
> + ctx->jobs[idx].syncop_count = syncs->count;
> + return 0;
> +}
> +
> +/**
> + * panthor_submit_ctx_get_sync_signal() - Search signal operation and add
> one if none was found.
> + * @ctx: Context to search the signal operation in.
> + * @handle: Syncobj handle.
> + * @point: Syncobj point.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_submit_ctx_get_sync_signal(struct panthor_submit_ctx *ctx, u32
> handle, u64 point)
> +{
> + struct panthor_sync_signal *sig_sync;
> +
> + sig_sync = panthor_submit_ctx_search_sync_signal(ctx, handle, point);
> + if (sig_sync)
> + return 0;
> +
> + return panthor_submit_ctx_add_sync_signal(ctx, handle, point);
> +}
> +
> +/**
> + * panthor_submit_ctx_update_job_sync_signal_fences() - Update fences
> + * on the signal operations specified by a job.
> + * @ctx: Context to search the signal operation in.
> + * @job_idx: Index of the job to operate on.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_submit_ctx_update_job_sync_signal_fences(struct panthor_submit_ctx
> *ctx,
> + u32 job_idx)
> +{
> + struct panthor_device *ptdev = container_of(ctx->file->minor->dev,
> + struct panthor_device,
> + base);
> + struct dma_fence *done_fence =
> &ctx->jobs[job_idx].job->s_fence->finished;
> + const struct drm_panthor_sync_op *sync_ops = ctx->jobs[job_idx].syncops;
> + u32 sync_op_count = ctx->jobs[job_idx].syncop_count;
> +
> + for (u32 i = 0; i < sync_op_count; i++) {
> + struct dma_fence *old_fence;
> + struct panthor_sync_signal *sig_sync;
> +
> + if (!sync_op_is_signal(&sync_ops[i]))
> + continue;
> +
> + sig_sync = panthor_submit_ctx_search_sync_signal(ctx,
> sync_ops[i].handle,
> +
> sync_ops[i].timeline_value);
> + if (drm_WARN_ON(&ptdev->base, !sig_sync))
> + return -EINVAL;
> +
> + old_fence = sig_sync->fence;
> + sig_sync->fence = dma_fence_get(done_fence);
> + dma_fence_put(old_fence);
> +
> + if (drm_WARN_ON(&ptdev->base, !sig_sync->fence))
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * panthor_submit_ctx_collect_job_signal_ops() - Iterate over all job signal
> operations
> + * and add them to the context.
> + * @ctx: Context to search the signal operation in.
> + * @job_idx: Index of the job to operate on.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_submit_ctx_collect_job_signal_ops(struct panthor_submit_ctx *ctx,
> + u32 job_idx)
> +{
> + const struct drm_panthor_sync_op *sync_ops = ctx->jobs[job_idx].syncops;
> + u32 sync_op_count = ctx->jobs[job_idx].syncop_count;
> +
> + for (u32 i = 0; i < sync_op_count; i++) {
> + int ret;
> +
> + if (!sync_op_is_signal(&sync_ops[i]))
> + continue;
> +
> + ret = panthor_check_sync_op(&sync_ops[i]);
> + if (ret)
> + return ret;
> +
> + ret = panthor_submit_ctx_get_sync_signal(ctx,
> + sync_ops[i].handle,
> +
> sync_ops[i].timeline_value);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * panthor_submit_ctx_push_fences() - Iterate over the signal array, and for
> each entry, push
> + * the currently assigned fence to the associated syncobj.
> + * @ctx: Context to push fences on.
> + *
> + * This is the last step of a submission procedure, and is done once we know
> the submission
> + * is effective and job fences are guaranteed to be signaled in finite time.
> + */
> +static void
> +panthor_submit_ctx_push_fences(struct panthor_submit_ctx *ctx)
> +{
> + struct panthor_sync_signal *sig_sync;
> +
> + list_for_each_entry(sig_sync, &ctx->signals, node) {
> + if (sig_sync->chain) {
> + drm_syncobj_add_point(sig_sync->syncobj,
> sig_sync->chain,
> + sig_sync->fence, sig_sync->point);
> + sig_sync->chain = NULL;
> + } else {
> + drm_syncobj_replace_fence(sig_sync->syncobj,
> sig_sync->fence);
> + }
> + }
> +}
> +
> +/**
> + * panthor_submit_ctx_add_sync_deps_to_job() - Add sync wait operations as
> + * job dependencies.
> + * @ctx: Submit context.
> + * @job_idx: Index of the job to operate on.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_submit_ctx_add_sync_deps_to_job(struct panthor_submit_ctx *ctx,
> + u32 job_idx)
> +{
> + struct panthor_device *ptdev = container_of(ctx->file->minor->dev,
> + struct panthor_device,
> + base);
> + const struct drm_panthor_sync_op *sync_ops = ctx->jobs[job_idx].syncops;
> + struct drm_sched_job *job = ctx->jobs[job_idx].job;
> + u32 sync_op_count = ctx->jobs[job_idx].syncop_count;
> + int ret = 0;
> +
> + for (u32 i = 0; i < sync_op_count; i++) {
> + struct panthor_sync_signal *sig_sync;
> + struct dma_fence *fence;
> +
> + if (!sync_op_is_wait(&sync_ops[i]))
> + continue;
> +
> + ret = panthor_check_sync_op(&sync_ops[i]);
> + if (ret)
> + return ret;
> +
> + sig_sync = panthor_submit_ctx_search_sync_signal(ctx,
> sync_ops[i].handle,
> +
> sync_ops[i].timeline_value);
> + if (sig_sync) {
> + if (drm_WARN_ON(&ptdev->base, !sig_sync->fence))
> + return -EINVAL;
> +
> + fence = dma_fence_get(sig_sync->fence);
> + } else {
> + ret = drm_syncobj_find_fence(ctx->file,
> sync_ops[i].handle,
> + sync_ops[i].timeline_value,
> + 0, &fence);
> + if (ret)
> + return ret;
> + }
> +
> + ret = drm_sched_job_add_dependency(job, fence);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * panthor_submit_ctx_collect_jobs_signal_ops() - Collect all signal
> operations
> + * and add them to the submit context.
> + * @ctx: Submit context.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_submit_ctx_collect_jobs_signal_ops(struct panthor_submit_ctx *ctx)
> +{
> + for (u32 i = 0; i < ctx->job_count; i++) {
> + int ret;
> +
> + ret = panthor_submit_ctx_collect_job_signal_ops(ctx, i);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * panthor_submit_ctx_add_deps_and_arm_jobs() - Add jobs dependencies and
> arm jobs
> + * @ctx: Submit context.
> + *
> + * Must be called after the resv preparation has been taken care of.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int
> +panthor_submit_ctx_add_deps_and_arm_jobs(struct panthor_submit_ctx *ctx)
> +{
> + for (u32 i = 0; i < ctx->job_count; i++) {
> + int ret;
> +
> + ret = panthor_submit_ctx_add_sync_deps_to_job(ctx, i);
> + if (ret)
> + return ret;
> +
> + drm_sched_job_arm(ctx->jobs[i].job);
> +
> + ret = panthor_submit_ctx_update_job_sync_signal_fences(ctx, i);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * panthor_submit_ctx_push_jobs() - Push jobs to their scheduling entities.
> + * @ctx: Submit context.
> + * @upd_resvs: Callback used to update reservation objects that were
> previously
> + * preapred.
> + */
> +static void
> +panthor_submit_ctx_push_jobs(struct panthor_submit_ctx *ctx,
> + void (*upd_resvs)(struct drm_exec *, struct
> drm_sched_job *))
> +{
> + for (u32 i = 0; i < ctx->job_count; i++) {
> + upd_resvs(&ctx->exec, ctx->jobs[i].job);
> + drm_sched_entity_push_job(ctx->jobs[i].job);
> +
> + /* Job is owned by the scheduler now. */
> + ctx->jobs[i].job = NULL;
> + }
> +
> + panthor_submit_ctx_push_fences(ctx);
> +}
> +
> +/**
> + * panthor_submit_ctx_init() - Initializes a submission context
> + * @ctx: Submit context to initialize.
> + * @file: drm_file this submission happens on.
> + * @job_count: Number of jobs that will be submitted.
> + *
> + * Return: 0 on success, a negative error code otherwise.
> + */
> +static int panthor_submit_ctx_init(struct panthor_submit_ctx *ctx,
> + struct drm_file *file, u32 job_count)
> +{
> + ctx->jobs = kvmalloc_array(job_count, sizeof(*ctx->jobs),
> + GFP_KERNEL | __GFP_ZERO);
> + if (!ctx->jobs)
> + return -ENOMEM;
> +
> + ctx->file = file;
> + ctx->job_count = job_count;
> + INIT_LIST_HEAD(&ctx->signals);
> + drm_exec_init(&ctx->exec, DRM_EXEC_INTERRUPTIBLE_WAIT |
> DRM_EXEC_IGNORE_DUPLICATES);
> + return 0;
> +}
> +
> +/**
> + * panthor_submit_ctx_cleanup() - Cleanup a submission context
> + * @ctx: Submit context to cleanup.
> + * @job_put: Job put callback.
> + */
> +static void panthor_submit_ctx_cleanup(struct panthor_submit_ctx *ctx,
> + void (*job_put)(struct drm_sched_job *))
> +{
> + struct panthor_sync_signal *sig_sync, *tmp;
> + unsigned long i;
> +
> + drm_exec_fini(&ctx->exec);
> +
> + list_for_each_entry_safe(sig_sync, tmp, &ctx->signals, node)
> + panthor_sync_signal_free(sig_sync);
> +
> + for (i = 0; i < ctx->job_count; i++) {
> + job_put(ctx->jobs[i].job);
> + kvfree(ctx->jobs[i].syncops);
> + }
> +
> + kvfree(ctx->jobs);
> +}
> +
> +static int panthor_ioctl_dev_query(struct drm_device *ddev, void *data,
> struct drm_file *file)
> +{
> + struct panthor_device *ptdev = container_of(ddev, struct
> panthor_device, base);
> + struct drm_panthor_dev_query *args = data;
> +
> + if (!args->pointer) {
> + switch (args->type) {
> + case DRM_PANTHOR_DEV_QUERY_GPU_INFO:
> + args->size = sizeof(ptdev->gpu_info);
> + return 0;
> +
> + case DRM_PANTHOR_DEV_QUERY_CSIF_INFO:
> + args->size = sizeof(ptdev->csif_info);
> + return 0;
> +
> + default:
> + return -EINVAL;
> + }
> + }
> +
> + switch (args->type) {
> + case DRM_PANTHOR_DEV_QUERY_GPU_INFO:
> + return PANTHOR_UOBJ_SET(args->pointer, args->size,
> ptdev->gpu_info);
> +
> + case DRM_PANTHOR_DEV_QUERY_CSIF_INFO:
> + return PANTHOR_UOBJ_SET(args->pointer, args->size,
> ptdev->csif_info);
> +
> + default:
> + return -EINVAL;
> + }
> +}
> +
> +#define PANTHOR_VM_CREATE_FLAGS 0
> +
> +static int panthor_ioctl_vm_create(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct panthor_device *ptdev = container_of(ddev, struct
> panthor_device, base);
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_vm_create *args = data;
> + int cookie, ret;
> +
> + if (!drm_dev_enter(ddev, &cookie))
> + return -ENODEV;
> +
> + ret = panthor_vm_pool_create_vm(ptdev, pfile->vms, args);
> + if (ret >= 0) {
> + args->id = ret;
> + ret = 0;
> + }
> +
> + drm_dev_exit(cookie);
> + return ret;
> +}
> +
> +static int panthor_ioctl_vm_destroy(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_vm_destroy *args = data;
> +
> + if (args->pad)
> + return -EINVAL;
> +
> + return panthor_vm_pool_destroy_vm(pfile->vms, args->id);
> +}
> +
> +#define PANTHOR_BO_FLAGS DRM_PANTHOR_BO_NO_MMAP
> +
> +static int panthor_ioctl_bo_create(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_bo_create *args = data;
> + struct panthor_vm *vm = NULL;
> + int cookie, ret;
> +
> + if (!drm_dev_enter(ddev, &cookie))
> + return -ENODEV;
> +
> + if (!args->size || args->pad ||
> + (args->flags & ~PANTHOR_BO_FLAGS)) {
> + ret = -EINVAL;
> + goto out_dev_exit;
> + }
> +
> + if (args->exclusive_vm_id) {
> + vm = panthor_vm_pool_get_vm(pfile->vms, args->exclusive_vm_id);
> + if (!vm) {
> + ret = -EINVAL;
> + goto out_dev_exit;
> + }
> + }
> +
> + ret = panthor_gem_create_with_handle(file, ddev, vm, args->size,
> + args->flags, &args->handle);
> +
> + panthor_vm_put(vm);
> +
> +out_dev_exit:
> + drm_dev_exit(cookie);
> + return ret;
> +}
> +
> +static int panthor_ioctl_bo_mmap_offset(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct drm_panthor_bo_mmap_offset *args = data;
> + struct drm_gem_object *obj;
> + int ret;
> +
> + if (args->pad)
> + return -EINVAL;
> +
> + obj = drm_gem_object_lookup(file, args->handle);
> + if (!obj)
> + return -ENOENT;
> +
> + ret = drm_gem_create_mmap_offset(obj);
> + if (ret)
> + goto out;
> +
> + args->offset = drm_vma_node_offset_addr(&obj->vma_node);
> +
> +out:
> + drm_gem_object_put(obj);
> + return ret;
> +}
> +
> +static int panthor_ioctl_group_submit(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_group_submit *args = data;
> + struct drm_panthor_queue_submit *jobs_args;
> + struct panthor_submit_ctx ctx;
> + int ret = 0, cookie;
> +
> + if (args->pad)
> + return -EINVAL;
> +
> + if (!drm_dev_enter(ddev, &cookie))
> + return -ENODEV;
> +
> + ret = PANTHOR_UOBJ_GET_ARRAY(jobs_args, &args->queue_submits);
> + if (ret)
> + goto out_dev_exit;
> +
> + ret = panthor_submit_ctx_init(&ctx, file, args->queue_submits.count);
> + if (ret)
> + goto out_free_jobs_args;
> +
> + /* Create jobs and attach sync operations */
> + for (u32 i = 0; i < args->queue_submits.count; i++) {
> + const struct drm_panthor_queue_submit *qsubmit = &jobs_args[i];
> + struct drm_sched_job *job;
> +
> + job = panthor_job_create(pfile, args->group_handle, qsubmit);
> + if (IS_ERR(job)) {
> + ret = PTR_ERR(job);
> + goto out_cleanup_submit_ctx;
> + }
> +
> + ret = panthor_submit_ctx_add_job(&ctx, i, job, &qsubmit->syncs);
> + if (ret)
> + goto out_cleanup_submit_ctx;
> + }
> +
> + /*
> + * Collect signal operations on all jobs, such that each job can pick
> + * from it for its dependencies and update the fence to signal when the
> + * job is submitted.
> + */
> + ret = panthor_submit_ctx_collect_jobs_signal_ops(&ctx);
> + if (ret)
> + goto out_cleanup_submit_ctx;
> +
> + /*
> + * We acquire/prepare revs on all jobs before proceeding with the
> + * dependency registration.
> + *
> + * This is solving two problems:
> + * 1. drm_sched_job_arm() and drm_sched_entity_push_job() must be
> + * protected by a lock to make sure no concurrent access to the same
> + * entity get interleaved, which would mess up with the fence seqno
> + * ordering. Luckily, one of the resv being acquired is the VM resv,
> + * and a scheduling entity is only bound to a single VM. As soon as
> + * we acquire the VM resv, we should be safe.
> + * 2. Jobs might depend on fences that were issued by previous jobs in
> + * the same batch, so we can't add dependencies on all jobs before
> + * arming previous jobs and registering the fence to the signal
> + * array, otherwise we might miss dependencies, or point to an
> + * outdated fence.
> + */
> + if (args->queue_submits.count > 0) {
> + /* All jobs target the same group, so they also point to the
> same VM. */
> + struct panthor_vm *vm = panthor_job_vm(ctx.jobs[0].job);
> +
> + drm_exec_until_all_locked(&ctx.exec) {
> + ret = panthor_vm_prepare_mapped_bos_resvs(&ctx.exec, vm,
> +
> args->queue_submits.count);
> + }
> +
> + if (ret)
> + goto out_cleanup_submit_ctx;
> + }
> +
> + /*
> + * Now that resvs are locked/prepared, we can iterate over each job to
> + * add the dependencies, arm the job fence, register the job fence to
> + * the signal array.
> + */
> + ret = panthor_submit_ctx_add_deps_and_arm_jobs(&ctx);
> + if (ret)
> + goto out_cleanup_submit_ctx;
> +
> + /* Nothing can fail after that point, so we can make our job fences
> + * visible to the outside world. Push jobs and set the job fences to
> + * the resv slots we reserved. This also pushes the fences to the
> + * syncobjs that are part of the signal array.
> + */
> + panthor_submit_ctx_push_jobs(&ctx, panthor_job_update_resvs);
> +
> +out_cleanup_submit_ctx:
> + panthor_submit_ctx_cleanup(&ctx, panthor_job_put);
> +
> +out_free_jobs_args:
> + kvfree(jobs_args);
> +
> +out_dev_exit:
> + drm_dev_exit(cookie);
> + return ret;
> +}
> +
> +static int panthor_ioctl_group_destroy(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_group_destroy *args = data;
> +
> + if (args->pad)
> + return -EINVAL;
> +
> + return panthor_group_destroy(pfile, args->group_handle);
> +}
> +
> +static int panthor_ioctl_group_create(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_group_create *args = data;
> + struct drm_panthor_queue_create *queue_args;
> + int ret;
> +
> + if (!args->queues.count)
> + return -EINVAL;
> +
> + ret = PANTHOR_UOBJ_GET_ARRAY(queue_args, &args->queues);
> + if (ret)
> + return ret;
> +
> + ret = panthor_group_create(pfile, args, queue_args);
> + if (ret >= 0) {
> + args->group_handle = ret;
> + ret = 0;
> + }
> +
> + kvfree(queue_args);
> + return ret;
> +}
> +
> +static int panthor_ioctl_group_get_state(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_group_get_state *args = data;
> +
> + return panthor_group_get_state(pfile, args);
> +}
> +
> +static int panthor_ioctl_tiler_heap_create(struct drm_device *ddev, void
> *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_tiler_heap_create *args = data;
> + struct panthor_heap_pool *pool;
> + struct panthor_vm *vm;
> + int ret;
> +
> + vm = panthor_vm_pool_get_vm(pfile->vms, args->vm_id);
> + if (!vm)
> + return -EINVAL;
> +
> + pool = panthor_vm_get_heap_pool(vm, true);
> + if (IS_ERR(pool)) {
> + ret = PTR_ERR(pool);
> + goto out_put_vm;
> + }
> +
> + ret = panthor_heap_create(pool,
> + args->initial_chunk_count,
> + args->chunk_size,
> + args->max_chunks,
> + args->target_in_flight,
> + &args->tiler_heap_ctx_gpu_va,
> + &args->first_heap_chunk_gpu_va);
> + if (ret < 0)
> + goto out_put_heap_pool;
> +
> + /* Heap pools are per-VM. We combine the VM and HEAP id to make
> + * a unique heap handle.
> + */
> + args->handle = (args->vm_id << 16) | ret;
> + ret = 0;
> +
> +out_put_heap_pool:
> + panthor_heap_pool_put(pool);
> +
> +out_put_vm:
> + panthor_vm_put(vm);
> + return ret;
> +}
> +
> +static int panthor_ioctl_tiler_heap_destroy(struct drm_device *ddev, void
> *data,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_tiler_heap_destroy *args = data;
> + struct panthor_heap_pool *pool;
> + struct panthor_vm *vm;
> + int ret;
> +
> + if (args->pad)
> + return -EINVAL;
> +
> + vm = panthor_vm_pool_get_vm(pfile->vms, args->handle >> 16);
> + if (!vm)
> + return -EINVAL;
> +
> + pool = panthor_vm_get_heap_pool(vm, false);
> + if (!pool) {
> + ret = -EINVAL;
> + goto out_put_vm;
> + }
> +
> + ret = panthor_heap_destroy(pool, args->handle & GENMASK(15, 0));
> + panthor_heap_pool_put(pool);
> +
> +out_put_vm:
> + panthor_vm_put(vm);
> + return ret;
> +}
> +
> +static int panthor_ioctl_vm_bind_async(struct drm_device *ddev,
> + struct drm_panthor_vm_bind *args,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_vm_bind_op *jobs_args;
> + struct panthor_submit_ctx ctx;
> + struct panthor_vm *vm;
> + int ret = 0;
> +
> + vm = panthor_vm_pool_get_vm(pfile->vms, args->vm_id);
> + if (!vm)
> + return -EINVAL;
> +
> + ret = PANTHOR_UOBJ_GET_ARRAY(jobs_args, &args->ops);
> + if (ret)
> + goto out_put_vm;
> +
> + ret = panthor_submit_ctx_init(&ctx, file, args->ops.count);
> + if (ret)
> + goto out_free_jobs_args;
> +
> + for (u32 i = 0; i < args->ops.count; i++) {
> + struct drm_panthor_vm_bind_op *op = &jobs_args[i];
> + struct drm_sched_job *job;
> +
> + job = panthor_vm_bind_job_create(file, vm, op);
> + if (IS_ERR(job)) {
> + ret = PTR_ERR(job);
> + goto out_cleanup_submit_ctx;
> + }
> +
> + ret = panthor_submit_ctx_add_job(&ctx, i, job, &op->syncs);
> + if (ret)
> + goto out_cleanup_submit_ctx;
> + }
> +
> + ret = panthor_submit_ctx_collect_jobs_signal_ops(&ctx);
> + if (ret)
> + goto out_cleanup_submit_ctx;
> +
> + /* Prepare reservation objects for each VM_BIND job. */
> + drm_exec_until_all_locked(&ctx.exec) {
> + for (u32 i = 0; i < ctx.job_count; i++) {
> + ret = panthor_vm_bind_job_prepare_resvs(&ctx.exec,
> ctx.jobs[i].job);
> + drm_exec_retry_on_contention(&ctx.exec);
> + if (ret)
> + goto out_cleanup_submit_ctx;
> + }
> + }
> +
> + ret = panthor_submit_ctx_add_deps_and_arm_jobs(&ctx);
> + if (ret)
> + goto out_cleanup_submit_ctx;
> +
> + /* Nothing can fail after that point. */
> + panthor_submit_ctx_push_jobs(&ctx, panthor_vm_bind_job_update_resvs);
> +
> +out_cleanup_submit_ctx:
> + panthor_submit_ctx_cleanup(&ctx, panthor_vm_bind_job_put);
> +
> +out_free_jobs_args:
> + kvfree(jobs_args);
> +
> +out_put_vm:
> + panthor_vm_put(vm);
> + return ret;
> +}
> +
> +static int panthor_ioctl_vm_bind_sync(struct drm_device *ddev,
> + struct drm_panthor_vm_bind *args,
> + struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> + struct drm_panthor_vm_bind_op *jobs_args;
> + struct panthor_vm *vm;
> + int ret;
> +
> + vm = panthor_vm_pool_get_vm(pfile->vms, args->vm_id);
> + if (!vm)
> + return -EINVAL;
> +
> + ret = PANTHOR_UOBJ_GET_ARRAY(jobs_args, &args->ops);
> + if (ret)
> + goto out_put_vm;
> +
> + for (u32 i = 0; i < args->ops.count; i++) {
> + ret = panthor_vm_bind_exec_sync_op(file, vm, &jobs_args[i]);
> + if (ret) {
> + /* Update ops.count so the user knows where things
> failed. */
> + args->ops.count = i;
> + break;
> + }
> + }
> +
> + kvfree(jobs_args);
> +
> +out_put_vm:
> + panthor_vm_put(vm);
> + return ret;
> +}
> +
> +#define PANTHOR_VM_BIND_FLAGS DRM_PANTHOR_VM_BIND_ASYNC
> +
> +static int panthor_ioctl_vm_bind(struct drm_device *ddev, void *data,
> + struct drm_file *file)
> +{
> + struct drm_panthor_vm_bind *args = data;
> + int cookie, ret;
> +
> + if (!drm_dev_enter(ddev, &cookie))
> + return -ENODEV;
> +
> + if (args->flags & DRM_PANTHOR_VM_BIND_ASYNC)
> + ret = panthor_ioctl_vm_bind_async(ddev, args, file);
> + else
> + ret = panthor_ioctl_vm_bind_sync(ddev, args, file);
> +
> + drm_dev_exit(cookie);
> + return ret;
> +}
> +
> +static int
> +panthor_open(struct drm_device *ddev, struct drm_file *file)
> +{
> + struct panthor_device *ptdev = container_of(ddev, struct
> panthor_device, base);
> + struct panthor_file *pfile;
> + int ret;
> +
> + if (!try_module_get(THIS_MODULE))
> + return -EINVAL;
> +
> + pfile = kzalloc(sizeof(*pfile), GFP_KERNEL);
> + if (!pfile) {
> + ret = -ENOMEM;
> + goto err_put_mod;
> + }
> +
> + pfile->ptdev = ptdev;
> +
> + ret = panthor_vm_pool_create(pfile);
> + if (ret)
> + goto err_free_file;
> +
> + ret = panthor_group_pool_create(pfile);
> + if (ret)
> + goto err_destroy_vm_pool;
> +
> + file->driver_priv = pfile;
> + return 0;
> +
> +err_destroy_vm_pool:
> + panthor_vm_pool_destroy(pfile);
> +
> +err_free_file:
> + kfree(pfile);
> +
> +err_put_mod:
> + module_put(THIS_MODULE);
> + return ret;
> +}
> +
> +static void
> +panthor_postclose(struct drm_device *ddev, struct drm_file *file)
> +{
> + struct panthor_file *pfile = file->driver_priv;
> +
> + panthor_group_pool_destroy(pfile);
> + panthor_vm_pool_destroy(pfile);
> +
> + kfree(pfile);
> + module_put(THIS_MODULE);
> +}
> +
> +static const struct drm_ioctl_desc panthor_drm_driver_ioctls[] = {
> +#define PANTHOR_IOCTL(n, func, flags) \
> + DRM_IOCTL_DEF_DRV(PANTHOR_##n, panthor_ioctl_##func, flags)
> +
> + PANTHOR_IOCTL(DEV_QUERY, dev_query, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(VM_CREATE, vm_create, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(VM_DESTROY, vm_destroy, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(VM_BIND, vm_bind, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(BO_CREATE, bo_create, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(BO_MMAP_OFFSET, bo_mmap_offset, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(GROUP_CREATE, group_create, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(GROUP_DESTROY, group_destroy, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(GROUP_GET_STATE, group_get_state, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(TILER_HEAP_CREATE, tiler_heap_create, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(TILER_HEAP_DESTROY, tiler_heap_destroy, DRM_RENDER_ALLOW),
> + PANTHOR_IOCTL(GROUP_SUBMIT, group_submit, DRM_RENDER_ALLOW),
> +};
> +
> +static int panthor_mmap(struct file *filp, struct vm_area_struct *vma)
> +{
> + struct drm_file *file = filp->private_data;
> + struct panthor_file *pfile = file->driver_priv;
> + struct panthor_device *ptdev = pfile->ptdev;
> + u64 offset = (u64)vma->vm_pgoff << PAGE_SHIFT;
> + int ret, cookie;
> +
> + if (!drm_dev_enter(file->minor->dev, &cookie))
> + return -ENODEV;
> +
> + if (panthor_device_mmio_offset(offset) >= DRM_PANTHOR_USER_MMIO_OFFSET)
> + ret = panthor_device_mmap_io(ptdev, vma);
> + else
> + ret = drm_gem_mmap(filp, vma);
> +
> + drm_dev_exit(cookie);
> + return ret;
> +}
> +
> +static const struct file_operations panthor_drm_driver_fops = {
> + .open = drm_open,
> + .release = drm_release,
> + .unlocked_ioctl = drm_ioctl,
> + .compat_ioctl = drm_compat_ioctl,
> + .poll = drm_poll,
> + .read = drm_read,
> + .llseek = noop_llseek,
> + .mmap = panthor_mmap,
> +};
> +
> +#ifdef CONFIG_DEBUG_FS
> +static void panthor_debugfs_init(struct drm_minor *minor)
> +{
> + panthor_mmu_debugfs_init(minor);
> +}
> +#endif
> +
> +/*
> + * PanCSF driver version:
> + * - 1.0 - initial interface
> + */
> +static const struct drm_driver panthor_drm_driver = {
> + .driver_features = DRIVER_RENDER | DRIVER_GEM | DRIVER_SYNCOBJ |
> + DRIVER_SYNCOBJ_TIMELINE | DRIVER_GEM_GPUVA,
> + .open = panthor_open,
> + .postclose = panthor_postclose,
> + .ioctls = panthor_drm_driver_ioctls,
> + .num_ioctls = ARRAY_SIZE(panthor_drm_driver_ioctls),
> + .fops = &panthor_drm_driver_fops,
> + .name = "panthor",
> + .desc = "Panthor DRM driver",
> + .date = "20230801",
> + .major = 1,
> + .minor = 0,
> +
> + .gem_create_object = panthor_gem_create_object,
> + .gem_prime_import_sg_table = drm_gem_shmem_prime_import_sg_table,
> +#ifdef CONFIG_DEBUG_FS
> + .debugfs_init = panthor_debugfs_init,
> +#endif
> +};
> +
> +static int panthor_probe(struct platform_device *pdev)
> +{
> + struct panthor_device *ptdev;
> + int ret;
> +
> + ptdev = devm_drm_dev_alloc(&pdev->dev, &panthor_drm_driver,
> + struct panthor_device, base);
> + if (!ptdev)
> + return -ENOMEM;
> +
> + platform_set_drvdata(pdev, ptdev);
> +
> + ret = panthor_device_init(ptdev);
> + if (ret)
> + return ret;
> +
> + return drm_dev_register(&ptdev->base, 0);
> +}
> +
> +static void panthor_remove(struct platform_device *pdev)
> +{
> + struct panthor_device *ptdev = platform_get_drvdata(pdev);
> +
> + panthor_device_unplug(ptdev);
> +}
> +
> +static const struct of_device_id dt_match[] = {
> + { .compatible = "rockchip,rk3588-mali" },
> + { .compatible = "arm,mali-valhall-csf" },
> + {}
> +};
> +MODULE_DEVICE_TABLE(of, dt_match);
> +
> +static DEFINE_RUNTIME_DEV_PM_OPS(panthor_pm_ops,
> + panthor_device_suspend,
> + panthor_device_resume,
> + NULL);
> +
> +static struct platform_driver panthor_driver = {
> + .probe = panthor_probe,
> + .remove_new = panthor_remove,
> + .driver = {
> + .name = "panthor",
> + .pm = &panthor_pm_ops,
> + .of_match_table = dt_match,
> + },
> +};
> +
> +/*
> + * Workqueue used to cleanup stuff.
> + *
> + * We create a dedicated workqueue so we can drain on unplug and
> + * make sure all resources are freed before the module is unloaded.
> + */
> +struct workqueue_struct *panthor_cleanup_wq;
> +
> +static int __init panthor_init(void)
> +{
> + int ret;
> +
> + ret = panthor_mmu_pt_cache_init();
> + if (ret)
> + return ret;
> +
> + panthor_cleanup_wq = alloc_workqueue("panthor-cleanup", WQ_UNBOUND, 0);
> + if (!panthor_cleanup_wq) {
> + pr_err("panthor: Failed to allocate the workqueues");
> + ret = -ENOMEM;
> + goto err_mmu_pt_cache_fini;
> + }
> +
> + ret = platform_driver_register(&panthor_driver);
> + if (ret)
> + goto err_destroy_cleanup_wq;
> +
> + return ret;
> +
> +err_mmu_pt_cache_fini:
> + panthor_mmu_pt_cache_fini();
> +
> +err_destroy_cleanup_wq:
> + destroy_workqueue(panthor_cleanup_wq);
> + return ret;
> +}
> +module_init(panthor_init);
> +
> +static void __exit panthor_exit(void)
> +{
> + platform_driver_unregister(&panthor_driver);
> + destroy_workqueue(panthor_cleanup_wq);
> + panthor_mmu_pt_cache_fini();
> +}
> +module_exit(panthor_exit);
> +
> +MODULE_AUTHOR("Panthor Project Developers");
> +MODULE_DESCRIPTION("Panthor DRM Driver");
> +MODULE_LICENSE("Dual MIT/GPL");
> --
> 2.43.0
>
--
====================
| I would like to |
| fix the world, |
| but they're not |
| giving me the |
\ source code! /
---------------
¯\_(ツ)_/¯
