nvpmodel: support clocks from the device tree

* Look for a device tree node to enable the driver.
* Support capping arbitrary clocks, provided from the device tree.
* Reorder bwmgr registration and sysfs file creation to avoid a
potential race where the store/show callback could be called before
registration.

Bug 1959611

Change-Id: I98fba96f0b2f5dc0f7abbb9df5e7f1f5da8907f0
Signed-off-by: Mustafa Yigit Bilgen <mbilgen@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/1539842
GVS: Gerrit_Virtual_Submit
Reviewed-by: Terry Wang <terwang@nvidia.com>
Reviewed-by: Bharat Nihalani <bnihalani@nvidia.com>

2 files changed, 189 insertions, 28 deletions

diff --git a/Documentation/devicetree/bindings/nvpmodel/nvpmodel.txt b/Documentation/devicetree/bindings/nvpmodel/nvpmodel.txt
new file mode 100644
index 000000000..5fd3af2d7
--- /dev/null
+++ b/Documentation/devicetree/bindings/nvpmodel/nvpmodel.txt
@@ -0,0 +1,30 @@
+NVIDIA nvpmodel driver bindings
+
+Nvpmodel is a driver that provides sysfs nodes that allow capping certain clock
+frequencies in order to keep the power consumption under a certain budget.
+
+These caps are designed to be relatively static. They should not be used
+during runtime (under load) to dynamically change the power budget.
+
+Required properties:
+
+- compatible: should be "nvidia,nvpmodel"
+
+Optional properties:
+
+- clocks: Clock IDs that the driver should support capping
+- clock-names: List of strings which identify the relevant clocks
+
+Both properties must have the same number of clocks. The strings that appear
+in the clock-names property will be the names of the sysfs nodes that will be
+provided. The clock IDs and names should appear in the same order.
+
+Sample:
+
+nvpmodel: {
+        compatible = "nvidia,nvpmodel";
+        clocks = <&tegra_car TEGRA186_CLK_NVENC
+                        &tegra_car TEGRA186_CLK_NVDEC>;
+        clock-names = "nvenc", "nvdec";
+        status = "okay";
+};
diff --git a/drivers/nvpmodel/nvpmodel_emc_cap.c b/drivers/nvpmodel/nvpmodel_emc_cap.c
index a55562d6b..dbff63947 100644
--- a/drivers/nvpmodel/nvpmodel_emc_cap.c
+++ b/drivers/nvpmodel/nvpmodel_emc_cap.c
@@ -21,13 +21,16 @@
 #include <linux/sysfs.h>
 #include <linux/init.h>
 #include <linux/fs.h>
+#include <linux/slab.h>
 #include <linux/string.h>
+#include <linux/clk.h>
+#include <linux/of.h>
 #include <linux/platform/tegra/emc_bwmgr.h>
 #include <linux/platform/tegra/bwmgr_mc.h>
 
 #define AUTHOR "Terry Wang <terwang@nvidia.com>"
-#define DESCRIPTION "Nvpmodel EMC cap driver"
-#define MODULE_NAME "Nvpmodel_EMC_cap"
+#define DESCRIPTION "Nvpmodel clock cap driver"
+#define MODULE_NAME "Nvpmodel_clk_cap"
 #define VERSION "1.0"
 
 /* Module information */
@@ -36,12 +39,20 @@ MODULE_DESCRIPTION(DESCRIPTION);
 MODULE_VERSION(VERSION);
 MODULE_LICENSE("GPL");
 
-static struct kobject *emc_iso_cap_kobject;
+static struct kobject *clk_cap_kobject;
 static unsigned long emc_iso_cap;
 
 /* bandwidth manager handle */
 struct tegra_bwmgr_client *bwmgr_handle;
 
