gpu: host1x: Introduce support for wide opcodes

The CDMA push buffer can currently only handle opcodes that take a
single word parameter. However, the host1x implementation on Tegra186
and later supports opcodes that require multiple words as parameters.

Unfortunately the way the push buffer is structured, these wide opcodes
cannot simply be composed of two regular opcodes because that could
result in the wide opcode being split across the end of the push buffer
and the final RESTART opcode required to wrap the push buffer around
would break the wide opcode.

One way to fix this would be to remove the concept of slots to simplify
push buffer operations. However, that's not entirely trivial and should
be done in a separate patch. For now, simply use a different function
to push four-word opcodes into the push buffer. Technically only three
words are pushed, with the fourth word used as padding to preserve the
2-word alignment required by the slots abstraction. The fourth word is
always a NOP opcode.

Additional care must be taken when the end of the push buffer is
reached. If a four-word opcode doesn't fit into the push buffer without
being split by the boundary, NOP opcodes will be introduced and the new
wide opcode placed at the beginning of the push buffer.

Signed-off-by: Thierry Reding <treding@nvidia.com>

diff --git a/drivers/gpu/host1x/cdma.c b/drivers/gpu/host1x/cdma.c
index 15bdeb836e3d711d2dc84fcd1054a4ccae29bbeb..64099cc1964b11b15dd6dd774b489e40e5e7e66c 100644 (file)
--- a/drivers/gpu/host1x/cdma.c
+++ b/drivers/gpu/host1x/cdma.c
@@ -217,6 +217,45 @@ unsigned int host1x_cdma_wait_locked(struct host1x_cdma *cdma,
        return 0;
 }
 
