drivers/pinctrl/pinctrl-lantiq.c

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