Skip to contentSkip to conversation

drm/tegra: Introduce a modern UABI

PATCH In review Thierry Reding 3 participants 23 messages Jul 9, 2021 – Jul 30, 2021

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

v8 cover drm/tegra: Introduce a modern UABI

From: Thierry Reding <[email protected]>

Hi all,

Mikko has been away for a few weeks, so I've been testing and revising the new UABI patches in the meantime. There are very minor changes to the naming of some of the UABI fields, but other than that it's mostly unchanged from v7.

One notable change is that mappings can now be read-only, write-only, read-write or none of them (rather than just read-only or read-write), since those combinations are all supported by the IOMMUs and it might be useful to make some mappings write-only.

For a full list of changes in v8, see the changelog in patch 6.

I've also updated the libdrm_tegra library to work against this version of the UABI. A branch can be found here:

https://gitlab.freedesktop.org/tagr/drm/-/commits/drm-tegra-uabi-v8

That contains helper APIs for the concepts introduced in this series and shows how they can be used in various tests that can be run for sanity checking.

In addition, Mikko has made updates to the following projects, though they may need to be updated for the minor changes in v8:

* vaapi-tegra-driver - https://github.com/cyndis/vaapi-tegra-driver
Experimental support for MPEG2 and H264 decoding on T210, T186 and T194.

* xf86-video-opentegra - https://github.com/grate-driver/xf86-video-opentegra
X11 userspace acceleration driver for Tegra20, Tegra30, and Tegra114.

* grate - https://github.com/grate-driver/grate
3D rendering testbed for Tegra20, Tegra30, and Tegra114

I plan on putting this into linux-next soon after v5.14-rc1 so that this can get some soak time.

Thierry

Mikko Perttunen (14):
gpu: host1x: Add DMA fence implementation
gpu: host1x: Add no-recovery mode
gpu: host1x: Add job release callback
gpu: host1x: Add support for syncpoint waits in CDMA pushbuffer drm/tegra: Extract tegra_gem_lookup
drm/tegra: Add new UAPI to header
drm/tegra: Boot VIC during runtime PM resume drm/tegra: Allocate per-engine channel in core code drm/tegra: Implement new UAPI
drm/tegra: Implement syncpoint management UAPI drm/tegra: Implement syncpoint wait UAPI
drm/tegra: Implement job submission part of new UAPI drm/tegra: Add job firewall
drm/tegra: Bump driver version

 drivers/gpu/drm/tegra/Makefile             |   4 +
 drivers/gpu/drm/tegra/drm.c                |  82 ++--
 drivers/gpu/drm/tegra/drm.h                |  12 +
 drivers/gpu/drm/tegra/firewall.c           | 254 ++++++++++
 drivers/gpu/drm/tegra/gather_bo.c          |  81 ++++
 drivers/gpu/drm/tegra/gather_bo.h          |  22 +
 drivers/gpu/drm/tegra/gem.c                |  13 +
 drivers/gpu/drm/tegra/gem.h                |   2 +
 drivers/gpu/drm/tegra/submit.c             | 527 +++++++++++++++++++++
 drivers/gpu/drm/tegra/submit.h             |  21 +
 drivers/gpu/drm/tegra/uapi.c               | 387 +++++++++++++++
 drivers/gpu/drm/tegra/uapi.h               |  58 +++
 drivers/gpu/drm/tegra/vic.c                | 112 ++---
 drivers/gpu/host1x/Makefile                |   1 +
 drivers/gpu/host1x/cdma.c                  |  58 ++-
 drivers/gpu/host1x/fence.c                 | 209 ++++++++
 drivers/gpu/host1x/fence.h                 |  13 +
 drivers/gpu/host1x/hw/channel_hw.c         |  87 +++-
 drivers/gpu/host1x/hw/debug_hw.c           |   9 +-
 drivers/gpu/host1x/hw/hw_host1x02_uclass.h |  12 +
 drivers/gpu/host1x/hw/hw_host1x04_uclass.h |  12 +
 drivers/gpu/host1x/hw/hw_host1x05_uclass.h |  12 +
 drivers/gpu/host1x/hw/hw_host1x06_uclass.h |  12 +
 drivers/gpu/host1x/hw/hw_host1x07_uclass.h |  12 +
 drivers/gpu/host1x/intr.c                  |   9 +
 drivers/gpu/host1x/intr.h                  |   2 +
 drivers/gpu/host1x/job.c                   |  77 ++-
 drivers/gpu/host1x/job.h                   |  16 +
 drivers/gpu/host1x/syncpt.c                |   2 +
 drivers/gpu/host1x/syncpt.h                |  12 +
 include/linux/host1x.h                     |  22 +-
 include/uapi/drm/tegra_drm.h               | 425 ++++++++++++++++-
 32 files changed, 2408 insertions(+), 169 deletions(-)
 create mode 100644 drivers/gpu/drm/tegra/firewall.c
 create mode 100644 drivers/gpu/drm/tegra/gather_bo.c
 create mode 100644 drivers/gpu/drm/tegra/gather_bo.h
 create mode 100644 drivers/gpu/drm/tegra/submit.c
 create mode 100644 drivers/gpu/drm/tegra/submit.h
 create mode 100644 drivers/gpu/drm/tegra/uapi.c
 create mode 100644 drivers/gpu/drm/tegra/uapi.h
 create mode 100644 drivers/gpu/host1x/fence.c
 create mode 100644 drivers/gpu/host1x/fence.h
Signature · 1 line
2.32.0
#1 lore raw

PATCH v8 1/14 gpu: host1x: Add DMA fence implementation

From: Mikko Perttunen <[email protected]>

Add an implementation of dma_fences based on syncpoints. Syncpoint interrupts are used to signal fences. Additionally, after software signaling has been enabled, a 30 second timeout is started. If the syncpoint threshold is not reached within this period, the fence is signalled with an -ETIMEDOUT error code. This is to allow fences that would never reach their syncpoint threshold to be cleaned up. The timeout can potentially be removed in the future after job tracking code has been refactored.

---
 drivers/gpu/host1x/Makefile |   1 +
 drivers/gpu/host1x/fence.c  | 209 ++++++++++++++++++++++++++++++++++++
 drivers/gpu/host1x/fence.h  |  13 +++
 drivers/gpu/host1x/intr.c   |   9 ++
 drivers/gpu/host1x/intr.h   |   2 +
 include/linux/host1x.h      |   3 +
 6 files changed, 237 insertions(+)
 create mode 100644 drivers/gpu/host1x/fence.c
 create mode 100644 drivers/gpu/host1x/fence.h
drivers/gpu/host1x/Makefile +1 -0
index 096017b8789d..d2b6f7de0498 100644
@@ -9,6 +9,7 @@ host1x-y = \
 	job.o \
 	debug.o \
 	mipi.o \
+	fence.o \
 	hw/host1x01.o \
 	hw/host1x02.o \
 	hw/host1x04.o \
drivers/gpu/host1x/fence.c new file +209 -0

209 lines not on this page · raw message

drivers/gpu/host1x/fence.h new file +13 -0
new file mode 100644
index 000000000000..70c91de82f14
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2020, NVIDIA Corporation.
+ */
+
+#ifndef HOST1X_FENCE_H
+#define HOST1X_FENCE_H
+
+struct host1x_syncpt_fence;
+
+void host1x_fence_signal(struct host1x_syncpt_fence *fence);
+
+#endif
drivers/gpu/host1x/intr.c +9 -0
index 6d1f3c0fdbe7..45b6be927ec4 100644
@@ -13,6 +13,7 @@
 #include <trace/events/host1x.h>
 #include "channel.h"
 #include "dev.h"
+#include "fence.h"
 #include "intr.h"
 
 /* Wait list management */
@@ -121,12 +122,20 @@ static void action_wakeup_interruptible(struct host1x_waitlist *waiter)
 	wake_up_interruptible(wq);
 }
 
+static void action_signal_fence(struct host1x_waitlist *waiter)
+{
+	struct host1x_syncpt_fence *f = waiter->data;
+
+	host1x_fence_signal(f);
+}
+
 typedef void (*action_handler)(struct host1x_waitlist *waiter);
 
 static const action_handler action_handlers[HOST1X_INTR_ACTION_COUNT] = {
 	action_submit_complete,
 	action_wakeup,
 	action_wakeup_interruptible,
+	action_signal_fence,
 };
 
 static void run_handlers(struct list_head completed[HOST1X_INTR_ACTION_COUNT])
drivers/gpu/host1x/intr.h +2 -0
index 6ea55e615e3a..e4c346099273 100644
@@ -33,6 +33,8 @@ enum host1x_intr_action {
 	 */
 	HOST1X_INTR_ACTION_WAKEUP_INTERRUPTIBLE,
 
+	HOST1X_INTR_ACTION_SIGNAL_FENCE,
+
 	HOST1X_INTR_ACTION_COUNT
 };
 
include/linux/host1x.h +3 -0
index 9b0487c88571..59e4a3bea0b0 100644
@@ -170,6 +170,9 @@ u32 host1x_syncpt_base_id(struct host1x_syncpt_base *base);
 void host1x_syncpt_release_vblank_reservation(struct host1x_client *client,
 					      u32 syncpt_id);
 
+struct dma_fence *host1x_fence_create(struct host1x_syncpt *sp, u32 threshold);
+int host1x_fence_extract(struct dma_fence *fence, u32 *id, u32 *threshold);
+
 /*
  * host1x channel
  */
Signature · 1 line
2.32.0
#2 lore raw

Re: [PATCH v8 01/14] gpu: host1x: Add DMA fence implementation

09.07.2021 22:31, Thierry Reding пишет:

Quoted 14 lines
drivers/gpu/host1x/fence.c new file +8 -0
new file mode 100644
index 000000000000..06c6b86237bd
@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Syncpoint dma_fence implementation
+ *
+ * Copyright (c) 2020, NVIDIA Corporation.
+ */
+
+#include <linux/dma-fence.h>

drivers/gpu/host1x/fence.c line 18

Quoted 10 lines
drivers/gpu/host1x/fence.c new file +10 -0
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/sync_file.h>
+
+#include "fence.h"
+#include "intr.h"
+#include "syncpt.h"
+
+DEFINE_SPINLOCK(lock);

*static*

#3 lore raw

PATCH v8 2/14 gpu: host1x: Add no-recovery mode

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Add a new property for jobs to enable or disable recovery i.e. CPU increments of syncpoints to max value on job timeout. This allows for a more solid model for hanged jobs, where userspace doesn't need to guess if a syncpoint increment happened because the job completed, or because job timeout was triggered.

On job timeout, we stop the channel, NOP all future jobs on the channel using the same syncpoint, mark the syncpoint as locked and resume the channel from the next job, if any.

The future jobs are NOPed, since because we don't do the CPU increments, the value of the syncpoint is no longer synchronized, and any waiters would become confused if a future job incremented the syncpoint. The syncpoint is marked locked to ensure that any future jobs cannot increment the syncpoint either, until the application has recognized the situation and reallocated the syncpoint.

---
 drivers/gpu/drm/tegra/drm.c        |  1 +
 drivers/gpu/host1x/cdma.c          | 58 ++++++++++++++++++++++++++----
 drivers/gpu/host1x/hw/channel_hw.c |  2 +-
 drivers/gpu/host1x/job.c           |  4 +++
 drivers/gpu/host1x/syncpt.c        |  2 ++
 drivers/gpu/host1x/syncpt.h        | 12 +++++++
 include/linux/host1x.h             |  9 +++++
 7 files changed, 81 insertions(+), 7 deletions(-)
drivers/gpu/drm/tegra/drm.c +1 -0
index f96c237b2242..739250acd498 100644
@@ -201,6 +201,7 @@ int tegra_drm_submit(struct tegra_drm_context *context,
 	job->client = client;
 	job->class = client->class;
 	job->serialize = true;
+	job->syncpt_recovery = true;
 
 	/*
 	 * Track referenced BOs so that they can be unreferenced after the
drivers/gpu/host1x/cdma.c +52 -6

91 lines not on this page · raw message

drivers/gpu/host1x/hw/channel_hw.c +1 -1
index d4c28faf27d1..bf21512e5078 100644
@@ -191,7 +191,7 @@ static int channel_submit(struct host1x_job *job)
 	/* schedule a submit complete interrupt */
 	err = host1x_intr_add_action(host, sp, syncval,
 				     HOST1X_INTR_ACTION_SUBMIT_COMPLETE, ch,
-				     completed_waiter, NULL);
+				     completed_waiter, &job->waiter);
 	completed_waiter = NULL;
 	WARN(err, "Failed to set submit complete interrupt");
 
