1 files changed, 478 insertions, 0 deletions

diff --git a/include/nvgpu/channel.h b/include/nvgpu/channel.h
new file mode 100644
index 0000000..764d047
--- /dev/null
+++ b/include/nvgpu/channel.h
@@ -0,0 +1,478 @@
+/*
+ * Copyright (c) 2018-2020, 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 AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+#ifndef NVGPU_CHANNEL_H
+#define NVGPU_CHANNEL_H
+
+#include <nvgpu/list.h>
+#include <nvgpu/lock.h>
+#include <nvgpu/timers.h>
+#include <nvgpu/cond.h>
+#include <nvgpu/atomic.h>
+#include <nvgpu/nvgpu_mem.h>
+#include <nvgpu/allocator.h>
+
+struct gk20a;
+struct dbg_session_gk20a;
+struct gk20a_fence;
+struct fifo_profile_gk20a;
+struct nvgpu_channel_sync;
+struct nvgpu_gpfifo_userdata;
+
+/* Flags to be passed to nvgpu_channel_setup_bind() */
+#define NVGPU_SETUP_BIND_FLAGS_SUPPORT_VPR              (1U << 0U)
+#define NVGPU_SETUP_BIND_FLAGS_SUPPORT_DETERMINISTIC    (1U << 1U)
+#define NVGPU_SETUP_BIND_FLAGS_REPLAYABLE_FAULTS_ENABLE (1U << 2U)
+#define NVGPU_SETUP_BIND_FLAGS_USERMODE_SUPPORT         (1U << 3U)
+
+/* Flags to be passed to nvgpu_submit_channel_gpfifo() */
+#define NVGPU_SUBMIT_FLAGS_FENCE_WAIT   (1U << 0U)
+#define NVGPU_SUBMIT_FLAGS_FENCE_GET    (1U << 1U)
+#define NVGPU_SUBMIT_FLAGS_HW_FORMAT    (1U << 2U)
+#define NVGPU_SUBMIT_FLAGS_SYNC_FENCE   (1U << 3U)
+#define NVGPU_SUBMIT_FLAGS_SUPPRESS_WFI (1U << 4U)
+#define NVGPU_SUBMIT_FLAGS_SKIP_BUFFER_REFCOUNTING      (1U << 5U)
+
+/*
+ * The binary format of 'struct nvgpu_channel_fence' introduced here
+ * should match that of 'struct nvgpu_fence' defined in uapi header, since
+ * this struct is intended to be a mirror copy of the uapi struct. This is
+ * not a hard requirement though because of nvgpu_get_fence_args conversion
+ * function.
+ */
+struct nvgpu_channel_fence {
+        u32 id;
+        u32 value;
+};
+
+/*
+ * The binary format of 'struct nvgpu_gpfifo_entry' introduced here
+ * should match that of 'struct nvgpu_gpfifo' defined in uapi header, since
+ * this struct is intended to be a mirror copy of the uapi struct. This is
+ * a rigid requirement because there's no conversion function and there are
+ * memcpy's present between the user gpfifo (of type nvgpu_gpfifo) and the
+ * kern gpfifo (of type nvgpu_gpfifo_entry).
+ */
+struct nvgpu_gpfifo_entry {
+        u32 entry0;
+        u32 entry1;
+};
+
+struct gpfifo_desc {
+        struct nvgpu_mem mem;
+        u32 entry_num;
+
+        u32 get;
+        u32 put;
+
+        bool wrap;
+
+        /* if gpfifo lives in vidmem or is forced to go via PRAMIN, first copy
+         * from userspace to pipe and then from pipe to gpu buffer */
+        void *pipe;
+};
+
+struct nvgpu_setup_bind_args {
+        u32 num_gpfifo_entries;
+        u32 num_inflight_jobs;
+        u32 userd_dmabuf_fd;
+        u64 userd_dmabuf_offset;
+        u32 gpfifo_dmabuf_fd;
+        u64 gpfifo_dmabuf_offset;
+        u32 work_submit_token;
+        u32 flags;
+};
+
+struct notification {
+        struct {
+                u32 nanoseconds[2];
+        } timestamp;
+        u32 info32;
+        u16 info16;
+        u16 status;
+};
+
+struct priv_cmd_queue {
+        struct nvgpu_mem mem;
+        u32 size;       /* num of entries in words */
+        u32 put;        /* put for priv cmd queue */
+        u32 get;        /* get for priv cmd queue */
+};
+
+struct priv_cmd_entry {
+        bool valid;
+        struct nvgpu_mem *mem;
+        u32 off;        /* offset in mem, in u32 entries */
+        u64 gva;
+        u32 get;        /* start of entry in queue */
+        u32 size;       /* in words */
+};
+
+struct channel_gk20a_job {
+        struct nvgpu_mapped_buf **mapped_buffers;
+        int num_mapped_buffers;
+        struct gk20a_fence *post_fence;
+        struct priv_cmd_entry *wait_cmd;
+        struct priv_cmd_entry *incr_cmd;
+        struct nvgpu_list_node list;
+};
+
+static inline struct channel_gk20a_job *
+channel_gk20a_job_from_list(struct nvgpu_list_node *node)
+{
+        return (struct channel_gk20a_job *)
+        ((uintptr_t)node - offsetof(struct channel_gk20a_job, list));
+};
+
+struct channel_gk20a_joblist {
+        struct {
+                bool enabled;
+                unsigned int length;
+                unsigned int put;
+                unsigned int get;
+                struct channel_gk20a_job *jobs;
+                struct nvgpu_mutex read_lock;
+        } pre_alloc;
+
+        struct {
+                struct nvgpu_list_node jobs;
+                struct nvgpu_spinlock lock;
+        } dynamic;
+
+        /*
+         * Synchronize abort cleanup (when closing a channel) and job cleanup
+         * (asynchronously from worker) - protect from concurrent access when
+         * job resources are being freed.
+         */
+        struct nvgpu_mutex cleanup_lock;
+};
+
+struct channel_gk20a_timeout {
+        /* lock protects the running timer state */
+        struct nvgpu_spinlock lock;
+        struct nvgpu_timeout timer;
+        bool running;
+        u32 gp_get;
+        u64 pb_get;
+
+        /* lock not needed */
+        u32 limit_ms;
+        bool enabled;
+        bool debug_dump;
+};
+
+/*
+ * Track refcount actions, saving their stack traces. This number specifies how
+ * many most recent actions are stored in a buffer. Set to 0 to disable. 128
+ * should be enough to track moderately hard problems from the start.
+ */
+#define GK20A_CHANNEL_REFCOUNT_TRACKING 0
+/* Stack depth for the saved actions. */
+#define GK20A_CHANNEL_REFCOUNT_TRACKING_STACKLEN 8
+
+/*
+ * Because the puts and gets are not linked together explicitly (although they
+ * should always come in pairs), it's not possible to tell which ref holder to
+ * delete from the list when doing a put. So, just store some number of most
+ * recent gets and puts in a ring buffer, to obtain a history.
+ *
+ * These are zeroed when a channel is closed, so a new one starts fresh.
+ */
+
+enum channel_gk20a_ref_action_type {
+        channel_gk20a_ref_action_get,
+        channel_gk20a_ref_action_put
+};
+
+#if GK20A_CHANNEL_REFCOUNT_TRACKING
+
+#include <linux/stacktrace.h>
+
+struct channel_gk20a_ref_action {
+        enum channel_gk20a_ref_action_type type;
+        s64 timestamp_ms;
+        /*
+         * Many of these traces will be similar. Simpler to just capture
+         * duplicates than to have a separate database for the entries.
+         */
+        struct stack_trace trace;
+        unsigned long trace_entries[GK20A_CHANNEL_REFCOUNT_TRACKING_STACKLEN];
+};
+#endif
+
+/* this is the priv element of struct nvhost_channel */
+struct channel_gk20a {
+        struct gk20a *g; /* set only when channel is active */
+