LCOV - code coverage report
Current view: top level - drivers/pinctrl - devicetree.c (source / functions) Hit Total Coverage
Test: Real Lines: 69 133 51.9 %
Date: 2020-10-17 15:46:16 Functions: 0 13 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * Device tree integration for the pin control subsystem
       4                 :            :  *
       5                 :            :  * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
       6                 :            :  */
       7                 :            : 
       8                 :            : #include <linux/device.h>
       9                 :            : #include <linux/of.h>
      10                 :            : #include <linux/pinctrl/pinctrl.h>
      11                 :            : #include <linux/slab.h>
      12                 :            : 
      13                 :            : #include "core.h"
      14                 :            : #include "devicetree.h"
      15                 :            : 
      16                 :            : /**
      17                 :            :  * struct pinctrl_dt_map - mapping table chunk parsed from device tree
      18                 :            :  * @node: list node for struct pinctrl's @dt_maps field
      19                 :            :  * @pctldev: the pin controller that allocated this struct, and will free it
      20                 :            :  * @maps: the mapping table entries
      21                 :            :  */
      22                 :            : struct pinctrl_dt_map {
      23                 :            :         struct list_head node;
      24                 :            :         struct pinctrl_dev *pctldev;
      25                 :            :         struct pinctrl_map *map;
      26                 :            :         unsigned num_maps;
      27                 :            : };
      28                 :            : 
      29                 :          3 : static void dt_free_map(struct pinctrl_dev *pctldev,
      30                 :            :                      struct pinctrl_map *map, unsigned num_maps)
      31                 :            : {
      32                 :            :         int i;
      33                 :            : 
      34                 :          3 :         for (i = 0; i < num_maps; ++i) {
      35                 :          3 :                 kfree_const(map[i].dev_name);
      36                 :          3 :                 map[i].dev_name = NULL;
      37                 :            :         }
      38                 :            : 
      39                 :          3 :         if (pctldev) {
      40                 :          3 :                 const struct pinctrl_ops *ops = pctldev->desc->pctlops;
      41                 :          3 :                 if (ops->dt_free_map)
      42                 :          3 :                         ops->dt_free_map(pctldev, map, num_maps);
      43                 :            :         } else {
      44                 :            :                 /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
      45                 :          0 :                 kfree(map);
      46                 :            :         }
      47                 :          3 : }
      48                 :            : 
      49                 :          3 : void pinctrl_dt_free_maps(struct pinctrl *p)
      50                 :            : {
      51                 :            :         struct pinctrl_dt_map *dt_map, *n1;
      52                 :            : 
      53                 :          3 :         list_for_each_entry_safe(dt_map, n1, &p->dt_maps, node) {
      54                 :          3 :                 pinctrl_unregister_map(dt_map->map);
      55                 :            :                 list_del(&dt_map->node);
      56                 :          3 :                 dt_free_map(dt_map->pctldev, dt_map->map,
      57                 :            :                             dt_map->num_maps);
      58                 :          3 :                 kfree(dt_map);
      59                 :            :         }
      60                 :            : 
      61                 :          3 :         of_node_put(p->dev->of_node);
      62                 :          3 : }
      63                 :            : 
      64                 :          3 : static int dt_remember_or_free_map(struct pinctrl *p, const char *statename,
      65                 :            :                                    struct pinctrl_dev *pctldev,
      66                 :            :                                    struct pinctrl_map *map, unsigned num_maps)
      67                 :            : {
      68                 :            :         int i;
      69                 :            :         struct pinctrl_dt_map *dt_map;
      70                 :            : 
      71                 :            :         /* Initialize common mapping table entry fields */
      72                 :          3 :         for (i = 0; i < num_maps; i++) {
      73                 :            :                 const char *devname;
      74                 :            : 
      75                 :          3 :                 devname = kstrdup_const(dev_name(p->dev), GFP_KERNEL);
      76                 :          3 :                 if (!devname)
      77                 :            :                         goto err_free_map;
      78                 :            : 
      79                 :          3 :                 map[i].dev_name = devname;
      80                 :          3 :                 map[i].name = statename;
      81                 :          3 :                 if (pctldev)
      82                 :          3 :                         map[i].ctrl_dev_name = dev_name(pctldev->dev);
      83                 :            :         }
      84                 :            : 
      85                 :            :         /* Remember the converted mapping table entries */
      86                 :          3 :         dt_map = kzalloc(sizeof(*dt_map), GFP_KERNEL);
      87                 :          3 :         if (!dt_map)
      88                 :            :                 goto err_free_map;
      89                 :            : 
      90                 :          3 :         dt_map->pctldev = pctldev;
      91                 :          3 :         dt_map->map = map;
      92                 :          3 :         dt_map->num_maps = num_maps;
      93                 :          3 :         list_add_tail(&dt_map->node, &p->dt_maps);
      94                 :            : 
      95                 :          3 :         return pinctrl_register_map(map, num_maps, false);
      96                 :            : 
      97                 :            : err_free_map:
      98                 :          0 :         dt_free_map(pctldev, map, num_maps);
      99                 :          0 :         return -ENOMEM;
     100                 :            : }
     101                 :            : 
     102                 :          0 : struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
     103                 :            : {
     104                 :          0 :         return get_pinctrl_dev_from_of_node(np);
     105                 :            : }
     106                 :            : 
     107                 :          3 : static int dt_to_map_one_config(struct pinctrl *p,
     108                 :            :                                 struct pinctrl_dev *hog_pctldev,
     109                 :            :                                 const char *statename,
     110                 :            :                                 struct device_node *np_config)
     111                 :            : {
     112                 :            :         struct pinctrl_dev *pctldev = NULL;
     113                 :            :         struct device_node *np_pctldev;
     114                 :            :         const struct pinctrl_ops *ops;
     115                 :            :         int ret;
     116                 :            :         struct pinctrl_map *map;
     117                 :            :         unsigned num_maps;
     118                 :            :         bool allow_default = false;
     119                 :            : 
     120                 :            :         /* Find the pin controller containing np_config */
     121                 :          3 :         np_pctldev = of_node_get(np_config);
     122                 :            :         for (;;) {
     123                 :          3 :                 if (!allow_default)
     124                 :            :                         allow_default = of_property_read_bool(np_pctldev,
     125                 :            :                                                               "pinctrl-use-default");
     126                 :            : 
     127                 :          3 :                 np_pctldev = of_get_next_parent(np_pctldev);
     128                 :          3 :                 if (!np_pctldev || of_node_is_root(np_pctldev)) {
     129                 :          0 :                         of_node_put(np_pctldev);
     130                 :            :                         /* keep deferring if modules are enabled unless we've timed out */
     131                 :          0 :                         if (IS_ENABLED(CONFIG_MODULES) && !allow_default)
     132                 :          0 :                                 return driver_deferred_probe_check_state_continue(p->dev);
     133                 :            : 
     134                 :          0 :                         return driver_deferred_probe_check_state(p->dev);
     135                 :            :                 }
     136                 :            :                 /* If we're creating a hog we can use the passed pctldev */
     137                 :          3 :                 if (hog_pctldev && (np_pctldev == p->dev->of_node)) {
     138                 :            :                         pctldev = hog_pctldev;
     139                 :            :                         break;
     140                 :            :                 }
     141                 :          3 :                 pctldev = get_pinctrl_dev_from_of_node(np_pctldev);
     142                 :          3 :                 if (pctldev)
     143                 :            :                         break;
     144                 :            :                 /* Do not defer probing of hogs (circular loop) */
     145                 :          0 :                 if (np_pctldev == p->dev->of_node) {
     146                 :          0 :                         of_node_put(np_pctldev);
     147                 :          0 :                         return -ENODEV;
     148                 :            :                 }
     149                 :            :         }
     150                 :          3 :         of_node_put(np_pctldev);
     151                 :            : 
     152                 :            :         /*
     153                 :            :          * Call pinctrl driver to parse device tree node, and
     154                 :            :          * generate mapping table entries
     155                 :            :          */
     156                 :          3 :         ops = pctldev->desc->pctlops;
     157                 :          3 :         if (!ops->dt_node_to_map) {
     158                 :          0 :                 dev_err(p->dev, "pctldev %s doesn't support DT\n",
     159                 :            :                         dev_name(pctldev->dev));
     160                 :          0 :                 return -ENODEV;
     161                 :            :         }
     162                 :          3 :         ret = ops->dt_node_to_map(pctldev, np_config, &map, &num_maps);
     163                 :          3 :         if (ret < 0)
     164                 :            :                 return ret;
     165                 :            : 
     166                 :            :         /* Stash the mapping table chunk away for later use */
     167                 :          3 :         return dt_remember_or_free_map(p, statename, pctldev, map, num_maps);
     168                 :            : }
     169                 :            : 
     170                 :          0 : static int dt_remember_dummy_state(struct pinctrl *p, const char *statename)
     171                 :            : {
     172                 :            :         struct pinctrl_map *map;
     173                 :            : 
     174                 :          0 :         map = kzalloc(sizeof(*map), GFP_KERNEL);
     175                 :          0 :         if (!map)
     176                 :            :                 return -ENOMEM;
     177                 :            : 
     178                 :            :         /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
     179                 :          0 :         map->type = PIN_MAP_TYPE_DUMMY_STATE;
     180                 :            : 
     181                 :          0 :         return dt_remember_or_free_map(p, statename, NULL, map, 1);
     182                 :            : }
     183                 :            : 
     184                 :          0 : bool pinctrl_dt_has_hogs(struct pinctrl_dev *pctldev)
     185                 :            : {
     186                 :            :         struct device_node *np;
     187                 :            :         struct property *prop;
     188                 :            :         int size;
     189                 :            : 
     190                 :          0 :         np = pctldev->dev->of_node;
     191                 :          0 :         if (!np)
     192                 :            :                 return false;
     193                 :            : 
     194                 :          0 :         prop = of_find_property(np, "pinctrl-0", &size);
     195                 :            : 
     196                 :          0 :         return prop ? true : false;
     197                 :            : }
     198                 :            : 
     199                 :          3 : int pinctrl_dt_to_map(struct pinctrl *p, struct pinctrl_dev *pctldev)
     200                 :            : {
     201                 :          3 :         struct device_node *np = p->dev->of_node;
     202                 :            :         int state, ret;
     203                 :            :         char *propname;
     204                 :            :         struct property *prop;
     205                 :            :         const char *statename;
     206                 :            :         const __be32 *list;
     207                 :            :         int size, config;
     208                 :            :         phandle phandle;
     209                 :            :         struct device_node *np_config;
     210                 :            : 
     211                 :            :         /* CONFIG_OF enabled, p->dev not instantiated from DT */
     212                 :          3 :         if (!np) {
     213                 :            :                 if (of_have_populated_dt())
     214                 :            :                         dev_dbg(p->dev,
     215                 :            :                                 "no of_node; not parsing pinctrl DT\n");
     216                 :            :                 return 0;
     217                 :            :         }
     218                 :            : 
     219                 :            :         /* We may store pointers to property names within the node */
     220                 :          3 :         of_node_get(np);
     221                 :            : 
     222                 :            :         /* For each defined state ID */
     223                 :          3 :         for (state = 0; ; state++) {
     224                 :            :                 /* Retrieve the pinctrl-* property */
     225                 :          3 :                 propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
     226                 :          3 :                 prop = of_find_property(np, propname, &size);
     227                 :          3 :                 kfree(propname);
     228                 :          3 :                 if (!prop) {
     229                 :          3 :                         if (state == 0) {
     230                 :          3 :                                 of_node_put(np);
     231                 :          3 :                                 return -ENODEV;
     232                 :            :                         }
     233                 :            :                         break;
     234                 :            :                 }
     235                 :          3 :                 list = prop->value;
     236                 :          3 :                 size /= sizeof(*list);
     237                 :            : 
     238                 :            :                 /* Determine whether pinctrl-names property names the state */
     239                 :            :                 ret = of_property_read_string_index(np, "pinctrl-names",
     240                 :            :                                                     state, &statename);
     241                 :            :                 /*
     242                 :            :                  * If not, statename is just the integer state ID. But rather
     243                 :            :                  * than dynamically allocate it and have to free it later,
     244                 :            :                  * just point part way into the property name for the string.
     245                 :            :                  */
     246                 :          3 :                 if (ret < 0)
     247                 :          0 :                         statename = prop->name + strlen("pinctrl-");
     248                 :            : 
     249                 :            :                 /* For every referenced pin configuration node in it */
     250                 :          3 :                 for (config = 0; config < size; config++) {
     251                 :          3 :                         phandle = be32_to_cpup(list++);
     252                 :            : 
     253                 :            :                         /* Look up the pin configuration node */
     254                 :          3 :                         np_config = of_find_node_by_phandle(phandle);
     255                 :          3 :                         if (!np_config) {
     256                 :          0 :                                 dev_err(p->dev,
     257                 :            :                                         "prop %s index %i invalid phandle\n",
     258                 :            :                                         prop->name, config);
     259                 :            :                                 ret = -EINVAL;
     260                 :          0 :                                 goto err;
     261                 :            :                         }
     262                 :            : 
     263                 :            :                         /* Parse the node */
     264                 :          3 :                         ret = dt_to_map_one_config(p, pctldev, statename,
     265                 :            :                                                    np_config);
     266                 :          3 :                         of_node_put(np_config);
     267                 :          3 :                         if (ret < 0)
     268                 :            :                                 goto err;
     269                 :            :                 }
     270                 :            : 
     271                 :            :                 /* No entries in DT? Generate a dummy state table entry */
     272                 :          3 :                 if (!size) {
     273                 :          0 :                         ret = dt_remember_dummy_state(p, statename);
     274                 :          0 :                         if (ret < 0)
     275                 :            :                                 goto err;
     276                 :            :                 }
     277                 :          3 :         }
     278                 :            : 
     279                 :            :         return 0;
     280                 :            : 
     281                 :            : err:
     282                 :          0 :         pinctrl_dt_free_maps(p);
     283                 :          0 :         return ret;
     284                 :            : }
     285                 :            : 
     286                 :            : /*
     287                 :            :  * For pinctrl binding, typically #pinctrl-cells is for the pin controller
     288                 :            :  * device, so either parent or grandparent. See pinctrl-bindings.txt.
     289                 :            :  */
     290                 :          0 : static int pinctrl_find_cells_size(const struct device_node *np)
     291                 :            : {
     292                 :            :         const char *cells_name = "#pinctrl-cells";
     293                 :            :         int cells_size, error;
     294                 :            : 
     295                 :          0 :         error = of_property_read_u32(np->parent, cells_name, &cells_size);
     296                 :          0 :         if (error) {
     297                 :          0 :                 error = of_property_read_u32(np->parent->parent,
     298                 :            :                                              cells_name, &cells_size);
     299                 :          0 :                 if (error)
     300                 :            :                         return -ENOENT;
     301                 :            :         }
     302                 :            : 
     303                 :          0 :         return cells_size;
     304                 :            : }
     305                 :            : 
     306                 :            : /**
     307                 :            :  * pinctrl_get_list_and_count - Gets the list and it's cell size and number
     308                 :            :  * @np: pointer to device node with the property
     309                 :            :  * @list_name: property that contains the list
     310                 :            :  * @list: pointer for the list found
     311                 :            :  * @cells_size: pointer for the cell size found
     312                 :            :  * @nr_elements: pointer for the number of elements found
     313                 :            :  *
     314                 :            :  * Typically np is a single pinctrl entry containing the list.
     315                 :            :  */
     316                 :          0 : static int pinctrl_get_list_and_count(const struct device_node *np,
     317                 :            :                                       const char *list_name,
     318                 :            :                                       const __be32 **list,
     319                 :            :                                       int *cells_size,
     320                 :            :                                       int *nr_elements)
     321                 :            : {
     322                 :            :         int size;
     323                 :            : 
     324                 :          0 :         *cells_size = 0;
     325                 :          0 :         *nr_elements = 0;
     326                 :            : 
     327                 :          0 :         *list = of_get_property(np, list_name, &size);
     328                 :          0 :         if (!*list)
     329                 :            :                 return -ENOENT;
     330                 :            : 
     331                 :          0 :         *cells_size = pinctrl_find_cells_size(np);
     332                 :          0 :         if (*cells_size < 0)
     333                 :            :                 return -ENOENT;
     334                 :            : 
     335                 :            :         /* First element is always the index within the pinctrl device */
     336                 :          0 :         *nr_elements = (size / sizeof(**list)) / (*cells_size + 1);
     337                 :            : 
     338                 :          0 :         return 0;
     339                 :            : }
     340                 :            : 
     341                 :            : /**
     342                 :            :  * pinctrl_count_index_with_args - Count number of elements in a pinctrl entry
     343                 :            :  * @np: pointer to device node with the property
     344                 :            :  * @list_name: property that contains the list
     345                 :            :  *
     346                 :            :  * Counts the number of elements in a pinctrl array consisting of an index
     347                 :            :  * within the controller and a number of u32 entries specified for each
     348                 :            :  * entry. Note that device_node is always for the parent pin controller device.
     349                 :            :  */
     350                 :          0 : int pinctrl_count_index_with_args(const struct device_node *np,
     351                 :            :                                   const char *list_name)
     352                 :            : {
     353                 :            :         const __be32 *list;
     354                 :            :         int size, nr_cells, error;
     355                 :            : 
     356                 :          0 :         error = pinctrl_get_list_and_count(np, list_name, &list,
     357                 :            :                                            &nr_cells, &size);
     358                 :          0 :         if (error)
     359                 :            :                 return error;
     360                 :            : 
     361                 :          0 :         return size;
     362                 :            : }
     363                 :            : EXPORT_SYMBOL_GPL(pinctrl_count_index_with_args);
     364                 :            : 
     365                 :            : /**
     366                 :            :  * pinctrl_copy_args - Populates of_phandle_args based on index
     367                 :            :  * @np: pointer to device node with the property
     368                 :            :  * @list: pointer to a list with the elements
     369                 :            :  * @index: entry within the list of elements
     370                 :            :  * @nr_cells: number of cells in the list
     371                 :            :  * @nr_elem: number of elements for each entry in the list
     372                 :            :  * @out_args: returned values
     373                 :            :  *
     374                 :            :  * Populates the of_phandle_args based on the index in the list.
     375                 :            :  */
     376                 :          0 : static int pinctrl_copy_args(const struct device_node *np,
     377                 :            :                              const __be32 *list,
     378                 :            :                              int index, int nr_cells, int nr_elem,
     379                 :            :                              struct of_phandle_args *out_args)
     380                 :            : {
     381                 :            :         int i;
     382                 :            : 
     383                 :          0 :         memset(out_args, 0, sizeof(*out_args));
     384                 :          0 :         out_args->np = (struct device_node *)np;
     385                 :          0 :         out_args->args_count = nr_cells + 1;
     386                 :            : 
     387                 :          0 :         if (index >= nr_elem)
     388                 :            :                 return -EINVAL;
     389                 :            : 
     390                 :          0 :         list += index * (nr_cells + 1);
     391                 :            : 
     392                 :          0 :         for (i = 0; i < nr_cells + 1; i++)
     393                 :          0 :                 out_args->args[i] = be32_to_cpup(list++);
     394                 :            : 
     395                 :            :         return 0;
     396                 :            : }
     397                 :            : 
     398                 :            : /**
     399                 :            :  * pinctrl_parse_index_with_args - Find a node pointed by index in a list
     400                 :            :  * @np: pointer to device node with the property
     401                 :            :  * @list_name: property that contains the list
     402                 :            :  * @index: index within the list
     403                 :            :  * @out_arts: entries in the list pointed by index
     404                 :            :  *
     405                 :            :  * Finds the selected element in a pinctrl array consisting of an index
     406                 :            :  * within the controller and a number of u32 entries specified for each
     407                 :            :  * entry. Note that device_node is always for the parent pin controller device.
     408                 :            :  */
     409                 :          0 : int pinctrl_parse_index_with_args(const struct device_node *np,
     410                 :            :                                   const char *list_name, int index,
     411                 :            :                                   struct of_phandle_args *out_args)
     412                 :            : {
     413                 :            :         const __be32 *list;
     414                 :            :         int nr_elem, nr_cells, error;
     415                 :            : 
     416                 :          0 :         error = pinctrl_get_list_and_count(np, list_name, &list,
     417                 :            :                                            &nr_cells, &nr_elem);
     418                 :          0 :         if (error || !nr_cells)
     419                 :            :                 return error;
     420                 :            : 
     421                 :          0 :         error = pinctrl_copy_args(np, list, index, nr_cells, nr_elem,
     422                 :            :                                   out_args);
     423                 :          0 :         if (error)
     424                 :          0 :                 return error;
     425                 :            : 
     426                 :            :         return 0;
     427                 :            : }
     428                 :            : EXPORT_SYMBOL_GPL(pinctrl_parse_index_with_args);
    

Generated by: LCOV version 1.14