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