drivers/gpu/host1x/job.c +4 -0
index adbdc225de8d..8f59b34672c2 100644
@@ -79,6 +79,10 @@ static void job_free(struct kref *ref)
 {
 	struct host1x_job *job = container_of(ref, struct host1x_job, ref);
 
+	if (job->waiter)
+		host1x_intr_put_ref(job->syncpt->host, job->syncpt->id,
+				    job->waiter, false);
+
 	if (job->syncpt)
 		host1x_syncpt_put(job->syncpt);
 
drivers/gpu/host1x/syncpt.c +2 -0
index e648ebbb2027..d198a10848c6 100644
@@ -407,6 +407,8 @@ static void syncpt_release(struct kref *ref)
 
 	atomic_set(&sp->max_val, host1x_syncpt_read(sp));
 
+	sp->locked = false;
+
 	mutex_lock(&sp->host->syncpt_mutex);
 
 	host1x_syncpt_base_free(sp->base);
drivers/gpu/host1x/syncpt.h +12 -0
index a6766f8d55ee..93e894677d89 100644
@@ -40,6 +40,13 @@ struct host1x_syncpt {
 
 	/* interrupt data */
 	struct host1x_syncpt_intr intr;
+
+	/* 
+	 * If a submission incrementing this syncpoint fails, lock it so that
+	 * further submission cannot be made until application has handled the
+	 * failure.
+	 */
+	bool locked;
 };
 
 /* Initialize sync point array  */
@@ -115,4 +122,9 @@ static inline int host1x_syncpt_is_valid(struct host1x_syncpt *sp)
 	return sp->id < host1x_syncpt_nb_pts(sp->host);
 }
 
+static inline void host1x_syncpt_set_locked(struct host1x_syncpt *sp)
+{
+	sp->locked = true;
+}
+
 #endif
include/linux/host1x.h +9 -0
index 59e4a3bea0b0..5fc12db94ca1 100644
@@ -237,9 +237,15 @@ struct host1x_job {
 	u32 syncpt_incrs;
 	u32 syncpt_end;
 
+	/* Completion waiter ref */
+	void *waiter;
+
 	/* Maximum time to wait for this job */
 	unsigned int timeout;
 
+	/* Job has timed out and should be released */
+	bool cancelled;
+
 	/* Index and number of slots used in the push buffer */
 	unsigned int first_get;
 	unsigned int num_slots;
@@ -260,6 +266,9 @@ struct host1x_job {
 
 	/* Add a channel wait for previous ops to complete */
 	bool serialize;
+
+	/* Fast-forward syncpoint increments on job timeout */
+	bool syncpt_recovery;
 };
 
 struct host1x_job *host1x_job_alloc(struct host1x_channel *ch,
Signature · 1 line
2.32.0
#4 lore raw

PATCH v8 3/14 gpu: host1x: Add job release callback

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Add a callback field to the job structure, to be called just before the job is to be freed. This allows the job's submitter to clean up any of its own state, like decrement runtime PM refcounts.

---
 drivers/gpu/host1x/job.c | 3 +++
 include/linux/host1x.h   | 4 ++++
 2 files changed, 7 insertions(+)
drivers/gpu/host1x/job.c +3 -0
index 8f59b34672c2..09097e19c0d0 100644
@@ -79,6 +79,9 @@ static void job_free(struct kref *ref)
 {
 	struct host1x_job *job = container_of(ref, struct host1x_job, ref);
 
+	if (job->release)
+		job->release(job);
+
 	if (job->waiter)
 		host1x_intr_put_ref(job->syncpt->host, job->syncpt->id,
 				    job->waiter, false);
include/linux/host1x.h +4 -0
index 5fc12db94ca1..7eecb0aa2519 100644
@@ -269,6 +269,10 @@ struct host1x_job {
 
 	/* Fast-forward syncpoint increments on job timeout */
 	bool syncpt_recovery;
+
+	/* Callback called when job is freed */
+	void (*release)(struct host1x_job *job);
+	void *user_data;
 };
 
 struct host1x_job *host1x_job_alloc(struct host1x_channel *ch,
Signature · 1 line
2.32.0
#5 lore raw

PATCH v8 4/14 gpu: host1x: Add support for syncpoint waits in CDMA pushbuffer

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Add support for inserting syncpoint waits in the CDMA pushbuffer. These waits need to be done in HOST1X class, while gather submitted by the application execute in engine class.

Support is added by converting the gather list of job into a command list that can include both gathers and waits. When the job is submitted, these commands are pushed as the appropriate opcodes on the CDMA pushbuffer.

Also supported are waits relative to the start of the job, which are useful for jobs doing multiple things with an engine that doesn't natively support pipelining.

While at it, use 32-bit waits on chips that support them.

---
 drivers/gpu/host1x/hw/channel_hw.c         | 85 +++++++++++++++++-----
 drivers/gpu/host1x/hw/debug_hw.c           |  9 ++-
 drivers/gpu/host1x/hw/hw_host1x02_uclass.h | 12 +++
 drivers/gpu/host1x/hw/hw_host1x04_uclass.h | 12 +++
 drivers/gpu/host1x/hw/hw_host1x05_uclass.h | 12 +++
 drivers/gpu/host1x/hw/hw_host1x06_uclass.h | 12 +++
 drivers/gpu/host1x/hw/hw_host1x07_uclass.h | 12 +++
 drivers/gpu/host1x/job.c                   | 70 +++++++++++++-----
 drivers/gpu/host1x/job.h                   | 16 ++++
 include/linux/host1x.h                     |  6 +-
 10 files changed, 203 insertions(+), 43 deletions(-)
drivers/gpu/host1x/hw/channel_hw.c +65 -20
index bf21512e5078..1999780a7203 100644
@@ -47,39 +47,84 @@ static void trace_write_gather(struct host1x_cdma *cdma, struct host1x_bo *bo,
 	}
 }
 
-static void submit_gathers(struct host1x_job *job)
+static void submit_wait(struct host1x_cdma *cdma, u32 id, u32 threshold,
+			u32 next_class)
+{
+#if HOST1X_HW >= 2
+	host1x_cdma_push_wide(cdma,
+		host1x_opcode_setclass(
+			HOST1X_CLASS_HOST1X,
+			HOST1X_UCLASS_LOAD_SYNCPT_PAYLOAD_32,
+			/* WAIT_SYNCPT_32 is at SYNCPT_PAYLOAD_32+2 */
+			BIT(0) | BIT(2)
+		),
+		threshold,
+		id,
+		host1x_opcode_setclass(next_class, 0, 0)
+	);
+#else
+	/* TODO add waitchk or use waitbases or other mitigation */
+	host1x_cdma_push(cdma,
+		host1x_opcode_setclass(
+			HOST1X_CLASS_HOST1X,
+			host1x_uclass_wait_syncpt_r(),
+			BIT(0)
+		),
+		host1x_class_host_wait_syncpt(id, threshold)
+	);
+	host1x_cdma_push(cdma,
+		host1x_opcode_setclass(next_class, 0, 0),
+		HOST1X_OPCODE_NOP
+	);
+#endif
+}
+
+static void submit_gathers(struct host1x_job *job, u32 job_syncpt_base)
 {
 	struct host1x_cdma *cdma = &job->channel->cdma;
 #if HOST1X_HW < 6
 	struct device *dev = job->channel->dev;
 #endif
 	unsigned int i;
+	u32 threshold;
 
-	for (i = 0; i < job->num_gathers; i++) {
-		struct host1x_job_gather *g = &job->gathers[i];
-		dma_addr_t addr = g->base + g->offset;
-		u32 op2, op3;
+	for (i = 0; i < job->num_cmds; i++) {
+		struct host1x_job_cmd *cmd = &job->cmds[i];
 
-		op2 = lower_32_bits(addr);
-		op3 = upper_32_bits(addr);
+		if (cmd->is_wait) {
+			if (cmd->wait.relative)
+				threshold = job_syncpt_base + cmd->wait.threshold;
+			else
+				threshold = cmd->wait.threshold;
 
-		trace_write_gather(cdma, g->bo, g->offset, g->words);
+			submit_wait(cdma, cmd->wait.id, threshold, cmd->wait.next_class);
+		} else {
+			struct host1x_job_gather *g = &cmd->gather;
+
+			dma_addr_t addr = g->base + g->offset;
+			u32 op2, op3;
+
+			op2 = lower_32_bits(addr);
+			op3 = upper_32_bits(addr);
 
-		if (op3 != 0) {
+			trace_write_gather(cdma, g->bo, g->offset, g->words);
+
+			if (op3 != 0) {
 #if HOST1X_HW >= 6
-			u32 op1 = host1x_opcode_gather_wide(g->words);
-			u32 op4 = HOST1X_OPCODE_NOP;
+				u32 op1 = host1x_opcode_gather_wide(g->words);
+				u32 op4 = HOST1X_OPCODE_NOP;
 
-			host1x_cdma_push_wide(cdma, op1, op2, op3, op4);
+				host1x_cdma_push_wide(cdma, op1, op2, op3, op4);
 #else
-			dev_err(dev, "invalid gather for push buffer %pad\n",
-				&addr);
-			continue;
+				dev_err(dev, "invalid gather for push buffer %pad\n",
+					&addr);
+				continue;
 #endif
-		} else {
-			u32 op1 = host1x_opcode_gather(g->words);
+			} else {
+				u32 op1 = host1x_opcode_gather(g->words);
 
-			host1x_cdma_push(cdma, op1, op2);
+				host1x_cdma_push(cdma, op1, op2);
+			}
 		}
 	}
 }
@@ -126,7 +171,7 @@ static int channel_submit(struct host1x_job *job)
 	struct host1x *host = dev_get_drvdata(ch->dev->parent);
 
 	trace_host1x_channel_submit(dev_name(ch->dev),
-				    job->num_gathers, job->num_relocs,
+				    job->num_cmds, job->num_relocs,
 				    job->syncpt->id, job->syncpt_incrs);
 
 	/* before error checks, return current max */
@@ -181,7 +226,7 @@ static int channel_submit(struct host1x_job *job)
 				 host1x_opcode_setclass(job->class, 0, 0),
 				 HOST1X_OPCODE_NOP);
 
-	submit_gathers(job);
+	submit_gathers(job, syncval - user_syncpt_incrs);
 
 	/* end CDMA submit & stash pinned hMems into sync queue */
 	host1x_cdma_end(&ch->cdma, job);
drivers/gpu/host1x/hw/debug_hw.c +7 -2
index ceb48229d14b..35952fd5597e 100644
@@ -208,10 +208,15 @@ static void show_channel_gathers(struct output *o, struct host1x_cdma *cdma)
 				    job->first_get, job->timeout,
 				    job->num_slots, job->num_unpins);
 
-		for (i = 0; i < job->num_gathers; i++) {
-			struct host1x_job_gather *g = &job->gathers[i];
+		for (i = 0; i < job->num_cmds; i++) {
+			struct host1x_job_gather *g;
 			u32 *mapped;
 
+			if (job->cmds[i].is_wait)
+				continue;
+
+			g = &job->cmds[i].gather;
+
 			if (job->gather_copy_mapped)
 				mapped = (u32 *)job->gather_copy_mapped;
 			else
drivers/gpu/host1x/hw/hw_host1x02_uclass.h +12 -0
index 4fc51f70496b..0a2ab8f1da6f 100644
@@ -165,5 +165,17 @@ static inline u32 host1x_uclass_indoff_rwn_read_v(void)
 }
 #define HOST1X_UCLASS_INDOFF_INDROFFSET_F(v) \
 	host1x_uclass_indoff_indroffset_f(v)
+static inline u32 host1x_uclass_load_syncpt_payload_32_r(void)
+{
+	return 0x4e;
+}
+#define HOST1X_UCLASS_LOAD_SYNCPT_PAYLOAD_32 \
+	host1x_uclass_load_syncpt_payload_32_r()
+static inline u32 host1x_uclass_wait_syncpt_32_r(void)
+{
+	return 0x50;
+}
+#define HOST1X_UCLASS_WAIT_SYNCPT_32 \
+	host1x_uclass_wait_syncpt_32_r()
 
 #endif
drivers/gpu/host1x/hw/hw_host1x04_uclass.h +12 -0
index 9e84a4adca9f..60c692b92955 100644
@@ -165,5 +165,17 @@ static inline u32 host1x_uclass_indoff_rwn_read_v(void)
 }
 #define HOST1X_UCLASS_INDOFF_INDROFFSET_F(v) \
 	host1x_uclass_indoff_indroffset_f(v)
+static inline u32 host1x_uclass_load_syncpt_payload_32_r(void)
+{
+	return 0x4e;
+}
+#define HOST1X_UCLASS_LOAD_SYNCPT_PAYLOAD_32 \
+	host1x_uclass_load_syncpt_payload_32_r()
+static inline u32 host1x_uclass_wait_syncpt_32_r(void)
+{
+	return 0x50;
+}
+#define HOST1X_UCLASS_WAIT_SYNCPT_32 \
+	host1x_uclass_wait_syncpt_32_r()
 
 #endif
drivers/gpu/host1x/hw/hw_host1x05_uclass.h +12 -0
index aee5a4e32877..2fcc9a2ad3ef 100644
@@ -165,5 +165,17 @@ static inline u32 host1x_uclass_indoff_rwn_read_v(void)
 }
 #define HOST1X_UCLASS_INDOFF_INDROFFSET_F(v) \
 	host1x_uclass_indoff_indroffset_f(v)
+static inline u32 host1x_uclass_load_syncpt_payload_32_r(void)
+{
+	return 0x4e;
+}
+#define HOST1X_UCLASS_LOAD_SYNCPT_PAYLOAD_32 \
+	host1x_uclass_load_syncpt_payload_32_r()
+static inline u32 host1x_uclass_wait_syncpt_32_r(void)
+{
+	return 0x50;
+}
+#define HOST1X_UCLASS_WAIT_SYNCPT_32 \
+	host1x_uclass_wait_syncpt_32_r()
 
 #endif
drivers/gpu/host1x/hw/hw_host1x06_uclass.h +12 -0
index c4bacdb7155f..5f831438d19b 100644
@@ -165,5 +165,17 @@ static inline u32 host1x_uclass_indoff_rwn_read_v(void)
 }
 #define HOST1X_UCLASS_INDOFF_INDROFFSET_F(v) \
 	host1x_uclass_indoff_indroffset_f(v)
+static inline u32 host1x_uclass_load_syncpt_payload_32_r(void)
+{
+	return 0x4e;
+}
+#define HOST1X_UCLASS_LOAD_SYNCPT_PAYLOAD_32 \
+	host1x_uclass_load_syncpt_payload_32_r()
+static inline u32 host1x_uclass_wait_syncpt_32_r(void)
+{
+	return 0x50;
+}
+#define HOST1X_UCLASS_WAIT_SYNCPT_32 \
+	host1x_uclass_wait_syncpt_32_r()
 
 #endif
drivers/gpu/host1x/hw/hw_host1x07_uclass.h +12 -0
index c74070f3f203..8cd2ef087d5d 100644
@@ -165,5 +165,17 @@ static inline u32 host1x_uclass_indoff_rwn_read_v(void)
 }
 #define HOST1X_UCLASS_INDOFF_INDROFFSET_F(v) \
 	host1x_uclass_indoff_indroffset_f(v)
