drivers/pinctrl/pinconf.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Core driver for the pin config portions of the pin control subsystem
   4  *
   5  * Copyright (C) 2011 ST-Ericsson SA
   6  * Written on behalf of Linaro for ST-Ericsson
   7  *
   8  * Author: Linus Walleij <linus.walleij@linaro.org>
   9  */
  10 #define pr_fmt(fmt) "pinconfig core: " fmt
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/device.h>
  16 #include <linux/slab.h>
  17 #include <linux/debugfs.h>
  18 #include <linux/seq_file.h>
  19 #include <linux/pinctrl/machine.h>
  20 #include <linux/pinctrl/pinctrl.h>
  21 #include <linux/pinctrl/pinconf.h>
  22 #include "core.h"
  23 #include "pinconf.h"
  24
  25 int pinconf_check_ops(struct pinctrl_dev *pctldev)
  26 {
  27         const struct pinconf_ops *ops = pctldev->desc->confops;
  28
  29         /* We have to be able to config the pins in SOME way */
  30         if (!ops->pin_config_set && !ops->pin_config_group_set) {
  31                 dev_err(pctldev->dev,
  32                         "pinconf has to be able to set a pins config\n");
  33                 return -EINVAL;
  34         }
  35         return 0;
  36 }
  37
  38 int pinconf_validate_map(const struct pinctrl_map *map, int i)
  39 {
  40         if (!map->data.configs.group_or_pin) {
  41                 pr_err("failed to register map %s (%d): no group/pin given\n",
  42                        map->name, i);
  43                 return -EINVAL;
  44         }
  45
  46         if (!map->data.configs.num_configs ||
  47                         !map->data.configs.configs) {
  48                 pr_err("failed to register map %s (%d): no configs given\n",
  49                        map->name, i);
  50                 return -EINVAL;
  51         }
  52
  53         return 0;
  54 }
  55
  56 int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
  57                            unsigned long *config)
  58 {
  59         const struct pinconf_ops *ops = pctldev->desc->confops;
  60
  61         if (!ops || !ops->pin_config_get) {
  62                 dev_dbg(pctldev->dev,
  63                         "cannot get pin configuration, .pin_config_get missing in driver\n");
  64                 return -ENOTSUPP;
  65         }
  66
  67         return ops->pin_config_get(pctldev, pin, config);
  68 }
  69
  70 int pin_config_group_get(const char *dev_name, const char *pin_group,
  71                          unsigned long *config)
  72 {
  73         struct pinctrl_dev *pctldev;
  74         const struct pinconf_ops *ops;
  75         int selector, ret;
  76
  77         pctldev = get_pinctrl_dev_from_devname(dev_name);
  78         if (!pctldev) {
  79                 ret = -EINVAL;
  80                 return ret;
  81         }
  82
  83         mutex_lock(&pctldev->mutex);
  84
  85         ops = pctldev->desc->confops;
  86
  87         if (!ops || !ops->pin_config_group_get) {
  88                 dev_dbg(pctldev->dev,
  89                         "cannot get configuration for pin group, missing group config get function in driver\n");
  90                 ret = -ENOTSUPP;
  91                 goto unlock;
  92         }
  93
  94         selector = pinctrl_get_group_selector(pctldev, pin_group);
  95         if (selector < 0) {
  96                 ret = selector;
  97                 goto unlock;
  98         }
  99
 100         ret = ops->pin_config_group_get(pctldev, selector, config);
 101
 102 unlock:
 103         mutex_unlock(&pctldev->mutex);
 104         return ret;
 105 }
 106
 107 int pinconf_map_to_setting(const struct pinctrl_map *map,
 108                           struct pinctrl_setting *setting)
 109 {
 110         struct pinctrl_dev *pctldev = setting->pctldev;
 111         int pin;
 112
 113         switch (setting->type) {
 114         case PIN_MAP_TYPE_CONFIGS_PIN:
 115                 pin = pin_get_from_name(pctldev,
 116                                         map->data.configs.group_or_pin);
 117                 if (pin < 0) {
 118                         dev_err(pctldev->dev, "could not map pin config for \"%s\"",
 119                                 map->data.configs.group_or_pin);
 120                         return pin;
 121                 }
 122                 setting->data.configs.group_or_pin = pin;
 123                 break;
 124         case PIN_MAP_TYPE_CONFIGS_GROUP:
 125                 pin = pinctrl_get_group_selector(pctldev,
 126                                          map->data.configs.group_or_pin);
 127                 if (pin < 0) {
 128                         dev_err(pctldev->dev, "could not map group config for \"%s\"",
 129                                 map->data.configs.group_or_pin);
 130                         return pin;
 131                 }
 132                 setting->data.configs.group_or_pin = pin;
 133                 break;
 134         default:
 135                 return -EINVAL;
 136         }
 137
 138         setting->data.configs.num_configs = map->data.configs.num_configs;
 139         setting->data.configs.configs = map->data.configs.configs;
 140
 141         return 0;
 142 }
 143
 144 void pinconf_free_setting(const struct pinctrl_setting *setting)
 145 {
 146 }
 147
 148 int pinconf_apply_setting(const struct pinctrl_setting *setting)
 149 {
 150         struct pinctrl_dev *pctldev = setting->pctldev;
 151         const struct pinconf_ops *ops = pctldev->desc->confops;
 152         int ret;
 153
 154         if (!ops) {
 155                 dev_err(pctldev->dev, "missing confops\n");
 156                 return -EINVAL;
 157         }
 158
 159         switch (setting->type) {
 160         case PIN_MAP_TYPE_CONFIGS_PIN:
 161                 if (!ops->pin_config_set) {
 162                         dev_err(pctldev->dev, "missing pin_config_set op\n");
 163                         return -EINVAL;
 164                 }
 165                 ret = ops->pin_config_set(pctldev,
 166                                 setting->data.configs.group_or_pin,
 167                                 setting->data.configs.configs,
 168                                 setting->data.configs.num_configs);
 169                 if (ret < 0) {
 170                         dev_err(pctldev->dev,
 171                                 "pin_config_set op failed for pin %d\n",
 172                                 setting->data.configs.group_or_pin);
 173                         return ret;
 174                 }
 175                 break;
 176         case PIN_MAP_TYPE_CONFIGS_GROUP:
 177                 if (!ops->pin_config_group_set) {
 178                         dev_err(pctldev->dev,
 179                                 "missing pin_config_group_set op\n");
 180                         return -EINVAL;
 181                 }
 182                 ret = ops->pin_config_group_set(pctldev,
 183                                 setting->data.configs.group_or_pin,
 184                                 setting->data.configs.configs,
 185                                 setting->data.configs.num_configs);
 186                 if (ret < 0) {
 187                         dev_err(pctldev->dev,
 188                                 "pin_config_group_set op failed for group %d\n",
 189                                 setting->data.configs.group_or_pin);
 190                         return ret;
 191                 }
 192                 break;
 193         default:
 194                 return -EINVAL;
 195         }
 196
 197         return 0;
 198 }
 199
 200 int pinconf_set_config(struct pinctrl_dev *pctldev, unsigned pin,
 201                        unsigned long *configs, size_t nconfigs)
 202 {
 203         const struct pinconf_ops *ops;
 204
 205         ops = pctldev->desc->confops;
 206         if (!ops || !ops->pin_config_set)
 207                 return -ENOTSUPP;
 208
 209         return ops->pin_config_set(pctldev, pin, configs, nconfigs);
 210 }
 211
 212 #ifdef CONFIG_DEBUG_FS
 213
 214 static void pinconf_show_config(struct seq_file *s, struct pinctrl_dev *pctldev,
 215                       unsigned long *configs, unsigned num_configs)
 216 {
 217         const struct pinconf_ops *confops;
 218         int i;
 219
 220         if (pctldev)
 221                 confops = pctldev->desc->confops;
 222         else
 223                 confops = NULL;
 224
 225         for (i = 0; i < num_configs; i++) {
 226                 seq_puts(s, "config ");
 227                 if (confops && confops->pin_config_config_dbg_show)
 228                         confops->pin_config_config_dbg_show(pctldev, s,
 229                                                             configs[i]);
 230                 else
 231                         seq_printf(s, "%08lx", configs[i]);
 232                 seq_putc(s, '\n');
 233         }
 234 }
 235
 236 void pinconf_show_map(struct seq_file *s, const struct pinctrl_map *map)
 237 {
 238         struct pinctrl_dev *pctldev;
 239
 240         pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name);
 241
 242         switch (map->type) {
 243         case PIN_MAP_TYPE_CONFIGS_PIN:
 244                 seq_puts(s, "pin ");
 245                 break;
 246         case PIN_MAP_TYPE_CONFIGS_GROUP:
 247                 seq_puts(s, "group ");
 248                 break;
 249         default:
 250                 break;
 251         }
 252
 253         seq_printf(s, "%s\n", map->data.configs.group_or_pin);
 254
 255         pinconf_show_config(s, pctldev, map->data.configs.configs,
 256                             map->data.configs.num_configs);
 257 }
 258
 259 void pinconf_show_setting(struct seq_file *s,
 260                           const struct pinctrl_setting *setting)
 261 {
 262         struct pinctrl_dev *pctldev = setting->pctldev;
 263         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 264         struct pin_desc *desc;
 265
 266         switch (setting->type) {
 267         case PIN_MAP_TYPE_CONFIGS_PIN:
 268                 desc = pin_desc_get(setting->pctldev,
 269                                     setting->data.configs.group_or_pin);
 270                 seq_printf(s, "pin %s (%d)", desc->name,
 271                            setting->data.configs.group_or_pin);
 272                 break;
 273         case PIN_MAP_TYPE_CONFIGS_GROUP:
 274                 seq_printf(s, "group %s (%d)",
 275                            pctlops->get_group_name(pctldev,
 276                                         setting->data.configs.group_or_pin),
 277                            setting->data.configs.group_or_pin);
 278                 break;
 279         default:
 280                 break;
 281         }
 282
 283         /*
 284          * FIXME: We should really get the pin controller to dump the config
 285          * values, so they can be decoded to something meaningful.
 286          */
 287         pinconf_show_config(s, pctldev, setting->data.configs.configs,
 288                             setting->data.configs.num_configs);
 289 }
 290
 291 static void pinconf_dump_pin(struct pinctrl_dev *pctldev,
 292                              struct seq_file *s, int pin)
 293 {
 294         const struct pinconf_ops *ops = pctldev->desc->confops;
 295
 296         /* no-op when not using generic pin config */
 297         pinconf_generic_dump_pins(pctldev, s, NULL, pin);
 298         if (ops && ops->pin_config_dbg_show)
 299                 ops->pin_config_dbg_show(pctldev, s, pin);
 300 }
 301
 302 static int pinconf_pins_show(struct seq_file *s, void *what)
 303 {
 304         struct pinctrl_dev *pctldev = s->private;
 305         unsigned i, pin;
 306
 307         seq_puts(s, "Pin config settings per pin\n");
 308         seq_puts(s, "Format: pin (name): configs\n");
 309
 310         mutex_lock(&pctldev->mutex);
 311
 312         /* The pin number can be retrived from the pin controller descriptor */
 313         for (i = 0; i < pctldev->desc->npins; i++) {
 314                 struct pin_desc *desc;
 315
 316                 pin = pctldev->desc->pins[i].number;
 317                 desc = pin_desc_get(pctldev, pin);
 318                 /* Skip if we cannot search the pin */
 319                 if (!desc)
 320                         continue;
 321
 322                 seq_printf(s, "pin %d (%s): ", pin, desc->name);
 323
 324                 pinconf_dump_pin(pctldev, s, pin);
 325                 seq_putc(s, '\n');
 326         }
 327
 328         mutex_unlock(&pctldev->mutex);
 329
 330         return 0;
 331 }
 332
 333 static void pinconf_dump_group(struct pinctrl_dev *pctldev,
 334                                struct seq_file *s, unsigned selector,
 335                                const char *gname)
 336 {
 337         const struct pinconf_ops *ops = pctldev->desc->confops;
 338
 339         /* no-op when not using generic pin config */
 340         pinconf_generic_dump_pins(pctldev, s, gname, 0);
 341         if (ops && ops->pin_config_group_dbg_show)
 342                 ops->pin_config_group_dbg_show(pctldev, s, selector);
 343 }
 344
 345 static int pinconf_groups_show(struct seq_file *s, void *what)
 346 {
 347         struct pinctrl_dev *pctldev = s->private;
 348         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 349         unsigned ngroups = pctlops->get_groups_count(pctldev);
 350         unsigned selector = 0;
 351
 352         seq_puts(s, "Pin config settings per pin group\n");
 353         seq_puts(s, "Format: group (name): configs\n");
 354
 355         while (selector < ngroups) {
 356                 const char *gname = pctlops->get_group_name(pctldev, selector);
 357
 358                 seq_printf(s, "%u (%s): ", selector, gname);
 359                 pinconf_dump_group(pctldev, s, selector, gname);
 360                 seq_putc(s, '\n');
 361                 selector++;
 362         }
 363
 364         return 0;
 365 }
 366
 367 DEFINE_SHOW_ATTRIBUTE(pinconf_pins);
 368 DEFINE_SHOW_ATTRIBUTE(pinconf_groups);
 369
 370 void pinconf_init_device_debugfs(struct dentry *devroot,
 371                          struct pinctrl_dev *pctldev)
 372 {
 373         debugfs_create_file("pinconf-pins", S_IFREG | S_IRUGO,
 374                             devroot, pctldev, &pinconf_pins_fops);
 375         debugfs_create_file("pinconf-groups", S_IFREG | S_IRUGO,
 376                             devroot, pctldev, &pinconf_groups_fops);
 377 }
 378
 379 #endif