video: tegra: host: update T186 VIC actmon driver

Modify T186/T210 VIC actmon driver and wmark_active governor
to address the following issues:

1. To let VIC actmon reports accurate VIC active
   cycle counts, set static WEIGHT_COUNT in both
   VIC actmon and VIC IP block. It ensures
   VIC actmon can capture all activity signal
   toggle event from VIC.

   The value of WEIGHT_COUNT are equal to:

   4 * (max VIC freq / VIC_actmon freq)
       = 4 * (1024 / 19.2)
      ~= 213

2. Since VIC actmon reports active "VIC clock
   cycle" instead of "VIC actmon clock cycle",
   "relative loading translation" should consider
   current VIC clock freq.

   E.g.,
     - sample_period = 80 us, VIC freq = 115.2 Mhz
     - 9216 cycles represents 100% loading
       (115.2 * 80)

3. Update upper/lower wmark settings after VIC
   clock scaled completed, to ensure wmark settings
   are equil to 0 ~ 100% loading of current freq.
   - Register 'get_dev_status' instance in
     devfreq_dev_profile, to let wmark active
     governor can query current device freq.
   - Register devfreq transition notifier in
     wmark_active governor. It will query current
     device freq. and update corresponding wmark
     value after VIC freq. changed.

Bug 200501949

Change-Id: Ic159eb93fddc37d55b0c9649a3afcb50ed82cac2
Signed-off-by: Aaron Tian <atian@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/2200520
GVS: Gerrit_Virtual_Submit
Reviewed-by: Arto Merilainen <amerilainen@nvidia.com>
Reviewed-by: Mikko Perttunen <mperttunen@nvidia.com>
Reviewed-by: mobile promotions <svcmobile_promotions@nvidia.com>
Tested-by: mobile promotions <svcmobile_promotions@nvidia.com>

8 files changed, 166 insertions, 16 deletions

