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/of.h>
  18 #include <linux/pinctrl/consumer.h>
  19 #include <linux/pinctrl/machine.h>
  20 #include <linux/pinctrl/pinconf.h>
  21 #include <linux/pinctrl/pinconf-generic.h>
  22 #include <linux/pinctrl/pinctrl.h>
  23 #include <linux/pinctrl/pinmux.h>
  24 #include <linux/slab.h>
  25 #include <linux/spinlock.h>
  26
  27 #include "core.h"
  28 #include "../core.h"
  29 #include "../pinconf.h"
  30
  31 struct sh_pfc_pin_config {
  32         u32 type;
  33 };
  34
  35 struct sh_pfc_pinctrl {
  36         struct pinctrl_dev *pctl;
  37         struct pinctrl_desc pctl_desc;
  38
  39         struct sh_pfc *pfc;
  40
  41         struct pinctrl_pin_desc *pins;
  42         struct sh_pfc_pin_config *configs;
  43 };
  44
  45 static int sh_pfc_get_groups_count(struct pinctrl_dev *pctldev)
  46 {
  47         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  48
  49         return pmx->pfc->info->nr_groups;
  50 }
  51
  52 static const char *sh_pfc_get_group_name(struct pinctrl_dev *pctldev,
  53                                          unsigned selector)
  54 {
  55         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  56
  57         return pmx->pfc->info->groups[selector].name;
  58 }
  59
  60 static int sh_pfc_get_group_pins(struct pinctrl_dev *pctldev, unsigned selector,
  61                                  const unsigned **pins, unsigned *num_pins)
  62 {
  63         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
  64
  65         *pins = pmx->pfc->info->groups[selector].pins;
  66         *num_pins = pmx->pfc->info->groups[selector].nr_pins;
  67
  68         return 0;
  69 }
  70
  71 static void sh_pfc_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
  72                                 unsigned offset)
  73 {
  74         seq_printf(s, "%s", DRV_NAME);
  75 }
  76
  77 #ifdef CONFIG_OF
  78 static int sh_pfc_map_add_config(struct pinctrl_map *map,
  79                                  const char *group_or_pin,
  80                                  enum pinctrl_map_type type,
  81                                  unsigned long *configs,
  82                                  unsigned int num_configs)
  83 {
  84         unsigned long *cfgs;
  85
  86         cfgs = kmemdup(configs, num_configs * sizeof(*cfgs),
  87                        GFP_KERNEL);
  88         if (cfgs == NULL)
  89                 return -ENOMEM;
  90
  91         map->type = type;
  92         map->data.configs.group_or_pin = group_or_pin;
  93         map->data.configs.configs = cfgs;
  94         map->data.configs.num_configs = num_configs;
  95
  96         return 0;
  97 }
  98
  99 static int sh_pfc_dt_subnode_to_map(struct device *dev, struct device_node *np,
 100                                     struct pinctrl_map **map,
 101                                     unsigned int *num_maps, unsigned int *index)
 102 {
 103         struct pinctrl_map *maps = *map;
 104         unsigned int nmaps = *num_maps;
 105         unsigned int idx = *index;
 106         unsigned int num_configs;
 107         const char *function = NULL;
 108         unsigned long *configs;
 109         struct property *prop;
 110         unsigned int num_groups;
 111         unsigned int num_pins;
 112         const char *group;
 113         const char *pin;
 114         int ret;
 115
 116         /* Parse the function and configuration properties. At least a function
 117          * or one configuration must be specified.
 118          */
 119         ret = of_property_read_string(np, "renesas,function", &function);
 120         if (ret < 0 && ret != -EINVAL) {
 121                 dev_err(dev, "Invalid function in DT\n");
 122                 return ret;
 123         }
 124
 125         ret = pinconf_generic_parse_dt_config(np, &configs, &num_configs);
 126         if (ret < 0)
 127                 return ret;
 128
 129         if (!function && num_configs == 0) {
 130                 dev_err(dev,
 131                         "DT node must contain at least a function or config\n");
 132                 goto done;
 133         }
 134
 135         /* Count the number of pins and groups and reallocate mappings. */
 136         ret = of_property_count_strings(np, "renesas,pins");
 137         if (ret == -EINVAL) {
 138                 num_pins = 0;
 139         } else if (ret < 0) {
 140                 dev_err(dev, "Invalid pins list in DT\n");
 141                 goto done;
 142         } else {
 143                 num_pins = ret;
 144         }
 145
 146         ret = of_property_count_strings(np, "renesas,groups");
 147         if (ret == -EINVAL) {
 148                 num_groups = 0;
 149         } else if (ret < 0) {
 150                 dev_err(dev, "Invalid pin groups list in DT\n");
 151                 goto done;
 152         } else {
 153                 num_groups = ret;
 154         }
 155
 156         if (!num_pins && !num_groups) {
 157                 dev_err(dev, "No pin or group provided in DT node\n");
 158                 ret = -ENODEV;
 159                 goto done;
 160         }
 161
 162         if (function)
 163                 nmaps += num_groups;
 164         if (configs)
 165                 nmaps += num_pins + num_groups;
 166
 167         maps = krealloc(maps, sizeof(*maps) * nmaps, GFP_KERNEL);
 168         if (maps == NULL) {
 169                 ret = -ENOMEM;
 170                 goto done;
 171         }
 172
 173         *map = maps;
 174         *num_maps = nmaps;
 175
 176         /* Iterate over pins and groups and create the mappings. */
 177         of_property_for_each_string(np, "renesas,groups", prop, group) {
 178                 if (function) {
 179                         maps[idx].type = PIN_MAP_TYPE_MUX_GROUP;
 180                         maps[idx].data.mux.group = group;
 181                         maps[idx].data.mux.function = function;
 182                         idx++;
 183                 }
 184
 185                 if (configs) {
 186                         ret = sh_pfc_map_add_config(&maps[idx], group,
 187                                                     PIN_MAP_TYPE_CONFIGS_GROUP,
 188                                                     configs, num_configs);
 189                         if (ret < 0)
 190                                 goto done;
 191
 192                         idx++;
 193                 }
 194         }
 195
 196         if (!configs) {
 197                 ret = 0;
 198                 goto done;
 199         }
 200
 201         of_property_for_each_string(np, "renesas,pins", prop, pin) {
 202                 ret = sh_pfc_map_add_config(&maps[idx], pin,
 203                                             PIN_MAP_TYPE_CONFIGS_PIN,
 204                                             configs, num_configs);
 205                 if (ret < 0)
 206                         goto done;
 207
 208                 idx++;
 209         }
 210
 211 done:
 212         *index = idx;
 213         kfree(configs);
 214         return ret;
 215 }
 216
 217 static void sh_pfc_dt_free_map(struct pinctrl_dev *pctldev,
 218                                struct pinctrl_map *map, unsigned num_maps)
 219 {
 220         unsigned int i;
 221
 222         if (map == NULL)
 223                 return;
 224
 225         for (i = 0; i < num_maps; ++i) {
 226                 if (map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP ||
 227                     map[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
 228                         kfree(map[i].data.configs.configs);
 229         }
 230
 231         kfree(map);
 232 }
 233
 234 static int sh_pfc_dt_node_to_map(struct pinctrl_dev *pctldev,
 235                                  struct device_node *np,
 236                                  struct pinctrl_map **map, unsigned *num_maps)
 237 {
 238         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 239         struct device *dev = pmx->pfc->dev;
 240         struct device_node *child;
 241         unsigned int index;
 242         int ret;
 243
 244         *map = NULL;
 245         *num_maps = 0;
 246         index = 0;
 247
 248         for_each_child_of_node(np, child) {
 249                 ret = sh_pfc_dt_subnode_to_map(dev, child, map, num_maps,
 250                                                &index);
 251                 if (ret < 0)
 252                         goto done;
 253         }
 254
 255         /* If no mapping has been found in child nodes try the config node. */
 256         if (*num_maps == 0) {
 257                 ret = sh_pfc_dt_subnode_to_map(dev, np, map, num_maps, &index);
 258                 if (ret < 0)
 259                         goto done;
 260         }
 261
 262         if (*num_maps)
 263                 return 0;
 264
 265         dev_err(dev, "no mapping found in node %s\n", np->full_name);
 266         ret = -EINVAL;
 267
 268 done:
 269         if (ret < 0)
 270                 sh_pfc_dt_free_map(pctldev, *map, *num_maps);
 271
 272         return ret;
 273 }
 274 #endif /* CONFIG_OF */
 275
 276 static const struct pinctrl_ops sh_pfc_pinctrl_ops = {
 277         .get_groups_count       = sh_pfc_get_groups_count,
 278         .get_group_name         = sh_pfc_get_group_name,
 279         .get_group_pins         = sh_pfc_get_group_pins,
 280         .pin_dbg_show           = sh_pfc_pin_dbg_show,
 281 #ifdef CONFIG_OF
 282         .dt_node_to_map         = sh_pfc_dt_node_to_map,
 283         .dt_free_map            = sh_pfc_dt_free_map,
 284 #endif
 285 };
 286
 287 static int sh_pfc_get_functions_count(struct pinctrl_dev *pctldev)
 288 {
 289         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 290
 291         return pmx->pfc->info->nr_functions;
 292 }
 293
 294 static const char *sh_pfc_get_function_name(struct pinctrl_dev *pctldev,
 295                                             unsigned selector)
 296 {
 297         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 298
 299         return pmx->pfc->info->functions[selector].name;
 300 }
 301
 302 static int sh_pfc_get_function_groups(struct pinctrl_dev *pctldev,
 303                                       unsigned selector,
 304                                       const char * const **groups,
 305                                       unsigned * const num_groups)
 306 {
 307         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 308
 309         *groups = pmx->pfc->info->functions[selector].groups;
 310         *num_groups = pmx->pfc->info->functions[selector].nr_groups;
 311
 312         return 0;
 313 }
 314
 315 static int sh_pfc_func_enable(struct pinctrl_dev *pctldev, unsigned selector,
 316                               unsigned group)
 317 {
 318         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 319         struct sh_pfc *pfc = pmx->pfc;
 320         const struct sh_pfc_pin_group *grp = &pfc->info->groups[group];
 321         unsigned long flags;
 322         unsigned int i;
 323         int ret = 0;
 324
 325         spin_lock_irqsave(&pfc->lock, flags);
 326
 327         for (i = 0; i < grp->nr_pins; ++i) {
 328                 int idx = sh_pfc_get_pin_index(pfc, grp->pins[i]);
 329                 struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 330
 331                 if (cfg->type != PINMUX_TYPE_NONE) {
 332                         ret = -EBUSY;
 333                         goto done;
 334                 }
 335         }
 336
 337         for (i = 0; i < grp->nr_pins; ++i) {
 338                 ret = sh_pfc_config_mux(pfc, grp->mux[i], PINMUX_TYPE_FUNCTION);
 339                 if (ret < 0)
 340                         break;
 341         }
 342
 343 done:
 344         spin_unlock_irqrestore(&pfc->lock, flags);
 345         return ret;
 346 }
 347
 348 static void sh_pfc_func_disable(struct pinctrl_dev *pctldev, unsigned selector,
 349                                 unsigned group)
 350 {
 351         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 352         struct sh_pfc *pfc = pmx->pfc;
 353         const struct sh_pfc_pin_group *grp = &pfc->info->groups[group];
 354         unsigned long flags;
 355         unsigned int i;
 356
 357         spin_lock_irqsave(&pfc->lock, flags);
 358
 359         for (i = 0; i < grp->nr_pins; ++i) {
 360                 int idx = sh_pfc_get_pin_index(pfc, grp->pins[i]);
 361                 struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 362
 363                 cfg->type = PINMUX_TYPE_NONE;
 364         }
 365
 366         spin_unlock_irqrestore(&pfc->lock, flags);
 367 }
 368
 369 static int sh_pfc_gpio_request_enable(struct pinctrl_dev *pctldev,
 370                                       struct pinctrl_gpio_range *range,
 371                                       unsigned offset)
 372 {
 373         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 374         struct sh_pfc *pfc = pmx->pfc;
 375         int idx = sh_pfc_get_pin_index(pfc, offset);
 376         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 377         unsigned long flags;
 378         int ret;
 379
 380         spin_lock_irqsave(&pfc->lock, flags);
 381
 382         if (cfg->type != PINMUX_TYPE_NONE) {
 383                 dev_err(pfc->dev,
 384                         "Pin %u is busy, can't configure it as GPIO.\n",
 385                         offset);
 386                 ret = -EBUSY;
 387                 goto done;
 388         }
 389
 390         if (!pfc->gpio) {
 391                 /* If GPIOs are handled externally the pin mux type need to be
 392                  * set to GPIO here.
 393                  */
 394                 const struct sh_pfc_pin *pin = &pfc->info->pins[idx];
 395
 396                 ret = sh_pfc_config_mux(pfc, pin->enum_id, PINMUX_TYPE_GPIO);
 397                 if (ret < 0)
 398                         goto done;
 399         }
 400
 401         cfg->type = PINMUX_TYPE_GPIO;
 402
 403         ret = 0;
 404
 405 done:
 406         spin_unlock_irqrestore(&pfc->lock, flags);
 407
 408         return ret;
 409 }
 410
 411 static void sh_pfc_gpio_disable_free(struct pinctrl_dev *pctldev,
 412                                      struct pinctrl_gpio_range *range,
 413                                      unsigned offset)
 414 {
 415         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 416         struct sh_pfc *pfc = pmx->pfc;
 417         int idx = sh_pfc_get_pin_index(pfc, offset);
 418         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 419         unsigned long flags;
 420
 421         spin_lock_irqsave(&pfc->lock, flags);
 422         cfg->type = PINMUX_TYPE_NONE;
 423         spin_unlock_irqrestore(&pfc->lock, flags);
 424 }
 425
 426 static int sh_pfc_gpio_set_direction(struct pinctrl_dev *pctldev,
 427                                      struct pinctrl_gpio_range *range,
 428                                      unsigned offset, bool input)
 429 {
 430         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 431         struct sh_pfc *pfc = pmx->pfc;
 432         int new_type = input ? PINMUX_TYPE_INPUT : PINMUX_TYPE_OUTPUT;
 433         int idx = sh_pfc_get_pin_index(pfc, offset);
 434         const struct sh_pfc_pin *pin = &pfc->info->pins[idx];
 435         struct sh_pfc_pin_config *cfg = &pmx->configs[idx];
 436         unsigned long flags;
 437         unsigned int dir;
 438         int ret;
 439
 440         /* Check if the requested direction is supported by the pin. Not all SoC
 441          * provide pin config data, so perform the check conditionally.
 442          */
 443         if (pin->configs) {
 444                 dir = input ? SH_PFC_PIN_CFG_INPUT : SH_PFC_PIN_CFG_OUTPUT;
 445                 if (!(pin->configs & dir))
 446                         return -EINVAL;
 447         }
 448
 449         spin_lock_irqsave(&pfc->lock, flags);
 450
 451         ret = sh_pfc_config_mux(pfc, pin->enum_id, new_type);
 452         if (ret < 0)
 453                 goto done;
 454
 455         cfg->type = new_type;
 456
 457 done:
 458         spin_unlock_irqrestore(&pfc->lock, flags);
 459         return ret;
 460 }
 461
 462 static const struct pinmux_ops sh_pfc_pinmux_ops = {
 463         .get_functions_count    = sh_pfc_get_functions_count,
 464         .get_function_name      = sh_pfc_get_function_name,
 465         .get_function_groups    = sh_pfc_get_function_groups,
 466         .enable                 = sh_pfc_func_enable,
 467         .disable                = sh_pfc_func_disable,
 468         .gpio_request_enable    = sh_pfc_gpio_request_enable,
 469         .gpio_disable_free      = sh_pfc_gpio_disable_free,
 470         .gpio_set_direction     = sh_pfc_gpio_set_direction,
 471 };
 472
 473 /* Check whether the requested parameter is supported for a pin. */
 474 static bool sh_pfc_pinconf_validate(struct sh_pfc *pfc, unsigned int _pin,
 475                                     enum pin_config_param param)
 476 {
 477         int idx = sh_pfc_get_pin_index(pfc, _pin);
 478         const struct sh_pfc_pin *pin = &pfc->info->pins[idx];
 479
 480         switch (param) {
 481         case PIN_CONFIG_BIAS_DISABLE:
 482                 return true;
 483
 484         case PIN_CONFIG_BIAS_PULL_UP:
 485                 return pin->configs & SH_PFC_PIN_CFG_PULL_UP;
 486
 487         case PIN_CONFIG_BIAS_PULL_DOWN:
 488                 return pin->configs & SH_PFC_PIN_CFG_PULL_DOWN;
 489
 490         default:
 491                 return false;
 492         }
 493 }
 494
 495 static int sh_pfc_pinconf_get(struct pinctrl_dev *pctldev, unsigned _pin,
 496                               unsigned long *config)
 497 {
 498         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 499         struct sh_pfc *pfc = pmx->pfc;
 500         enum pin_config_param param = pinconf_to_config_param(*config);
 501         unsigned long flags;
 502         unsigned int bias;
 503
 504         if (!sh_pfc_pinconf_validate(pfc, _pin, param))
 505                 return -ENOTSUPP;
 506
 507         switch (param) {
 508         case PIN_CONFIG_BIAS_DISABLE:
 509         case PIN_CONFIG_BIAS_PULL_UP:
 510         case PIN_CONFIG_BIAS_PULL_DOWN:
 511                 if (!pfc->info->ops || !pfc->info->ops->get_bias)
 512                         return -ENOTSUPP;
 513
 514                 spin_lock_irqsave(&pfc->lock, flags);
 515                 bias = pfc->info->ops->get_bias(pfc, _pin);
 516                 spin_unlock_irqrestore(&pfc->lock, flags);
 517
 518                 if (bias != param)
 519                         return -EINVAL;
 520
 521                 *config = 0;
 522                 break;
 523
 524         default:
 525                 return -ENOTSUPP;
 526         }
 527
 528         return 0;
 529 }
 530
 531 static int sh_pfc_pinconf_set(struct pinctrl_dev *pctldev, unsigned _pin,
 532                               unsigned long config)
 533 {
 534         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 535         struct sh_pfc *pfc = pmx->pfc;
 536         enum pin_config_param param = pinconf_to_config_param(config);
 537         unsigned long flags;
 538
 539         if (!sh_pfc_pinconf_validate(pfc, _pin, param))
 540                 return -ENOTSUPP;
 541
 542         switch (param) {
 543         case PIN_CONFIG_BIAS_PULL_UP:
 544         case PIN_CONFIG_BIAS_PULL_DOWN:
 545         case PIN_CONFIG_BIAS_DISABLE:
 546                 if (!pfc->info->ops || !pfc->info->ops->set_bias)
 547                         return -ENOTSUPP;
 548
 549                 spin_lock_irqsave(&pfc->lock, flags);
 550                 pfc->info->ops->set_bias(pfc, _pin, param);
 551                 spin_unlock_irqrestore(&pfc->lock, flags);
 552
 553                 break;
 554
 555         default:
 556                 return -ENOTSUPP;
 557         }
 558
 559         return 0;
 560 }
 561
 562 static int sh_pfc_pinconf_group_set(struct pinctrl_dev *pctldev, unsigned group,
 563                                     unsigned long config)
 564 {
 565         struct sh_pfc_pinctrl *pmx = pinctrl_dev_get_drvdata(pctldev);
 566         const unsigned int *pins;
 567         unsigned int num_pins;
 568         unsigned int i;
 569
 570         pins = pmx->pfc->info->groups[group].pins;
 571         num_pins = pmx->pfc->info->groups[group].nr_pins;
 572
 573         for (i = 0; i < num_pins; ++i)
 574                 sh_pfc_pinconf_set(pctldev, pins[i], config);
 575
 576         return 0;
 577 }
 578
 579 static const struct pinconf_ops sh_pfc_pinconf_ops = {
 580         .is_generic                     = true,
 581         .pin_config_get                 = sh_pfc_pinconf_get,
 582         .pin_config_set                 = sh_pfc_pinconf_set,
 583         .pin_config_group_set           = sh_pfc_pinconf_group_set,
 584         .pin_config_config_dbg_show     = pinconf_generic_dump_config,
 585 };
 586
 587 /* PFC ranges -> pinctrl pin descs */
 588 static int sh_pfc_map_pins(struct sh_pfc *pfc, struct sh_pfc_pinctrl *pmx)
 589 {
 590         const struct pinmux_range *ranges;
 591         struct pinmux_range def_range;
 592         unsigned int nr_ranges;
 593         unsigned int nr_pins;
 594         unsigned int i;
 595
 596         if (pfc->info->ranges == NULL) {
 597                 def_range.begin = 0;
 598                 def_range.end = pfc->info->nr_pins - 1;
 599                 ranges = &def_range;
 600                 nr_ranges = 1;
 601         } else {
 602                 ranges = pfc->info->ranges;
 603                 nr_ranges = pfc->info->nr_ranges;
 604         }
 605
 606         pmx->pins = devm_kzalloc(pfc->dev,
 607                                  sizeof(*pmx->pins) * pfc->info->nr_pins,
 608                                  GFP_KERNEL);
 609         if (unlikely(!pmx->pins))
 610                 return -ENOMEM;
 611
 612         pmx->configs = devm_kzalloc(pfc->dev,
 613                                     sizeof(*pmx->configs) * pfc->info->nr_pins,
 614                                     GFP_KERNEL);
 615         if (unlikely(!pmx->configs))
 616                 return -ENOMEM;
 617
 618         for (i = 0, nr_pins = 0; i < nr_ranges; ++i) {
 619                 const struct pinmux_range *range = &ranges[i];
 620                 unsigned int number;
 621
 622                 for (number = range->begin; number <= range->end;
 623                      number++, nr_pins++) {
 624                         struct sh_pfc_pin_config *cfg = &pmx->configs[nr_pins];
 625                         struct pinctrl_pin_desc *pin = &pmx->pins[nr_pins];
 626                         const struct sh_pfc_pin *info =
 627                                 &pfc->info->pins[nr_pins];
 628
 629                         pin->number = number;
 630                         pin->name = info->name;
 631                         cfg->type = PINMUX_TYPE_NONE;
 632                 }
 633         }
 634
 635         pfc->nr_pins = ranges[nr_ranges-1].end + 1;
 636
 637         return nr_ranges;
 638 }
 639
 640 int sh_pfc_register_pinctrl(struct sh_pfc *pfc)
 641 {
 642         struct sh_pfc_pinctrl *pmx;
 643         int nr_ranges;
 644
 645         pmx = devm_kzalloc(pfc->dev, sizeof(*pmx), GFP_KERNEL);
 646         if (unlikely(!pmx))
 647                 return -ENOMEM;
 648
 649         pmx->pfc = pfc;
 650         pfc->pinctrl = pmx;
 651
 652         nr_ranges = sh_pfc_map_pins(pfc, pmx);
 653         if (unlikely(nr_ranges < 0))
 654                 return nr_ranges;
 655
 656         pmx->pctl_desc.name = DRV_NAME;
 657         pmx->pctl_desc.owner = THIS_MODULE;
 658         pmx->pctl_desc.pctlops = &sh_pfc_pinctrl_ops;
 659         pmx->pctl_desc.pmxops = &sh_pfc_pinmux_ops;
 660         pmx->pctl_desc.confops = &sh_pfc_pinconf_ops;
 661         pmx->pctl_desc.pins = pmx->pins;
 662         pmx->pctl_desc.npins = pfc->info->nr_pins;
 663
 664         pmx->pctl = pinctrl_register(&pmx->pctl_desc, pfc->dev, pmx);
 665         if (pmx->pctl == NULL)
 666                 return -EINVAL;
 667
 668         return 0;
 669 }
 670
 671 int sh_pfc_unregister_pinctrl(struct sh_pfc *pfc)
 672 {
 673         struct sh_pfc_pinctrl *pmx = pfc->pinctrl;
 674
 675         pinctrl_unregister(pmx->pctl);
 676
 677         pfc->pinctrl = NULL;
 678         return 0;
 679 }