LCOV - code coverage report
Current view: top level - drivers/pinctrl - pinconf.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 11 151 7.3 %
Date: 2020-09-30 20:25:40 Functions: 3 18 16.7 %
Branches: 3 74 4.1 %

           Branch data     Line data    Source code
       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                 :        207 : int pinconf_check_ops(struct pinctrl_dev *pctldev)
      26                 :            : {
      27                 :        207 :         const struct pinconf_ops *ops = pctldev->desc->confops;
      28                 :            : 
      29                 :            :         /* We have to be able to config the pins in SOME way */
      30   [ -  +  #  # ]:        207 :         if (!ops->pin_config_set && !ops->pin_config_group_set) {
      31                 :          0 :                 dev_err(pctldev->dev,
      32                 :            :                         "pinconf has to be able to set a pins config\n");
      33                 :          0 :                 return -EINVAL;
      34                 :            :         }
      35                 :            :         return 0;
      36                 :            : }
      37                 :            : 
      38                 :          0 : int pinconf_validate_map(const struct pinctrl_map *map, int i)
      39                 :            : {
      40         [ #  # ]:          0 :         if (!map->data.configs.group_or_pin) {
      41                 :          0 :                 pr_err("failed to register map %s (%d): no group/pin given\n",
      42                 :            :                        map->name, i);
      43                 :          0 :                 return -EINVAL;
      44                 :            :         }
      45                 :            : 
      46   [ #  #  #  # ]:          0 :         if (!map->data.configs.num_configs ||
      47                 :          0 :                         !map->data.configs.configs) {
      48                 :          0 :                 pr_err("failed to register map %s (%d): no configs given\n",
      49                 :            :                        map->name, i);
      50                 :          0 :                 return -EINVAL;
      51                 :            :         }
      52                 :            : 
      53                 :            :         return 0;
      54                 :            : }
      55                 :            : 
      56                 :          0 : int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
      57                 :            :                            unsigned long *config)
      58                 :            : {
      59                 :          0 :         const struct pinconf_ops *ops = pctldev->desc->confops;
      60                 :            : 
      61   [ #  #  #  # ]:          0 :         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                 :          0 :         return ops->pin_config_get(pctldev, pin, config);
      68                 :            : }
      69                 :            : 
      70                 :          0 : 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                 :          0 :         pctldev = get_pinctrl_dev_from_devname(dev_name);
      78         [ #  # ]:          0 :         if (!pctldev) {
      79                 :            :                 ret = -EINVAL;
      80                 :            :                 return ret;
      81                 :            :         }
      82                 :            : 
      83                 :          0 :         mutex_lock(&pctldev->mutex);
      84                 :            : 
      85                 :          0 :         ops = pctldev->desc->confops;
      86                 :            : 
      87   [ #  #  #  # ]:          0 :         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                 :          0 :         selector = pinctrl_get_group_selector(pctldev, pin_group);
      95         [ #  # ]:          0 :         if (selector < 0) {
      96                 :            :                 ret = selector;
      97                 :            :                 goto unlock;
      98                 :            :         }
      99                 :            : 
     100                 :          0 :         ret = ops->pin_config_group_get(pctldev, selector, config);
     101                 :            : 
     102                 :            : unlock:
     103                 :          0 :         mutex_unlock(&pctldev->mutex);
     104                 :          0 :         return ret;
     105                 :            : }
     106                 :            : 
     107                 :          0 : int pinconf_map_to_setting(const struct pinctrl_map *map,
     108                 :            :                           struct pinctrl_setting *setting)
     109                 :            : {
     110                 :          0 :         struct pinctrl_dev *pctldev = setting->pctldev;
     111                 :            :         int pin;
     112                 :            : 
     113      [ #  #  # ]:          0 :         switch (setting->type) {
     114                 :            :         case PIN_MAP_TYPE_CONFIGS_PIN:
     115                 :          0 :                 pin = pin_get_from_name(pctldev,
     116                 :            :                                         map->data.configs.group_or_pin);
     117         [ #  # ]:          0 :                 if (pin < 0) {
     118                 :          0 :                         dev_err(pctldev->dev, "could not map pin config for \"%s\"",
     119                 :            :                                 map->data.configs.group_or_pin);
     120                 :          0 :                         return pin;
     121                 :            :                 }
     122                 :          0 :                 setting->data.configs.group_or_pin = pin;
     123                 :          0 :                 break;
     124                 :            :         case PIN_MAP_TYPE_CONFIGS_GROUP:
     125                 :          0 :                 pin = pinctrl_get_group_selector(pctldev,
     126                 :            :                                          map->data.configs.group_or_pin);
     127         [ #  # ]:          0 :                 if (pin < 0) {
     128                 :          0 :                         dev_err(pctldev->dev, "could not map group config for \"%s\"",
     129                 :            :                                 map->data.configs.group_or_pin);
     130                 :          0 :                         return pin;
     131                 :            :                 }
     132                 :          0 :                 setting->data.configs.group_or_pin = pin;
     133                 :          0 :                 break;
     134                 :            :         default:
     135                 :            :                 return -EINVAL;
     136                 :            :         }
     137                 :            : 
     138                 :          0 :         setting->data.configs.num_configs = map->data.configs.num_configs;
     139                 :          0 :         setting->data.configs.configs = map->data.configs.configs;
     140                 :            : 
     141                 :          0 :         return 0;
     142                 :            : }
     143                 :            : 
     144                 :          0 : void pinconf_free_setting(const struct pinctrl_setting *setting)
     145                 :            : {
     146                 :          0 : }
     147                 :            : 
     148                 :          0 : int pinconf_apply_setting(const struct pinctrl_setting *setting)
     149                 :            : {
     150                 :          0 :         struct pinctrl_dev *pctldev = setting->pctldev;
     151                 :          0 :         const struct pinconf_ops *ops = pctldev->desc->confops;
     152                 :            :         int ret;
     153                 :            : 
     154         [ #  # ]:          0 :         if (!ops) {
     155                 :          0 :                 dev_err(pctldev->dev, "missing confops\n");
     156                 :          0 :                 return -EINVAL;
     157                 :            :         }
     158                 :            : 
     159      [ #  #  # ]:          0 :         switch (setting->type) {
     160                 :            :         case PIN_MAP_TYPE_CONFIGS_PIN:
     161         [ #  # ]:          0 :                 if (!ops->pin_config_set) {
     162                 :          0 :                         dev_err(pctldev->dev, "missing pin_config_set op\n");
     163                 :          0 :                         return -EINVAL;
     164                 :            :                 }
     165                 :          0 :                 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         [ #  # ]:          0 :                 if (ret < 0) {
     170                 :          0 :                         dev_err(pctldev->dev,
     171                 :            :                                 "pin_config_set op failed for pin %d\n",
     172                 :            :                                 setting->data.configs.group_or_pin);
     173                 :          0 :                         return ret;
     174                 :            :                 }
     175                 :            :                 break;
     176                 :            :         case PIN_MAP_TYPE_CONFIGS_GROUP:
     177         [ #  # ]:          0 :                 if (!ops->pin_config_group_set) {
     178                 :          0 :                         dev_err(pctldev->dev,
     179                 :            :                                 "missing pin_config_group_set op\n");
     180                 :          0 :                         return -EINVAL;
     181                 :            :                 }
     182                 :          0 :                 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         [ #  # ]:          0 :                 if (ret < 0) {
     187                 :          0 :                         dev_err(pctldev->dev,
     188                 :            :                                 "pin_config_group_set op failed for group %d\n",
     189                 :            :                                 setting->data.configs.group_or_pin);
     190                 :          0 :                         return ret;
     191                 :            :                 }
     192                 :            :                 break;
     193                 :            :         default:
     194                 :            :                 return -EINVAL;
     195                 :            :         }
     196                 :            : 
     197                 :            :         return 0;
     198                 :            : }
     199                 :            : 
     200                 :        828 : 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                 :        828 :         ops = pctldev->desc->confops;
     206   [ +  -  +  - ]:        828 :         if (!ops || !ops->pin_config_set)
     207                 :            :                 return -ENOTSUPP;
     208                 :            : 
     209                 :        828 :         return ops->pin_config_set(pctldev, pin, configs, nconfigs);
     210                 :            : }
     211                 :            : 
     212                 :            : #ifdef CONFIG_DEBUG_FS
     213                 :            : 
     214                 :          0 : 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         [ #  # ]:          0 :         if (pctldev)
     221                 :          0 :                 confops = pctldev->desc->confops;
     222                 :            :         else
     223                 :            :                 confops = NULL;
     224                 :            : 
     225         [ #  # ]:          0 :         for (i = 0; i < num_configs; i++) {
     226                 :          0 :                 seq_puts(s, "config ");
     227   [ #  #  #  # ]:          0 :                 if (confops && confops->pin_config_config_dbg_show)
     228                 :          0 :                         confops->pin_config_config_dbg_show(pctldev, s,
     229                 :          0 :                                                             configs[i]);
     230                 :            :                 else
     231                 :          0 :                         seq_printf(s, "%08lx", configs[i]);
     232                 :          0 :                 seq_putc(s, '\n');
     233                 :            :         }
     234                 :          0 : }
     235                 :            : 
     236                 :          0 : void pinconf_show_map(struct seq_file *s, const struct pinctrl_map *map)
     237                 :            : {
     238                 :            :         struct pinctrl_dev *pctldev;
     239                 :            : 
     240                 :          0 :         pctldev = get_pinctrl_dev_from_devname(map->ctrl_dev_name);
     241                 :            : 
     242      [ #  #  # ]:          0 :         switch (map->type) {
     243                 :            :         case PIN_MAP_TYPE_CONFIGS_PIN:
     244                 :          0 :                 seq_puts(s, "pin ");
     245                 :          0 :                 break;
     246                 :            :         case PIN_MAP_TYPE_CONFIGS_GROUP:
     247                 :          0 :                 seq_puts(s, "group ");
     248                 :          0 :                 break;
     249                 :            :         default:
     250                 :            :                 break;
     251                 :            :         }
     252                 :            : 
     253                 :          0 :         seq_printf(s, "%s\n", map->data.configs.group_or_pin);
     254                 :            : 
     255                 :          0 :         pinconf_show_config(s, pctldev, map->data.configs.configs,
     256                 :            :                             map->data.configs.num_configs);
     257                 :          0 : }
     258                 :            : 
     259                 :          0 : void pinconf_show_setting(struct seq_file *s,
     260                 :            :                           const struct pinctrl_setting *setting)
     261                 :            : {
     262                 :          0 :         struct pinctrl_dev *pctldev = setting->pctldev;
     263                 :          0 :         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
     264                 :            :         struct pin_desc *desc;
     265                 :            : 
     266      [ #  #  # ]:          0 :         switch (setting->type) {
     267                 :            :         case PIN_MAP_TYPE_CONFIGS_PIN:
     268                 :          0 :                 desc = pin_desc_get(setting->pctldev,
     269                 :            :                                     setting->data.configs.group_or_pin);
     270                 :          0 :                 seq_printf(s, "pin %s (%d)", desc->name,
     271                 :            :                            setting->data.configs.group_or_pin);
     272                 :          0 :                 break;
     273                 :            :         case PIN_MAP_TYPE_CONFIGS_GROUP:
     274                 :          0 :                 seq_printf(s, "group %s (%d)",
     275                 :          0 :                            pctlops->get_group_name(pctldev,
     276                 :            :                                         setting->data.configs.group_or_pin),
     277                 :            :                            setting->data.configs.group_or_pin);
     278                 :          0 :                 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                 :          0 :         pinconf_show_config(s, pctldev, setting->data.configs.configs,
     288                 :            :                             setting->data.configs.num_configs);
     289                 :          0 : }
     290                 :            : 
     291                 :          0 : static void pinconf_dump_pin(struct pinctrl_dev *pctldev,
     292                 :            :                              struct seq_file *s, int pin)
     293                 :            : {
     294                 :          0 :         const struct pinconf_ops *ops = pctldev->desc->confops;
     295                 :            : 
     296                 :            :         /* no-op when not using generic pin config */
     297                 :          0 :         pinconf_generic_dump_pins(pctldev, s, NULL, pin);
     298   [ #  #  #  # ]:          0 :         if (ops && ops->pin_config_dbg_show)
     299                 :          0 :                 ops->pin_config_dbg_show(pctldev, s, pin);
     300                 :          0 : }
     301                 :            : 
     302                 :          0 : static int pinconf_pins_show(struct seq_file *s, void *what)
     303                 :            : {
     304                 :          0 :         struct pinctrl_dev *pctldev = s->private;
     305                 :            :         unsigned i, pin;
     306                 :            : 
     307                 :          0 :         seq_puts(s, "Pin config settings per pin\n");
     308                 :          0 :         seq_puts(s, "Format: pin (name): configs\n");
     309                 :            : 
     310                 :          0 :         mutex_lock(&pctldev->mutex);
     311                 :            : 
     312                 :            :         /* The pin number can be retrived from the pin controller descriptor */
     313         [ #  # ]:          0 :         for (i = 0; i < pctldev->desc->npins; i++) {
     314                 :            :                 struct pin_desc *desc;
     315                 :            : 
     316                 :          0 :                 pin = pctldev->desc->pins[i].number;
     317                 :            :                 desc = pin_desc_get(pctldev, pin);
     318                 :            :                 /* Skip if we cannot search the pin */
     319         [ #  # ]:          0 :                 if (!desc)
     320                 :          0 :                         continue;
     321                 :            : 
     322                 :          0 :                 seq_printf(s, "pin %d (%s): ", pin, desc->name);
     323                 :            : 
     324                 :          0 :                 pinconf_dump_pin(pctldev, s, pin);
     325                 :          0 :                 seq_putc(s, '\n');
     326                 :            :         }
     327                 :            : 
     328                 :          0 :         mutex_unlock(&pctldev->mutex);
     329                 :            : 
     330                 :          0 :         return 0;
     331                 :            : }
     332                 :            : 
     333                 :          0 : static void pinconf_dump_group(struct pinctrl_dev *pctldev,
     334                 :            :                                struct seq_file *s, unsigned selector,
     335                 :            :                                const char *gname)
     336                 :            : {
     337                 :          0 :         const struct pinconf_ops *ops = pctldev->desc->confops;
     338                 :            : 
     339                 :            :         /* no-op when not using generic pin config */
     340                 :          0 :         pinconf_generic_dump_pins(pctldev, s, gname, 0);
     341   [ #  #  #  # ]:          0 :         if (ops && ops->pin_config_group_dbg_show)
     342                 :          0 :                 ops->pin_config_group_dbg_show(pctldev, s, selector);
     343                 :          0 : }
     344                 :            : 
     345                 :          0 : static int pinconf_groups_show(struct seq_file *s, void *what)
     346                 :            : {
     347                 :          0 :         struct pinctrl_dev *pctldev = s->private;
     348                 :          0 :         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
     349                 :          0 :         unsigned ngroups = pctlops->get_groups_count(pctldev);
     350                 :            :         unsigned selector = 0;
     351                 :            : 
     352                 :          0 :         seq_puts(s, "Pin config settings per pin group\n");
     353                 :          0 :         seq_puts(s, "Format: group (name): configs\n");
     354                 :            : 
     355         [ #  # ]:          0 :         while (selector < ngroups) {
     356                 :          0 :                 const char *gname = pctlops->get_group_name(pctldev, selector);
     357                 :            : 
     358                 :          0 :                 seq_printf(s, "%u (%s): ", selector, gname);
     359                 :          0 :                 pinconf_dump_group(pctldev, s, selector, gname);
     360                 :          0 :                 seq_putc(s, '\n');
     361                 :          0 :                 selector++;
     362                 :            :         }
     363                 :            : 
     364                 :          0 :         return 0;
     365                 :            : }
     366                 :            : 
     367                 :          0 : DEFINE_SHOW_ATTRIBUTE(pinconf_pins);
     368                 :          0 : DEFINE_SHOW_ATTRIBUTE(pinconf_groups);
     369                 :            : 
     370                 :        207 : void pinconf_init_device_debugfs(struct dentry *devroot,
     371                 :            :                          struct pinctrl_dev *pctldev)
     372                 :            : {
     373                 :        207 :         debugfs_create_file("pinconf-pins", S_IFREG | S_IRUGO,
     374                 :            :                             devroot, pctldev, &pinconf_pins_fops);
     375                 :        207 :         debugfs_create_file("pinconf-groups", S_IFREG | S_IRUGO,
     376                 :            :                             devroot, pctldev, &pinconf_groups_fops);
     377                 :        207 : }
     378                 :            : 
     379                 :            : #endif

Generated by: LCOV version 1.14