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

diff --git a/include/os/linux/module.c b/include/os/linux/module.c
new file mode 100644
index 0000000..807df2c
--- /dev/null
+++ b/include/os/linux/module.c
@@ -0,0 +1,1529 @@
+/*
+ * GK20A Graphics
+ *
+ * Copyright (c) 2011-2020, 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 <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
+#include <linux/of_address.h>
+#include <linux/interrupt.h>
+#include <linux/pm_runtime.h>
+#include <linux/reset.h>
+#include <linux/reboot.h>
+#include <linux/notifier.h>
+#include <linux/platform/tegra/common.h>
+#include <linux/pci.h>
+
+#include <uapi/linux/nvgpu.h>
+#include <dt-bindings/soc/gm20b-fuse.h>
+#include <dt-bindings/soc/gp10b-fuse.h>
+#include <dt-bindings/soc/gv11b-fuse.h>
+
+#include <soc/tegra/fuse.h>
+
+#include <nvgpu/hal_init.h>
+#include <nvgpu/dma.h>
+#include <nvgpu/kmem.h>
+#include <nvgpu/nvgpu_common.h>
+#include <nvgpu/soc.h>
+#include <nvgpu/enabled.h>
+#include <nvgpu/debug.h>
+#include <nvgpu/ctxsw_trace.h>
+#include <nvgpu/vidmem.h>
+#include <nvgpu/sim.h>
+#include <nvgpu/clk_arb.h>
+#include <nvgpu/timers.h>
+#include <nvgpu/channel.h>
+
+#include "platform_gk20a.h"
+#include "sysfs.h"
+#include "vgpu/vgpu_linux.h"
+#include "scale.h"
+#include "pci.h"
+#include "module.h"
+#include "module_usermode.h"
+#include "intr.h"
+#include "ioctl.h"
+#include "ioctl_ctrl.h"
+
+#include "os_linux.h"
+#include "os_ops.h"
+#include "ctxsw_trace.h"
+#include "driver_common.h"
+#include "channel.h"
+#include "debug_pmgr.h"
+
+#ifdef CONFIG_NVGPU_SUPPORT_CDE
+#include "cde.h"
+#endif
+
+#define CLASS_NAME "nvidia-gpu"
+/* TODO: Change to e.g. "nvidia-gpu%s" once we have symlinks in place. */
+
+#define GK20A_WAIT_FOR_IDLE_MS  2000
+
+#define CREATE_TRACE_POINTS
+#include <trace/events/gk20a.h>
+
+static int nvgpu_kernel_shutdown_notification(struct notifier_block *nb,
+                                        unsigned long event, void *unused)
+{
+        struct gk20a *g = container_of(nb, struct gk20a, nvgpu_reboot_nb);
+
+        __nvgpu_set_enabled(g, NVGPU_KERNEL_IS_DYING, true);
+        return NOTIFY_DONE;
+}
+
+struct device_node *nvgpu_get_node(struct gk20a *g)
+{
+        struct device *dev = dev_from_gk20a(g);
+
+        if (dev_is_pci(dev)) {
+                struct pci_bus *bus = to_pci_dev(dev)->bus;
+
+                while (!pci_is_root_bus(bus))
+                        bus = bus->parent;
+
+                return bus->bridge->parent->of_node;
+        }
+
+        return dev->of_node;
+}
+
+void gk20a_busy_noresume(struct gk20a *g)
+{
+        pm_runtime_get_noresume(dev_from_gk20a(g));
+}
+
+/*
+ * Check if the device can go busy.
+ */
+static int nvgpu_can_busy(struct gk20a *g)
+{
+        /* Can't do anything if the system is rebooting/shutting down. */
+        if (nvgpu_is_enabled(g, NVGPU_KERNEL_IS_DYING))
+                return 0;
+
+        /* Can't do anything if the driver is restarting. */
+        if (nvgpu_is_enabled(g, NVGPU_DRIVER_IS_DYING))
+                return 0;
+
+        return 1;
+}
+
+int gk20a_busy(struct gk20a *g)
+{
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
+        int ret = 0;
+        struct device *dev;
+
+        if (!g)
+                return -ENODEV;
+
+        atomic_inc(&g->usage_count.atomic_var);
+
+        down_read(&l->busy_lock);
+
+        if (!nvgpu_can_busy(g)) {
+                ret = -ENODEV;
+                atomic_dec(&g->usage_count.atomic_var);
+                goto fail;
+        }
+
+        dev = dev_from_gk20a(g);
+
+        if (pm_runtime_enabled(dev)) {
+                /* Increment usage count and attempt to resume device */
+                ret = pm_runtime_get_sync(dev);
+                if (ret < 0) {
+                        /* Mark suspended so runtime pm will retry later */
+                        pm_runtime_set_suspended(dev);
+                        pm_runtime_put_noidle(dev);
+                        atomic_dec(&g->usage_count.atomic_var);
+                        goto fail;
+                }
+        } else {
+                ret = gk20a_gpu_is_virtual(dev) ?
+                        vgpu_pm_finalize_poweron(dev) :
+                        gk20a_pm_finalize_poweron(dev);
+                if (ret) {
+                        atomic_dec(&g->usage_count.atomic_var);
+                        goto fail;
+                }
+        }
+
+fail:
+        up_read(&l->busy_lock);
+
+        return ret < 0 ? ret : 0;
+}
+
+void gk20a_idle_nosuspend(struct gk20a *g)
+{
+        pm_runtime_put_noidle(dev_from_gk20a(g));
+}
+
+void gk20a_idle(struct gk20a *g)
+{
+        struct device *dev;
+
+        atomic_dec(&g->usage_count.atomic_var);
+
+        dev = dev_from_gk20a(g);
+
+        if (!(dev && nvgpu_can_busy(g)))
+                return;
+
+        if (pm_runtime_enabled(dev)) {
+                pm_runtime_mark_last_busy(dev);
+                pm_runtime_put_sync_autosuspend(dev);
+        }
+}
+
+/*
+ * Undoes gk20a_lockout_registers().
+ */
+static int gk20a_restore_registers(struct gk20a *g)
+{
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
+
+        l->regs = l->regs_saved;
+        l->bar1 = l->bar1_saved;
+
+        nvgpu_restore_usermode_registers(g);
+
+        return 0;
+}
+
+int nvgpu_finalize_poweron_linux(struct nvgpu_os_linux *l)
+{
+        struct gk20a *g = &l->g;
+        int err;
+
+        if (l->init_done)
+                return 0;
+
+        err = nvgpu_init_channel_support_linux(l);
+        if (err) {
+                nvgpu_err(g, "failed to init linux channel support");