Include nvgpu headers

These are needed to build on NVIDIA's Jetson boards for the time
being. Only a couple structs are required, so it should be fairly
easy to remove this dependency at some point in the future.

1 files changed, 657 insertions, 0 deletions

diff --git a/include/os/linux/linux-channel.c b/include/os/linux/linux-channel.c
new file mode 100644
index 0000000..d035baf
--- /dev/null
+++ b/include/os/linux/linux-channel.c
@@ -0,0 +1,657 @@
+/*
+ * Copyright (c) 2017-2018, NVIDIA Corporation.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <nvgpu/enabled.h>
+#include <nvgpu/debug.h>
+#include <nvgpu/error_notifier.h>
+#include <nvgpu/os_sched.h>
+#include <nvgpu/gk20a.h>
+#include <nvgpu/channel.h>
+#include <nvgpu/dma.h>
+
+/*
+ * This is required for nvgpu_vm_find_buf() which is used in the tracing
+ * code. Once we can get and access userspace buffers without requiring
+ * direct dma_buf usage this can be removed.
+ */
+#include <nvgpu/linux/vm.h>
+
+#include "channel.h"
+#include "ioctl_channel.h"
+#include "os_linux.h"
+#include "dmabuf.h"
+
+#include <nvgpu/hw/gk20a/hw_pbdma_gk20a.h>
+
+#include <linux/uaccess.h>
+#include <linux/dma-buf.h>
+#include <trace/events/gk20a.h>
+#include <uapi/linux/nvgpu.h>
+
+#include "sync_sema_android.h"
+
+u32 nvgpu_submit_gpfifo_user_flags_to_common_flags(u32 user_flags)
+{
+        u32 flags = 0;
+
+        if (user_flags & NVGPU_SUBMIT_GPFIFO_FLAGS_FENCE_WAIT)
+                flags |= NVGPU_SUBMIT_FLAGS_FENCE_WAIT;
+
+        if (user_flags & NVGPU_SUBMIT_GPFIFO_FLAGS_FENCE_GET)
+                flags |= NVGPU_SUBMIT_FLAGS_FENCE_GET;
+
+        if (user_flags & NVGPU_SUBMIT_GPFIFO_FLAGS_HW_FORMAT)
+                flags |= NVGPU_SUBMIT_FLAGS_HW_FORMAT;
+
+        if (user_flags & NVGPU_SUBMIT_GPFIFO_FLAGS_SYNC_FENCE)
+                flags |= NVGPU_SUBMIT_FLAGS_SYNC_FENCE;
+
+        if (user_flags & NVGPU_SUBMIT_GPFIFO_FLAGS_SUPPRESS_WFI)
+                flags |= NVGPU_SUBMIT_FLAGS_SUPPRESS_WFI;
+
+        if (user_flags & NVGPU_SUBMIT_GPFIFO_FLAGS_SKIP_BUFFER_REFCOUNTING)
+                flags |= NVGPU_SUBMIT_FLAGS_SKIP_BUFFER_REFCOUNTING;
+
+        return flags;
+}
+
+/*
+ * API to convert error_notifiers in common code and of the form
+ * NVGPU_ERR_NOTIFIER_* into Linux specific error_notifiers exposed to user
+ * space and of the form  NVGPU_CHANNEL_*
+ */
+static u32 nvgpu_error_notifier_to_channel_notifier(u32 error_notifier)
+{
+        switch (error_notifier) {
+        case NVGPU_ERR_NOTIFIER_FIFO_ERROR_IDLE_TIMEOUT:
+                return NVGPU_CHANNEL_FIFO_ERROR_IDLE_TIMEOUT;
+        case NVGPU_ERR_NOTIFIER_GR_ERROR_SW_METHOD:
+                return NVGPU_CHANNEL_GR_ERROR_SW_METHOD;
+        case NVGPU_ERR_NOTIFIER_GR_ERROR_SW_NOTIFY:
+                return NVGPU_CHANNEL_GR_ERROR_SW_NOTIFY;
+        case NVGPU_ERR_NOTIFIER_GR_EXCEPTION:
+                return NVGPU_CHANNEL_GR_EXCEPTION;
+        case NVGPU_ERR_NOTIFIER_GR_SEMAPHORE_TIMEOUT:
+                return NVGPU_CHANNEL_GR_SEMAPHORE_TIMEOUT;
+        case NVGPU_ERR_NOTIFIER_GR_ILLEGAL_NOTIFY:
+                return NVGPU_CHANNEL_GR_ILLEGAL_NOTIFY;
+        case NVGPU_ERR_NOTIFIER_FIFO_ERROR_MMU_ERR_FLT:
+                return NVGPU_CHANNEL_FIFO_ERROR_MMU_ERR_FLT;
+        case NVGPU_ERR_NOTIFIER_PBDMA_ERROR:
+                return NVGPU_CHANNEL_PBDMA_ERROR;
+        case NVGPU_ERR_NOTIFIER_FECS_ERR_UNIMP_FIRMWARE_METHOD:
+                return NVGPU_CHANNEL_FECS_ERR_UNIMP_FIRMWARE_METHOD;
+        case NVGPU_ERR_NOTIFIER_RESETCHANNEL_VERIF_ERROR:
+                return NVGPU_CHANNEL_RESETCHANNEL_VERIF_ERROR;
+        case NVGPU_ERR_NOTIFIER_PBDMA_PUSHBUFFER_CRC_MISMATCH:
+                return NVGPU_CHANNEL_PBDMA_PUSHBUFFER_CRC_MISMATCH;
+        }
+
+        pr_warn("%s: invalid error_notifier requested %u\n", __func__, error_notifier);
+
+        return error_notifier;
+}
+
+/**
+ * nvgpu_set_error_notifier_locked()
+ * Should be called with ch->error_notifier_mutex held
+ *
+ * error should be of the form  NVGPU_ERR_NOTIFIER_*
+ */
+void nvgpu_set_error_notifier_locked(struct channel_gk20a *ch, u32 error)
+{
+        struct nvgpu_channel_linux *priv = ch->os_priv;
+
+        error = nvgpu_error_notifier_to_channel_notifier(error);
+
+        if (priv->error_notifier.dmabuf) {
+                struct nvgpu_notification *notification =
+                        priv->error_notifier.notification;
+                struct timespec time_data;
+                u64 nsec;
+
+                getnstimeofday(&time_data);
+                nsec = ((u64)time_data.tv_sec) * 1000000000u +
+                                (u64)time_data.tv_nsec;
+                notification->time_stamp.nanoseconds[0] =
+                                (u32)nsec;
+                notification->time_stamp.nanoseconds[1] =
+                                (u32)(nsec >> 32);
+                notification->info32 = error;
+                notification->status = 0xffff;
+
+                nvgpu_err(ch->g,
+                    "error notifier set to %d for ch %d", error, ch->chid);
+        }
+}
+
+/* error should be of the form  NVGPU_ERR_NOTIFIER_* */
+void nvgpu_set_error_notifier(struct channel_gk20a *ch, u32 error)
+{
+        struct nvgpu_channel_linux *priv = ch->os_priv;
+
+        nvgpu_mutex_acquire(&priv->error_notifier.mutex);
+        nvgpu_set_error_notifier_locked(ch, error);
+        nvgpu_mutex_release(&priv->error_notifier.mutex);
+}
+
+void nvgpu_set_error_notifier_if_empty(struct channel_gk20a *ch, u32 error)
+{
+        struct nvgpu_channel_linux *priv = ch->os_priv;
+
+        nvgpu_mutex_acquire(&priv->error_notifier.mutex);
+        if (priv->error_notifier.dmabuf) {
+                struct nvgpu_notification *notification =
+                        priv->error_notifier.notification;
+
+                /* Don't overwrite error flag if it is already set */
+                if (notification->status != 0xffff)
+                        nvgpu_set_error_notifier_locked(ch, error);
+        }
+        nvgpu_mutex_release(&priv->error_notifier.mutex);
+}
+
+/* error_notifier should be of the form  NVGPU_ERR_NOTIFIER_* */
+bool nvgpu_is_error_notifier_set(struct channel_gk20a *ch, u32 error_notifier)
+{
+        struct nvgpu_channel_linux *priv = ch->os_priv;
+        bool notifier_set = false;
+
+        error_notifier = nvgpu_error_notifier_to_channel_notifier(error_notifier);
+
+        nvgpu_mutex_acquire(&priv->error_notifier.mutex);
+        if (priv->error_notifier.dmabuf) {
+                struct nvgpu_notification *notification =
+                        priv->error_notifier.notification;
+                u32 err = notification->info32;
+
+                if (err == error_notifier)
+                        notifier_set = true;
+        }
+        nvgpu_mutex_release(&priv->error_notifier.mutex);
+
+        return notifier_set;
+}
+
+static void gk20a_channel_update_runcb_fn(struct work_struct *work)
+{
+        struct nvgpu_channel_completion_cb *completion_cb =
+                container_of(work, struct nvgpu_channel_completion_cb, work);
+        struct nvgpu_channel_linux *priv =
+                container_of(completion_cb,
+                                struct nvgpu_channel_linux, completion_cb);
+        struct channel_gk20a *ch = priv->ch;
+        void (*fn)(struct channel_gk20a *, void *);
+        void *user_data;
+
+        nvgpu_spinlock_acquire(&completion_cb->lock);
+        fn = completion_cb->fn;
+        user_data = completion_cb->user_data;
+        nvgpu_spinlock_release(&completion_cb->lock);
+
+        if (fn)
+                fn(ch, user_data);
+}
+
+static void nvgpu_channel_work_c