+struct nvpmodel_clk {
+        struct kobj_attribute attr;
+        struct clk *clk;
+};
+
+static struct nvpmodel_clk *clks;
+static int num_clocks;
+
 static ssize_t emc_iso_cap_show(struct kobject *kobj,
                                 struct kobj_attribute *attr, char *buf)
 {
@@ -53,12 +64,16 @@ static ssize_t emc_iso_cap_store(struct kobject *kobj,
                                 size_t count)
 {
         int error = 0;
-        sscanf(buf, "%lu", &emc_iso_cap);
+        if (sscanf(buf, "%lu", &emc_iso_cap) != 1)
+                return -EINVAL;
+
         error = tegra_bwmgr_set_emc(bwmgr_handle, emc_iso_cap,
                                 TEGRA_BWMGR_SET_EMC_ISO_CAP);
-        if (error)
+        if (error) {
                 pr_warn("Nvpmodel failed to set EMC hz=%lu errno=%d\n",
                         emc_iso_cap, error);
+                return error;
+        }
 
         return count;
 }
@@ -66,47 +81,163 @@ static ssize_t emc_iso_cap_store(struct kobject *kobj,
 static struct kobj_attribute emc_iso_cap_attribute =
         __ATTR(emc_iso_cap, 0660, emc_iso_cap_show, emc_iso_cap_store);
 
-static int __init nvpmodel_emc_cap_init(void)
+static ssize_t clk_cap_show(struct kobject *kobj,
+                                struct kobj_attribute *attr, char *buf)
+{
+        long rate;
+        struct nvpmodel_clk *clk = container_of(attr, struct nvpmodel_clk, attr);
+
+        rate = clk_round_rate(clk->clk, 1UL << 63);
+        if (rate < 0) {
+                pr_err("clk_round_rate failed: %ld\n", rate);
+                return rate;
+        }
+
+        return sprintf(buf, "%ld\n", rate);
+}
+
+static ssize_t clk_cap_store(struct kobject *kobj,
+                                struct kobj_attribute *attr, const char *buf,
+                                size_t count)
+{
+        unsigned long rate;
+        int ret;
+        struct nvpmodel_clk *clk = container_of(attr, struct nvpmodel_clk, attr);
+
+        if (sscanf(buf, "%lu", &rate) != 1)
+                return -EINVAL;
+
+        ret = clk_set_max_rate(clk->clk, rate);
+        if (ret) {
+                pr_err("setting cap failed: %d\n", ret);
+                return ret;
+        }
+
+        return count;
+}
+
+static void free_resources(void)
+{
+        int i;
+
+        if (clks) {
+                for (i = 0; i < num_clocks; i++) {
+                        if (clks[i].attr.attr.name)
+                                kfree_const(clks[i].attr.attr.name);
+                        if (clks[i].clk)
+                                clk_put(clks[i].clk);
+                }
+                kfree(clks);
+                clks = NULL;
+                num_clocks = 0;
+        }
+        if (bwmgr_handle) {
+                tegra_bwmgr_unregister(bwmgr_handle);
+                bwmgr_handle = NULL;
+        }
+        if (clk_cap_kobject) {
+                kobject_put(clk_cap_kobject);
+                clk_cap_kobject = NULL;
+        }
+}
+
+static int __init nvpmodel_clk_cap_init(void)
 {
         int error = 0;
+        int i;
+        const char *clk_name;
+        struct device_node *dn;
+
+        dn = of_find_compatible_node(NULL, NULL, "nvidia,nvpmodel");
+        if (!dn || !of_device_is_available(dn)) {
+                of_node_put(dn);
+                return -ENODEV;
+        }
 
-        emc_iso_cap_kobject = kobject_create_and_add("nvpmodel_emc_cap",
+        clk_cap_kobject = kobject_create_and_add("nvpmodel_emc_cap",
                                                  kernel_kobj);
-        if (!emc_iso_cap_kobject)
-                return -ENOMEM;
-        error = sysfs_create_file(emc_iso_cap_kobject,
-                                &emc_iso_cap_attribute.attr);
-        if (error) {
-                pr_err("failed to create emc_iso_cap sysfs: error %d\n", error);
-                kobject_put(emc_iso_cap_kobject);
-                return error;
+        if (!clk_cap_kobject) {
+                error = -ENOMEM;
+                goto exit;
         }
 
         bwmgr_handle = tegra_bwmgr_register(TEGRA_BWMGR_CLIENT_NVPMODEL);
         if (IS_ERR_OR_NULL(bwmgr_handle)) {
                 error = IS_ERR(bwmgr_handle) ?
                         PTR_ERR(bwmgr_handle) : -ENODEV;
-                pr_warn("Nvpmodel can't register EMC bwmgr (%d)\n", error);
-                goto put_bwmgr;
+                pr_err("Nvpmodel can't register EMC bwmgr (%d)\n", error);
+                goto exit;
         }
 
-        pr_info("Module initialized successfully \n");
-        return error;
+        error = sysfs_create_file(clk_cap_kobject,
+                                &emc_iso_cap_attribute.attr);
+        if (error) {
+                pr_err("failed to create emc_iso_cap sysfs: error %d\n", error);
+                goto exit;
+        }
 
-put_bwmgr:
-        if (!IS_ERR_OR_NULL(bwmgr_handle))
-                tegra_bwmgr_unregister(bwmgr_handle);
-        kobject_put(emc_iso_cap_kobject);
+        num_clocks = of_property_count_strings(dn, "clock-names");
+        if (num_clocks <= 0) {
+                num_clocks = 0;
+                goto exit;
+        }
 
+        clks = kzalloc(sizeof(*clks) * num_clocks, GFP_KERNEL);
+        if (!clks) {
+                num_clocks = 0;
+                pr_err("couldn't allocate clks!\n");
+                error = -ENOMEM;
+                goto exit;
+        }
+
+        for (i = 0; i < num_clocks; i++) {
+                if (of_property_read_string_index(dn, "clock-names", i,
+                                        &clk_name)) {
+                        pr_warn("couldn't get clock %d from device tree\n", i);
+                        continue;
+                }
+
+                clks[i].clk = of_clk_get(dn, i);
+                if (IS_ERR(clks[i].clk)) {
+                        clks[i].clk = NULL;
+                        pr_warn("couldn't get clock: %s, error %d\n", clk_name,
+                                        error);
+                        continue;
+                }
+
+                clks[i].attr.attr.name = kstrdup_const(clk_name, GFP_KERNEL);
+                if (!clks[i].attr.attr.name) {
+                        pr_warn("couldn't allocate memory for clock %s\n",
+                                        clk_name);
+                        continue;
+                }
+
+                clks[i].attr.attr.mode = 0660;
+                clks[i].attr.show = clk_cap_show;
+                clks[i].attr.store = clk_cap_store;
+                if (sysfs_create_file(clk_cap_kobject,
+                                &clks[i].attr.attr)) {
+                        pr_warn("failed to create %s cap sysfs file: error %d\n",
+                                        clk_name, error);
+                        continue;
+                }
+        }
+exit:
+        if (error) {
+                free_resources();
+                pr_err("nvpmodel: initialization failed: error %d\n", error);
+        } else {
+                pr_info("nvpmodel: initialized successfully\n");
+        }
+        of_node_put(dn);
         return error;
 }
 
-static void __exit nvpmodel_emc_cap_exit(void)
+static void __exit nvpmodel_clk_cap_exit(void)
 {
-        tegra_bwmgr_unregister(bwmgr_handle);
-        kobject_put(emc_iso_cap_kobject);
+        free_resources();
         pr_info("Module exit successfully \n");
 }
 
-module_init(nvpmodel_emc_cap_init);
-module_exit(nvpmodel_emc_cap_exit);
+module_init(nvpmodel_clk_cap_init);
+module_exit(nvpmodel_clk_cap_exit);