drivers/pinctrl/pinctrl-lantiq.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/drivers/pinctrl/pinctrl-lantiq.c
   4  *  based on linux/drivers/pinctrl/pinctrl-pxa3xx.c
   5  *
   6  *  Copyright (C) 2012 John Crispin <john@phrozen.org>
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/device.h>
  11 #include <linux/io.h>
  12 #include <linux/platform_device.h>
  13 #include <linux/slab.h>
  14 #include <linux/of.h>
  15
  16 #include "pinctrl-lantiq.h"
  17
  18 static int ltq_get_group_count(struct pinctrl_dev *pctrldev)
  19 {
  20         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
  21         return info->num_grps;
  22 }
  23
  24 static const char *ltq_get_group_name(struct pinctrl_dev *pctrldev,
  25                                          unsigned selector)
  26 {
  27         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
  28         if (selector >= info->num_grps)
  29                 return NULL;
  30         return info->grps[selector].name;
  31 }
  32
  33 static int ltq_get_group_pins(struct pinctrl_dev *pctrldev,
  34                                  unsigned selector,
  35                                  const unsigned **pins,
  36                                  unsigned *num_pins)
  37 {
  38         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
  39         if (selector >= info->num_grps)
  40                 return -EINVAL;
  41         *pins = info->grps[selector].pins;
  42         *num_pins = info->grps[selector].npins;
  43         return 0;
  44 }
  45
  46 static void ltq_pinctrl_dt_free_map(struct pinctrl_dev *pctldev,
  47                                     struct pinctrl_map *map, unsigned num_maps)
  48 {
  49         int i;
  50
  51         for (i = 0; i < num_maps; i++)
  52                 if (map[i].type == PIN_MAP_TYPE_CONFIGS_PIN ||
  53                     map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP)
  54                         kfree(map[i].data.configs.configs);
  55         kfree(map);
  56 }
  57
  58 static void ltq_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
  59                                         struct seq_file *s,
  60                                         unsigned offset)
  61 {
  62         seq_printf(s, " %s", dev_name(pctldev->dev));
  63 }
  64
  65 static void ltq_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
  66                                 struct device_node *np,
  67                                 struct pinctrl_map **map)
  68 {
  69         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctldev);
  70         struct property *pins = of_find_property(np, "lantiq,pins", NULL);
  71         struct property *groups = of_find_property(np, "lantiq,groups", NULL);
  72         unsigned long configs[3];
  73         unsigned num_configs = 0;
  74         struct property *prop;
  75         const char *group, *pin;
  76         const char *function;
  77         int ret, i;
  78
  79         if (!pins && !groups) {
  80                 dev_err(pctldev->dev, "%pOFn defines neither pins nor groups\n",
  81                         np);
  82                 return;
  83         }
  84
  85         if (pins && groups) {
  86                 dev_err(pctldev->dev, "%pOFn defines both pins and groups\n",
  87                         np);
  88                 return;
  89         }
  90
  91         ret = of_property_read_string(np, "lantiq,function", &function);
  92         if (groups && !ret) {
  93                 of_property_for_each_string(np, "lantiq,groups", prop, group) {
  94                         (*map)->type = PIN_MAP_TYPE_MUX_GROUP;
  95                         (*map)->name = function;
  96                         (*map)->data.mux.group = group;
  97                         (*map)->data.mux.function = function;
  98                         (*map)++;
  99                 }
 100         }
 101
 102         for (i = 0; i < info->num_params; i++) {
 103                 u32 val;
 104                 int ret = of_property_read_u32(np,
 105                                 info->params[i].property, &val);
 106                 if (!ret)
 107                         configs[num_configs++] =
 108                                 LTQ_PINCONF_PACK(info->params[i].param,
 109                                 val);
 110         }
 111
 112         if (!num_configs)
 113                 return;
 114
 115         of_property_for_each_string(np, "lantiq,pins", prop, pin) {
 116                 (*map)->data.configs.configs = kmemdup(configs,
 117                                         num_configs * sizeof(unsigned long),
 118                                         GFP_KERNEL);
 119                 (*map)->type = PIN_MAP_TYPE_CONFIGS_PIN;
 120                 (*map)->name = pin;
 121                 (*map)->data.configs.group_or_pin = pin;
 122                 (*map)->data.configs.num_configs = num_configs;
 123                 (*map)++;
 124         }
 125         of_property_for_each_string(np, "lantiq,groups", prop, group) {
 126                 (*map)->data.configs.configs = kmemdup(configs,
 127                                         num_configs * sizeof(unsigned long),
 128                                         GFP_KERNEL);
 129                 (*map)->type = PIN_MAP_TYPE_CONFIGS_GROUP;
 130                 (*map)->name = group;
 131                 (*map)->data.configs.group_or_pin = group;
 132                 (*map)->data.configs.num_configs = num_configs;
 133                 (*map)++;
 134         }
 135 }
 136
 137 static int ltq_pinctrl_dt_subnode_size(struct device_node *np)
 138 {
 139         int ret;
 140
 141         ret = of_property_count_strings(np, "lantiq,groups");
 142         if (ret < 0)
 143                 ret = of_property_count_strings(np, "lantiq,pins");
 144         return ret;
 145 }
 146
 147 static int ltq_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
 148                                       struct device_node *np_config,
 149                                       struct pinctrl_map **map,
 150                                       unsigned *num_maps)
 151 {
 152         struct pinctrl_map *tmp;
 153         struct device_node *np;
 154         int max_maps = 0;
 155
 156         for_each_child_of_node(np_config, np)
 157                 max_maps += ltq_pinctrl_dt_subnode_size(np);
 158         *map = kzalloc(array3_size(max_maps, sizeof(struct pinctrl_map), 2),
 159                        GFP_KERNEL);
 160         if (!*map)
 161                 return -ENOMEM;
 162         tmp = *map;
 163
 164         for_each_child_of_node(np_config, np)
 165                 ltq_pinctrl_dt_subnode_to_map(pctldev, np, &tmp);
 166         *num_maps = ((int)(tmp - *map));
 167
 168         return 0;
 169 }
 170
 171 static const struct pinctrl_ops ltq_pctrl_ops = {
 172         .get_groups_count       = ltq_get_group_count,
 173         .get_group_name         = ltq_get_group_name,
 174         .get_group_pins         = ltq_get_group_pins,
 175         .pin_dbg_show           = ltq_pinctrl_pin_dbg_show,
 176         .dt_node_to_map         = ltq_pinctrl_dt_node_to_map,
 177         .dt_free_map            = ltq_pinctrl_dt_free_map,
 178 };
 179
 180 static int ltq_pmx_func_count(struct pinctrl_dev *pctrldev)
 181 {
 182         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
 183
 184         return info->num_funcs;
 185 }
 186
 187 static const char *ltq_pmx_func_name(struct pinctrl_dev *pctrldev,
 188                                          unsigned selector)
 189 {
 190         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
 191
 192         if (selector >= info->num_funcs)
 193                 return NULL;
 194
 195         return info->funcs[selector].name;
 196 }
 197
 198 static int ltq_pmx_get_groups(struct pinctrl_dev *pctrldev,
 199                                 unsigned func,
 200                                 const char * const **groups,
 201                                 unsigned * const num_groups)
 202 {
 203         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
 204
 205         *groups = info->funcs[func].groups;
 206         *num_groups = info->funcs[func].num_groups;
 207
 208         return 0;
 209 }
 210
 211 /* Return function number. If failure, return negative value. */
 212 static int match_mux(const struct ltq_mfp_pin *mfp, unsigned mux)
 213 {
 214         int i;
 215         for (i = 0; i < LTQ_MAX_MUX; i++) {
 216                 if (mfp->func[i] == mux)
 217                         break;
 218         }
 219         if (i >= LTQ_MAX_MUX)
 220                 return -EINVAL;
 221         return i;
 222 }
 223
 224 /* dont assume .mfp is linearly mapped. find the mfp with the correct .pin */
 225 static int match_mfp(const struct ltq_pinmux_info *info, int pin)
 226 {
 227         int i;
 228         for (i = 0; i < info->num_mfp; i++) {
 229                 if (info->mfp[i].pin == pin)
 230                         return i;
 231         }
 232         return -1;
 233 }
 234
 235 /* check whether current pin configuration is valid. Negative for failure */
 236 static int match_group_mux(const struct ltq_pin_group *grp,
 237                            const struct ltq_pinmux_info *info,
 238                            unsigned mux)
 239 {
 240         int i, pin, ret = 0;
 241         for (i = 0; i < grp->npins; i++) {
 242                 pin = match_mfp(info, grp->pins[i]);
 243                 if (pin < 0) {
 244                         dev_err(info->dev, "could not find mfp for pin %d\n",
 245                                 grp->pins[i]);
 246                         return -EINVAL;
 247                 }
 248                 ret = match_mux(&info->mfp[pin], mux);
 249                 if (ret < 0) {
 250                         dev_err(info->dev, "Can't find mux %d on pin%d\n",
 251                                 mux, pin);
 252                         break;
 253                 }
 254         }
 255         return ret;
 256 }
 257
 258 static int ltq_pmx_set(struct pinctrl_dev *pctrldev,
 259                        unsigned func,
 260                        unsigned group)
 261 {
 262         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
 263         const struct ltq_pin_group *pin_grp = &info->grps[group];
 264         int i, pin, pin_func, ret;
 265
 266         if (!pin_grp->npins ||
 267                 (match_group_mux(pin_grp, info, pin_grp->mux) < 0)) {
 268                 dev_err(info->dev, "Failed to set the pin group: %s\n",
 269                         info->grps[group].name);
 270                 return -EINVAL;
 271         }
 272         for (i = 0; i < pin_grp->npins; i++) {
 273                 pin = match_mfp(info, pin_grp->pins[i]);
 274                 if (pin < 0) {
 275                         dev_err(info->dev, "could not find mfp for pin %d\n",
 276                                 pin_grp->pins[i]);
 277                         return -EINVAL;
 278                 }
 279                 pin_func = match_mux(&info->mfp[pin], pin_grp->mux);
 280                 ret = info->apply_mux(pctrldev, pin, pin_func);
 281                 if (ret) {
 282                         dev_err(info->dev,
 283                                 "failed to apply mux %d for pin %d\n",
 284                                 pin_func, pin);
 285                         return ret;
 286                 }
 287         }
 288         return 0;
 289 }
 290
 291 static int ltq_pmx_gpio_request_enable(struct pinctrl_dev *pctrldev,
 292                                 struct pinctrl_gpio_range *range,
 293                                 unsigned pin)
 294 {
 295         struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
 296         int mfp = match_mfp(info, pin);
 297         int pin_func;
 298
 299         if (mfp < 0) {
 300                 dev_err(info->dev, "could not find mfp for pin %d\n", pin);
 301                 return -EINVAL;
 302         }
 303
 304         pin_func = match_mux(&info->mfp[mfp], 0);
 305         if (pin_func < 0) {
 306                 dev_err(info->dev, "No GPIO function on pin%d\n", mfp);
 307                 return -EINVAL;
 308         }
 309
 310         return info->apply_mux(pctrldev, mfp, pin_func);
 311 }
 312
 313 static const struct pinmux_ops ltq_pmx_ops = {
 314         .get_functions_count    = ltq_pmx_func_count,
 315         .get_function_name      = ltq_pmx_func_name,
 316         .get_function_groups    = ltq_pmx_get_groups,
 317         .set_mux                = ltq_pmx_set,
 318         .gpio_request_enable    = ltq_pmx_gpio_request_enable,
 319 };
 320
 321 /*
 322  * allow different socs to register with the generic part of the lanti
 323  * pinctrl code
 324  */
 325 int ltq_pinctrl_register(struct platform_device *pdev,
 326                                 struct ltq_pinmux_info *info)
 327 {
 328         struct pinctrl_desc *desc;
 329
 330         if (!info)
 331                 return -EINVAL;
 332         desc = info->desc;
 333         desc->pctlops = &ltq_pctrl_ops;
 334         desc->pmxops = &ltq_pmx_ops;
 335         info->dev = &pdev->dev;
 336
 337         info->pctrl = devm_pinctrl_register(&pdev->dev, desc, info);
 338         if (IS_ERR(info->pctrl)) {
 339                 dev_err(&pdev->dev, "failed to register LTQ pinmux driver\n");
 340                 return PTR_ERR(info->pctrl);
 341         }
 342         platform_set_drvdata(pdev, info);
 343         return 0;
 344 }