drivers/pinctrl/sh-pfc/pinctrl.c

   1 /*
   2  * SuperH Pin Function Controller pinmux support.
   3  *
   4  * Copyright (C) 2012  Paul Mundt
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file "COPYING" in the main directory of this archive
   8  * for more details.
   9  */
  10
  11 #define DRV_NAME "sh-pfc"
  12 #define pr_fmt(fmt) KBUILD_MODNAME " pinctrl: " fmt
  13
  14 #include <linux/device.h>
  15 #include <linux/err.h>
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/pinctrl/consumer.h>
  19 #include <linux/pinctrl/pinconf.h>
  20 #include <linux/pinctrl/pinconf-generic.h>
  21 #include <linux/pinctrl/pinctrl.h>
  22 #include <linux/pinctrl/pinmux.h>
  23 #include <linux/slab.h>
  24 #include <linux/spinlock.h>
  25
  26 #include "core.h"
  27
  28 struct sh_pfc_pin_config {
  29         u32 type;
  30 };
  31
  32 struct sh_pfc_pinctrl {
  33         struct pinctrl_dev *pctl;
  34         struct pinctrl_desc pctl_desc;
  35
  36         struct sh_pfc *pfc;
  37
  38         struct pinctrl_pin_desc *pins;
  39         struct sh_pfc_pin_config *configs;
  40 };
  41
  42 static int sh_pfc_get_groups_count(struct pinctrl_dev *pctldev)
  43 {
  44         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  45
  46         return pmx->pfc->info->nr_groups;
  47 }
  48
  49 static const char *sh_pfc_get_group_name(struct pinctrl_dev *pctldev,
  50                                          unsigned selector)
  51 {
  52         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  53
  54         return pmx->pfc->info->groups[selector].name;
  55 }
  56
  57 static int sh_pfc_get_group_pins(struct pinctrl_dev *pctldev, unsigned selector,
  58                                  const unsigned **pins, unsigned *num_pins)
  59 {
  60         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  61
  62         *pins = pmx->pfc->info->groups[selector].pins;
  63         *num_pins = pmx->pfc->info->groups[selector].nr_pins;
  64
  65         return 0;
  66 }
  67
  68 static void sh_pfc_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
  69                                 unsigned offset)
  70 {
  71         seq_printf(s, "%s", DRV_NAME);
  72 }
  73
  74 static const struct pinctrl_ops sh_pfc_pinctrl_ops = {
  75         .get_groups_count       = sh_pfc_get_groups_count,
  76         .get_group_name         = sh_pfc_get_group_name,
  77         .get_group_pins         = sh_pfc_get_group_pins,
  78         .pin_dbg_show           = sh_pfc_pin_dbg_show,
  79 };
  80
  81 static int sh_pfc_get_functions_count(struct pinctrl_dev *pctldev)
  82 {
  83         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  84
  85         return pmx->pfc->info->nr_functions;
  86 }
  87
  88 static const char *sh_pfc_get_function_name(struct pinctrl_dev *pctldev,
  89                                             unsigned selector)
  90 {
  91         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  92
  93         return pmx->pfc->info->functions[selector].name;
  94 }
  95
  96 static int sh_pfc_get_function_groups(struct pinctrl_dev *pctldev,
  97                                       unsigned selector,
  98                                       const char * const **groups,
  99                                       unsigned * const num_groups)
 100 {
 101         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 102
 103         *groups = pmx->pfc->info->functions[selector].groups;
 104         *num_groups = pmx->pfc->info->functions[selector].nr_groups;
 105
 106         return 0;
 107 }
 108
 109 static int sh_pfc_func_enable(struct pinctrl_dev *pctldev, unsigned selector,
 110                               unsigned group)
 111 {
 112         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 113         struct sh_pfc *pfc = pmx->pfc;
 114         const struct sh_pfc_pin_group *grp = &pfc->info->groups[group];
 115         unsigned long flags;
 116         unsigned int i;
 117         int ret = -EINVAL;
 118
 119         spin_lock_irqsave(&pfc->lock, flags);
 120
 121         for (i = 0; i < grp->nr_pins; ++i) {
 122                 if (sh_pfc_config_mux(pfc, grp->mux[i], PINMUX_TYPE_FUNCTION))
 123                         goto done;
 124         }
 125
 126         ret = 0;
 127
 128 done:
 129         spin_unlock_irqrestore(&pfc->lock, flags);
 130         return ret;
 131 }
 132
 133 static void sh_pfc_func_disable(struct pinctrl_dev *pctldev, unsigned selector,
 134                                 unsigned group)
 135 {
 136 }
 137
 138 static int sh_pfc_reconfig_pin(struct sh_pfc_pinctrl *pmx, unsigned offset,
 139                                int new_type)
 140 {
 141         struct sh_pfc *pfc = pmx->pfc;
 142         int idx = sh_pfc_get_pin_index(pfc, offset);
 143         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 144         const struct sh_pfc_pin *pin = &pfc->info->pins[idx];
 145         unsigned int mark = pin->enum_id;
 146         unsigned long flags;
 147         int ret = -EINVAL;
 148
 149         spin_lock_irqsave(&pfc->lock, flags);
 150
 151         switch (cfg->type) {
 152         case PINMUX_TYPE_GPIO:
 153         case PINMUX_TYPE_OUTPUT:
 154         case PINMUX_TYPE_INPUT:
 155         case PINMUX_TYPE_INPUT_PULLUP:
 156         case PINMUX_TYPE_INPUT_PULLDOWN:
 157                 break;
 158         default:
 159                 goto err;
 160         }
 161
 162         if (sh_pfc_config_mux(pfc, mark, new_type) != 0)
 163                 goto err;
 164
 165         cfg->type = new_type;
 166
 167         ret = 0;
 168
 169 err:
 170         spin_unlock_irqrestore(&pfc->lock, flags);
 171
 172         return ret;
 173 }
 174
 175 static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev,
 176                                       struct pinctrl_gpio_range *range,
 177                                       unsigned offset)
 178 {
 179         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 180         struct sh_pfc *pfc = pmx->pfc;
 181         int idx = sh_pfc_get_pin_index(pfc, offset);
 182         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 183         unsigned long flags;
 184         int ret;
 185
 186         spin_lock_irqsave(&pfc->lock, flags);
 187
 188         switch (cfg->type) {
 189         case PINMUX_TYPE_GPIO:
 190         case PINMUX_TYPE_INPUT:
 191         case PINMUX_TYPE_OUTPUT:
 192                 break;
 193         case PINMUX_TYPE_FUNCTION:
 194         default:
 195                 pr_err("Unsupported mux type (%d), bailing...\n", cfg->type);
 196                 ret = -ENOTSUPP;
 197                 goto err;
 198         }
 199
 200         ret = 0;
 201
 202 err:
 203         spin_unlock_irqrestore(&pfc->lock, flags);
 204
 205         return ret;
 206 }
 207
 208 static void sh_pfc_gpio_disable_free(struct pinctrl_dev *pctldev,
 209                                      struct pinctrl_gpio_range *range,
 210                                      unsigned offset)
 211 {
 212 }
 213
 214 static int sh_pfc_gpio_set_direction(struct pinctrl_dev *pctldev,
 215                                      struct pinctrl_gpio_range *range,
 216                                      unsigned offset, bool input)
 217 {
 218         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 219         int type = input ? PINMUX_TYPE_INPUT : PINMUX_TYPE_OUTPUT;
 220
 221         return sh_pfc_reconfig_pin(pmx, offset, type);
 222 }
 223
 224 static const struct pinmux_ops sh_pfc_pinmux_ops = {
 225         .get_functions_count    = sh_pfc_get_functions_count,
 226         .get_function_name      = sh_pfc_get_function_name,
 227         .get_function_groups    = sh_pfc_get_function_groups,
 228         .enable                 = sh_pfc_func_enable,
 229         .disable                = sh_pfc_func_disable,
 230         .gpio_request_enable    = sh_pfc_gpio_request_enable,
 231         .gpio_disable_free      = sh_pfc_gpio_disable_free,
 232         .gpio_set_direction     = sh_pfc_gpio_set_direction,
 233 };
 234
 235 static int sh_pfc_pinconf_get(struct pinctrl_dev *pctldev, unsigned _pin,
 236                               unsigned long *config)
 237 {
 238         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 239         struct sh_pfc *pfc = pmx->pfc;
 240         int idx = sh_pfc_get_pin_index(pfc, _pin);
 241         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 242
 243         *config = cfg->type;
 244
 245         return 0;
 246 }
 247
 248 static int sh_pfc_pinconf_set(struct pinctrl_dev *pctldev, unsigned pin,
 249                               unsigned long config)
 250 {
 251         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 252
 253         /* Validate the new type */
 254         if (config >= PINMUX_FLAG_TYPE)
 255                 return -EINVAL;
 256
 257         return sh_pfc_reconfig_pin(pmx, pin, config);
 258 }
 259
 260 static void sh_pfc_pinconf_dbg_show(struct pinctrl_dev *pctldev,
 261                                     struct seq_file *s, unsigned pin)
 262 {
 263         const char *pinmux_type_str[] = {
 264                 [PINMUX_TYPE_NONE]              = "none",
 265                 [PINMUX_TYPE_FUNCTION]          = "function",
 266                 [PINMUX_TYPE_GPIO]              = "gpio",
 267                 [PINMUX_TYPE_OUTPUT]            = "output",
 268                 [PINMUX_TYPE_INPUT]             = "input",
 269                 [PINMUX_TYPE_INPUT_PULLUP]      = "input bias pull up",
 270                 [PINMUX_TYPE_INPUT_PULLDOWN]    = "input bias pull down",
 271         };
 272         unsigned long config;
 273         int rc;
 274
 275         rc = sh_pfc_pinconf_get(pctldev, pin, &config);
 276         if (unlikely(rc != 0))
 277                 return;
 278
 279         seq_printf(s, " %s", pinmux_type_str[config]);
 280 }
 281
 282 static const struct pinconf_ops sh_pfc_pinconf_ops = {
 283         .pin_config_get         = sh_pfc_pinconf_get,
 284         .pin_config_set         = sh_pfc_pinconf_set,
 285         .pin_config_dbg_show    = sh_pfc_pinconf_dbg_show,
 286 };
 287
 288 /* PFC ranges -> pinctrl pin descs */
 289 static int sh_pfc_map_pins(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx)
 290 {
 291         const struct pinmux_range *ranges;
 292         struct pinmux_range def_range;
 293         unsigned int nr_ranges;
 294         unsigned int nr_pins;
 295         unsigned int i;
 296
 297         if (pfc->info->ranges == NULL) {
 298                 def_range.begin = 0;
 299                 def_range.end = pfc->info->nr_pins - 1;
 300                 ranges = &def_range;
 301                 nr_ranges = 1;
 302         } else {
 303                 ranges = pfc->info->ranges;
 304                 nr_ranges = pfc->info->nr_ranges;
 305         }
 306
 307         pmx->pins = devm_kzalloc(pfc->dev,
 308                                  sizeof(*pmx->pins) * pfc->info->nr_pins,
 309                                  GFP_KERNEL);
 310         if (unlikely(!pmx->pins))
 311                 return -ENOMEM;
 312
 313         pmx->configs = devm_kzalloc(pfc->dev,
 314                                     sizeof(*pmx->configs) * pfc->info->nr_pins,
 315                                     GFP_KERNEL);
 316         if (unlikely(!pmx->configs))
 317                 return -ENOMEM;
 318
 319         for (i = 0, nr_pins = 0; i < nr_ranges; ++i) {
 320                 const struct pinmux_range *range = &ranges[i];
 321                 unsigned int number;
 322
 323                 for (number = range->begin; number <= range->end;
 324                      number++, nr_pins++) {
 325                         struct sh_pfc_pin_config *cfg = &pmx->configs[nr_pins];
 326                         struct pinctrl_pin_desc *pin = &pmx->pins[nr_pins];
 327                         const struct sh_pfc_pin *info =
 328                                 &pfc->info->pins[nr_pins];
 329
 330                         pin->number = number;
 331                         pin->name = info->name;
 332                         cfg->type = PINMUX_TYPE_GPIO;
 333                 }
 334         }
 335
 336         pfc->nr_pins = ranges[nr_ranges-1].end + 1;
 337
 338         return nr_ranges;
 339 }
 340
 341 int sh_pfc_register_pinctrl(struct sh_pfc *pfc)
 342 {
 343         struct sh_pfc_pinctrl *pmx;
 344         int nr_ranges;
 345
 346         pmx = devm_kzalloc(pfc->dev, sizeof(*pmx), GFP_KERNEL);
 347         if (unlikely(!pmx))
 348                 return -ENOMEM;
 349
 350         pmx->pfc = pfc;
 351         pfc->pinctrl = pmx;
 352
 353         nr_ranges = sh_pfc_map_pins(pfc, pmx);
 354         if (unlikely(nr_ranges < 0))
 355                 return nr_ranges;
 356
 357         pmx->pctl_desc.name = DRV_NAME;
 358         pmx->pctl_desc.owner = THIS_MODULE;
 359         pmx->pctl_desc.pctlops = &sh_pfc_pinctrl_ops;
 360         pmx->pctl_desc.pmxops = &sh_pfc_pinmux_ops;
 361         pmx->pctl_desc.confops = &sh_pfc_pinconf_ops;
 362         pmx->pctl_desc.pins = pmx->pins;
 363         pmx->pctl_desc.npins = pfc->info->nr_pins;
 364
 365         pmx->pctl = pinctrl_register(&pmx->pctl_desc, pfc->dev, pmx);
 366         if (pmx->pctl == NULL)
 367                 return -EINVAL;
 368
 369         return 0;
 370 }
 371
 372 int sh_pfc_unregister_pinctrl(struct sh_pfc *pfc)
 373 {
 374         struct sh_pfc_pinctrl *pmx = pfc->pinctrl;
 375
 376         pinctrl_unregister(pmx->pctl);
 377
 378         pfc->pinctrl = NULL;
 379         return 0;
 380 }