+static inline u32 host1x_uclass_load_syncpt_payload_32_r(void)
+{
+	return 0x4e;
+}
+#define HOST1X_UCLASS_LOAD_SYNCPT_PAYLOAD_32 \
+	host1x_uclass_load_syncpt_payload_32_r()
+static inline u32 host1x_uclass_wait_syncpt_32_r(void)
+{
+	return 0x50;
+}
+#define HOST1X_UCLASS_WAIT_SYNCPT_32 \
+	host1x_uclass_wait_syncpt_32_r()
 
 #endif
drivers/gpu/host1x/job.c +51 -19

148 lines not on this page · raw message

drivers/gpu/host1x/job.h +16 -0
index 94bc2e4ae241..b4428c5495c9 100644
@@ -18,6 +18,22 @@ struct host1x_job_gather {
 	bool handled;
 };
 
+struct host1x_job_wait {
+	u32 id;
+	u32 threshold;
+	u32 next_class;
+	bool relative;
+};
+
+struct host1x_job_cmd {
+	bool is_wait;
+
+	union {
+		struct host1x_job_gather gather;
+		struct host1x_job_wait wait;
+	};
+};
+
 struct host1x_job_unpin_data {
 	struct host1x_bo *bo;
 	struct sg_table *sgt;
include/linux/host1x.h +4 -2
index 7eecb0aa2519..9b6784708f2e 100644
@@ -219,8 +219,8 @@ struct host1x_job {
 	struct host1x_client *client;
 
 	/* Gathers and their memory */
-	struct host1x_job_gather *gathers;
-	unsigned int num_gathers;
+	struct host1x_job_cmd *cmds;
+	unsigned int num_cmds;
 
 	/* Array of handles to be pinned & unpinned */
 	struct host1x_reloc *relocs;
@@ -279,6 +279,8 @@ struct host1x_job *host1x_job_alloc(struct host1x_channel *ch,
 				    u32 num_cmdbufs, u32 num_relocs);
 void host1x_job_add_gather(struct host1x_job *job, struct host1x_bo *bo,
 			   unsigned int words, unsigned int offset);
+void host1x_job_add_wait(struct host1x_job *job, u32 id, u32 thresh,
+			 bool relative, u32 next_class);
 struct host1x_job *host1x_job_get(struct host1x_job *job);
 void host1x_job_put(struct host1x_job *job);
 int host1x_job_pin(struct host1x_job *job, struct device *dev);
Signature · 1 line
2.32.0
#6 lore raw

PATCH v8 5/14 drm/tegra: Extract tegra_gem_lookup

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

The static function host1x_bo_lookup in drm.c is also useful elsewhere. Extract it as tegra_gem_lookup in gem.c.

---
 drivers/gpu/drm/tegra/drm.c | 20 +++-----------------
 drivers/gpu/drm/tegra/gem.c | 13 +++++++++++++
 drivers/gpu/drm/tegra/gem.h |  2 ++
 3 files changed, 18 insertions(+), 17 deletions(-)
drivers/gpu/drm/tegra/drm.c +3 -17
index 739250acd498..87954e69ab6c 100644
@@ -107,20 +107,6 @@ static void tegra_drm_context_free(struct tegra_drm_context *context)
 	kfree(context);
 }
 
-static struct host1x_bo *
-host1x_bo_lookup(struct drm_file *file, u32 handle)
-{
-	struct drm_gem_object *gem;
-	struct tegra_bo *bo;
-
-	gem = drm_gem_object_lookup(file, handle);
-	if (!gem)
-		return NULL;
-
-	bo = to_tegra_bo(gem);
-	return &bo->base;
-}
-
 static int host1x_reloc_copy_from_user(struct host1x_reloc *dest,
 				       struct drm_tegra_reloc __user *src,
 				       struct drm_device *drm,
@@ -151,11 +137,11 @@ static int host1x_reloc_copy_from_user(struct host1x_reloc *dest,
 
 	dest->flags = HOST1X_RELOC_READ | HOST1X_RELOC_WRITE;
 
-	dest->cmdbuf.bo = host1x_bo_lookup(file, cmdbuf);
+	dest->cmdbuf.bo = tegra_gem_lookup(file, cmdbuf);
 	if (!dest->cmdbuf.bo)
 		return -ENOENT;
 
-	dest->target.bo = host1x_bo_lookup(file, target);
+	dest->target.bo = tegra_gem_lookup(file, target);
 	if (!dest->target.bo)
 		return -ENOENT;
 
@@ -238,7 +224,7 @@ int tegra_drm_submit(struct tegra_drm_context *context,
 			goto fail;
 		}
 
-		bo = host1x_bo_lookup(file, cmdbuf.handle);
+		bo = tegra_gem_lookup(file, cmdbuf.handle);
 		if (!bo) {
 			err = -ENOENT;
 			goto fail;
drivers/gpu/drm/tegra/gem.c +13 -0
index 26af8daa9a16..6ec598f5d5b3 100644
@@ -707,3 +707,16 @@ struct drm_gem_object *tegra_gem_prime_import(struct drm_device *drm,
 
 	return &bo->gem;
 }
+
+struct host1x_bo *tegra_gem_lookup(struct drm_file *file, u32 handle)
+{
+	struct drm_gem_object *gem;
+	struct tegra_bo *bo;
+
+	gem = drm_gem_object_lookup(file, handle);
+	if (!gem)
+		return NULL;
+
+	bo = to_tegra_bo(gem);
+	return &bo->base;
+}
drivers/gpu/drm/tegra/gem.h +2 -0
index c15fd99d6cb2..cb5146a67668 100644
@@ -80,4 +80,6 @@ struct dma_buf *tegra_gem_prime_export(struct drm_gem_object *gem,
 struct drm_gem_object *tegra_gem_prime_import(struct drm_device *drm,
 					      struct dma_buf *buf);
 
+struct host1x_bo *tegra_gem_lookup(struct drm_file *file, u32 handle);
+
 #endif
Signature · 1 line
2.32.0
#7 lore raw

PATCH v8 6/14 drm/tegra: Add new UAPI to header

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Update the tegra_drm.h UAPI header, adding the new proposed UAPI. The old staging UAPI is left in for now, with minor modification to avoid name collisions.

---
Changes in v8:
- renamed hardware_flags to capabilities (flags sounds like they can be user-specified)
- renamed hardware_version to just version
- consistently use "context" to refer to channels contexts
- allow channel mappings to be read-only or write-only (or neither)
- consistently use "mapping" (instead of "mapping_id")
- rename BLOCKLINEAR relocation flag to SECTOR_LAYOUT for a more accurate description of what it does
- cleanup submission syncpoint structure:
- drop _incr suffix for conciseness
- rename fence_value to just value
- rename num_incrs to increments
- rename syncpoint threshold to value for consistency
- add padding to make all structures 64-bit aligned

 include/uapi/drm/tegra_drm.h | 425 +++++++++++++++++++++++++++++++++--
 1 file changed, 402 insertions(+), 23 deletions(-)
include/uapi/drm/tegra_drm.h +402 -23
index c4df3c3668b3..94cfc306d50a 100644
@@ -1,24 +1,5 @@
-/*
- * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
+/* SPDX-License-Identifier: MIT */
+/* Copyright (c) 2012-2020 NVIDIA Corporation */
 
 #ifndef _UAPI_TEGRA_DRM_H_
 #define _UAPI_TEGRA_DRM_H_
@@ -29,6 +10,8 @@
 extern "C" {
 #endif
 
+/* Tegra DRM legacy UAPI. Only enabled with STAGING */
+
 #define DRM_TEGRA_GEM_CREATE_TILED     (1 << 0)
 #define DRM_TEGRA_GEM_CREATE_BOTTOM_UP (1 << 1)
 
@@ -649,8 +632,8 @@ struct drm_tegra_gem_get_flags {
 #define DRM_TEGRA_SYNCPT_READ		0x02
 #define DRM_TEGRA_SYNCPT_INCR		0x03
 #define DRM_TEGRA_SYNCPT_WAIT		0x04
-#define DRM_TEGRA_OPEN_CHANNEL		0x05
-#define DRM_TEGRA_CLOSE_CHANNEL		0x06
+#define DRM_TEGRA_OPEN_CHANNEL	        0x05
+#define DRM_TEGRA_CLOSE_CHANNEL	        0x06
 #define DRM_TEGRA_GET_SYNCPT		0x07
 #define DRM_TEGRA_SUBMIT		0x08
 #define DRM_TEGRA_GET_SYNCPT_BASE	0x09
@@ -674,6 +657,402 @@ struct drm_tegra_gem_get_flags {
 #define DRM_IOCTL_TEGRA_GEM_SET_FLAGS DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_SET_FLAGS, struct drm_tegra_gem_set_flags)
 #define DRM_IOCTL_TEGRA_GEM_GET_FLAGS DRM_IOWR(DRM_COMMAND_BASE + DRM_TEGRA_GEM_GET_FLAGS, struct drm_tegra_gem_get_flags)
 
+/* New Tegra DRM UAPI */
+
+/*
+ * Reported by the driver in the `capabilities` field.
+ *
+ * DRM_TEGRA_CHANNEL_CAP_CACHE_COHERENT: If set, the engine is cache coherent
+ * with regard to the system memory.
+ */
+#define DRM_TEGRA_CHANNEL_CAP_CACHE_COHERENT (1 << 0)
+
+struct drm_tegra_channel_open {
+	/**
+	 * @host1x_class: [in]
+	 *
+	 * Host1x class of the engine that will be programmed using this
+	 * channel.
+	 */
+	__u32 host1x_class;
+
+	/**
+	 * @flags: [in]
+	 *
+	 * Flags.
+	 */
+	__u32 flags;
+
+	/**
+	 * @context: [out]
+	 *
+	 * Opaque identifier corresponding to the opened channel.
+	 */
+	__u32 context;
+
+	/**
+	 * @version: [out]
+	 *
+	 * Version of the engine hardware. This can be used by userspace
+	 * to determine how the engine needs to be programmed.
+	 */
+	__u32 version;
+
+	/**
+	 * @capabilities: [out]
+	 *
+	 * Flags describing the hardware capabilities.
+	 */
+	__u32 capabilities;
+	__u32 padding;
+};
+
+struct drm_tegra_channel_close {
+	/**
+	 * @context: [in]
+	 *
+	 * Identifier of the channel to close.
+	 */
+	__u32 context;
+	__u32 padding;
+};
+
+/*
+ * Mapping flags that can be used to influence how the mapping is created.
+ *
+ * DRM_TEGRA_CHANNEL_MAP_READ: create mapping that allows HW read access
+ * DRM_TEGRA_CHANNEL_MAP_WRITE: create mapping that allows HW write access
+ */
+#define DRM_TEGRA_CHANNEL_MAP_READ  (1 << 0)
+#define DRM_TEGRA_CHANNEL_MAP_WRITE (1 << 1)
+#define DRM_TEGRA_CHANNEL_MAP_READ_WRITE (DRM_TEGRA_CHANNEL_MAP_READ | \
+					  DRM_TEGRA_CHANNEL_MAP_WRITE)
+
+struct drm_tegra_channel_map {
+	/**
+	 * @context: [in]
+	 *
+	 * Identifier of the channel to which make memory available for.
+	 */
+	__u32 context;
+
+	/**
+	 * @handle: [in]
+	 *
+	 * GEM handle of the memory to map.
+	 */
+	__u32 handle;
+
+	/**
+	 * @flags: [in]
+	 *
+	 * Flags.
+	 */
+	__u32 flags;
+
+	/**
+	 * @mapping: [out]
+	 *
+	 * Identifier corresponding to the mapping, to be used for
+	 * relocations or unmapping later.
+	 */
+	__u32 mapping;
+};
+
+struct drm_tegra_channel_unmap {
+	/**
+	 * @context: [in]
+	 *
+	 * Channel identifier of the channel to unmap memory from.
+	 */
+	__u32 context;
+
+	/**
+	 * @mapping: [in]
+	 *
+	 * Mapping identifier of the memory mapping to unmap.
+	 */
+	__u32 mapping;
+};
+
+/* Submission */
+
+/**
+ * Specify that bit 39 of the patched-in address should be set to switch
+ * swizzling between Tegra and non-Tegra sector layout on systems that store
+ * surfaces in system memory in non-Tegra sector layout.
+ */
+#define DRM_TEGRA_SUBMIT_RELOC_SECTOR_LAYOUT (1 << 0)
+
+struct drm_tegra_submit_buf {
+	/**
+	 * @mapping: [in]
+	 *
+	 * Identifier of the mapping to use in the submission.
+	 */
+	__u32 mapping;
+
+	/**
+	 * @flags: [in]
+	 *
+	 * Flags.
+	 */
+	__u32 flags;
+
+	/**
+	 * Information for relocation patching.
+	 */
+	struct {
+		/**
+		 * @target_offset: [in]
+		 *
+		 * Offset from the start of the mapping of the data whose
+		 * address is to be patched into the gather.
+		 */
+		__u64 target_offset;
+
+		/**
+		 * @gather_offset_words: [in]
+		 *
+		 * Offset in words from the start of the gather data to
+		 * where the address should be patched into.
+		 */
+		__u32 gather_offset_words;
+
+		/**
+		 * @shift: [in]
+		 *
+		 * Number of bits the address should be shifted right before
+		 * patching in.
+		 */
+		__u32 shift;
+	} reloc;
+};
+
+/**
+ * Execute `words` words of Host1x opcodes specified in the `gather_data_ptr`
+ * buffer. Each GATHER_UPTR command uses successive words from the buffer.
+ */
+#define DRM_TEGRA_SUBMIT_CMD_GATHER_UPTR		0
+/**
+ * Wait for a syncpoint to reach a value before continuing with further
+ * commands.
+ */
+#define DRM_TEGRA_SUBMIT_CMD_WAIT_SYNCPT		1
+/**
+ * Wait for a syncpoint to reach a value before continuing with further
+ * commands. The threshold is calculated relative to the start of the job.
+ */
+#define DRM_TEGRA_SUBMIT_CMD_WAIT_SYNCPT_RELATIVE	2
+
+struct drm_tegra_submit_cmd_gather_uptr {
+	__u32 words;
+	__u32 reserved[3];
+};
+
+struct drm_tegra_submit_cmd_wait_syncpt {
+	__u32 id;
+	__u32 value;
+	__u32 reserved[2];
+};
+
+struct drm_tegra_submit_cmd {
+	/**
+	 * @type: [in]
+	 *
+	 * Command type to execute. One of the DRM_TEGRA_SUBMIT_CMD*
+	 * defines.
+	 */
+	__u32 type;
+
+	/**
+	 * @flags: [in]
+	 *
+	 * Flags.
+	 */
+	__u32 flags;
+
+	union {
+		struct drm_tegra_submit_cmd_gather_uptr gather_uptr;
+		struct drm_tegra_submit_cmd_wait_syncpt wait_syncpt;
+		__u32 reserved[4];
+	};
+};
+
+struct drm_tegra_submit_syncpt {
+	/**
+	 * @id: [in]
+	 *
+	 * ID of the syncpoint that the job will increment.
+	 */
+	__u32 id;
+
+	/**
+	 * @flags: [in]
+	 *
+	 * Flags.
+	 */
+	__u32 flags;
+
+	/**
+	 * @increments: [in]
+	 *
+	 * Number of times the job will increment this syncpoint.
+	 */
+	__u32 increments;
+
+	/**
+	 * @value: [out]
+	 *
+	 * Value the syncpoint will have once the job has completed all
+	 * its specified syncpoint increments.
+	 *
+	 * Note that the kernel may increment the syncpoint before or after
+	 * the job. These increments are not reflected in this field.
+	 *
+	 * If the job hangs or times out, not all of the increments may
+	 * get executed.
+	 */
+	__u32 value;
+};
+
+struct drm_tegra_channel_submit {
+	/**
+	 * @context: [in]
+	 *
+	 * Identifier of the channel to submit this job to.
+	 */
+	__u32 context;
+
+	/**
+	 * @num_bufs: [in]
+	 *
+	 * Number of elements in the `bufs_ptr` array.
+	 */
+	__u32 num_bufs;
+
+	/**
+	 * @num_cmds: [in]
+	 *
+	 * Number of elements in the `cmds_ptr` array.
+	 */
+	__u32 num_cmds;
+
+	/**
+	 * @gather_data_words: [in]
+	 *
+	 * Number of 32-bit words in the `gather_data_ptr` array.
+	 */
+	__u32 gather_data_words;
+
+	/**
+	 * @bufs_ptr: [in]
+	 *
+	 * Pointer to an array of drm_tegra_submit_buf structures.
+	 */
+	__u64 bufs_ptr;
+
+	/**
+	 * @cmds_ptr: [in]
+	 *
+	 * Pointer to an array of drm_tegra_submit_cmd structures.
+	 */
+	__u64 cmds_ptr;
+
+	/**
+	 * @gather_data_ptr: [in]
+	 *
+	 * Pointer to an array of Host1x opcodes to be used by GATHER_UPTR
+	 * commands.
+	 */
+	__u64 gather_data_ptr;
+
+	/**
+	 * @syncobj_in: [in]
+	 *
+	 * Handle for DRM syncobj that will be waited before submission.
+	 * Ignored if zero.
+	 */
+	__u32 syncobj_in;
+
+	/**
+	 * @syncobj_out: [in]
+	 *
+	 * Handle for DRM syncobj that will have its fence replaced with
+	 * the job's completion fence. Ignored if zero.
+	 */
+	__u32 syncobj_out;
+
+	/**
+	 * @syncpt_incr: [in,out]
+	 *
+	 * Information about the syncpoint the job will increment.
+	 */
+	struct drm_tegra_submit_syncpt syncpt;
+};
+
+struct drm_tegra_syncpoint_allocate {
+	/**
+	 * @id: [out]
+	 *
+	 * ID of allocated syncpoint.
+	 */
+	__u32 id;
+	__u32 padding;
+};
+
+struct drm_tegra_syncpoint_free {
+	/**
+	 * @id: [in]
+	 *
+	 * ID of syncpoint to free.
+	 */
+	__u32 id;
+	__u32 padding;
+};
+
+struct drm_tegra_syncpoint_wait {
+	/**
+	 * @timeout: [in]
+	 *
+	 * Absolute timestamp at which the wait will time out.
+	 */
+	__s64 timeout_ns;
+
+	/**
+	 * @id: [in]
+	 *
+	 * ID of syncpoint to wait on.
+	 */
+	__u32 id;
+
+	/**
+	 * @threshold: [in]
+	 *
+	 * Threshold to wait for.
+	 */
+	__u32 threshold;
+
+	/**
+	 * @value: [out]
+	 *
+	 * Value of the syncpoint upon wait completion.
+	 */
+	__u32 value;
+
+	__u32 padding;
+};
+
+#define DRM_IOCTL_TEGRA_CHANNEL_OPEN DRM_IOWR(DRM_COMMAND_BASE + 0x10, struct drm_tegra_channel_open)
+#define DRM_IOCTL_TEGRA_CHANNEL_CLOSE DRM_IOWR(DRM_COMMAND_BASE + 0x11, struct drm_tegra_channel_close)
+#define DRM_IOCTL_TEGRA_CHANNEL_MAP DRM_IOWR(DRM_COMMAND_BASE + 0x12, struct drm_tegra_channel_map)
+#define DRM_IOCTL_TEGRA_CHANNEL_UNMAP DRM_IOWR(DRM_COMMAND_BASE + 0x13, struct drm_tegra_channel_unmap)
+#define DRM_IOCTL_TEGRA_CHANNEL_SUBMIT DRM_IOWR(DRM_COMMAND_BASE + 0x14, struct drm_tegra_channel_submit)
+
+#define DRM_IOCTL_TEGRA_SYNCPOINT_ALLOCATE DRM_IOWR(DRM_COMMAND_BASE + 0x20, struct drm_tegra_syncpoint_allocate)
+#define DRM_IOCTL_TEGRA_SYNCPOINT_FREE DRM_IOWR(DRM_COMMAND_BASE + 0x21, struct drm_tegra_syncpoint_free)
+#define DRM_IOCTL_TEGRA_SYNCPOINT_WAIT DRM_IOWR(DRM_COMMAND_BASE + 0x22, struct drm_tegra_syncpoint_wait)
+
 #if defined(__cplusplus)
 }
 #endif
Signature · 1 line
2.32.0
#8 lore raw

PATCH v8 7/14 drm/tegra: Boot VIC during runtime PM resume

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

With the new UAPI implementation, engines are powered on and off when there are active jobs, and the core code handles channel allocation. To accommodate that, boot the engine as part of runtime PM instead of using the open_channel callback, which is not used by the new submit path.

---
 drivers/gpu/drm/tegra/vic.c | 112 ++++++++++++++++--------------------
 1 file changed, 51 insertions(+), 61 deletions(-)
drivers/gpu/drm/tegra/vic.c +51 -61
index c9d55a9a3180..c02010ff2b7f 100644
@@ -29,7 +29,6 @@ struct vic_config {
 
 struct vic {
 	struct falcon falcon;
-	bool booted;
 
 	void __iomem *regs;
 	struct tegra_drm_client client;
@@ -52,48 +51,6 @@ static void vic_writel(struct vic *vic, u32 value, unsigned int offset)
 	writel(value, vic->regs + offset);
 }
 
-static int vic_runtime_resume(struct device *dev)
-{
-	struct vic *vic = dev_get_drvdata(dev);
-	int err;
-
-	err = clk_prepare_enable(vic->clk);
-	if (err < 0)
-		return err;
-
-	usleep_range(10, 20);
-
-	err = reset_control_deassert(vic->rst);
-	if (err < 0)
-		goto disable;
-
-	usleep_range(10, 20);
-
-	return 0;
-
-disable:
-	clk_disable_unprepare(vic->clk);
-	return err;
-}
-
-static int vic_runtime_suspend(struct device *dev)
-{
-	struct vic *vic = dev_get_drvdata(dev);
-	int err;
-
-	err = reset_control_assert(vic->rst);
-	if (err < 0)
-		return err;
-
-	usleep_range(2000, 4000);
-
-	clk_disable_unprepare(vic->clk);
-
-	vic->booted = false;
-
-	return 0;
-}
-
 static int vic_boot(struct vic *vic)
 {
 #ifdef CONFIG_IOMMU_API
@@ -103,9 +60,6 @@ static int vic_boot(struct vic *vic)
 	void *hdr;
 	int err = 0;
 
-	if (vic->booted)
-		return 0;
-
 #ifdef CONFIG_IOMMU_API
 	if (vic->config->supports_sid && spec) {
 		u32 value;
@@ -168,8 +122,6 @@ static int vic_boot(struct vic *vic)
 		return err;
 	}
 
-	vic->booted = true;
-
 	return 0;
 }
 
@@ -323,35 +275,74 @@ static int vic_load_firmware(struct vic *vic)
 	return err;
 }
 
-static int vic_open_channel(struct tegra_drm_client *client,
-			    struct tegra_drm_context *context)
+
+static int vic_runtime_resume(struct device *dev)
 {
-	struct vic *vic = to_vic(client);
+	struct vic *vic = dev_get_drvdata(dev);
 	int err;
 
-	err = pm_runtime_resume_and_get(vic->dev);
+	err = clk_prepare_enable(vic->clk);
 	if (err < 0)
 		return err;
 
+	usleep_range(10, 20);
+
+	err = reset_control_deassert(vic->rst);
+	if (err < 0)
+		goto disable;
+
+	usleep_range(10, 20);
+
 	err = vic_load_firmware(vic);
 	if (err < 0)
-		goto rpm_put;
+		goto assert;
 
 	err = vic_boot(vic);
 	if (err < 0)
-		goto rpm_put;
+		goto assert;
+
+	return 0;
+
+assert:
+	reset_control_assert(vic->rst);
+disable:
+	clk_disable_unprepare(vic->clk);
+	return err;
+}
+
+static int vic_runtime_suspend(struct device *dev)
+{
+	struct vic *vic = dev_get_drvdata(dev);
+	int err;
+
+	err = reset_control_assert(vic->rst);
+	if (err < 0)
+		return err;
+
+	usleep_range(2000, 4000);
+
+	clk_disable_unprepare(vic->clk);
+
+	return 0;
+}
+
+static int vic_open_channel(struct tegra_drm_client *client,
+			    struct tegra_drm_context *context)
+{
+	struct vic *vic = to_vic(client);
+	int err;
+
+	err = pm_runtime_resume_and_get(vic->dev);
+	if (err < 0)
+		return err;
 
 	context->channel = host1x_channel_get(vic->channel);
 	if (!context->channel) {
-		err = -ENOMEM;
-		goto rpm_put;
+		pm_runtime_put(vic->dev);
+		return -ENOMEM;
 	}
 
 	return 0;
-
-rpm_put:
-	pm_runtime_put(vic->dev);
-	return err;
 }
 
 static void vic_close_channel(struct tegra_drm_context *context)
@@ -359,7 +350,6 @@ static void vic_close_channel(struct tegra_drm_context *context)
 	struct vic *vic = to_vic(context->client);
 
 	host1x_channel_put(context->channel);
-
 	pm_runtime_put(vic->dev);
 }
 
Signature · 1 line
2.32.0
#9 lore raw

PATCH v8 8/14 drm/tegra: Allocate per-engine channel in core code

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

To avoid code duplication, allocate the per-engine shared channel in the core code instead. This is the usual channel that all jobs are submitted to when MLOCKing is not in use. Once MLOCKs are implemented on Host1x side, we can also update this to avoid allocating a shared channel when MLOCKs are enabled.

---
 drivers/gpu/drm/tegra/drm.c | 11 +++++++++++
 drivers/gpu/drm/tegra/drm.h |  2 ++
 2 files changed, 13 insertions(+)
drivers/gpu/drm/tegra/drm.c +11 -0
index 87954e69ab6c..cddee6425461 100644
@@ -870,6 +870,14 @@ static const struct drm_driver tegra_drm_driver = {
 int tegra_drm_register_client(struct tegra_drm *tegra,
 			      struct tegra_drm_client *client)
 {
+	/*
+	 * When MLOCKs are implemented, change to allocate a shared channel
+	 * only when MLOCKs are disabled.
+	 */
+	client->shared_channel = host1x_channel_request(&client->base);
+	if (!client->shared_channel)
+		return -EBUSY;
+
 	mutex_lock(&tegra->clients_lock);
 	list_add_tail(&client->list, &tegra->clients);
 	client->drm = tegra;
@@ -886,6 +894,9 @@ int tegra_drm_unregister_client(struct tegra_drm *tegra,
 	client->drm = NULL;
 	mutex_unlock(&tegra->clients_lock);
 
+	if (client->shared_channel)
+		host1x_channel_put(client->shared_channel);
+
 	return 0;
 }
 
drivers/gpu/drm/tegra/drm.h +2 -0
index 0cb868065348..536861017d24 100644
@@ -91,7 +91,9 @@ struct tegra_drm_client {
 	struct host1x_client base;
 	struct list_head list;
 	struct tegra_drm *drm;
+	struct host1x_channel *shared_channel;
 
+	/* Set by driver */
 	unsigned int version;
 	const struct tegra_drm_client_ops *ops;
 };
Signature · 1 line
2.32.0
#10 lore raw

PATCH v8 9/14 drm/tegra: Implement new UAPI

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Implement the non-submission parts of the new UAPI, including channel management and memory mapping. The UAPI is under the CONFIG_DRM_TEGRA_STAGING config flag for now.

---
Changes in v8:
- rebase on top of latest UABI changes

 drivers/gpu/drm/tegra/Makefile |   1 +
 drivers/gpu/drm/tegra/drm.c    |  37 ++--
 drivers/gpu/drm/tegra/drm.h    |  10 ++
 drivers/gpu/drm/tegra/uapi.c   | 313 +++++++++++++++++++++++++++++++++
 drivers/gpu/drm/tegra/uapi.h   |  51 ++++++
 5 files changed, 396 insertions(+), 16 deletions(-)
 create mode 100644 drivers/gpu/drm/tegra/uapi.c
 create mode 100644 drivers/gpu/drm/tegra/uapi.h
drivers/gpu/drm/tegra/Makefile +1 -0
index d6cf202414f0..783475ffd943 100644
@@ -3,6 +3,7 @@ ccflags-$(CONFIG_DRM_TEGRA_DEBUG) += -DDEBUG
 
 tegra-drm-y := \
 	drm.o \
+	uapi.o \
 	gem.o \
 	fb.o \
 	dp.o \
drivers/gpu/drm/tegra/drm.c +21 -16
index cddee6425461..6ee08e49ec57 100644
@@ -21,6 +21,7 @@
 #include <drm/drm_prime.h>
 #include <drm/drm_vblank.h>
 
+#include "uapi.h"
 #include "drm.h"
 #include "gem.h"
 
@@ -34,11 +35,6 @@
 #define CARVEOUT_SZ SZ_64M
 #define CDMA_GATHER_FETCHES_MAX_NB 16383
 
-struct tegra_drm_file {
-	struct idr contexts;
-	struct mutex lock;
-};
-
 static int tegra_atomic_check(struct drm_device *drm,
 			      struct drm_atomic_state *state)
 {
@@ -94,7 +90,8 @@ static int tegra_drm_open(struct drm_device *drm, struct drm_file *filp)
 	if (!fpriv)
 		return -ENOMEM;
 
-	idr_init_base(&fpriv->contexts, 1);
+	idr_init_base(&fpriv->legacy_contexts, 1);
+	xa_init_flags(&fpriv->contexts, XA_FLAGS_ALLOC1);
 	mutex_init(&fpriv->lock);
 	filp->driver_priv = fpriv;
 
@@ -419,7 +416,7 @@ static int tegra_client_open(struct tegra_drm_file *fpriv,
 	if (err < 0)
 		return err;
 
-	err = idr_alloc(&fpriv->contexts, context, 1, 0, GFP_KERNEL);
+	err = idr_alloc(&fpriv->legacy_contexts, context, 1, 0, GFP_KERNEL);
 	if (err < 0) {
 		client->ops->close_channel(context);
 		return err;
@@ -474,13 +471,13 @@ static int tegra_close_channel(struct drm_device *drm, void *data,
 
 	mutex_lock(&fpriv->lock);
 
-	context = idr_find(&fpriv->contexts, args->context);
+	context = idr_find(&fpriv->legacy_contexts, args->context);
 	if (!context) {
 		err = -EINVAL;
 		goto unlock;
 	}
 
-	idr_remove(&fpriv->contexts, context->id);
+	idr_remove(&fpriv->legacy_contexts, context->id);
 	tegra_drm_context_free(context);
 
 unlock:
@@ -499,7 +496,7 @@ static int tegra_get_syncpt(struct drm_device *drm, void *data,
 
 	mutex_lock(&fpriv->lock);
 
-	context = idr_find(&fpriv->contexts, args->context);
+	context = idr_find(&fpriv->legacy_contexts, args->context);
 	if (!context) {
 		err = -ENODEV;
 		goto unlock;
@@ -528,7 +525,7 @@ static int tegra_submit(struct drm_device *drm, void *data,
 
 	mutex_lock(&fpriv->lock);
 
-	context = idr_find(&fpriv->contexts, args->context);
+	context = idr_find(&fpriv->legacy_contexts, args->context);
 	if (!context) {
 		err = -ENODEV;
 		goto unlock;
@@ -553,7 +550,7 @@ static int tegra_get_syncpt_base(struct drm_device *drm, void *data,
 
 	mutex_lock(&fpriv->lock);
 
-	context = idr_find(&fpriv->contexts, args->context);
+	context = idr_find(&fpriv->legacy_contexts, args->context);
 	if (!context) {
 		err = -ENODEV;
 		goto unlock;
@@ -722,10 +719,17 @@ static int tegra_gem_get_flags(struct drm_device *drm, void *data,
 
 static const struct drm_ioctl_desc tegra_drm_ioctls[] = {
 #ifdef CONFIG_DRM_TEGRA_STAGING
-	DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE, tegra_gem_create,
+	DRM_IOCTL_DEF_DRV(TEGRA_CHANNEL_OPEN, tegra_drm_ioctl_channel_open,
+			  DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(TEGRA_CHANNEL_CLOSE, tegra_drm_ioctl_channel_close,
 			  DRM_RENDER_ALLOW),
-	DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP, tegra_gem_mmap,
+	DRM_IOCTL_DEF_DRV(TEGRA_CHANNEL_MAP, tegra_drm_ioctl_channel_map,
 			  DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(TEGRA_CHANNEL_UNMAP, tegra_drm_ioctl_channel_unmap,
+			  DRM_RENDER_ALLOW),
+
+	DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE, tegra_gem_create, DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP, tegra_gem_mmap, DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_READ, tegra_syncpt_read,
 			  DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPT_INCR, tegra_syncpt_incr,
@@ -779,10 +783,11 @@ static void tegra_drm_postclose(struct drm_device *drm, struct drm_file *file)
 	struct tegra_drm_file *fpriv = file->driver_priv;
 
 	mutex_lock(&fpriv->lock);
-	idr_for_each(&fpriv->contexts, tegra_drm_context_cleanup, NULL);
+	idr_for_each(&fpriv->legacy_contexts, tegra_drm_context_cleanup, NULL);
+	tegra_drm_uapi_close_file(fpriv);
 	mutex_unlock(&fpriv->lock);
 
-	idr_destroy(&fpriv->contexts);
+	idr_destroy(&fpriv->legacy_contexts);
 	mutex_destroy(&fpriv->lock);
 	kfree(fpriv);
 }
drivers/gpu/drm/tegra/drm.h +10 -0
index 536861017d24..8b28327c931c 100644
@@ -64,12 +64,22 @@ struct tegra_drm {
 	struct tegra_display_hub *hub;
 };
 
+static inline struct host1x *tegra_drm_to_host1x(struct tegra_drm *tegra)
+{
+	return dev_get_drvdata(tegra->drm->dev->parent);
+}
+
 struct tegra_drm_client;
 
 struct tegra_drm_context {
 	struct tegra_drm_client *client;
 	struct host1x_channel *channel;
+
+	/* Only used by legacy UAPI. */
 	unsigned int id;
+
+	/* Only used by new UAPI. */
+	struct xarray mappings;
 };
 
 struct tegra_drm_client_ops {
drivers/gpu/drm/tegra/uapi.c new file +313 -0

313 lines not on this page · raw message

drivers/gpu/drm/tegra/uapi.h new file +51 -0

51 lines not on this page · raw message

Signature · 1 line
2.32.0
#11 lore raw

Re: [PATCH v8 09/14] drm/tegra: Implement new UAPI

09.07.2021 22:31, Thierry Reding пишет:

drivers/gpu/drm/tegra/drm.c line 26

Quoted 11 lines
drivers/gpu/drm/tegra/drm.c +1 -0
index cddee6425461..6ee08e49ec57 100644
@@ -21,6 +21,7 @@
 #include <drm/drm_prime.h>
 #include <drm/drm_vblank.h>
 
+#include "uapi.h"
 #include "drm.h"
 #include "gem.h"

alphabet order

#12 lore raw

PATCH v8 10/14 drm/tegra: Implement syncpoint management UAPI

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Implement TegraDRM IOCTLs for allocating and freeing syncpoints.

---
 drivers/gpu/drm/tegra/drm.c  |  5 ++++
 drivers/gpu/drm/tegra/uapi.c | 52 ++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/tegra/uapi.h |  5 ++++
 3 files changed, 62 insertions(+)
drivers/gpu/drm/tegra/drm.c +5 -0
index 6ee08e49ec57..18aee825a1ff 100644
@@ -92,6 +92,7 @@ static int tegra_drm_open(struct drm_device *drm, struct drm_file *filp)
 
 	idr_init_base(&fpriv->legacy_contexts, 1);
 	xa_init_flags(&fpriv->contexts, XA_FLAGS_ALLOC1);
+	xa_init(&fpriv->syncpoints);
 	mutex_init(&fpriv->lock);
 	filp->driver_priv = fpriv;
 
@@ -727,6 +728,10 @@ static const struct drm_ioctl_desc tegra_drm_ioctls[] = {
 			  DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_CHANNEL_UNMAP, tegra_drm_ioctl_channel_unmap,
 			  DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPOINT_ALLOCATE, tegra_drm_ioctl_syncpoint_allocate,
+			  DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPOINT_FREE, tegra_drm_ioctl_syncpoint_free,
+			  DRM_RENDER_ALLOW),
 
 	DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE, tegra_gem_create, DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP, tegra_gem_mmap, DRM_RENDER_ALLOW),
drivers/gpu/drm/tegra/uapi.c +52 -0

67 lines not on this page · raw message

drivers/gpu/drm/tegra/uapi.h +5 -0
index fbef39726c29..e4e498facf61 100644
@@ -21,6 +21,7 @@ struct tegra_drm_file {
 
 	/* New UAPI state */
 	struct xarray contexts;
+	struct xarray syncpoints;
 };
 
 struct tegra_drm_mapping {
@@ -44,6 +45,10 @@ int tegra_drm_ioctl_channel_unmap(struct drm_device *drm, void *data,
 				  struct drm_file *file);
 int tegra_drm_ioctl_channel_submit(struct drm_device *drm, void *data,
 				   struct drm_file *file);
+int tegra_drm_ioctl_syncpoint_allocate(struct drm_device *drm, void *data,
+				       struct drm_file *file);
+int tegra_drm_ioctl_syncpoint_free(struct drm_device *drm, void *data,
+				   struct drm_file *file);
 
 void tegra_drm_uapi_close_file(struct tegra_drm_file *file);
 void tegra_drm_mapping_put(struct tegra_drm_mapping *mapping);
Signature · 1 line
2.32.0
#13 lore raw

PATCH v8 11/14 drm/tegra: Implement syncpoint wait UAPI

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Implement new syncpoint wait UAPI. This is different from the legacy one in taking an absolute timestamp in line with modern DRM conventions.

---
Changes in v8:
- rebase on top of latest UABI changes

 drivers/gpu/drm/tegra/drm.c  |  2 ++
 drivers/gpu/drm/tegra/uapi.c | 22 ++++++++++++++++++++++
 drivers/gpu/drm/tegra/uapi.h |  2 ++
 3 files changed, 26 insertions(+)
drivers/gpu/drm/tegra/drm.c +2 -0
index 18aee825a1ff..082d520bdffc 100644
@@ -732,6 +732,8 @@ static const struct drm_ioctl_desc tegra_drm_ioctls[] = {
 			  DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPOINT_FREE, tegra_drm_ioctl_syncpoint_free,
 			  DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPOINT_WAIT, tegra_drm_ioctl_syncpoint_wait,
+			  DRM_RENDER_ALLOW),
 
 	DRM_IOCTL_DEF_DRV(TEGRA_GEM_CREATE, tegra_gem_create, DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_GEM_MMAP, tegra_gem_mmap, DRM_RENDER_ALLOW),
drivers/gpu/drm/tegra/uapi.c +22 -0
index e91394e7264e..0ba57697706b 100644
@@ -7,6 +7,7 @@
 
 #include <drm/drm_drv.h>
 #include <drm/drm_file.h>
+#include <drm/drm_utils.h>
 
 #include "drm.h"
 #include "uapi.h"
@@ -363,3 +364,24 @@ int tegra_drm_ioctl_syncpoint_free(struct drm_device *drm, void *data,
 
 	return 0;
 }
+
+int tegra_drm_ioctl_syncpoint_wait(struct drm_device *drm, void *data,
+				   struct drm_file *file)
+{
+	struct host1x *host1x = tegra_drm_to_host1x(drm->dev_private);
+	struct drm_tegra_syncpoint_wait *args = data;
+	signed long timeout_jiffies;
+	struct host1x_syncpt *sp;
+
+	if (args->padding != 0)
+		return -EINVAL;
+
+	sp = host1x_syncpt_get_by_id_noref(host1x, args->id);
+	if (!sp)
+		return -EINVAL;
+
+	timeout_jiffies = drm_timeout_abs_to_jiffies(args->timeout_ns);
+
+	return host1x_syncpt_wait(sp, args->threshold, timeout_jiffies,
+				  &args->value);
+}
drivers/gpu/drm/tegra/uapi.h +2 -0
index e4e498facf61..12adad770ad3 100644
@@ -49,6 +49,8 @@ int tegra_drm_ioctl_syncpoint_allocate(struct drm_device *drm, void *data,
 				       struct drm_file *file);
 int tegra_drm_ioctl_syncpoint_free(struct drm_device *drm, void *data,
 				   struct drm_file *file);
+int tegra_drm_ioctl_syncpoint_wait(struct drm_device *drm, void *data,
+				   struct drm_file *file);
 
 void tegra_drm_uapi_close_file(struct tegra_drm_file *file);
 void tegra_drm_mapping_put(struct tegra_drm_mapping *mapping);
Signature · 1 line
2.32.0
#14 lore raw

PATCH v8 12/14 drm/tegra: Implement job submission part of new UAPI

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Implement the job submission IOCTL with a minimum feature set.

---
Changes in v8:
- rebased on top of latest UABI changes

 drivers/gpu/drm/tegra/Makefile    |   2 +
 drivers/gpu/drm/tegra/drm.c       |   4 +-
 drivers/gpu/drm/tegra/gather_bo.c |  81 +++++
 drivers/gpu/drm/tegra/gather_bo.h |  22 ++
 drivers/gpu/drm/tegra/submit.c    | 521 ++++++++++++++++++++++++++++++
 drivers/gpu/drm/tegra/submit.h    |  17 +
 6 files changed, 646 insertions(+), 1 deletion(-)
 create mode 100644 drivers/gpu/drm/tegra/gather_bo.c
 create mode 100644 drivers/gpu/drm/tegra/gather_bo.h
 create mode 100644 drivers/gpu/drm/tegra/submit.c
 create mode 100644 drivers/gpu/drm/tegra/submit.h
drivers/gpu/drm/tegra/Makefile +2 -0
index 783475ffd943..ab4289d1c991 100644
@@ -4,6 +4,8 @@ ccflags-$(CONFIG_DRM_TEGRA_DEBUG) += -DDEBUG
 tegra-drm-y := \
 	drm.o \
 	uapi.o \
+	submit.o \
+	gather_bo.o \
 	gem.o \
 	fb.o \
 	dp.o \
drivers/gpu/drm/tegra/drm.c +3 -1
index 082d520bdffc..ae9dafc32c2b 100644
@@ -728,6 +728,8 @@ static const struct drm_ioctl_desc tegra_drm_ioctls[] = {
 			  DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_CHANNEL_UNMAP, tegra_drm_ioctl_channel_unmap,
 			  DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(TEGRA_CHANNEL_SUBMIT, tegra_drm_ioctl_channel_submit,
+			  DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPOINT_ALLOCATE, tegra_drm_ioctl_syncpoint_allocate,
 			  DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(TEGRA_SYNCPOINT_FREE, tegra_drm_ioctl_syncpoint_free,
@@ -852,7 +854,7 @@ static void tegra_debugfs_init(struct drm_minor *minor)
 
 static const struct drm_driver tegra_drm_driver = {
 	.driver_features = DRIVER_MODESET | DRIVER_GEM |
-			   DRIVER_ATOMIC | DRIVER_RENDER,
+			   DRIVER_ATOMIC | DRIVER_RENDER | DRIVER_SYNCOBJ,
 	.open = tegra_drm_open,
 	.postclose = tegra_drm_postclose,
 	.lastclose = drm_fb_helper_lastclose,
drivers/gpu/drm/tegra/gather_bo.c new file +81 -0

81 lines not on this page · raw message

drivers/gpu/drm/tegra/gather_bo.h new file +22 -0
new file mode 100644
index 000000000000..6b4c9d83ac91
@@ -0,0 +1,22 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/* Copyright (c) 2020 NVIDIA Corporation */
+
+#ifndef _TEGRA_DRM_SUBMIT_GATHER_BO_H
+#define _TEGRA_DRM_SUBMIT_GATHER_BO_H
+
+#include <linux/host1x.h>
+#include <linux/kref.h>
+
+struct gather_bo {
+	struct host1x_bo base;
+
+	struct kref ref;
+
+	u32 *gather_data;
+	size_t gather_data_words;
+};
+
+extern const struct host1x_bo_ops gather_bo_ops;
+void gather_bo_put(struct host1x_bo *host_bo);
+
+#endif
drivers/gpu/drm/tegra/submit.c new file +521 -0

521 lines not on this page · raw message

drivers/gpu/drm/tegra/submit.h new file +17 -0
new file mode 100644
index 000000000000..0a165e9e4bda
@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/* Copyright (c) 2020 NVIDIA Corporation */
+
+#ifndef _TEGRA_DRM_UAPI_SUBMIT_H
+#define _TEGRA_DRM_UAPI_SUBMIT_H
+
+struct tegra_drm_used_mapping {
+	struct tegra_drm_mapping *mapping;
+	u32 flags;
+};
+
+struct tegra_drm_submit_data {
+	struct tegra_drm_used_mapping *used_mappings;
+	u32 num_used_mappings;
+};
+
+#endif
Signature · 1 line
2.32.0
#15 lore raw

PATCH v8 13/14 drm/tegra: Add job firewall

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Add a firewall that validates jobs before submission to ensure they don't do anything they aren't allowed to do, like accessing memory they should not access.

The firewall is functionality-wise a copy of the firewall already implemented in gpu/host1x. It is copied here as it makes more sense for it to live on the DRM side, as it is only needed for userspace job submissions, and generally the data it needs to do its job is easier to access here.

In the future, the other implementation will be removed.

---
 drivers/gpu/drm/tegra/Makefile   |   1 +
 drivers/gpu/drm/tegra/firewall.c | 254 +++++++++++++++++++++++++++++++
 drivers/gpu/drm/tegra/submit.c   |  10 +-
 drivers/gpu/drm/tegra/submit.h   |   4 +
 4 files changed, 267 insertions(+), 2 deletions(-)
 create mode 100644 drivers/gpu/drm/tegra/firewall.c
drivers/gpu/drm/tegra/Makefile +1 -0
index ab4289d1c991..5d2039f0c734 100644
@@ -6,6 +6,7 @@ tegra-drm-y := \
 	uapi.o \
 	submit.o \
 	gather_bo.o \
+	firewall.o \
 	gem.o \
 	fb.o \
 	dp.o \
drivers/gpu/drm/tegra/firewall.c new file +254 -0

254 lines not on this page · raw message

drivers/gpu/drm/tegra/submit.c +8 -2
index 0225706e3163..c53b7207c478 100644
@@ -233,7 +233,7 @@ static int submit_get_syncpt(struct tegra_drm_context *context, struct host1x_jo
 static int submit_job_add_gather(struct host1x_job *job, struct tegra_drm_context *context,
 				 struct drm_tegra_submit_cmd_gather_uptr *cmd,
 				 struct gather_bo *bo, u32 *offset,
-				 struct tegra_drm_submit_data *job_data)
+				 struct tegra_drm_submit_data *job_data, u32 *class)
 {
 	u32 next_offset;
 
@@ -258,6 +258,12 @@ static int submit_job_add_gather(struct host1x_job *job, struct tegra_drm_contex
 		return -EINVAL;
 	}
 
+	if (tegra_drm_fw_validate(context->client, bo->gather_data, *offset,
+				  cmd->words, job_data, class)) {
+		SUBMIT_ERR(context, "job was rejected by firewall");
+		return -EINVAL;
+	}
+
 	host1x_job_add_gather(job, &bo->base, cmd->words, *offset * 4);
 
 	*offset = next_offset;
@@ -311,7 +317,7 @@ submit_create_job(struct tegra_drm_context *context, struct gather_bo *bo,
 
 		if (cmd->type == DRM_TEGRA_SUBMIT_CMD_GATHER_UPTR) {
 			err = submit_job_add_gather(job, context, &cmd->gather_uptr, bo,
-						    &gather_offset, job_data);
+						    &gather_offset, job_data, &class);
 			if (err)
 				goto free_job;
 		} else if (cmd->type == DRM_TEGRA_SUBMIT_CMD_WAIT_SYNCPT) {
drivers/gpu/drm/tegra/submit.h +4 -0
index 0a165e9e4bda..cf6a2f0a29fc 100644
@@ -14,4 +14,8 @@ struct tegra_drm_submit_data {
 	u32 num_used_mappings;
 };
 
+int tegra_drm_fw_validate(struct tegra_drm_client *client, u32 *data, u32 start,
+			  u32 words, struct tegra_drm_submit_data *submit,
+			  u32 *job_class);
+
 #endif
Signature · 1 line
2.32.0
#16 lore raw

PATCH v8 14/14 drm/tegra: Bump driver version

In reply to Thierry Reding

From: Mikko Perttunen <[email protected]>

Bump driver version to 1.0.0 to allow userspace to detect availability of new interfaces.

---
 drivers/gpu/drm/tegra/drm.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/tegra/drm.c +1 -1
index ae9dafc32c2b..b20fd0833661 100644
@@ -28,7 +28,7 @@
 #define DRIVER_NAME "tegra"
 #define DRIVER_DESC "NVIDIA Tegra graphics"
 #define DRIVER_DATE "20120330"
-#define DRIVER_MAJOR 0
+#define DRIVER_MAJOR 1
 #define DRIVER_MINOR 0
 #define DRIVER_PATCHLEVEL 0
 
Signature · 1 line
2.32.0
#17 lore raw
In reply to Thierry Reding

Hello Thierry,

09.07.2021 22:31, Thierry Reding пишет:

Quoted 8 lines

From: Thierry Reding <[email protected]>

Hi all,

Mikko has been away for a few weeks, so I've been testing and revising the new UABI patches in the meantime. There are very minor changes to the naming of some of the UABI fields, but other than that it's mostly unchanged from v7.

Why you haven't addressed any of the previous review comments? There were some obvious problems in v7 and v8 still has them.

Quoted 23 lines

One notable change is that mappings can now be read-only, write-only, read-write or none of them (rather than just read-only or read-write), since those combinations are all supported by the IOMMUs and it might be useful to make some mappings write-only.

For a full list of changes in v8, see the changelog in patch 6.

I've also updated the libdrm_tegra library to work against this version of the UABI. A branch can be found here:

https://gitlab.freedesktop.org/tagr/drm/-/commits/drm-tegra-uabi-v8

That contains helper APIs for the concepts introduced in this series and shows how they can be used in various tests that can be run for sanity checking.

In addition, Mikko has made updates to the following projects, though they may need to be updated for the minor changes in v8:

* vaapi-tegra-driver - https://github.com/cyndis/vaapi-tegra-driver
Experimental support for MPEG2 and H264 decoding on T210, T186 and T194.

Quoted 8 lines

* xf86-video-opentegra - https://github.com/grate-driver/xf86-video-opentegra
X11 userspace acceleration driver for Tegra20, Tegra30, and Tegra114.

* grate - https://github.com/grate-driver/grate
3D rendering testbed for Tegra20, Tegra30, and Tegra114

I plan on putting this into linux-next soon after v5.14-rc1 so that this can get some soak time.

It should be a bit too early to push it into kernel. The UAPI is not ready because it's missing essential features. We can't call this a 'modern UABI' until it's fully implemented. The design decisions are still questionable because this UAPI is built around the proprietary firmware (and based on UAPI of downstream driver) which doesn't fit well into DRM world. I haven't got all the answers to my previous questions, should I repeat them?

UAPI is not the only problem that we have. The performance and stability of the driver are in a very bad shape too. The modern UAPI can't be built on top of the old code. It's clear now that this is a very serious problem that must be addressed along with the UAPI work and I'm getting silence from you guys.

#18 lore raw
Quoted 47 lines · Dmitry Osipenko

Hello Thierry,

09.07.2021 22:31, Thierry Reding пишет:

Quoted 8 lines

From: Thierry Reding <[email protected]>

Hi all,

Mikko has been away for a few weeks, so I've been testing and revising the new UABI patches in the meantime. There are very minor changes to the naming of some of the UABI fields, but other than that it's mostly unchanged from v7.

Why you haven't addressed any of the previous review comments? There were some obvious problems in v7 and v8 still has them.

Quoted 23 lines

One notable change is that mappings can now be read-only, write-only, read-write or none of them (rather than just read-only or read-write), since those combinations are all supported by the IOMMUs and it might be useful to make some mappings write-only.

For a full list of changes in v8, see the changelog in patch 6.

I've also updated the libdrm_tegra library to work against this version of the UABI. A branch can be found here:

https://gitlab.freedesktop.org/tagr/drm/-/commits/drm-tegra-uabi-v8

That contains helper APIs for the concepts introduced in this series and shows how they can be used in various tests that can be run for sanity checking.

In addition, Mikko has made updates to the following projects, though they may need to be updated for the minor changes in v8:

* vaapi-tegra-driver - https://github.com/cyndis/vaapi-tegra-driver
Experimental support for MPEG2 and H264 decoding on T210, T186 and T194.

Quoted 8 lines

* xf86-video-opentegra - https://github.com/grate-driver/xf86-video-opentegra
X11 userspace acceleration driver for Tegra20, Tegra30, and Tegra114.

* grate - https://github.com/grate-driver/grate
3D rendering testbed for Tegra20, Tegra30, and Tegra114

I plan on putting this into linux-next soon after v5.14-rc1 so that this can get some soak time.

Quoted 7 lines

It should be a bit too early to push it into kernel. The UAPI is not ready because it's missing essential features. We can't call this a 'modern UABI' until it's fully implemented. The design decisions are still questionable because this UAPI is built around the proprietary firmware (and based on UAPI of downstream driver) which doesn't fit well into DRM world. I haven't got all the answers to my previous questions, should I repeat them?

I don't know what you means by "built around the proprietary firmware". Yes, this ends up using proprietary firmware for some of the hardware engines that host1x drives, but that's completely orthogonal to the UABI. No matter what UABI we'd be introducing, we'd be using that same firmware.

And yes, this is based on the UABI of the downstream drivers. The design is guided by what we've learned over the last decade working with this hardware in use-cases that customers need. It'd be dumb not to use that knowledge to our advantage. This is the only way to ensure we can deliver an upstream driver that's on par with our downstream drivers and therefore make it possible to eventually adopt the upstream driver.

And frankly, you did get answers to previous questions, though perhaps not all, but I'm out of patience. We've been going in circles and at some point we have to make a decision so we can make progress.

I made several attempts over the years to get something usable merged upstream so that we can finally make use of this hardware and get it supported upstream and each time I made the mistake of trying to make it perfect and accomodate all wishlist items. The result is that I wasted a lot of time and have nothing to show for it.

I've also been very hard Mikko with his work on this and I think we've stretched this as far as we can without compromising too much on what we are going to need from this UABI in the future.

We've gone through the process of making sure all existing userspace can and does work with this new UABI and even left the old UABI in place in case we need it.

I'm reasonably satisfied with what we have now and I don't see any reason to hold this back any further. We always have the option of adding UABI if we need it for something, or extend functionality of existing UABI where it makes sense. But we also do have to start somewhere, otherwise we're just not going to get anywhere, as the last 10 years have shown.

Quoted 5 lines

UAPI is not the only problem that we have. The performance and stability of the driver are in a very bad shape too. The modern UAPI can't be built on top of the old code. It's clear now that this is a very serious problem that must be addressed along with the UAPI work and I'm getting silence from you guys.

We've been over this multiple times before, though perhaps never over email. So let me make this clear here again and for future reference: we will *not* be rewriting the driver from scratch.

If there are any serious performance and stability issues, then we'll find them and address them incrementally, like we always do in the kernel.

Thierry

#19 lore raw

14.07.2021 11:30, Thierry Reding пишет:

Quoted 69 lines · Dmitry Osipenko
Quoted 47 lines

Hello Thierry,

09.07.2021 22:31, Thierry Reding пишет:

Quoted 8 lines

From: Thierry Reding <[email protected]>

Hi all,

Mikko has been away for a few weeks, so I've been testing and revising the new UABI patches in the meantime. There are very minor changes to the naming of some of the UABI fields, but other than that it's mostly unchanged from v7.

Why you haven't addressed any of the previous review comments? There were some obvious problems in v7 and v8 still has them.

Quoted 23 lines

One notable change is that mappings can now be read-only, write-only, read-write or none of them (rather than just read-only or read-write), since those combinations are all supported by the IOMMUs and it might be useful to make some mappings write-only.

For a full list of changes in v8, see the changelog in patch 6.

I've also updated the libdrm_tegra library to work against this version of the UABI. A branch can be found here:

https://gitlab.freedesktop.org/tagr/drm/-/commits/drm-tegra-uabi-v8

That contains helper APIs for the concepts introduced in this series and shows how they can be used in various tests that can be run for sanity checking.

In addition, Mikko has made updates to the following projects, though they may need to be updated for the minor changes in v8:

* vaapi-tegra-driver - https://github.com/cyndis/vaapi-tegra-driver
Experimental support for MPEG2 and H264 decoding on T210, T186 and T194.

Quoted 8 lines

* xf86-video-opentegra - https://github.com/grate-driver/xf86-video-opentegra
X11 userspace acceleration driver for Tegra20, Tegra30, and Tegra114.

* grate - https://github.com/grate-driver/grate
3D rendering testbed for Tegra20, Tegra30, and Tegra114

I plan on putting this into linux-next soon after v5.14-rc1 so that this can get some soak time.

Quoted 7 lines

It should be a bit too early to push it into kernel. The UAPI is not ready because it's missing essential features. We can't call this a 'modern UABI' until it's fully implemented. The design decisions are still questionable because this UAPI is built around the proprietary firmware (and based on UAPI of downstream driver) which doesn't fit well into DRM world. I haven't got all the answers to my previous questions, should I repeat them?

I don't know what you means by "built around the proprietary firmware". Yes, this ends up using proprietary firmware for some of the hardware engines that host1x drives, but that's completely orthogonal to the UABI. No matter what UABI we'd be introducing, we'd be using that same firmware.

And yes, this is based on the UABI of the downstream drivers. The design is guided by what we've learned over the last decade working with this hardware in use-cases that customers need. It'd be dumb not to use that knowledge to our advantage. This is the only way to ensure we can deliver an upstream driver that's on par with our downstream drivers and therefore make it possible to eventually adopt the upstream driver.

Quoted 3 lines

And frankly, you did get answers to previous questions, though perhaps not all, but I'm out of patience. We've been going in circles and at some point we have to make a decision so we can make progress.

By firmware I was referring to the supervisor OS and inter-VM integration, sorry for not making it clear. My rough understanding is that it's all software defined and technically it's possible to avoid going though the trouble of supporting the firmware convention defined by downstream, and thus, making driver less optimal than it could be. It's still not clear to me how much that firmware is relevant to upstream in practice.

Quoted 5 lines

I made several attempts over the years to get something usable merged upstream so that we can finally make use of this hardware and get it supported upstream and each time I made the mistake of trying to make it perfect and accomodate all wishlist items. The result is that I wasted a lot of time and have nothing to show for it.

It's a problem that you try to do everything on your own and not collaborating as much as you could. Writing code isn't a problem, the problem is that there is no clear understanding of what needs to be done, IMO. I have a vision of whats need to be done from a perspective of older SoCs, but I never could start implementing it for upstream because it requires yours feedback and preliminary agreement since you're the only maintainer of the driver who could merge patches I don't want to waste my time too.

Quoted 7 lines

I've also been very hard Mikko with his work on this and I think we've stretched this as far as we can without compromising too much on what we are going to need from this UABI in the future.

We've gone through the process of making sure all existing userspace can and does work with this new UABI and even left the old UABI in place in case we need it.

That is great, but it is not enough. So far we are enabling a minimal support for newer hardware here, but we also need to solve the older problems that are relevant to all SoCs and may well affect the UABI decisions.

It became apparent to me now that yours only goal here is to enable newer hardware, which is fine. It's also apparent to me that you still don't have a clear vision of what needs to be done overall, but this is fine too since nothing is removed here and it's in a staging phase yet.

Quoted 6 lines

I'm reasonably satisfied with what we have now and I don't see any reason to hold this back any further. We always have the option of adding UABI if we need it for something, or extend functionality of existing UABI where it makes sense. But we also do have to start somewhere, otherwise we're just not going to get anywhere, as the last 10 years have shown.

We're starting in a bit wrong direction by extending the old code base, adding unnecessary burden to userspace of older SoCs and adding sync point UAPI that may not integrate with the proper jobs scheduling. It probably shouldn't be a big problem to rework it all later on if will be needed, but we could avoid this extra work beforehand if we could put more effort into implementing more features from the start.

Quoted 9 lines
Quoted 5 lines

UAPI is not the only problem that we have. The performance and stability of the driver are in a very bad shape too. The modern UAPI can't be built on top of the old code. It's clear now that this is a very serious problem that must be addressed along with the UAPI work and I'm getting silence from you guys.

We've been over this multiple times before, though perhaps never over email. So let me make this clear here again and for future reference: we will *not* be rewriting the driver from scratch.

This was unnecessary, we agreed on the incremental updates long time ago. My point is that we shouldn't be building the new UAPI on top of the old code, instead we should prioritize the upgrading to a modern APIs and fixing the lame abstractions of the legacy driver.

Mikko assures that this effort won't stop after merging this first bits and we will start upgrading driver soon. I trust Mikko. You guys want to light up the newer hardware so much that I don't know how to stop you :) Even if this will become a mistake later on, likely it won't be a critical mistake, so let's not hold it.

#20 lore raw
Quoted 74 lines · Dmitry Osipenko

14.07.2021 11:30, Thierry Reding пишет:

Quoted 69 lines · Dmitry Osipenko
Quoted 47 lines

Hello Thierry,

09.07.2021 22:31, Thierry Reding пишет:

Quoted 8 lines

From: Thierry Reding <[email protected]>

Hi all,

Mikko has been away for a few weeks, so I've been testing and revising the new UABI patches in the meantime. There are very minor changes to the naming of some of the UABI fields, but other than that it's mostly unchanged from v7.

Why you haven't addressed any of the previous review comments? There were some obvious problems in v7 and v8 still has them.

Quoted 23 lines

One notable change is that mappings can now be read-only, write-only, read-write or none of them (rather than just read-only or read-write), since those combinations are all supported by the IOMMUs and it might be useful to make some mappings write-only.

For a full list of changes in v8, see the changelog in patch 6.

I've also updated the libdrm_tegra library to work against this version of the UABI. A branch can be found here:

https://gitlab.freedesktop.org/tagr/drm/-/commits/drm-tegra-uabi-v8

That contains helper APIs for the concepts introduced in this series and shows how they can be used in various tests that can be run for sanity checking.

In addition, Mikko has made updates to the following projects, though they may need to be updated for the minor changes in v8:

* vaapi-tegra-driver - https://github.com/cyndis/vaapi-tegra-driver
Experimental support for MPEG2 and H264 decoding on T210, T186 and T194.

Quoted 8 lines

* xf86-video-opentegra - https://github.com/grate-driver/xf86-video-opentegra
X11 userspace acceleration driver for Tegra20, Tegra30, and Tegra114.

* grate - https://github.com/grate-driver/grate
3D rendering testbed for Tegra20, Tegra30, and Tegra114

I plan on putting this into linux-next soon after v5.14-rc1 so that this can get some soak time.

Quoted 7 lines

It should be a bit too early to push it into kernel. The UAPI is not ready because it's missing essential features. We can't call this a 'modern UABI' until it's fully implemented. The design decisions are still questionable because this UAPI is built around the proprietary firmware (and based on UAPI of downstream driver) which doesn't fit well into DRM world. I haven't got all the answers to my previous questions, should I repeat them?

I don't know what you means by "built around the proprietary firmware". Yes, this ends up using proprietary firmware for some of the hardware engines that host1x drives, but that's completely orthogonal to the UABI. No matter what UABI we'd be introducing, we'd be using that same firmware.

And yes, this is based on the UABI of the downstream drivers. The design is guided by what we've learned over the last decade working with this hardware in use-cases that customers need. It'd be dumb not to use that knowledge to our advantage. This is the only way to ensure we can deliver an upstream driver that's on par with our downstream drivers and therefore make it possible to eventually adopt the upstream driver.

Quoted 3 lines

And frankly, you did get answers to previous questions, though perhaps not all, but I'm out of patience. We've been going in circles and at some point we have to make a decision so we can make progress.

Quoted 7 lines

By firmware I was referring to the supervisor OS and inter-VM integration, sorry for not making it clear. My rough understanding is that it's all software defined and technically it's possible to avoid going though the trouble of supporting the firmware convention defined by downstream, and thus, making driver less optimal than it could be. It's still not clear to me how much that firmware is relevant to upstream in practice.

As mentioned in discussion elsewhere, there is no 'firmware convention'. The view I've formed so far is that the model of ephemeral syncpoint allocations and value resets, which I believe you are talking about here, is fundamentally opposed to the design intent of the hardware, and would result in a less efficient system regardless of inter-VM integration convention.

Quoted 29 lines
Quoted 6 lines

I made several attempts over the years to get something usable merged upstream so that we can finally make use of this hardware and get it supported upstream and each time I made the mistake of trying to make it perfect and accomodate all wishlist items. The result is that I wasted a lot of time and have nothing to show for it.

It's a problem that you try to do everything on your own and not collaborating as much as you could. Writing code isn't a problem, the problem is that there is no clear understanding of what needs to be done, IMO. I have a vision of whats need to be done from a perspective of older SoCs, but I never could start implementing it for upstream because it requires yours feedback and preliminary agreement since you're the only maintainer of the driver who could merge patches I don't want to waste my time too.

Quoted 7 lines

I've also been very hard Mikko with his work on this and I think we've stretched this as far as we can without compromising too much on what we are going to need from this UABI in the future.

We've gone through the process of making sure all existing userspace can and does work with this new UABI and even left the old UABI in place in case we need it.

That is great, but it is not enough. So far we are enabling a minimal support for newer hardware here, but we also need to solve the older problems that are relevant to all SoCs and may well affect the UABI decisions.

Quoted 4 lines

It became apparent to me now that yours only goal here is to enable newer hardware, which is fine. It's also apparent to me that you still don't have a clear vision of what needs to be done overall, but this is fine too since nothing is removed here and it's in a staging phase yet.

While my goal of course is to enable proper use of Host1x on the newer SoCs, there is absolutely no intention to forget about the older SoCs. Observably, to me at least, GR2D and GR3D are working -- the test suites are passing (though I did not port/try mesa). We are also not regressing anything, and I do not think after this series we are worse (at least in any fundamental manner) than the downstream software stack that these chips were originally productized with. As such I have a hard time understanding the doom and gloom about the driver's state and needing grand overarching re-architectures.

Quoted 8 lines
Quoted 7 lines

I'm reasonably satisfied with what we have now and I don't see any reason to hold this back any further. We always have the option of adding UABI if we need it for something, or extend functionality of existing UABI where it makes sense. But we also do have to start somewhere, otherwise we're just not going to get anywhere, as the last 10 years have shown.

Quoted 7 lines

We're starting in a bit wrong direction by extending the old code base, adding unnecessary burden to userspace of older SoCs and adding sync point UAPI that may not integrate with the proper jobs scheduling. It probably shouldn't be a big problem to rework it all later on if will be needed, but we could avoid this extra work beforehand if we could put more effort into implementing more features from the start.

As mentioned before, in my opinion, redoing the internals while supporting the legacy UAPI would be more difficult. Having the new UAPI in place will also guide the improvements to be made - and at least on new SoCs where hardware scheduling works fine we want to take advantage of that in the UAPI. And I don't know of any issue in the UAPI that would prevent use of a software scheduler (depending on implementation some fields could be unused in some cases but it's already the case that you don't always use every field).

Quoted 15 lines
Quoted 9 lines
Quoted 5 lines

UAPI is not the only problem that we have. The performance and stability of the driver are in a very bad shape too. The modern UAPI can't be built on top of the old code. It's clear now that this is a very serious problem that must be addressed along with the UAPI work and I'm getting silence from you guys.

We've been over this multiple times before, though perhaps never over email. So let me make this clear here again and for future reference: we will *not* be rewriting the driver from scratch.

This was unnecessary, we agreed on the incremental updates long time ago. My point is that we shouldn't be building the new UAPI on top of the old code, instead we should prioritize the upgrading to a modern APIs and fixing the lame abstractions of the legacy driver.

Quoted 6 lines

Mikko assures that this effort won't stop after merging this first bits and we will start upgrading driver soon. I trust Mikko. You guys want to light up the newer hardware so much that I don't know how to stop you :) Even if this will become a mistake later on, likely it won't be a critical mistake, so let's not hold it.

I have a long TODO list of improvements to work on. Admittedly, I won't have as much time to work on it as I would have before since I need to start working on other projects in parallel as well. And things will need to be agreed on (e.g. as alluded to earlier I still don't know of any concrete reason why we would need to add a software scheduler. I can only make guesses. It probably makes sense for the old SoCs, but I don't know why we now need one and downstream never did)

Mikko

#21 lore raw

14.07.2021 18:26, Mikko Perttunen пишет:
...

Quoted 11 lines

While my goal of course is to enable proper use of Host1x on the newer SoCs, there is absolutely no intention to forget about the older SoCs. Observably, to me at least, GR2D and GR3D are working -- the test suites are passing (though I did not port/try mesa). We are also not regressing anything, and I do not think after this series we are worse (at least in any fundamental manner) than the downstream software stack that these chips were originally productized with.

As such I have a hard time
understanding the doom and gloom about the driver's state and needing grand overarching re-architectures.

You need to work with a real consumer device and use it everyday to feel all those problems. But problems always exist, we will fix them eventually and then have new problems. We also have an alternative experimental driver that solves the problems for the time being, so it's not really that bad.

I may sound a bit too negative, but that's because you're are already doing this work and I want to get your attention to a core problems that in my opinion should be solved first to avoid a need to re-do the work later on.

...

Quoted 4 lines

I have a long TODO list of improvements to work on. Admittedly, I won't have as much time to work on it as I would have before since I need to start working on other projects in parallel as well. And things will need to be agreed on

A slow pace parallel work is a normal thing, that's exactly what me and everyone else are doing in regards to having fun with Tegra development. We already managed to achieve a lot this way and it's only getting better every day.

Quoted 4 lines

(e.g. as alluded to earlier I still don't know of
any concrete reason why we would need to add a software scheduler. I can only make guesses. It probably makes sense for the old SoCs, but I don't know why we now need one and downstream never did)

Scheduler is needed for running jobs in a correct order. You don't feel like it's needed because you use only a single h/w engine and haven't seen places where it's needed.

DRM scheduler also has a much cleaner code, has more features, it's optimized, well thought, uses modern upstream concepts and successfully used by multiple drivers in comparison to what we have in the Host1x driver.

We will discuss it in a more details.

#22 lore raw
In reply to Thierry Reding

09.07.2021 22:31, Thierry Reding пишет:

Quoted 43 lines

From: Thierry Reding <[email protected]>

Hi all,

Mikko has been away for a few weeks, so I've been testing and revising the new UABI patches in the meantime. There are very minor changes to the naming of some of the UABI fields, but other than that it's mostly unchanged from v7.

One notable change is that mappings can now be read-only, write-only, read-write or none of them (rather than just read-only or read-write), since those combinations are all supported by the IOMMUs and it might be useful to make some mappings write-only.

For a full list of changes in v8, see the changelog in patch 6.

I've also updated the libdrm_tegra library to work against this version of the UABI. A branch can be found here:

https://gitlab.freedesktop.org/tagr/drm/-/commits/drm-tegra-uabi-v8

That contains helper APIs for the concepts introduced in this series and shows how they can be used in various tests that can be run for sanity checking.

In addition, Mikko has made updates to the following projects, though they may need to be updated for the minor changes in v8:

* vaapi-tegra-driver - https://github.com/cyndis/vaapi-tegra-driver
Experimental support for MPEG2 and H264 decoding on T210, T186 and T194.

* xf86-video-opentegra - https://github.com/grate-driver/xf86-video-opentegra
X11 userspace acceleration driver for Tegra20, Tegra30, and Tegra114.

* grate - https://github.com/grate-driver/grate
3D rendering testbed for Tegra20, Tegra30, and Tegra114

I plan on putting this into linux-next soon after v5.14-rc1 so that this can get some soak time.

Thierry

Quoted 15 lines

Mikko Perttunen (14):
gpu: host1x: Add DMA fence implementation
gpu: host1x: Add no-recovery mode
gpu: host1x: Add job release callback
gpu: host1x: Add support for syncpoint waits in CDMA pushbuffer drm/tegra: Extract tegra_gem_lookup
drm/tegra: Add new UAPI to header
drm/tegra: Boot VIC during runtime PM resume drm/tegra: Allocate per-engine channel in core code drm/tegra: Implement new UAPI
drm/tegra: Implement syncpoint management UAPI drm/tegra: Implement syncpoint wait UAPI
drm/tegra: Implement job submission part of new UAPI drm/tegra: Add job firewall
drm/tegra: Bump driver version

The "gpu: host1x: Add option to skip firewall for a job" of v7 is not here.

The tegra_drm_ioctl_channel_map() uses wrong BO size again, which breaks firewall, it was fixed in v7.

The DRM_TEGRA_CHANNEL_MAP_WRITE and DRM_TEGRA_CHANNEL_MAP_READ values should be swapped to preserve compatibility with the current userspace.

Please fix all the coding style problems reported by "./scripts/checkpatch.pl --strict" and other things reported previously. Re-submit v9.