drivers/opp/debugfs.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Generic OPP debugfs interface
   4  *
   5  * Copyright (C) 2015-2016 Viresh Kumar <viresh.kumar@linaro.org>
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/debugfs.h>
  11 #include <linux/device.h>
  12 #include <linux/err.h>
  13 #include <linux/of.h>
  14 #include <linux/init.h>
  15 #include <linux/limits.h>
  16 #include <linux/slab.h>
  17
  18 #include "opp.h"
  19
  20 static struct dentry *rootdir;
  21
  22 static void opp_set_dev_name(const struct device *dev, char *name)
  23 {
  24         if (dev->parent)
  25                 snprintf(name, NAME_MAX, "%s-%s", dev_name(dev->parent),
  26                          dev_name(dev));
  27         else
  28                 snprintf(name, NAME_MAX, "%s", dev_name(dev));
  29 }
  30
  31 void opp_debug_remove_one(struct dev_pm_opp *opp)
  32 {
  33         debugfs_remove_recursive(opp->dentry);
  34 }
  35
  36 static ssize_t bw_name_read(struct file *fp, char __user *userbuf,
  37                             size_t count, loff_t *ppos)
  38 {
  39         struct icc_path *path = fp->private_data;
  40         const char *name = icc_get_name(path);
  41         char buf[64];
  42         int i = 0;
  43
  44         if (name)
  45                 i = scnprintf(buf, sizeof(buf), "%.62s\n", name);
  46
  47         return simple_read_from_buffer(userbuf, count, ppos, buf, i);
  48 }
  49
  50 static const struct file_operations bw_name_fops = {
  51         .open = simple_open,
  52         .read = bw_name_read,
  53         .llseek = default_llseek,
  54 };
  55
  56 static void opp_debug_create_bw(struct dev_pm_opp *opp,
  57                                 struct opp_table *opp_table,
  58                                 struct dentry *pdentry)
  59 {
  60         struct dentry *d;
  61         char name[] = "icc-path-XXXXXXXXXXX"; /* Integers can take 11 chars max */
  62         int i;
  63
  64         for (i = 0; i < opp_table->path_count; i++) {
  65                 snprintf(name, sizeof(name), "icc-path-%d", i);
  66
  67                 /* Create per-path directory */
  68                 d = debugfs_create_dir(name, pdentry);
  69
  70                 debugfs_create_file("name", S_IRUGO, d, opp_table->paths[i],
  71                                     &bw_name_fops);
  72                 debugfs_create_u32("peak_bw", S_IRUGO, d,
  73                                    &opp->bandwidth[i].peak);
  74                 debugfs_create_u32("avg_bw", S_IRUGO, d,
  75                                    &opp->bandwidth[i].avg);
  76         }
  77 }
  78
  79 static void opp_debug_create_clks(struct dev_pm_opp *opp,
  80                                   struct opp_table *opp_table,
  81                                   struct dentry *pdentry)
  82 {
  83         char name[] = "rate_hz_XXXXXXXXXXX"; /* Integers can take 11 chars max */
  84         int i;
  85
  86         if (opp_table->clk_count == 1) {
  87                 debugfs_create_ulong("rate_hz", S_IRUGO, pdentry, &opp->rates[0]);
  88                 return;
  89         }
  90
  91         for (i = 0; i < opp_table->clk_count; i++) {
  92                 snprintf(name, sizeof(name), "rate_hz_%d", i);
  93                 debugfs_create_ulong(name, S_IRUGO, pdentry, &opp->rates[i]);
  94         }
  95 }
  96
  97 static void opp_debug_create_supplies(struct dev_pm_opp *opp,
  98                                       struct opp_table *opp_table,
  99                                       struct dentry *pdentry)
 100 {
 101         struct dentry *d;
 102         int i;
 103
 104         for (i = 0; i < opp_table->regulator_count; i++) {
 105                 char name[] = "supply-XXXXXXXXXXX"; /* Integers can take 11 chars max */
 106
 107                 snprintf(name, sizeof(name), "supply-%d", i);
 108
 109                 /* Create per-opp directory */
 110                 d = debugfs_create_dir(name, pdentry);
 111
 112                 debugfs_create_ulong("u_volt_target", S_IRUGO, d,
 113                                      &opp->supplies[i].u_volt);
 114
 115                 debugfs_create_ulong("u_volt_min", S_IRUGO, d,
 116                                      &opp->supplies[i].u_volt_min);
 117
 118                 debugfs_create_ulong("u_volt_max", S_IRUGO, d,
 119                                      &opp->supplies[i].u_volt_max);
 120
 121                 debugfs_create_ulong("u_amp", S_IRUGO, d,
 122                                      &opp->supplies[i].u_amp);
 123
 124                 debugfs_create_ulong("u_watt", S_IRUGO, d,
 125                                      &opp->supplies[i].u_watt);
 126         }
 127 }
 128
 129 void opp_debug_create_one(struct dev_pm_opp *opp, struct opp_table *opp_table)
 130 {
 131         struct dentry *pdentry = opp_table->dentry;
 132         struct dentry *d;
 133         unsigned long id;
 134         char name[25];  /* 20 chars for 64 bit value + 5 (opp:\0) */
 135
 136         /*
 137          * Get directory name for OPP.
 138          *
 139          * - Normally rate is unique to each OPP, use it to get unique opp-name.
 140          * - For some devices rate isn't available or there are multiple, use
 141          *   index instead for them.
 142          */
 143         if (likely(opp_table->clk_count == 1 && opp->rates[0]))
 144                 id = opp->rates[0];
 145         else
 146                 id = _get_opp_count(opp_table);
 147
 148         snprintf(name, sizeof(name), "opp:%lu", id);
 149
 150         /* Create per-opp directory */
 151         d = debugfs_create_dir(name, pdentry);
 152
 153         debugfs_create_bool("available", S_IRUGO, d, &opp->available);
 154         debugfs_create_bool("dynamic", S_IRUGO, d, &opp->dynamic);
 155         debugfs_create_bool("turbo", S_IRUGO, d, &opp->turbo);
 156         debugfs_create_bool("suspend", S_IRUGO, d, &opp->suspend);
 157         debugfs_create_u32("level", S_IRUGO, d, &opp->level);
 158         debugfs_create_ulong("clock_latency_ns", S_IRUGO, d,
 159                              &opp->clock_latency_ns);
 160
 161         opp->of_name = of_node_full_name(opp->np);
 162         debugfs_create_str("of_name", S_IRUGO, d, (char **)&opp->of_name);
 163
 164         opp_debug_create_clks(opp, opp_table, d);
 165         opp_debug_create_supplies(opp, opp_table, d);
 166         opp_debug_create_bw(opp, opp_table, d);
 167
 168         opp->dentry = d;
 169 }
 170
 171 static void opp_list_debug_create_dir(struct opp_device *opp_dev,
 172                                       struct opp_table *opp_table)
 173 {
 174         const struct device *dev = opp_dev->dev;
 175         struct dentry *d;
 176
 177         opp_set_dev_name(dev, opp_table->dentry_name);
 178
 179         /* Create device specific directory */
 180         d = debugfs_create_dir(opp_table->dentry_name, rootdir);
 181
 182         opp_dev->dentry = d;
 183         opp_table->dentry = d;
 184 }
 185
 186 static void opp_list_debug_create_link(struct opp_device *opp_dev,
 187                                        struct opp_table *opp_table)
 188 {
 189         char name[NAME_MAX];
 190
 191         opp_set_dev_name(opp_dev->dev, name);
 192
 193         /* Create device specific directory link */
 194         opp_dev->dentry = debugfs_create_symlink(name, rootdir,
 195                                                  opp_table->dentry_name);
 196 }
 197
 198 /**
 199  * opp_debug_register - add a device opp node to the debugfs 'opp' directory
 200  * @opp_dev: opp-dev pointer for device
 201  * @opp_table: the device-opp being added
 202  *
 203  * Dynamically adds device specific directory in debugfs 'opp' directory. If the
 204  * device-opp is shared with other devices, then links will be created for all
 205  * devices except the first.
 206  */
 207 void opp_debug_register(struct opp_device *opp_dev, struct opp_table *opp_table)
 208 {
 209         if (opp_table->dentry)
 210                 opp_list_debug_create_link(opp_dev, opp_table);
 211         else
 212                 opp_list_debug_create_dir(opp_dev, opp_table);
 213 }
 214
 215 static void opp_migrate_dentry(struct opp_device *opp_dev,
 216                                struct opp_table *opp_table)
 217 {
 218         struct opp_device *new_dev = NULL, *iter;
 219         const struct device *dev;
 220         struct dentry *dentry;
 221
 222         /* Look for next opp-dev */
 223         list_for_each_entry(iter, &opp_table->dev_list, node)
 224                 if (iter != opp_dev) {
 225                         new_dev = iter;
 226                         break;
 227                 }
 228
 229         BUG_ON(!new_dev);
 230
 231         /* new_dev is guaranteed to be valid here */
 232         dev = new_dev->dev;
 233         debugfs_remove_recursive(new_dev->dentry);
 234
 235         opp_set_dev_name(dev, opp_table->dentry_name);
 236
 237         dentry = debugfs_rename(rootdir, opp_dev->dentry, rootdir,
 238                                 opp_table->dentry_name);
 239         if (IS_ERR(dentry)) {
 240                 dev_err(dev, "%s: Failed to rename link from: %s to %s\n",
 241                         __func__, dev_name(opp_dev->dev), dev_name(dev));
 242                 return;
 243         }
 244
 245         new_dev->dentry = dentry;
 246         opp_table->dentry = dentry;
 247 }
 248
 249 /**
 250  * opp_debug_unregister - remove a device opp node from debugfs opp directory
 251  * @opp_dev: opp-dev pointer for device
 252  * @opp_table: the device-opp being removed
 253  *
 254  * Dynamically removes device specific directory from debugfs 'opp' directory.
 255  */
 256 void opp_debug_unregister(struct opp_device *opp_dev,
 257                           struct opp_table *opp_table)
 258 {
 259         if (opp_dev->dentry == opp_table->dentry) {
 260                 /* Move the real dentry object under another device */
 261                 if (!list_is_singular(&opp_table->dev_list)) {
 262                         opp_migrate_dentry(opp_dev, opp_table);
 263                         goto out;
 264                 }
 265                 opp_table->dentry = NULL;
 266         }
 267
 268         debugfs_remove_recursive(opp_dev->dentry);
 269
 270 out:
 271         opp_dev->dentry = NULL;
 272 }
 273
 274 static int __init opp_debug_init(void)
 275 {
 276         /* Create /sys/kernel/debug/opp directory */
 277         rootdir = debugfs_create_dir("opp", NULL);
 278
 279         return 0;
 280 }
 281 core_initcall(opp_debug_init);