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
  13 #include <linux/device.h>
  14 #include <linux/err.h>
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/pinctrl/consumer.h>
  18 #include <linux/pinctrl/pinconf.h>
  19 #include <linux/pinctrl/pinconf-generic.h>
  20 #include <linux/pinctrl/pinctrl.h>
  21 #include <linux/pinctrl/pinmux.h>
  22 #include <linux/slab.h>
  23 #include <linux/spinlock.h>
  24
  25 #include "core.h"
  26 #include "../core.h"
  27 #include "../pinconf.h"
  28
  29 struct sh_pfc_pin_config {
  30         u32 type;
  31 };
  32
  33 struct sh_pfc_pinctrl {
  34         struct pinctrl_dev *pctl;
  35         struct pinctrl_desc pctl_desc;
  36
  37         struct sh_pfc *pfc;
  38
  39         struct pinctrl_pin_desc *pins;
  40         struct sh_pfc_pin_config *configs;
  41 };
  42
  43 static int sh_pfc_get_groups_count(struct pinctrl_dev *pctldev)
  44 {
  45         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  46
  47         return pmx->pfc->info->nr_groups;
  48 }
  49
  50 static const char *sh_pfc_get_group_name(struct pinctrl_dev *pctldev,
  51                                          unsigned selector)
  52 {
  53         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  54
  55         return pmx->pfc->info->groups[selector].name;
  56 }
  57
  58 static int sh_pfc_get_group_pins(struct pinctrl_dev *pctldev, unsigned selector,
  59                                  const unsigned **pins, unsigned *num_pins)
  60 {
  61         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  62
  63         *pins = pmx->pfc->info->groups[selector].pins;
  64         *num_pins = pmx->pfc->info->groups[selector].nr_pins;
  65
  66         return 0;
  67 }
  68
  69 static void sh_pfc_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
  70                                 unsigned offset)
  71 {
  72         seq_printf(s, "%s", DRV_NAME);
  73 }
  74
  75 static const struct pinctrl_ops sh_pfc_pinctrl_ops = {
  76         .get_groups_count       = sh_pfc_get_groups_count,
  77         .get_group_name         = sh_pfc_get_group_name,
  78         .get_group_pins         = sh_pfc_get_group_pins,
  79         .pin_dbg_show           = sh_pfc_pin_dbg_show,
  80 };
  81
  82 static int sh_pfc_get_functions_count(struct pinctrl_dev *pctldev)
  83 {
  84         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  85
  86         return pmx->pfc->info->nr_functions;
  87 }
  88
  89 static const char *sh_pfc_get_function_name(struct pinctrl_dev *pctldev,
  90                                             unsigned selector)
  91 {
  92         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  93
  94         return pmx->pfc->info->functions[selector].name;
  95 }
  96
  97 static int sh_pfc_get_function_groups(struct pinctrl_dev *pctldev,
  98                                       unsigned selector,
  99                                       const char * const **groups,
 100                                       unsigned * const num_groups)
 101 {
 102         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 103
 104         *groups = pmx->pfc->info->functions[selector].groups;
 105         *num_groups = pmx->pfc->info->functions[selector].nr_groups;
 106
 107         return 0;
 108 }
 109
 110 static int sh_pfc_func_enable(struct pinctrl_dev *pctldev, unsigned selector,
 111                               unsigned group)
 112 {
 113         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 114         struct sh_pfc *pfc = pmx->pfc;
 115         const struct sh_pfc_pin_group *grp = &pfc->info->groups[group];
 116         unsigned long flags;
 117         unsigned int i;
 118         int ret = 0;
 119
 120         spin_lock_irqsave(&pfc->lock, flags);
 121
 122         for (i = 0; i < grp->nr_pins; ++i) {
 123                 int idx = sh_pfc_get_pin_index(pfc, grp->pins[i]);
 124                 struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 125
 126                 if (cfg->type != PINMUX_TYPE_NONE) {
 127                         ret = -EBUSY;
 128                         goto done;
 129                 }
 130         }
 131
 132         for (i = 0; i < grp->nr_pins; ++i) {
 133                 ret = sh_pfc_config_mux(pfc, grp->mux[i], PINMUX_TYPE_FUNCTION);
 134                 if (ret < 0)
 135                         break;
 136         }
 137
 138 done:
 139         spin_unlock_irqrestore(&pfc->lock, flags);
 140         return ret;
 141 }
 142
 143 static void sh_pfc_func_disable(struct pinctrl_dev *pctldev, unsigned selector,
 144                                 unsigned group)
 145 {
 146         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 147         struct sh_pfc *pfc = pmx->pfc;
 148         const struct sh_pfc_pin_group *grp = &pfc->info->groups[group];
 149         unsigned long flags;
 150         unsigned int i;
 151
 152         spin_lock_irqsave(&pfc->lock, flags);
 153
 154         for (i = 0; i < grp->nr_pins; ++i) {
 155                 int idx = sh_pfc_get_pin_index(pfc, grp->pins[i]);
 156                 struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 157
 158                 cfg->type = PINMUX_TYPE_NONE;
 159         }
 160
 161         spin_unlock_irqrestore(&pfc->lock, flags);
 162 }
 163
 164 static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev,
 165                                       struct pinctrl_gpio_range *range,
 166                                       unsigned offset)
 167 {
 168         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 169         struct sh_pfc *pfc = pmx->pfc;
 170         int idx = sh_pfc_get_pin_index(pfc, offset);
 171         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 172         unsigned long flags;
 173         int ret;
 174
 175         spin_lock_irqsave(&pfc->lock, flags);
 176
 177         if (cfg->type != PINMUX_TYPE_NONE) {
 178                 dev_err(pfc->dev,
 179                         "Pin %u is busy, can't configure it as GPIO.\n",
 180                         offset);
 181                 ret = -EBUSY;
 182                 goto done;
 183         }
 184
 185         if (!pfc->gpio) {
 186                 /* If GPIOs are handled externally the pin mux type need to be
 187                  * set to GPIO here.
 188                  */
 189                 const struct sh_pfc_pin *pin = &pfc->info->pins[idx];
 190
 191                 ret = sh_pfc_config_mux(pfc, pin->enum_id, PINMUX_TYPE_GPIO);
 192                 if (ret < 0)
 193                         goto done;
 194         }
 195
 196         cfg->type = PINMUX_TYPE_GPIO;
 197
 198         ret = 0;
 199
 200 done:
 201         spin_unlock_irqrestore(&pfc->lock, flags);
 202
 203         return ret;
 204 }
 205
 206 static void sh_pfc_gpio_disable_free(struct pinctrl_dev *pctldev,
 207                                      struct pinctrl_gpio_range *range,
 208                                      unsigned offset)
 209 {
 210         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 211         struct sh_pfc *pfc = pmx->pfc;
 212         int idx = sh_pfc_get_pin_index(pfc, offset);
 213         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 214         unsigned long flags;
 215
 216         spin_lock_irqsave(&pfc->lock, flags);
 217         cfg->type = PINMUX_TYPE_NONE;
 218         spin_unlock_irqrestore(&pfc->lock, flags);
 219 }
 220
 221 static int sh_pfc_gpio_set_direction(struct pinctrl_dev *pctldev,
 222                                      struct pinctrl_gpio_range *range,
 223                                      unsigned offset, bool input)
 224 {
 225         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 226         struct sh_pfc *pfc = pmx->pfc;
 227         int new_type = input ? PINMUX_TYPE_INPUT : PINMUX_TYPE_OUTPUT;
 228         int idx = sh_pfc_get_pin_index(pfc, offset);
 229         const struct sh_pfc_pin *pin = &pfc->info->pins[idx];
 230         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 231         unsigned long flags;
 232         unsigned int dir;
 233         int ret;
 234
 235         /* Check if the requested direction is supported by the pin. Not all SoC
 236          * provide pin config data, so perform the check conditionally.
 237          */
 238         if (pin->configs) {
 239                 dir = input ? SH_PFC_PIN_CFG_INPUT : SH_PFC_PIN_CFG_OUTPUT;
 240                 if (!(pin->configs & dir))
 241                         return -EINVAL;
 242         }
 243
 244         spin_lock_irqsave(&pfc->lock, flags);
 245
 246         ret = sh_pfc_config_mux(pfc, pin->enum_id, new_type);
 247         if (ret < 0)
 248                 goto done;
 249
 250         cfg->type = new_type;
 251
 252 done:
 253         spin_unlock_irqrestore(&pfc->lock, flags);
 254         return ret;
 255 }
 256
 257 static const struct pinmux_ops sh_pfc_pinmux_ops = {
 258         .get_functions_count    = sh_pfc_get_functions_count,
 259         .get_function_name      = sh_pfc_get_function_name,
 260         .get_function_groups    = sh_pfc_get_function_groups,
 261         .enable                 = sh_pfc_func_enable,
 262         .disable                = sh_pfc_func_disable,
 263         .gpio_request_enable    = sh_pfc_gpio_request_enable,
 264         .gpio_disable_free      = sh_pfc_gpio_disable_free,
 265         .gpio_set_direction     = sh_pfc_gpio_set_direction,
 266 };
 267
 268 /* Check whether the requested parameter is supported for a pin. */
 269 static bool sh_pfc_pinconf_validate(struct sh_pfc *pfc, unsigned int _pin,
 270                                     enum pin_config_param param)
 271 {
 272         int idx = sh_pfc_get_pin_index(pfc, _pin);
 273         const struct sh_pfc_pin *pin = &pfc->info->pins[idx];
 274
 275         switch (param) {
 276         case PIN_CONFIG_BIAS_DISABLE:
 277                 return true;
 278
 279         case PIN_CONFIG_BIAS_PULL_UP:
 280                 return pin->configs & SH_PFC_PIN_CFG_PULL_UP;
 281
 282         case PIN_CONFIG_BIAS_PULL_DOWN:
 283                 return pin->configs & SH_PFC_PIN_CFG_PULL_DOWN;
 284
 285         default:
 286                 return false;
 287         }
 288 }
 289
 290 static int sh_pfc_pinconf_get(struct pinctrl_dev *pctldev, unsigned _pin,
 291                               unsigned long *config)
 292 {
 293         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 294         struct sh_pfc *pfc = pmx->pfc;
 295         enum pin_config_param param = pinconf_to_config_param(*config);
 296         unsigned long flags;
 297         unsigned int bias;
 298
 299         if (!sh_pfc_pinconf_validate(pfc, _pin, param))
 300                 return -ENOTSUPP;
 301
 302         switch (param) {
 303         case PIN_CONFIG_BIAS_DISABLE:
 304         case PIN_CONFIG_BIAS_PULL_UP:
 305         case PIN_CONFIG_BIAS_PULL_DOWN:
 306                 if (!pfc->info->ops || !pfc->info->ops->get_bias)
 307                         return -ENOTSUPP;
 308
 309                 spin_lock_irqsave(&pfc->lock, flags);
 310                 bias = pfc->info->ops->get_bias(pfc, _pin);
 311                 spin_unlock_irqrestore(&pfc->lock, flags);
 312
 313                 if (bias != param)
 314                         return -EINVAL;
 315
 316                 *config = 0;
 317                 break;
 318
 319         default:
 320                 return -ENOTSUPP;
 321         }
 322
 323         return 0;
 324 }
 325
 326 static int sh_pfc_pinconf_set(struct pinctrl_dev *pctldev, unsigned _pin,
 327                               unsigned long config)
 328 {
 329         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 330         struct sh_pfc *pfc = pmx->pfc;
 331         enum pin_config_param param = pinconf_to_config_param(config);
 332         unsigned long flags;
 333
 334         if (!sh_pfc_pinconf_validate(pfc, _pin, param))
 335                 return -ENOTSUPP;
 336
 337         switch (param) {
 338         case PIN_CONFIG_BIAS_PULL_UP:
 339         case PIN_CONFIG_BIAS_PULL_DOWN:
 340         case PIN_CONFIG_BIAS_DISABLE:
 341                 if (!pfc->info->ops || !pfc->info->ops->set_bias)
 342                         return -ENOTSUPP;
 343
 344                 spin_lock_irqsave(&pfc->lock, flags);
 345                 pfc->info->ops->set_bias(pfc, _pin, param);
 346                 spin_unlock_irqrestore(&pfc->lock, flags);
 347
 348                 break;
 349
 350         default:
 351                 return -ENOTSUPP;
 352         }
 353
 354         return 0;
 355 }
 356
 357 static int sh_pfc_pinconf_group_set(struct pinctrl_dev *pctldev, unsigned group,
 358                                     unsigned long config)
 359 {
 360         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 361         const unsigned int *pins;
 362         unsigned int num_pins;
 363         unsigned int i;
 364
 365         pins = pmx->pfc->info->groups[group].pins;
 366         num_pins = pmx->pfc->info->groups[group].nr_pins;
 367
 368         for (i = 0; i < num_pins; ++i)
 369                 sh_pfc_pinconf_set(pctldev, pins[i], config);
 370
 371         return 0;
 372 }
 373
 374 static const struct pinconf_ops sh_pfc_pinconf_ops = {
 375         .is_generic                     = true,
 376         .pin_config_get                 = sh_pfc_pinconf_get,
 377         .pin_config_set                 = sh_pfc_pinconf_set,
 378         .pin_config_group_set           = sh_pfc_pinconf_group_set,
 379         .pin_config_config_dbg_show     = pinconf_generic_dump_config,
 380 };
 381
 382 /* PFC ranges -> pinctrl pin descs */
 383 static int sh_pfc_map_pins(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx)
 384 {
 385         const struct pinmux_range *ranges;
 386         struct pinmux_range def_range;
 387         unsigned int nr_ranges;
 388         unsigned int nr_pins;
 389         unsigned int i;
 390
 391         if (pfc->info->ranges == NULL) {
 392                 def_range.begin = 0;
 393                 def_range.end = pfc->info->nr_pins - 1;
 394                 ranges = &def_range;
 395                 nr_ranges = 1;
 396         } else {
 397                 ranges = pfc->info->ranges;
 398                 nr_ranges = pfc->info->nr_ranges;
 399         }
 400
 401         pmx->pins = devm_kzalloc(pfc->dev,
 402                                  sizeof(*pmx->pins) * pfc->info->nr_pins,
 403                                  GFP_KERNEL);
 404         if (unlikely(!pmx->pins))
 405                 return -ENOMEM;
 406
 407         pmx->configs = devm_kzalloc(pfc->dev,
 408                                     sizeof(*pmx->configs) * pfc->info->nr_pins,
 409                                     GFP_KERNEL);
 410         if (unlikely(!pmx->configs))
 411                 return -ENOMEM;
 412
 413         for (i = 0, nr_pins = 0; i < nr_ranges; ++i) {
 414                 const struct pinmux_range *range = &ranges[i];
 415                 unsigned int number;
 416
 417                 for (number = range->begin; number <= range->end;
 418                      number++, nr_pins++) {
 419                         struct sh_pfc_pin_config *cfg = &pmx->configs[nr_pins];
 420                         struct pinctrl_pin_desc *pin = &pmx->pins[nr_pins];
 421                         const struct sh_pfc_pin *info =
 422                                 &pfc->info->pins[nr_pins];
 423
 424                         pin->number = number;
 425                         pin->name = info->name;
 426                         cfg->type = PINMUX_TYPE_NONE;
 427                 }
 428         }
 429
 430         pfc->nr_pins = ranges[nr_ranges-1].end + 1;
 431
 432         return nr_ranges;
 433 }
 434
 435 int sh_pfc_register_pinctrl(struct sh_pfc *pfc)
 436 {
 437         struct sh_pfc_pinctrl *pmx;
 438         int nr_ranges;
 439
 440         pmx = devm_kzalloc(pfc->dev, sizeof(*pmx), GFP_KERNEL);
 441         if (unlikely(!pmx))
 442                 return -ENOMEM;
 443
 444         pmx->pfc = pfc;
 445         pfc->pinctrl = pmx;
 446
 447         nr_ranges = sh_pfc_map_pins(pfc, pmx);
 448         if (unlikely(nr_ranges < 0))
 449                 return nr_ranges;
 450
 451         pmx->pctl_desc.name = DRV_NAME;
 452         pmx->pctl_desc.owner = THIS_MODULE;
 453         pmx->pctl_desc.pctlops = &sh_pfc_pinctrl_ops;
 454         pmx->pctl_desc.pmxops = &sh_pfc_pinmux_ops;
 455         pmx->pctl_desc.confops = &sh_pfc_pinconf_ops;
 456         pmx->pctl_desc.pins = pmx->pins;
 457         pmx->pctl_desc.npins = pfc->info->nr_pins;
 458
 459         pmx->pctl = pinctrl_register(&pmx->pctl_desc, pfc->dev, pmx);
 460         if (pmx->pctl == NULL)
 461                 return -EINVAL;
 462
 463         return 0;
 464 }
 465
 466 int sh_pfc_unregister_pinctrl(struct sh_pfc *pfc)
 467 {
 468         struct sh_pfc_pinctrl *pmx = pfc->pinctrl;
 469
 470         pinctrl_unregister(pmx->pctl);
 471
 472         pfc->pinctrl = NULL;
 473         return 0;
 474 }