drm/v3d: Refactor job management. (a783a09e) · Commits · 戴 / test

drivers/gpu/drm/v3d/v3d_drv.h

+39 −38

Original line number	Diff line number	Diff line
		@@ -67,8 +67,8 @@ struct v3d_dev {

		struct work_struct overflow_mem_work;

		struct v3d_exec_info *bin_job;
		struct v3d_exec_info *render_job;
		struct v3d_bin_job *bin_job;
		struct v3d_render_job *render_job;
		struct v3d_tfu_job *tfu_job;

		struct v3d_queue_state queue[V3D_MAX_QUEUES];
		@@ -117,7 +117,7 @@ struct v3d_bo {
		struct drm_mm_node node;

		/* List entry for the BO's position in
		* v3d_exec_info->unref_list
		* v3d_render_job->unref_list
		*/
		struct list_head unref_head;
		};
		@@ -157,7 +157,15 @@ to_v3d_fence(struct dma_fence *fence)
		struct v3d_job {
		struct drm_sched_job base;

		struct v3d_exec_info *exec;
		struct kref refcount;

		struct v3d_dev *v3d;

		/* This is the array of BOs that were looked up at the start
		* of submission.
		*/
		struct drm_gem_object **bo;
		u32 bo_count;

		/* An optional fence userspace can pass in for the job to depend on. */
		struct dma_fence *in_fence;
		@@ -165,59 +173,53 @@ struct v3d_job {
		/* v3d fence to be signaled by IRQ handler when the job is complete. */
		struct dma_fence *irq_fence;

		/* scheduler fence for when the job is considered complete and
		* the BO reservations can be released.
		*/
		struct dma_fence *done_fence;

		/* Callback for the freeing of the job on refcount going to 0. */
		void (free)(struct kref ref);
		};

		struct v3d_bin_job {
		struct v3d_job base;

		/* GPU virtual addresses of the start/end of the CL job. */
		u32 start, end;

		u32 timedout_ctca, timedout_ctra;
		};

		struct v3d_exec_info {
		struct v3d_dev *v3d;
		/* Corresponding render job, for attaching our overflow memory. */
		struct v3d_render_job *render;

		/* Submitted tile memory allocation start/size, tile state. */
		u32 qma, qms, qts;
		};

		struct v3d_job bin, render;
		struct v3d_render_job {
		struct v3d_job base;

		/* Fence for when the scheduler considers the binner to be
		* done, for render to depend on.
		/* Optional fence for the binner, to depend on before starting
		* our job.
		*/
		struct dma_fence *bin_done_fence;

		/* Fence for when the scheduler considers the render to be
		* done, for when the BOs reservations should be complete.
		*/
		struct dma_fence *render_done_fence;

		struct kref refcount;
		/* GPU virtual addresses of the start/end of the CL job. */
		u32 start, end;

		/* This is the array of BOs that were looked up at the start of exec. */
		struct drm_gem_object **bo;
		u32 bo_count;
		u32 timedout_ctca, timedout_ctra;

		/* List of overflow BOs used in the job that need to be
		* released once the job is complete.
		*/
		struct list_head unref_list;

		/* Submitted tile memory allocation start/size, tile state. */
		u32 qma, qms, qts;
		};

		struct v3d_tfu_job {
		struct drm_sched_job base;
		struct v3d_job base;

		struct drm_v3d_submit_tfu args;

		/* An optional fence userspace can pass in for the job to depend on. */
		struct dma_fence *in_fence;

		/* v3d fence to be signaled by IRQ handler when the job is complete. */
		struct dma_fence *irq_fence;

		struct v3d_dev *v3d;

		struct kref refcount;

		/* This is the array of BOs that were looked up at the start of exec. */
		struct drm_gem_object *bo[4];
		};

		/**
		@@ -283,8 +285,7 @@ int v3d_submit_tfu_ioctl(struct drm_device dev, void data,
		struct drm_file *file_priv);
		int v3d_wait_bo_ioctl(struct drm_device dev, void data,
		struct drm_file *file_priv);
		void v3d_exec_put(struct v3d_exec_info *exec);
		void v3d_tfu_job_put(struct v3d_tfu_job *exec);
		void v3d_job_put(struct v3d_job *job);
		void v3d_reset(struct v3d_dev *v3d);
		void v3d_invalidate_caches(struct v3d_dev *v3d);

drivers/gpu/drm/v3d/v3d_gem.c

+186 −179

Original line number	Diff line number	Diff line
		@@ -193,18 +193,6 @@ v3d_invalidate_caches(struct v3d_dev *v3d)
		v3d_invalidate_slices(v3d, 0);
		}

		static void
		v3d_attach_object_fences(struct drm_gem_object **bos, int bo_count,
		struct dma_fence *fence)
		{
		int i;

		for (i = 0; i < bo_count; i++) {
		/* XXX: Use shared fences for read-only objects. */
		reservation_object_add_excl_fence(bos[i]->resv, fence);
		}
		}

		/* Takes the reservation lock on all the BOs being referenced, so that
		* at queue submit time we can update the reservations.
		*
		@@ -239,11 +227,11 @@ v3d_lock_bo_reservations(struct drm_gem_object **bos,
		}

		/**
		* v3d_cl_lookup_bos() - Sets up exec->bo[] with the GEM objects
		* v3d_lookup_bos() - Sets up job->bo[] with the GEM objects
		* referenced by the job.
		* @dev: DRM device
		* @file_priv: DRM file for this fd
		* @exec: V3D job being set up
		* @job: V3D job being set up
		*
		* The command validator needs to reference BOs by their index within
		* the submitted job's BO list. This does the validation of the job's
		@@ -253,18 +241,19 @@ v3d_lock_bo_reservations(struct drm_gem_object **bos,
		* failure, because that will happen at v3d_exec_cleanup() time.
		*/
		static int
		v3d_cl_lookup_bos(struct drm_device *dev,
		v3d_lookup_bos(struct drm_device *dev,
		struct drm_file *file_priv,
		struct drm_v3d_submit_cl *args,
		struct v3d_exec_info *exec)
		struct v3d_job *job,
		u64 bo_handles,
		u32 bo_count)
		{
		u32 *handles;
		int ret = 0;
		int i;

		exec->bo_count = args->bo_handle_count;
		job->bo_count = bo_count;

		if (!exec->bo_count) {
		if (!job->bo_count) {
		/* See comment on bo_index for why we have to check
		* this.
		*/
		@@ -272,15 +261,15 @@ v3d_cl_lookup_bos(struct drm_device *dev,
		return -EINVAL;
		}

		exec->bo = kvmalloc_array(exec->bo_count,
		job->bo = kvmalloc_array(job->bo_count,
		sizeof(struct drm_gem_cma_object *),
		GFP_KERNEL \| __GFP_ZERO);
		if (!exec->bo) {
		if (!job->bo) {
		DRM_DEBUG("Failed to allocate validated BO pointers\n");
		return -ENOMEM;
		}

		handles = kvmalloc_array(exec->bo_count, sizeof(u32), GFP_KERNEL);
		handles = kvmalloc_array(job->bo_count, sizeof(u32), GFP_KERNEL);
		if (!handles) {
		ret = -ENOMEM;
		DRM_DEBUG("Failed to allocate incoming GEM handles\n");
		@@ -288,15 +277,15 @@ v3d_cl_lookup_bos(struct drm_device *dev,
		}

		if (copy_from_user(handles,
		(void __user *)(uintptr_t)args->bo_handles,
		exec->bo_count * sizeof(u32))) {
		(void __user *)(uintptr_t)bo_handles,
		job->bo_count * sizeof(u32))) {
		ret = -EFAULT;
		DRM_DEBUG("Failed to copy in GEM handles\n");
		goto fail;
		}

		spin_lock(&file_priv->table_lock);
		for (i = 0; i < exec->bo_count; i++) {
		for (i = 0; i < job->bo_count; i++) {
		struct drm_gem_object *bo = idr_find(&file_priv->object_idr,
		handles[i]);
		if (!bo) {
		@@ -307,7 +296,7 @@ v3d_cl_lookup_bos(struct drm_device *dev,
		goto fail;
		}
		drm_gem_object_get(bo);
		exec->bo[i] = bo;
		job->bo[i] = bo;
		}
		spin_unlock(&file_priv->table_lock);

		@@ -317,67 +306,44 @@ fail:
		}

		static void
		v3d_exec_cleanup(struct kref *ref)
		v3d_job_free(struct kref *ref)
		{
		struct v3d_exec_info *exec = container_of(ref, struct v3d_exec_info,
		refcount);
		struct v3d_dev *v3d = exec->v3d;
		unsigned int i;
		struct v3d_bo bo, save;

		dma_fence_put(exec->bin.in_fence);
		dma_fence_put(exec->render.in_fence);

		dma_fence_put(exec->bin.irq_fence);
		dma_fence_put(exec->render.irq_fence);

		dma_fence_put(exec->bin_done_fence);
		dma_fence_put(exec->render_done_fence);

		for (i = 0; i < exec->bo_count; i++)
		drm_gem_object_put_unlocked(exec->bo[i]);
		kvfree(exec->bo);
		struct v3d_job *job = container_of(ref, struct v3d_job, refcount);
		int i;

		list_for_each_entry_safe(bo, save, &exec->unref_list, unref_head) {
		drm_gem_object_put_unlocked(&bo->base.base);
		for (i = 0; i < job->bo_count; i++) {
		if (job->bo[i])
		drm_gem_object_put_unlocked(job->bo[i]);
		}
		kvfree(job->bo);

		pm_runtime_mark_last_busy(v3d->dev);
		pm_runtime_put_autosuspend(v3d->dev);
		dma_fence_put(job->in_fence);
		dma_fence_put(job->irq_fence);
		dma_fence_put(job->done_fence);

		kfree(exec);
		}
		pm_runtime_mark_last_busy(job->v3d->dev);
		pm_runtime_put_autosuspend(job->v3d->dev);

		void v3d_exec_put(struct v3d_exec_info *exec)
		{
		kref_put(&exec->refcount, v3d_exec_cleanup);
		kfree(job);
		}

		static void
		v3d_tfu_job_cleanup(struct kref *ref)
		v3d_render_job_free(struct kref *ref)
		{
		struct v3d_tfu_job *job = container_of(ref, struct v3d_tfu_job,
		refcount);
		struct v3d_dev *v3d = job->v3d;
		unsigned int i;

		dma_fence_put(job->in_fence);
		dma_fence_put(job->irq_fence);
		struct v3d_render_job *job = container_of(ref, struct v3d_render_job,
		base.refcount);
		struct v3d_bo bo, save;

		for (i = 0; i < ARRAY_SIZE(job->bo); i++) {
		if (job->bo[i])
		drm_gem_object_put_unlocked(job->bo[i]);
		list_for_each_entry_safe(bo, save, &job->unref_list, unref_head) {
		drm_gem_object_put_unlocked(&bo->base.base);
		}

		pm_runtime_mark_last_busy(v3d->dev);
		pm_runtime_put_autosuspend(v3d->dev);

		kfree(job);
		v3d_job_free(ref);
		}

		void v3d_tfu_job_put(struct v3d_tfu_job *job)
		void v3d_job_put(struct v3d_job *job)
		{
		kref_put(&job->refcount, v3d_tfu_job_cleanup);
		kref_put(&job->refcount, job->free);
		}

		int
		@@ -413,6 +379,77 @@ v3d_wait_bo_ioctl(struct drm_device dev, void data,
		return ret;
		}

		static int
		v3d_job_init(struct v3d_dev v3d, struct drm_file file_priv,
		struct v3d_job job, void (free)(struct kref *ref),
		u32 in_sync)
		{
		int ret;

		job->v3d = v3d;
		job->free = free;

		ret = pm_runtime_get_sync(v3d->dev);
		if (ret < 0)
		return ret;

		ret = drm_syncobj_find_fence(file_priv, in_sync, 0, 0, &job->in_fence);
		if (ret == -EINVAL) {
		pm_runtime_put_autosuspend(v3d->dev);
		return ret;
		}

		kref_init(&job->refcount);

		return 0;
		}

		static int
		v3d_push_job(struct v3d_file_priv *v3d_priv,
		struct v3d_job *job, enum v3d_queue queue)
		{
		int ret;

		ret = drm_sched_job_init(&job->base, &v3d_priv->sched_entity[queue],
		v3d_priv);
		if (ret)
		return ret;

		job->done_fence = dma_fence_get(&job->base.s_fence->finished);

		/* put by scheduler job completion */
		kref_get(&job->refcount);

		drm_sched_entity_push_job(&job->base, &v3d_priv->sched_entity[queue]);

		return 0;
		}

		static void
		v3d_attach_fences_and_unlock_reservation(struct drm_file *file_priv,
		struct v3d_job *job,
		struct ww_acquire_ctx *acquire_ctx,
		u32 out_sync)
		{
		struct drm_syncobj *sync_out;
		int i;

		for (i = 0; i < job->bo_count; i++) {
		/* XXX: Use shared fences for read-only objects. */
		reservation_object_add_excl_fence(job->bo[i]->resv,
		job->done_fence);
		}

		drm_gem_unlock_reservations(job->bo, job->bo_count, acquire_ctx);

		/* Update the return sync object for the job */
		sync_out = drm_syncobj_find(file_priv, out_sync);
		if (sync_out) {
		drm_syncobj_replace_fence(sync_out, job->done_fence);
		drm_syncobj_put(sync_out);
		}
		}

		/**
		* v3d_submit_cl_ioctl() - Submits a job (frame) to the V3D.
		* @dev: DRM device
		@@ -432,9 +469,9 @@ v3d_submit_cl_ioctl(struct drm_device dev, void data,
		struct v3d_dev *v3d = to_v3d_dev(dev);
		struct v3d_file_priv *v3d_priv = file_priv->driver_priv;
		struct drm_v3d_submit_cl *args = data;
		struct v3d_exec_info *exec;
		struct v3d_bin_job *bin = NULL;
		struct v3d_render_job *render;
		struct ww_acquire_ctx acquire_ctx;
		struct drm_syncobj *sync_out;
		int ret = 0;

		trace_v3d_submit_cl_ioctl(&v3d->drm, args->rcl_start, args->rcl_end);
		@@ -444,100 +481,83 @@ v3d_submit_cl_ioctl(struct drm_device dev, void data,
		return -EINVAL;
		}

		exec = kcalloc(1, sizeof(*exec), GFP_KERNEL);
		if (!exec)
		render = kcalloc(1, sizeof(*render), GFP_KERNEL);
		if (!render)
		return -ENOMEM;

		ret = pm_runtime_get_sync(v3d->dev);
		if (ret < 0) {
		kfree(exec);
		render->start = args->rcl_start;
		render->end = args->rcl_end;
		INIT_LIST_HEAD(&render->unref_list);

		ret = v3d_job_init(v3d, file_priv, &render->base,
		v3d_render_job_free, args->in_sync_rcl);
		if (ret) {
		kfree(render);
		return ret;
		}

		kref_init(&exec->refcount);
		if (args->bcl_start != args->bcl_end) {
		bin = kcalloc(1, sizeof(*bin), GFP_KERNEL);
		if (!bin)
		return -ENOMEM;

		ret = drm_syncobj_find_fence(file_priv, args->in_sync_bcl,
		0, 0, &exec->bin.in_fence);
		if (ret == -EINVAL)
		goto fail;
		ret = v3d_job_init(v3d, file_priv, &bin->base,
		v3d_job_free, args->in_sync_bcl);
		if (ret) {
		v3d_job_put(&render->base);
		return ret;
		}

		ret = drm_syncobj_find_fence(file_priv, args->in_sync_rcl,
		0, 0, &exec->render.in_fence);
		if (ret == -EINVAL)
		goto fail;
		bin->start = args->bcl_start;
		bin->end = args->bcl_end;
		bin->qma = args->qma;
		bin->qms = args->qms;
		bin->qts = args->qts;
		bin->render = render;
		}

		exec->qma = args->qma;
		exec->qms = args->qms;
		exec->qts = args->qts;
		exec->bin.exec = exec;
		exec->bin.start = args->bcl_start;
		exec->bin.end = args->bcl_end;
		exec->render.exec = exec;
		exec->render.start = args->rcl_start;
		exec->render.end = args->rcl_end;
		exec->v3d = v3d;
		INIT_LIST_HEAD(&exec->unref_list);

		ret = v3d_cl_lookup_bos(dev, file_priv, args, exec);
		ret = v3d_lookup_bos(dev, file_priv, &render->base,
		args->bo_handles, args->bo_handle_count);
		if (ret)
		goto fail;

		ret = v3d_lock_bo_reservations(exec->bo, exec->bo_count,
		ret = v3d_lock_bo_reservations(render->base.bo, render->base.bo_count,
		&acquire_ctx);
		if (ret)
		goto fail;

		mutex_lock(&v3d->sched_lock);
		if (exec->bin.start != exec->bin.end) {
		ret = drm_sched_job_init(&exec->bin.base,
		&v3d_priv->sched_entity[V3D_BIN],
		v3d_priv);
		if (bin) {
		ret = v3d_push_job(v3d_priv, &bin->base, V3D_BIN);
		if (ret)
		goto fail_unreserve;

		exec->bin_done_fence =
		dma_fence_get(&exec->bin.base.s_fence->finished);

		kref_get(&exec->refcount); /* put by scheduler job completion */
		drm_sched_entity_push_job(&exec->bin.base,
		&v3d_priv->sched_entity[V3D_BIN]);
		render->bin_done_fence = dma_fence_get(bin->base.done_fence);
		}

		ret = drm_sched_job_init(&exec->render.base,
		&v3d_priv->sched_entity[V3D_RENDER],
		v3d_priv);
		ret = v3d_push_job(v3d_priv, &render->base, V3D_RENDER);
		if (ret)
		goto fail_unreserve;

		exec->render_done_fence =
		dma_fence_get(&exec->render.base.s_fence->finished);

		kref_get(&exec->refcount); /* put by scheduler job completion */
		drm_sched_entity_push_job(&exec->render.base,
		&v3d_priv->sched_entity[V3D_RENDER]);
		mutex_unlock(&v3d->sched_lock);

		v3d_attach_object_fences(exec->bo, exec->bo_count,
		exec->render_done_fence);
		v3d_attach_fences_and_unlock_reservation(file_priv,
		&render->base, &acquire_ctx,
		args->out_sync);

		drm_gem_unlock_reservations(exec->bo, exec->bo_count, &acquire_ctx);

		/* Update the return sync object for the */
		sync_out = drm_syncobj_find(file_priv, args->out_sync);
		if (sync_out) {
		drm_syncobj_replace_fence(sync_out, exec->render_done_fence);
		drm_syncobj_put(sync_out);
		}

		v3d_exec_put(exec);
		if (bin)
		v3d_job_put(&bin->base);
		v3d_job_put(&render->base);

		return 0;

		fail_unreserve:
		mutex_unlock(&v3d->sched_lock);
		drm_gem_unlock_reservations(exec->bo, exec->bo_count, &acquire_ctx);
		drm_gem_unlock_reservations(render->base.bo,
		render->base.bo_count, &acquire_ctx);
		fail:
		v3d_exec_put(exec);
		if (bin)
		v3d_job_put(&bin->base);
		v3d_job_put(&render->base);

		return ret;
		}
		@@ -560,10 +580,7 @@ v3d_submit_tfu_ioctl(struct drm_device dev, void data,
		struct drm_v3d_submit_tfu *args = data;
		struct v3d_tfu_job *job;
		struct ww_acquire_ctx acquire_ctx;
		struct drm_syncobj *sync_out;
		struct dma_fence *sched_done_fence;
		int ret = 0;
		int bo_count;

		trace_v3d_submit_tfu_ioctl(&v3d->drm, args->iia);

		@@ -571,81 +588,71 @@ v3d_submit_tfu_ioctl(struct drm_device dev, void data,
		if (!job)
		return -ENOMEM;

		ret = pm_runtime_get_sync(v3d->dev);
		if (ret < 0) {
		ret = v3d_job_init(v3d, file_priv, &job->base,
		v3d_job_free, args->in_sync);
		if (ret) {
		kfree(job);
		return ret;
		}

		kref_init(&job->refcount);

		ret = drm_syncobj_find_fence(file_priv, args->in_sync,
		0, 0, &job->in_fence);
		if (ret == -EINVAL)
		goto fail;
		job->base.bo = kcalloc(ARRAY_SIZE(args->bo_handles),
		sizeof(*job->base.bo), GFP_KERNEL);
		if (!job->base.bo) {
		v3d_job_put(&job->base);
		return -ENOMEM;
		}

		job->args = *args;
		job->v3d = v3d;

		spin_lock(&file_priv->table_lock);
		for (bo_count = 0; bo_count < ARRAY_SIZE(job->bo); bo_count++) {
		for (job->base.bo_count = 0;
		job->base.bo_count < ARRAY_SIZE(args->bo_handles);
		job->base.bo_count++) {
		struct drm_gem_object *bo;

		if (!args->bo_handles[bo_count])
		if (!args->bo_handles[job->base.bo_count])
		break;

		bo = idr_find(&file_priv->object_idr,
		args->bo_handles[bo_count]);
		args->bo_handles[job->base.bo_count]);
		if (!bo) {
		DRM_DEBUG("Failed to look up GEM BO %d: %d\n",
		bo_count, args->bo_handles[bo_count]);
		job->base.bo_count,
		args->bo_handles[job->base.bo_count]);
		ret = -ENOENT;
		spin_unlock(&file_priv->table_lock);
		goto fail;
		}
		drm_gem_object_get(bo);
		job->bo[bo_count] = bo;
		job->base.bo[job->base.bo_count] = bo;
		}
		spin_unlock(&file_priv->table_lock);

		ret = v3d_lock_bo_reservations(job->bo, bo_count, &acquire_ctx);
		ret = v3d_lock_bo_reservations(job->base.bo, job->base.bo_count,
		&acquire_ctx);
		if (ret)
		goto fail;

		mutex_lock(&v3d->sched_lock);
		ret = drm_sched_job_init(&job->base,
		&v3d_priv->sched_entity[V3D_TFU],
		v3d_priv);
		ret = v3d_push_job(v3d_priv, &job->base, V3D_TFU);
		if (ret)
		goto fail_unreserve;

		sched_done_fence = dma_fence_get(&job->base.s_fence->finished);

		kref_get(&job->refcount); /* put by scheduler job completion */
		drm_sched_entity_push_job(&job->base, &v3d_priv->sched_entity[V3D_TFU]);
		mutex_unlock(&v3d->sched_lock);

		v3d_attach_object_fences(job->bo, bo_count, sched_done_fence);
		v3d_attach_fences_and_unlock_reservation(file_priv,
		&job->base, &acquire_ctx,
		args->out_sync);

		drm_gem_unlock_reservations(job->bo, bo_count, &acquire_ctx);

		/* Update the return sync object */
		sync_out = drm_syncobj_find(file_priv, args->out_sync);
		if (sync_out) {
		drm_syncobj_replace_fence(sync_out, sched_done_fence);
		drm_syncobj_put(sync_out);
		}
		dma_fence_put(sched_done_fence);

		v3d_tfu_job_put(job);
		v3d_job_put(&job->base);

		return 0;

		fail_unreserve:
		mutex_unlock(&v3d->sched_lock);
		drm_gem_unlock_reservations(job->bo, bo_count, &acquire_ctx);
		drm_gem_unlock_reservations(job->base.bo, job->base.bo_count,
		&acquire_ctx);
		fail:
		v3d_tfu_job_put(job);
		v3d_job_put(&job->base);

		return ret;
		}
		@@ -703,7 +710,7 @@ v3d_gem_destroy(struct drm_device *dev)

		v3d_sched_fini(v3d);

		/* Waiting for exec to finish would need to be done before
		/* Waiting for jobs to finish would need to be done before
		* unregistering V3D.
		*/
		WARN_ON(v3d->bin_job);

drivers/gpu/drm/v3d/v3d_irq.c

+4 −4

Original line number	Diff line number	Diff line
		@@ -62,7 +62,7 @@ v3d_overflow_mem_work(struct work_struct *work)
		}

		drm_gem_object_get(obj);
		list_add_tail(&bo->unref_head, &v3d->bin_job->unref_list);
		list_add_tail(&bo->unref_head, &v3d->bin_job->render->unref_list);
		spin_unlock_irqrestore(&v3d->job_lock, irqflags);

		V3D_CORE_WRITE(0, V3D_PTB_BPOA, bo->node.start << PAGE_SHIFT);
		@@ -96,7 +96,7 @@ v3d_irq(int irq, void *arg)

		if (intsts & V3D_INT_FLDONE) {
		struct v3d_fence *fence =
		to_v3d_fence(v3d->bin_job->bin.irq_fence);
		to_v3d_fence(v3d->bin_job->base.irq_fence);

		trace_v3d_bcl_irq(&v3d->drm, fence->seqno);
		dma_fence_signal(&fence->base);
		@@ -105,7 +105,7 @@ v3d_irq(int irq, void *arg)

		if (intsts & V3D_INT_FRDONE) {
		struct v3d_fence *fence =
		to_v3d_fence(v3d->render_job->render.irq_fence);
		to_v3d_fence(v3d->render_job->base.irq_fence);

		trace_v3d_rcl_irq(&v3d->drm, fence->seqno);
		dma_fence_signal(&fence->base);
		@@ -141,7 +141,7 @@ v3d_hub_irq(int irq, void *arg)

		if (intsts & V3D_HUB_INT_TFUC) {
		struct v3d_fence *fence =
		to_v3d_fence(v3d->tfu_job->irq_fence);
		to_v3d_fence(v3d->tfu_job->base.irq_fence);

		trace_v3d_tfu_irq(&v3d->drm, fence->seqno);
		dma_fence_signal(&fence->base);

drivers/gpu/drm/v3d/v3d_sched.c

+151 −108

File changed.

Preview size limit exceeded, changes collapsed.

Admin message