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, 472 insertions, 0 deletions

diff --git a/include/gk20a/regops_gk20a.c b/include/gk20a/regops_gk20a.c
new file mode 100644
index 0000000..0aec4f8
--- /dev/null
+++ b/include/gk20a/regops_gk20a.c
@@ -0,0 +1,472 @@
+/*
+ * Tegra GK20A GPU Debugger Driver Register Ops
+ *
+ * Copyright (c) 2013-2018, 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.
+ */
+
+#include "gk20a.h"
+#include "gr_gk20a.h"
+#include "dbg_gpu_gk20a.h"
+#include "regops_gk20a.h"
+
+#include <nvgpu/log.h>
+#include <nvgpu/bsearch.h>
+#include <nvgpu/bug.h>
+#include <nvgpu/io.h>
+
+static int regop_bsearch_range_cmp(const void *pkey, const void *pelem)
+{
+        u32 key = *(u32 *)pkey;
+        struct regop_offset_range *prange = (struct regop_offset_range *)pelem;
+        if (key < prange->base) {
+                return -1;
+        } else if (prange->base <= key && key < (prange->base +
+                                               (prange->count * 4U))) {
+                return 0;
+        }
+        return 1;
+}
+
+static inline bool linear_search(u32 offset, const u32 *list, int size)
+{
+        int i;
+        for (i = 0; i < size; i++) {
+                if (list[i] == offset) {
+                        return true;
+                }
+        }
+        return false;
+}
+
+/*
+ * In order to perform a context relative op the context has
+ * to be created already... which would imply that the
+ * context switch mechanism has already been put in place.
+ * So by the time we perform such an opertation it should always
+ * be possible to query for the appropriate context offsets, etc.
+ *
+ * But note: while the dbg_gpu bind requires the a channel fd,
+ * it doesn't require an allocated gr/compute obj at that point...
+ */
+static bool gr_context_info_available(struct gr_gk20a *gr)
+{
+        int err;
+
+        nvgpu_mutex_acquire(&gr->ctx_mutex);
+        err = !gr->ctx_vars.golden_image_initialized;
+        nvgpu_mutex_release(&gr->ctx_mutex);
+        if (err) {
+                return false;
+        }
+
+        return true;
+
+}
+
+static bool validate_reg_ops(struct dbg_session_gk20a *dbg_s,
+                             u32 *ctx_rd_count, u32 *ctx_wr_count,
+                             struct nvgpu_dbg_reg_op *ops,
+                             u32 op_count);
+
+
+int exec_regops_gk20a(struct dbg_session_gk20a *dbg_s,
+                      struct nvgpu_dbg_reg_op *ops,
+                      u64 num_ops,
+                      bool *is_current_ctx)
+{
+        int err = 0;
+        unsigned int i;
+        struct channel_gk20a *ch = NULL;
+        struct gk20a *g = dbg_s->g;
+        /*struct gr_gk20a *gr = &g->gr;*/
+        u32 data32_lo = 0, data32_hi = 0;
+        u32 ctx_rd_count = 0, ctx_wr_count = 0;
+        bool skip_read_lo, skip_read_hi;
+        bool ok;
+
+        nvgpu_log(g, gpu_dbg_fn | gpu_dbg_gpu_dbg, " ");
+
+        ch = nvgpu_dbg_gpu_get_session_channel(dbg_s);
+
+        /* For vgpu, the regops routines need to be handled in the
+         * context of the server and support for that does not exist.
+         *
+         * The two users of the regops interface are the compute driver
+         * and tools. The compute driver will work without a functional
+         * regops implementation, so we return -ENOSYS. This will allow
+         * compute apps to run with vgpu. Tools will not work in this
+         * configuration and are not required to work at this time. */
+        if (g->is_virtual) {
+                return -ENOSYS;
+        }
+
+        ok = validate_reg_ops(dbg_s,
+                              &ctx_rd_count, &ctx_wr_count,
+                              ops, num_ops);
+        if (!ok) {
+                nvgpu_err(g, "invalid op(s)");
+                err = -EINVAL;
+                /* each op has its own err/status */
+                goto clean_up;
+        }
+
+        /* be sure that ctx info is in place if there are ctx ops */
+        if (ctx_wr_count | ctx_rd_count) {
+                if (!gr_context_info_available(&g->gr)) {
+                        nvgpu_err(g, "gr context data not available");
+                        return -ENODEV;
+                }
+        }
+
+        for (i = 0; i < num_ops; i++) {
+                /* if it isn't global then it is done in the ctx ops... */
+                if (ops[i].type != REGOP(TYPE_GLOBAL)) {
+                        continue;
+                }
+
+                switch (ops[i].op) {
+
+                case REGOP(READ_32):
+                        ops[i].value_hi = 0;
+                        ops[i].value_lo = gk20a_readl(g, ops[i].offset);
+                        nvgpu_log(g, gpu_dbg_gpu_dbg, "read_32 0x%08x from 0x%08x",
+                                   ops[i].value_lo, ops[i].offset);
+
+                        break;
+
+                case REGOP(READ_64):
+                        ops[i].value_lo = gk20a_readl(g, ops[i].offset);
+                        ops[i].value_hi =
+                                gk20a_readl(g, ops[i].offset + 4);
+
+                        nvgpu_log(g, gpu_dbg_gpu_dbg, "read_64 0x%08x:%08x from 0x%08x",
+                                   ops[i].value_hi, ops[i].value_lo,
+                                   ops[i].offset);
+                break;
+
+                case REGOP(WRITE_32):
+                case REGOP(WRITE_64):
+                        /* some of this appears wonky/unnecessary but
+                           we've kept it for compat with existing
+                           debugger code.  just in case... */
+                        skip_read_lo = skip_read_hi = false;
+                        if (ops[i].and_n_mask_lo == ~(u32)0) {
+                                data32_lo = ops[i].value_lo;
+                                skip_read_lo = true;
+                        }
+
+                        if ((ops[i].op == REGOP(WRITE_64)) &&
+                            (ops[i].and_n_mask_hi == ~(u32)0)) {
+                                data32_hi = ops[i].value_hi;
+                                skip_read_hi = true;
+                        }
+
+                        /* read first 32bits */
+                        if (skip_read_lo == false) {
+                                data32_lo = gk20a_readl(g, ops[i].offset);
+                                data32_lo &= ~ops[i].and_n_mask_lo;
+                                data32_lo |= ops[i].value_lo;
+                        }
+
+                        /* if desired, read second 32bits */
+                        if ((ops[i].op == REGOP(WRITE_64)) &&
+                            !skip_read_hi) {
+                                data32_hi = gk20a_readl(g, ops[i].offset + 4);
+                                data32_hi &= ~ops[i].and_n_mask_hi;
+                                data32_hi |= ops[i].value_hi;
+                        }
+
+                        /* now update first 32bits */
+                        gk20a_writel(g, ops[i].offset, data32_lo);
+                        nvgpu_log(g, gpu_dbg_gpu_dbg, "Wrote 0x%08x to 0x%08x ",
+                                   data32_lo, ops[i].offset);
+                        /* if desired, update second 32bits */
+                        if (ops[i].op == REGOP(WRITE_64)) {
+                                gk20a_writel(g, ops[i].offset + 4, data32_hi);
+                                nvgpu_log(g, gpu_dbg_gpu_dbg, "Wrote 0x%08x to 0x%08x ",
+                                           data32_hi, ops[i].offset + 4);
+
+                        }
+
+
+                        break;
+