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

diff --git a/include/os/linux/scale.c b/include/os/linux/scale.c
new file mode 100644
index 0000000..388e168
--- /dev/null
+++ b/include/os/linux/scale.c
@@ -0,0 +1,435 @@
+/*
+ * gk20a clock scaling profile
+ *
+ * Copyright (c) 2013-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/devfreq.h>
+#include <linux/export.h>
+#include <soc/tegra/chip-id.h>
+#include <linux/pm_qos.h>
+
+#include <governor.h>
+
+#include <nvgpu/kmem.h>
+#include <nvgpu/log.h>
+#include <nvgpu/gk20a.h>
+#include <nvgpu/clk_arb.h>
+
+#include "platform_gk20a.h"
+#include "scale.h"
+#include "os_linux.h"
+
+/*
+ * gk20a_scale_qos_notify()
+ *
+ * This function is called when the minimum QoS requirement for the device
+ * has changed. The function calls postscaling callback if it is defined.
+ */
+
+#if defined(CONFIG_GK20A_PM_QOS) && defined(CONFIG_COMMON_CLK)
+int gk20a_scale_qos_notify(struct notifier_block *nb,
+                          unsigned long n, void *p)
+{
+        struct gk20a_scale_profile *profile =
+                        container_of(nb, struct gk20a_scale_profile,
+                        qos_notify_block);
+        struct gk20a *g = get_gk20a(profile->dev);
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
+        struct devfreq *devfreq = l->devfreq;
+
+        if (!devfreq)
+                return NOTIFY_OK;
+
+        mutex_lock(&devfreq->lock);
+        /* check for pm_qos min and max frequency requirement */
+        profile->qos_min_freq =
+          (unsigned long)pm_qos_read_min_bound(PM_QOS_GPU_FREQ_BOUNDS) * 1000UL;
+        profile->qos_max_freq =
+          (unsigned long)pm_qos_read_max_bound(PM_QOS_GPU_FREQ_BOUNDS) * 1000UL;
+
+        if (profile->qos_min_freq > profile->qos_max_freq) {
+                nvgpu_err(g,
+                        "QoS: setting invalid limit, min_freq=%lu max_freq=%lu",
+                        profile->qos_min_freq, profile->qos_max_freq);
+                profile->qos_min_freq = profile->qos_max_freq;
+        }
+
+        update_devfreq(devfreq);
+        mutex_unlock(&devfreq->lock);
+
+        return NOTIFY_OK;
+}
+#elif defined(CONFIG_GK20A_PM_QOS)
+int gk20a_scale_qos_notify(struct notifier_block *nb,
+                          unsigned long n, void *p)
+{
+        struct gk20a_scale_profile *profile =
+                container_of(nb, struct gk20a_scale_profile,
+                             qos_notify_block);
+        struct gk20a_platform *platform = dev_get_drvdata(profile->dev);
+        struct gk20a *g = get_gk20a(profile->dev);
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
+        unsigned long freq;
+
+        if (!platform->postscale)
+                return NOTIFY_OK;
+
+        /* get the frequency requirement. if devfreq is enabled, check if it
+         * has higher demand than qos */
+        freq = platform->clk_round_rate(profile->dev,
+                        (u32)pm_qos_read_min_bound(PM_QOS_GPU_FREQ_BOUNDS));
+        if (l->devfreq)
+                freq = max(l->devfreq->previous_freq, freq);
+
+        /* Update gpu load because we may scale the emc target
+         * if the gpu load changed. */
+        nvgpu_pmu_load_update(g);
+        platform->postscale(profile->dev, freq);
+
+        return NOTIFY_OK;
+}
+#else
+int gk20a_scale_qos_notify(struct notifier_block *nb,
+                          unsigned long n, void *p)
+{
+        return 0;
+}
+#endif
+
+/*
+ * gk20a_scale_make_freq_table(profile)
+ *
+ * This function initialises the frequency table for the given device profile
+ */
+
+static int gk20a_scale_make_freq_table(struct gk20a_scale_profile *profile)
+{
+        struct gk20a_platform *platform = dev_get_drvdata(profile->dev);
+        int num_freqs, err;
+        unsigned long *freqs;
+
+        if (platform->get_clk_freqs) {
+                /* get gpu frequency table */
+                err = platform->get_clk_freqs(profile->dev, &freqs,
+                                        &num_freqs);
+
+                if (err)
+                        return -ENOSYS;
+        } else
+                return -ENOSYS;
+
+        profile->devfreq_profile.freq_table = (unsigned long *)freqs;
+        profile->devfreq_profile.max_state = num_freqs;
+
+        return 0;
+}
+
+/*
+ * gk20a_scale_target(dev, *freq, flags)
+ *
+ * This function scales the clock
+ */
+
+static int gk20a_scale_target(struct device *dev, unsigned long *freq,
+                              u32 flags)
+{
+        struct gk20a_platform *platform = dev_get_drvdata(dev);
+        struct gk20a *g = platform->g;
+        struct nvgpu_os_linux *l = nvgpu_os_linux_from_gk20a(g);
+        struct gk20a_scale_profile *profile = g->scale_profile;
+        struct devfreq *devfreq = l->devfreq;
+        unsigned long local_freq = *freq;
+        unsigned long rounded_rate;
+        unsigned long min_freq = 0, max_freq = 0;
+
+        if (nvgpu_clk_arb_has_active_req(g))
+                return 0;
+        /*
+         * Calculate floor and cap frequency values
+         *
+         * Policy :
+         * We have two APIs to clip the frequency
+         *  1. devfreq
+         *  2. pm_qos
+         *
+         * To calculate floor (min) freq, we select MAX of floor frequencies
+         * requested from both APIs
+         * To get cap (max) freq, we select MIN of max frequencies
+         *
+         * In case we have conflict (min_freq > max_freq) after above
+         * steps, we ensure that max_freq wins over min_freq
+         */
+        min_freq = max_t(u32, devfreq->min_freq, profile->qos_min_freq);
+        max_freq = min_t(u32, devfreq->max_freq, profile->qos_max_freq);
+
+        if (min_freq > max_freq)
+                min_freq = max_freq;
+
+        /* Clip requested frequency */
+        if (local_freq < min_freq)
+                local_freq = min_freq;
+
+        if (local_freq > max_freq)
+                local_freq = max_freq;
+
+        /* set the final frequency */
+        rounded_rate = platform->clk_round_rate(dev, local_freq);
+
+        /* Check for duplicate request */
+        if (rounded_rate == g->last_freq)
+                return 0;
+
+        if (g->ops.clk.get_rate(g, CTRL_CLK_DOMAIN_GPCCLK) == rounded_rate)
+                *freq = rounded_rate;
+        else {
+                g->ops.clk.set_rate(g, CTRL_CLK_DOMAIN_GPCCLK, rounded_rate);
+                *freq = g->ops.clk.get_rate(g, CTRL_CLK_DOMAIN_GPCCLK);
+        }
+
+        g->last_freq = *freq;
+
+        /* postscale will only scale emc (dram clock) if evaluating
+         * gk20a_tegra_get_emc_rate() produces a new or different emc
+         * target because the load or_and gpufreq has changed */
+        if (platform->postscale)
+                platform->postscale(dev, rounded_rate);
+
+        return 0;
+}
+
+/*
+ * update_load_estimate_busy_cycles(dev)
+ *
+ * Update load estimate using pmu idle counters. Result is normalised
+ * based on the time it was asked last time.
+ */