+/*
+ * Sleep (if necessary) until the push buffer has enough free space.
+ *
+ * Must be called with the cdma lock held.
+ */
+int host1x_cdma_wait_pushbuffer_space(struct host1x *host1x,
+                                     struct host1x_cdma *cdma,
+                                     unsigned int needed)
+{
+       while (true) {
+               struct push_buffer *pb = &cdma->push_buffer;
+               unsigned int space;
+
+               space = host1x_pushbuffer_space(pb);
+               if (space >= needed)
+                       break;
+
+               trace_host1x_wait_cdma(dev_name(cdma_to_channel(cdma)->dev),
+                                      CDMA_EVENT_PUSH_BUFFER_SPACE);
+
+               host1x_hw_cdma_flush(host1x, cdma);
+
+               /* If somebody has managed to already start waiting, yield */
+               if (cdma->event != CDMA_EVENT_NONE) {
+                       mutex_unlock(&cdma->lock);
+                       schedule();
+                       mutex_lock(&cdma->lock);
+                       continue;
+               }
+
+               cdma->event = CDMA_EVENT_PUSH_BUFFER_SPACE;
+
+               mutex_unlock(&cdma->lock);
+               wait_for_completion(&cdma->complete);
+               mutex_lock(&cdma->lock);
+       }
+
+       return 0;
+}
 /*
  * Start timer that tracks the time spent by the job.
  * Must be called with the cdma lock held.
@@ -509,6 +548,59 @@ void host1x_cdma_push(struct host1x_cdma *cdma, u32 op1, u32 op2)
        host1x_pushbuffer_push(pb, op1, op2);
 }
 
+/*
+ * Push four words into two consecutive push buffer slots. Note that extra
+ * care needs to be taken not to split the two slots across the end of the
+ * push buffer. Otherwise the RESTART opcode at the end of the push buffer
+ * that ensures processing will restart at the beginning will break up the
+ * four words.
+ *
+ * Blocks as necessary if the push buffer is full.
+ */
+void host1x_cdma_push_wide(struct host1x_cdma *cdma, u32 op1, u32 op2,
+                          u32 op3, u32 op4)
+{
+       struct host1x_channel *channel = cdma_to_channel(cdma);
+       struct host1x *host1x = cdma_to_host1x(cdma);
+       struct push_buffer *pb = &cdma->push_buffer;
+       unsigned int needed = 2, extra = 0, i;
+       unsigned int space = cdma->slots_free;
+
+       if (host1x_debug_trace_cmdbuf)
+               trace_host1x_cdma_push_wide(dev_name(channel->dev), op1, op2,
+                                           op3, op4);
+
+       /* compute number of extra slots needed for padding */
+       if (pb->pos + 16 > pb->size) {
+               extra = (pb->size - pb->pos) / 8;
+               needed += extra;
+       }
+
+       host1x_cdma_wait_pushbuffer_space(host1x, cdma, needed);
+       space = host1x_pushbuffer_space(pb);
+
+       cdma->slots_free = space - needed;
+       cdma->slots_used += needed;
+
+       /*
+        * Note that we rely on the fact that this is only used to submit wide
+        * gather opcodes, which consist of 3 words, and they are padded with
+        * a NOP to avoid having to deal with fractional slots (a slot always
+        * represents 2 words). The fourth opcode passed to this function will
+        * therefore always be a NOP.
+        *
+        * This works around a slight ambiguity when it comes to opcodes. For
+        * all current host1x incarnations the NOP opcode uses the exact same
+        * encoding (0x20000000), so we could hard-code the value here, but a
+        * new incarnation may change it and break that assumption.
+        */
+       for (i = 0; i < extra; i++)
+               host1x_pushbuffer_push(pb, op4, op4);
+
+       host1x_pushbuffer_push(pb, op1, op2);
+       host1x_pushbuffer_push(pb, op3, op4);
+}
+
 /*
  * End a cdma submit
  * Kick off DMA, add job to the sync queue, and a number of slots to be freed

diff --git a/drivers/gpu/host1x/cdma.h b/drivers/gpu/host1x/cdma.h
index 71078359c626c70dfb02f395bff103837fa7b084..3a5e0408b8d17ed29edde00e3a9479c222a1a493 100644 (file)
--- a/drivers/gpu/host1x/cdma.h
+++ b/drivers/gpu/host1x/cdma.h
@@ -90,6 +90,8 @@ int host1x_cdma_init(struct host1x_cdma *cdma);
 int host1x_cdma_deinit(struct host1x_cdma *cdma);
 int host1x_cdma_begin(struct host1x_cdma *cdma, struct host1x_job *job);
 void host1x_cdma_push(struct host1x_cdma *cdma, u32 op1, u32 op2);
+void host1x_cdma_push_wide(struct host1x_cdma *cdma, u32 op1, u32 op2,
+                          u32 op3, u32 op4);
 void host1x_cdma_end(struct host1x_cdma *cdma, struct host1x_job *job);
 void host1x_cdma_update(struct host1x_cdma *cdma);
 void host1x_cdma_peek(struct host1x_cdma *cdma, u32 dmaget, int slot,

diff --git a/include/trace/events/host1x.h b/include/trace/events/host1x.h
index a37ef73092e5730db801685d0b0e7433adeeec8c..3d340b6f1ea3817adfd293aad0ed0a96a6b2481b 100644 (file)
--- a/include/trace/events/host1x.h
+++ b/include/trace/events/host1x.h
@@ -80,6 +80,32 @@ TRACE_EVENT(host1x_cdma_push,
                __entry->name, __entry->op1, __entry->op2)
 );
 
+TRACE_EVENT(host1x_cdma_push_wide,
+       TP_PROTO(const char *name, u32 op1, u32 op2, u32 op3, u32 op4),
+
+       TP_ARGS(name, op1, op2, op3, op4),
+
+       TP_STRUCT__entry(
+               __field(const char *, name)
+               __field(u32, op1)
+               __field(u32, op2)
+               __field(u32, op3)
+               __field(u32, op4)
+       ),
+
+       TP_fast_assign(
+               __entry->name = name;
+               __entry->op1 = op1;
+               __entry->op2 = op2;
+               __entry->op3 = op3;
+               __entry->op4 = op4;
+       ),
+
+       TP_printk("name=%s, op1=%08x, op2=%08x, op3=%08x op4=%08x",
+               __entry->name, __entry->op1, __entry->op2, __entry->op3,
+               __entry->op4)
+);
+
 TRACE_EVENT(host1x_cdma_push_gather,
        TP_PROTO(const char *name, struct host1x_bo *bo,
                        u32 words, u32 offset, void *cmdbuf),