diff --git a/drivers/devfreq/governor_wmark_active.c b/drivers/devfreq/governor_wmark_active.c
index 4f6d41c7a..8e98c809d 100644
--- a/drivers/devfreq/governor_wmark_active.c
+++ b/drivers/devfreq/governor_wmark_active.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014-2017, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2014-2019, 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,
@@ -46,6 +46,9 @@ struct wmark_gov_info {
 
         /* variable for keeping the average frequency request */
         unsigned long long      average_target_freq;
+
+        /* devfreq notifier_block */
+        struct notifier_block nb;
 };
 
 static unsigned long freqlist_up(struct wmark_gov_info *wmarkinfo,
@@ -185,9 +188,6 @@ static int devfreq_watermark_target_freq(struct devfreq *df,
                 (wmarkinfo->p_smooth * wmarkinfo->average_target_freq +
                  ideal_freq) / (wmarkinfo->p_smooth + 1);
 
-        /* update watermarks to match the ideal frequency */
-        update_watermarks(df, dev_stat.current_frequency, ideal_freq);
-
         /* do not scale too often */
         if (dt < wmarkinfo->p_block_window)
                 return 0;
@@ -276,11 +276,38 @@ static int devfreq_watermark_start(struct devfreq *df)
         return 0;
 }
 
+static int devfreq_watermark_notifier_call(struct notifier_block *nb,
+                        unsigned long event, void *ptr)
+{
+        struct wmark_gov_info *data
+                                = container_of(nb, struct wmark_gov_info, nb);
+        struct devfreq *df = (struct devfreq *)data->df;
+        unsigned long freq = 0;
+
+        switch (event) {
+        case DEVFREQ_PRECHANGE:
+                break;
+        case DEVFREQ_POSTCHANGE:
+                /* get device freq. */
+                df->profile->get_cur_freq(df->dev.parent, &freq);
+
+                /* update watermarks by current device freq. */
+                if (freq)
+                        update_watermarks(df, freq, freq);
+                break;
+        default:
+                break;
+        }
+
+        return NOTIFY_DONE;
+}
+
 static int devfreq_watermark_event_handler(struct devfreq *df,
                         unsigned int event, void *wmark_type)
 {
         struct wmark_gov_info *wmarkinfo;
         int ret = 0;
+        struct notifier_block *nb;
 
         switch (event) {
         case DEVFREQ_GOV_START:
@@ -300,10 +327,20 @@ static int devfreq_watermark_event_handler(struct devfreq *df,
 
                 update_watermarks(df, dev_stat.current_frequency,
                                         dev_stat.current_frequency);
+
+                nb = &wmarkinfo->nb;
+                nb->notifier_call = devfreq_watermark_notifier_call;
+                ret = devm_devfreq_register_notifier(df->dev.parent,
+                                df, nb, DEVFREQ_TRANSITION_NOTIFIER);
                 break;
         }
         case DEVFREQ_GOV_STOP:
                 devfreq_watermark_debug_stop(df);
+
+                wmarkinfo = df->data;
+                nb = &wmarkinfo->nb;
+                devm_devfreq_unregister_notifier(df->dev.parent,
+                                df, nb, DEVFREQ_TRANSITION_NOTIFIER);
                 break;
         case DEVFREQ_GOV_SUSPEND:
                 devfreq_monitor_suspend(df);
diff --git a/drivers/video/tegra/host/host1x/host1x_actmon_t186.c b/drivers/video/tegra/host/host1x/host1x_actmon_t186.c
index 656e56469..8d2a3a52d 100644
--- a/drivers/video/tegra/host/host1x/host1x_actmon_t186.c
+++ b/drivers/video/tegra/host/host1x/host1x_actmon_t186.c
@@ -1,7 +1,7 @@
 /*
  * Tegra Graphics Host Actmon support for T186
  *
- * Copyright (c) 2015-2017, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2015-2019, 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,
@@ -181,6 +181,21 @@ static void __iomem *host1x_actmon_get_regs(struct host1x_actmon *actmon)
         return NULL;
 }
 
+static unsigned long get_module_freq(struct host1x_actmon *actmon)
+{
+        unsigned long freq = 0;
+
+        struct platform_device *pdev = actmon->pdev;
+        struct nvhost_device_data *engine_pdata = platform_get_drvdata(pdev);
+        struct devfreq *df = engine_pdata->power_manager;
+        struct nvhost_device_data *pdata = dev_get_drvdata(df->dev.parent);
+        struct nvhost_device_profile *profile = pdata->power_profile;
+
+        freq = clk_get_rate(profile->clk);
+
+        return freq;
+}
+
 static int host1x_actmon_init(struct host1x_actmon *actmon)
 {
         struct platform_device *host_pdev = actmon->host->dev;
@@ -226,6 +241,10 @@ static int host1x_actmon_init(struct host1x_actmon *actmon)
         val |= actmon_local_ctrl_enb_cumulative_f(1);
         actmon_writel(actmon, val, actmon_local_ctrl_r());
 
+        /* Set COUNT_WEIGHT @actmon */
+        actmon_writel(actmon, engine_pdata->actmon_weight_count,
+                                        actmon_local_count_weight_r());
+
         /* Enable global interrupt */
         if (engine_pdata->actmon_irq)
                 actmon_writel(actmon, 0x1, actmon_glb_intr_en_r());
@@ -297,6 +316,8 @@ static int host1x_actmon_avg_norm(struct host1x_actmon *actmon, u32 *avg)
 {
         long val;
         int err;
+        unsigned long freq = 0;
+        u32 dev_cycle_per_sample = 0;
 
         if (!(actmon->init == ACTMON_READY && actmon->clks_per_sample > 0 &&
             actmon->divider)) {
@@ -313,7 +334,11 @@ static int host1x_actmon_avg_norm(struct host1x_actmon *actmon, u32 *avg)
         val = actmon_readl(actmon, actmon_local_avg_count_r());
         nvhost_module_idle(actmon->host->dev);
 
-        *avg = (val * 1000) / (actmon->clks_per_sample * actmon->divider);
+        freq = get_module_freq(actmon);
+        dev_cycle_per_sample = ((freq / 1000) * actmon->usecs_per_sample)
+                                                                / 1000;
+
+        *avg = (val * 1000) / dev_cycle_per_sample;
 
         return 0;
 }
@@ -366,13 +391,20 @@ static int host1x_actmon_count_norm(struct host1x_actmon *actmon, u32 *avg)
 
 static int host1x_set_high_wmark(struct host1x_actmon *actmon, u32 val_scaled)
 {
-        u32 val = (val_scaled < 1000) ?
-                ((val_scaled * actmon->clks_per_sample * actmon->divider) /
-                1000) : actmon->clks_per_sample * actmon->divider;
+        u32 freq_khz = 0;
+        u32 dev_cycle_per_sample = 0;
+        u32 val = 0;
 
         if (actmon->init != ACTMON_READY)
                 return 0;
 
+        freq_khz = get_module_freq(actmon) / 1000;
+        dev_cycle_per_sample = (actmon->usecs_per_sample * freq_khz) / 1000;
+
+        val = (val_scaled < 1000) ?
+                ((val_scaled * dev_cycle_per_sample) / 1000) :
+                dev_cycle_per_sample;
+
         /* write new watermark */
         actmon_writel(actmon, val, actmon_local_avg_upper_wmark_r());
 
@@ -391,13 +423,20 @@ static int host1x_set_high_wmark(struct host1x_actmon *actmon, u32 val_scaled)
 
 static int host1x_set_low_wmark(struct host1x_actmon *actmon, u32 val_scaled)
 {
-        u32 val = (val_scaled < 1000) ?
-                ((val_scaled * actmon->clks_per_sample * actmon->divider) /
-                1000) : actmon->clks_per_sample * actmon->divider;
+        u32 freq_khz = 0;
+        u32 dev_cycle_per_sample = 0;
+        u32 val = 0;
 
         if (actmon->init != ACTMON_READY)
                 return 0;
 
+        freq_khz = get_module_freq(actmon) / 1000;
+        dev_cycle_per_sample = (actmon->usecs_per_sample * freq_khz) / 1000;
+
+        val = (val_scaled < 1000) ?
+                ((val_scaled * dev_cycle_per_sample) / 1000) :
+                dev_cycle_per_sample;
+
         /* write new watermark */
         actmon_writel(actmon, val, actmon_local_avg_lower_wmark_r());
 
@@ -410,7 +449,6 @@ static int host1x_set_low_wmark(struct host1x_actmon *actmon, u32 val_scaled)
         actmon_writel(actmon, val, actmon_local_intr_en_r());
 
         host1x_actmon_dump_regs(actmon);
-
         return 0;
 }
 
diff --git a/drivers/video/tegra/host/host1x/hw_host1x5_actmon.h b/drivers/video/tegra/host/host1x/hw_host1x5_actmon.h
index c53c851b4..8e60ca821 100644
--- a/drivers/video/tegra/host/host1x/hw_host1x5_actmon.h
+++ b/drivers/video/tegra/host/host1x/hw_host1x5_actmon.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2015, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2015-2019, 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,
@@ -154,6 +154,10 @@ static inline u32 actmon_local_avg_count_r(void)
 {
         return 0xa4;
 }
+static inline u32 actmon_local_count_weight_r(void)
+{
+        return 0xa8;
+}
 static inline u32 actmon_local_cumulative_r(void)
 {
         return 0xac;
diff --git a/drivers/video/tegra/host/nvhost_acm.c b/drivers/video/tegra/host/nvhost_acm.c
index b78355c56..beed307d6 100644
--- a/drivers/video/tegra/host/nvhost_acm.c
+++ b/drivers/video/tegra/host/nvhost_acm.c
@@ -59,6 +59,7 @@
 #define MAX_DEVID_LENGTH                        32
 
 static void nvhost_module_load_regs(struct platform_device *pdev, bool prod);
+static void nvhost_module_set_actmon_regs(struct platform_device *pdev);
 
 #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 14, 0)
 static int nvhost_module_toggle_slcg(struct notifier_block *nb,
@@ -141,6 +142,9 @@ void nvhost_module_reset(struct platform_device *dev, bool reboot)
                 /* Load clockgating registers */
                 nvhost_module_load_regs(dev, pdata->engine_can_cg);
 
+                /* Set actmon registers */
+                nvhost_module_set_actmon_regs(dev);
+
                 /* initialize device vm */
                 nvhost_vm_init_device(dev);
 
@@ -970,6 +974,23 @@ static void nvhost_module_load_regs(struct platform_device *pdev, bool prod)
         }
 }
 
+static void nvhost_module_set_actmon_regs(struct platform_device *pdev)
+{
+        struct nvhost_device_data *pdata = platform_get_drvdata(pdev);
+        struct nvhost_actmon_register *regs = pdata->actmon_setting_regs;
+
+        if (!regs)
+                return;
+
+        if (nvhost_dev_is_virtual(pdev))
+                return;
+
+        while (regs->addr) {
+                host1x_writel(pdev, regs->addr, regs->val);
+                regs++;
+        }
+}
+
 static int nvhost_module_runtime_suspend(struct device *dev)
 {
         int err;
@@ -1192,6 +1213,10 @@ static int nvhost_module_finalize_poweron(struct device *dev)
                 goto out;
         }
 
+
+        /* Set actmon registers */
+        nvhost_module_set_actmon_regs(pdev);
+
         /* set default EMC rate to zero */
         if (pdata->bwmgr_handle) {
                 for (i = 0; i < NVHOST_MODULE_MAX_CLOCKS; i++) {
diff --git a/drivers/video/tegra/host/nvhost_scale.c b/drivers/video/tegra/host/nvhost_scale.c
index eafb6eef6..abfacf0ca 100644
--- a/drivers/video/tegra/host/nvhost_scale.c
+++ b/drivers/video/tegra/host/nvhost_scale.c
@@ -1,7 +1,7 @@
 /*
  * Tegra Graphics Host Unit clock scaling
  *
- * Copyright (c) 2010-2018, NVIDIA Corporation. All rights reserved.
+ * Copyright (c) 2010-2019, 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,
@@ -288,6 +288,17 @@ static int nvhost_scale_get_dev_status(struct device *dev,
         return 0;
 }
 
+static int nvhost_scale_get_cur_freq(struct device *dev, unsigned long *freq)
+{
+        struct nvhost_device_data *pdata = dev_get_drvdata(dev);
+        struct nvhost_device_profile *profile = pdata->power_profile;
+
+        if (freq)
+                *freq = clk_get_rate(profile->clk);
+
+        return 0;
+}
+
 /*
  * nvhost_scale_set_low_wmark(dev, threshold)
  *
@@ -417,6 +428,8 @@ void nvhost_scale_init(struct platform_device *pdev)
                 profile->devfreq_profile.target = nvhost_scale_target;
                 profile->devfreq_profile.get_dev_status =
                         nvhost_scale_get_dev_status;
+                profile->devfreq_profile.get_cur_freq =
+                        nvhost_scale_get_cur_freq;
                 profile->devfreq_profile.set_low_wmark =
                         nvhost_scale_set_low_wmark;
                 profile->devfreq_profile.set_high_wmark =
diff --git a/drivers/video/tegra/host/t186/actmon_regs.c b/drivers/video/tegra/host/t186/actmon_regs.c
new file mode 100644
index 000000000..abf521d38
--- /dev/null
+++ b/drivers/video/tegra/host/t186/actmon_regs.c
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2019, NVIDIA Corporation.  All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License.
+ *
+ *  This program is distributed in the hope that 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/>.
+ */
+
+static struct nvhost_actmon_register __attribute__((__unused__))
+        t18x_vic_actmon_registers[] = {
+        /* NV_PVIC_TFBIF_ACTMON_ACTIVE_WEIGHT */
+        { .addr = 0x00002054, .val = 0x000000d5 },
+        {}
+};
diff --git a/drivers/video/tegra/host/t186/t186.c b/drivers/video/tegra/host/t186/t186.c
index f56f21e2a..e0c79926e 100644
--- a/drivers/video/tegra/host/t186/t186.c
+++ b/drivers/video/tegra/host/t186/t186.c
@@ -1,7 +1,7 @@
 /*
  * Tegra Graphics Init for T186 Architecture Chips
  *
- * Copyright (c) 2014-2018, NVIDIA Corporation. All rights reserved.
+ * Copyright (c) 2014-2019, 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,
@@ -48,6 +48,7 @@
 
 #include "streamid_regs.c"
 #include "cg_regs.c"
+#include "actmon_regs.c"
 
 #define HOST_EMC_FLOOR 204000000
 #define HOST_NVDEC_EMC_FLOOR 102000000
@@ -446,6 +447,8 @@ struct nvhost_device_data t18_vic_info = {
         .actmon_regs            = HOST1X_THOST_ACTMON_VIC,
         .actmon_enabled         = false,
         .actmon_irq             = 3,
+        .actmon_weight_count    = 213,
+        .actmon_setting_regs    = t18x_vic_actmon_registers,
         .devfreq_governor       = "wmark_active",
         .freqs                  = {100000000, 200000000, 300000000,
                                         400000000, 500000000, 600000000},
diff --git a/include/linux/nvhost.h b/include/linux/nvhost.h
index d6170f7dc..68b967888 100644
--- a/include/linux/nvhost.h
+++ b/include/linux/nvhost.h
@@ -108,6 +108,11 @@ struct nvhost_gating_register {
         u32 disable;
 };
 
+struct nvhost_actmon_register {
+        u32 addr;
+        u32 val;
+};
+
 struct nvhost_clock {
         char *name;
         unsigned long default_rate;
@@ -244,6 +249,9 @@ struct nvhost_device_data {
         bool                            linear_emc;
         /* Offset to actmon registers */
         u32                             actmon_regs;
+        /* WEIGHT_COUNT of actmon */
+        u32                             actmon_weight_count;
+        struct nvhost_actmon_register   *actmon_setting_regs;
         /* Devfreq governor name */
         const char                      *devfreq_governor;
         unsigned long freqs[NVHOST_MODULE_MAX_FREQS];