drivers/pinctrl/pinmux.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Core driver for the pin muxing portions of the pin control subsystem
   4  *
   5  * Copyright (C) 2011-2012 ST-Ericsson SA
   6  * Written on behalf of Linaro for ST-Ericsson
   7  * Based on bits of regulator core, gpio core and clk core
   8  *
   9  * Author: Linus Walleij <linus.walleij@linaro.org>
  10  *
  11  * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
  12  */
  13 #define pr_fmt(fmt) "pinmux core: " fmt
  14
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/init.h>
  18 #include <linux/device.h>
  19 #include <linux/slab.h>
  20 #include <linux/radix-tree.h>
  21 #include <linux/err.h>
  22 #include <linux/list.h>
  23 #include <linux/string.h>
  24 #include <linux/debugfs.h>
  25 #include <linux/seq_file.h>
  26 #include <linux/pinctrl/machine.h>
  27 #include <linux/pinctrl/pinmux.h>
  28 #include "core.h"
  29 #include "pinmux.h"
  30
  31 int pinmux_check_ops(struct pinctrl_dev *pctldev)
  32 {
  33         const struct pinmux_ops *ops = pctldev->desc->pmxops;
  34         unsigned nfuncs;
  35         unsigned selector = 0;
  36
  37         /* Check that we implement required operations */
  38         if (!ops ||
  39             !ops->get_functions_count ||
  40             !ops->get_function_name ||
  41             !ops->get_function_groups ||
  42             !ops->set_mux) {
  43                 dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n");
  44                 return -EINVAL;
  45         }
  46         /* Check that all functions registered have names */
  47         nfuncs = ops->get_functions_count(pctldev);
  48         while (selector < nfuncs) {
  49                 const char *fname = ops->get_function_name(pctldev,
  50                                                            selector);
  51                 if (!fname) {
  52                         dev_err(pctldev->dev, "pinmux ops has no name for function%u\n",
  53                                 selector);
  54                         return -EINVAL;
  55                 }
  56                 selector++;
  57         }
  58
  59         return 0;
  60 }
  61
  62 int pinmux_validate_map(const struct pinctrl_map *map, int i)
  63 {
  64         if (!map->data.mux.function) {
  65                 pr_err("failed to register map %s (%d): no function given\n",
  66                        map->name, i);
  67                 return -EINVAL;
  68         }
  69
  70         return 0;
  71 }
  72
  73 /**
  74  * pin_request() - request a single pin to be muxed in, typically for GPIO
  75  * @pin: the pin number in the global pin space
  76  * @owner: a representation of the owner of this pin; typically the device
  77  *      name that controls its mux function, or the requested GPIO name
  78  * @gpio_range: the range matching the GPIO pin if this is a request for a
  79  *      single GPIO pin
  80  */
  81 static int pin_request(struct pinctrl_dev *pctldev,
  82                        int pin, const char *owner,
  83                        struct pinctrl_gpio_range *gpio_range)
  84 {
  85         struct pin_desc *desc;
  86         const struct pinmux_ops *ops = pctldev->desc->pmxops;
  87         int status = -EINVAL;
  88
  89         desc = pin_desc_get(pctldev, pin);
  90         if (desc == NULL) {
  91                 dev_err(pctldev->dev,
  92                         "pin %d is not registered so it cannot be requested\n",
  93                         pin);
  94                 goto out;
  95         }
  96
  97         dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n",
  98                 pin, desc->name, owner);
  99
 100         if ((!gpio_range || ops->strict) &&
 101             desc->mux_usecount && strcmp(desc->mux_owner, owner)) {
 102                 dev_err(pctldev->dev,
 103                         "pin %s already requested by %s; cannot claim for %s\n",
 104                         desc->name, desc->mux_owner, owner);
 105                 goto out;
 106         }
 107
 108         if ((gpio_range || ops->strict) && desc->gpio_owner) {
 109                 dev_err(pctldev->dev,
 110                         "pin %s already requested by %s; cannot claim for %s\n",
 111                         desc->name, desc->gpio_owner, owner);
 112                 goto out;
 113         }
 114
 115         if (gpio_range) {
 116                 desc->gpio_owner = owner;
 117         } else {
 118                 desc->mux_usecount++;
 119                 if (desc->mux_usecount > 1)
 120                         return 0;
 121
 122                 desc->mux_owner = owner;
 123         }
 124
 125         /* Let each pin increase references to this module */
 126         if (!try_module_get(pctldev->owner)) {
 127                 dev_err(pctldev->dev,
 128                         "could not increase module refcount for pin %d\n",
 129                         pin);
 130                 status = -EINVAL;
 131                 goto out_free_pin;
 132         }
 133
 134         /*
 135          * If there is no kind of request function for the pin we just assume
 136          * we got it by default and proceed.
 137          */
 138         if (gpio_range && ops->gpio_request_enable)
 139                 /* This requests and enables a single GPIO pin */
 140                 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
 141         else if (ops->request)
 142                 status = ops->request(pctldev, pin);
 143         else
 144                 status = 0;
 145
 146         if (status) {
 147                 dev_err(pctldev->dev, "request() failed for pin %d\n", pin);
 148                 module_put(pctldev->owner);
 149         }
 150
 151 out_free_pin:
 152         if (status) {
 153                 if (gpio_range) {
 154                         desc->gpio_owner = NULL;
 155                 } else {
 156                         desc->mux_usecount--;
 157                         if (!desc->mux_usecount)
 158                                 desc->mux_owner = NULL;
 159                 }
 160         }
 161 out:
 162         if (status)
 163                 dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
 164                         pin, owner, status);
 165
 166         return status;
 167 }
 168
 169 /**
 170  * pin_free() - release a single muxed in pin so something else can be muxed
 171  * @pctldev: pin controller device handling this pin
 172  * @pin: the pin to free
 173  * @gpio_range: the range matching the GPIO pin if this is a request for a
 174  *      single GPIO pin
 175  *
 176  * This function returns a pointer to the previous owner. This is used
 177  * for callers that dynamically allocate an owner name so it can be freed
 178  * once the pin is free. This is done for GPIO request functions.
 179  */
 180 static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
 181                             struct pinctrl_gpio_range *gpio_range)
 182 {
 183         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 184         struct pin_desc *desc;
 185         const char *owner;
 186
 187         desc = pin_desc_get(pctldev, pin);
 188         if (desc == NULL) {
 189                 dev_err(pctldev->dev,
 190                         "pin is not registered so it cannot be freed\n");
 191                 return NULL;
 192         }
 193
 194         if (!gpio_range) {
 195                 /*
 196                  * A pin should not be freed more times than allocated.
 197                  */
 198                 if (WARN_ON(!desc->mux_usecount))
 199                         return NULL;
 200                 desc->mux_usecount--;
 201                 if (desc->mux_usecount)
 202                         return NULL;
 203         }
 204
 205         /*
 206          * If there is no kind of request function for the pin we just assume
 207          * we got it by default and proceed.
 208          */
 209         if (gpio_range && ops->gpio_disable_free)
 210                 ops->gpio_disable_free(pctldev, gpio_range, pin);
 211         else if (ops->free)
 212                 ops->free(pctldev, pin);
 213
 214         if (gpio_range) {
 215                 owner = desc->gpio_owner;
 216                 desc->gpio_owner = NULL;
 217         } else {
 218                 owner = desc->mux_owner;
 219                 desc->mux_owner = NULL;
 220                 desc->mux_setting = NULL;
 221         }
 222
 223         module_put(pctldev->owner);
 224
 225         return owner;
 226 }
 227
 228 /**
 229  * pinmux_request_gpio() - request pinmuxing for a GPIO pin
 230  * @pctldev: pin controller device affected
 231  * @pin: the pin to mux in for GPIO
 232  * @range: the applicable GPIO range
 233  */
 234 int pinmux_request_gpio(struct pinctrl_dev *pctldev,
 235                         struct pinctrl_gpio_range *range,
 236                         unsigned pin, unsigned gpio)
 237 {
 238         const char *owner;
 239         int ret;
 240
 241         /* Conjure some name stating what chip and pin this is taken by */
 242         owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio);
 243         if (!owner)
 244                 return -ENOMEM;
 245
 246         ret = pin_request(pctldev, pin, owner, range);
 247         if (ret < 0)
 248                 kfree(owner);
 249
 250         return ret;
 251 }
 252
 253 /**
 254  * pinmux_free_gpio() - release a pin from GPIO muxing
 255  * @pctldev: the pin controller device for the pin
 256  * @pin: the affected currently GPIO-muxed in pin
 257  * @range: applicable GPIO range
 258  */
 259 void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
 260                       struct pinctrl_gpio_range *range)
 261 {
 262         const char *owner;
 263
 264         owner = pin_free(pctldev, pin, range);
 265         kfree(owner);
 266 }
 267
 268 /**
 269  * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
 270  * @pctldev: the pin controller handling this pin
 271  * @range: applicable GPIO range
 272  * @pin: the affected GPIO pin in this controller
 273  * @input: true if we set the pin as input, false for output
 274  */
 275 int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
 276                           struct pinctrl_gpio_range *range,
 277                           unsigned pin, bool input)
 278 {
 279         const struct pinmux_ops *ops;
 280         int ret;
 281
 282         ops = pctldev->desc->pmxops;
 283
 284         if (ops->gpio_set_direction)
 285                 ret = ops->gpio_set_direction(pctldev, range, pin, input);
 286         else
 287                 ret = 0;
 288
 289         return ret;
 290 }
 291
 292 static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
 293                                         const char *function)
 294 {
 295         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 296         unsigned nfuncs = ops->get_functions_count(pctldev);
 297         unsigned selector = 0;
 298
 299         /* See if this pctldev has this function */
 300         while (selector < nfuncs) {
 301                 const char *fname = ops->get_function_name(pctldev, selector);
 302
 303                 if (!strcmp(function, fname))
 304                         return selector;
 305
 306                 selector++;
 307         }
 308
 309         return -EINVAL;
 310 }
 311
 312 int pinmux_map_to_setting(const struct pinctrl_map *map,
 313                           struct pinctrl_setting *setting)
 314 {
 315         struct pinctrl_dev *pctldev = setting->pctldev;
 316         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
 317         char const * const *groups;
 318         unsigned num_groups;
 319         int ret;
 320         const char *group;
 321
 322         if (!pmxops) {
 323                 dev_err(pctldev->dev, "does not support mux function\n");
 324                 return -EINVAL;
 325         }
 326
 327         ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function);
 328         if (ret < 0) {
 329                 dev_err(pctldev->dev, "invalid function %s in map table\n",
 330                         map->data.mux.function);
 331                 return ret;
 332         }
 333         setting->data.mux.func = ret;
 334
 335         ret = pmxops->get_function_groups(pctldev, setting->data.mux.func,
 336                                           &groups, &num_groups);
 337         if (ret < 0) {
 338                 dev_err(pctldev->dev, "can't query groups for function %s\n",
 339                         map->data.mux.function);
 340                 return ret;
 341         }
 342         if (!num_groups) {
 343                 dev_err(pctldev->dev,
 344                         "function %s can't be selected on any group\n",
 345                         map->data.mux.function);
 346                 return -EINVAL;
 347         }
 348         if (map->data.mux.group) {
 349                 group = map->data.mux.group;
 350                 ret = match_string(groups, num_groups, group);
 351                 if (ret < 0) {
 352                         dev_err(pctldev->dev,
 353                                 "invalid group \"%s\" for function \"%s\"\n",
 354                                 group, map->data.mux.function);
 355                         return ret;
 356                 }
 357         } else {
 358                 group = groups[0];
 359         }
 360
 361         ret = pinctrl_get_group_selector(pctldev, group);
 362         if (ret < 0) {
 363                 dev_err(pctldev->dev, "invalid group %s in map table\n",
 364                         map->data.mux.group);
 365                 return ret;
 366         }
 367         setting->data.mux.group = ret;
 368
 369         return 0;
 370 }
 371
 372 void pinmux_free_setting(const struct pinctrl_setting *setting)
 373 {
 374         /* This function is currently unused */
 375 }
 376
 377 int pinmux_enable_setting(const struct pinctrl_setting *setting)
 378 {
 379         struct pinctrl_dev *pctldev = setting->pctldev;
 380         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 381         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 382         int ret = 0;
 383         const unsigned *pins = NULL;
 384         unsigned num_pins = 0;
 385         int i;
 386         struct pin_desc *desc;
 387
 388         if (pctlops->get_group_pins)
 389                 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
 390                                               &pins, &num_pins);
 391
 392         if (ret) {
 393                 const char *gname;
 394
 395                 /* errors only affect debug data, so just warn */
 396                 gname = pctlops->get_group_name(pctldev,
 397                                                 setting->data.mux.group);
 398                 dev_warn(pctldev->dev,
 399                          "could not get pins for group %s\n",
 400                          gname);
 401                 num_pins = 0;
 402         }
 403
 404         /* Try to allocate all pins in this group, one by one */
 405         for (i = 0; i < num_pins; i++) {
 406                 ret = pin_request(pctldev, pins[i], setting->dev_name, NULL);
 407                 if (ret) {
 408                         const char *gname;
 409                         const char *pname;
 410
 411                         desc = pin_desc_get(pctldev, pins[i]);
 412                         pname = desc ? desc->name : "non-existing";
 413                         gname = pctlops->get_group_name(pctldev,
 414                                                 setting->data.mux.group);
 415                         dev_err(pctldev->dev,
 416                                 "could not request pin %d (%s) from group %s "
 417                                 " on device %s\n",
 418                                 pins[i], pname, gname,
 419                                 pinctrl_dev_get_name(pctldev));
 420                         goto err_pin_request;
 421                 }
 422         }
 423
 424         /* Now that we have acquired the pins, encode the mux setting */
 425         for (i = 0; i < num_pins; i++) {
 426                 desc = pin_desc_get(pctldev, pins[i]);
 427                 if (desc == NULL) {
 428                         dev_warn(pctldev->dev,
 429                                  "could not get pin desc for pin %d\n",
 430                                  pins[i]);
 431                         continue;
 432                 }
 433                 desc->mux_setting = &(setting->data.mux);
 434         }
 435
 436         ret = ops->set_mux(pctldev, setting->data.mux.func,
 437                            setting->data.mux.group);
 438
 439         if (ret)
 440                 goto err_set_mux;
 441
 442         return 0;
 443
 444 err_set_mux:
 445         for (i = 0; i < num_pins; i++) {
 446                 desc = pin_desc_get(pctldev, pins[i]);
 447                 if (desc)
 448                         desc->mux_setting = NULL;
 449         }
 450 err_pin_request:
 451         /* On error release all taken pins */
 452         while (--i >= 0)
 453                 pin_free(pctldev, pins[i], NULL);
 454
 455         return ret;
 456 }
 457
 458 void pinmux_disable_setting(const struct pinctrl_setting *setting)
 459 {
 460         struct pinctrl_dev *pctldev = setting->pctldev;
 461         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 462         int ret = 0;
 463         const unsigned *pins = NULL;
 464         unsigned num_pins = 0;
 465         int i;
 466         struct pin_desc *desc;
 467
 468         if (pctlops->get_group_pins)
 469                 ret = pctlops->get_group_pins(pctldev, setting->data.mux.group,
 470                                               &pins, &num_pins);
 471         if (ret) {
 472                 const char *gname;
 473
 474                 /* errors only affect debug data, so just warn */
 475                 gname = pctlops->get_group_name(pctldev,
 476                                                 setting->data.mux.group);
 477                 dev_warn(pctldev->dev,
 478                          "could not get pins for group %s\n",
 479                          gname);
 480                 num_pins = 0;
 481         }
 482
 483         /* Flag the descs that no setting is active */
 484         for (i = 0; i < num_pins; i++) {
 485                 desc = pin_desc_get(pctldev, pins[i]);
 486                 if (desc == NULL) {
 487                         dev_warn(pctldev->dev,
 488                                  "could not get pin desc for pin %d\n",
 489                                  pins[i]);
 490                         continue;
 491                 }
 492                 if (desc->mux_setting == &(setting->data.mux)) {
 493                         pin_free(pctldev, pins[i], NULL);
 494                 } else {
 495                         const char *gname;
 496
 497                         gname = pctlops->get_group_name(pctldev,
 498                                                 setting->data.mux.group);
 499                         dev_warn(pctldev->dev,
 500                                  "not freeing pin %d (%s) as part of "
 501                                  "deactivating group %s - it is already "
 502                                  "used for some other setting",
 503                                  pins[i], desc->name, gname);
 504                 }
 505         }
 506 }
 507
 508 #ifdef CONFIG_DEBUG_FS
 509
 510 /* Called from pincontrol core */
 511 static int pinmux_functions_show(struct seq_file *s, void *what)
 512 {
 513         struct pinctrl_dev *pctldev = s->private;
 514         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
 515         unsigned nfuncs;
 516         unsigned func_selector = 0;
 517
 518         if (!pmxops)
 519                 return 0;
 520
 521         mutex_lock(&pctldev->mutex);
 522         nfuncs = pmxops->get_functions_count(pctldev);
 523         while (func_selector < nfuncs) {
 524                 const char *func = pmxops->get_function_name(pctldev,
 525                                                           func_selector);
 526                 const char * const *groups;
 527                 unsigned num_groups;
 528                 int ret;
 529                 int i;
 530
 531                 ret = pmxops->get_function_groups(pctldev, func_selector,
 532                                                   &groups, &num_groups);
 533                 if (ret) {
 534                         seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
 535                                    func);
 536                         func_selector++;
 537                         continue;
 538                 }
 539
 540                 seq_printf(s, "function: %s, groups = [ ", func);
 541                 for (i = 0; i < num_groups; i++)
 542                         seq_printf(s, "%s ", groups[i]);
 543                 seq_puts(s, "]\n");
 544
 545                 func_selector++;
 546         }
 547
 548         mutex_unlock(&pctldev->mutex);
 549
 550         return 0;
 551 }
 552
 553 static int pinmux_pins_show(struct seq_file *s, void *what)
 554 {
 555         struct pinctrl_dev *pctldev = s->private;
 556         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 557         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
 558         unsigned i, pin;
 559
 560         if (!pmxops)
 561                 return 0;
 562
 563         seq_puts(s, "Pinmux settings per pin\n");
 564         if (pmxops->strict)
 565                 seq_puts(s,
 566                  "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n");
 567         else
 568                 seq_puts(s,
 569                 "Format: pin (name): mux_owner gpio_owner hog?\n");
 570
 571         mutex_lock(&pctldev->mutex);
 572
 573         /* The pin number can be retrived from the pin controller descriptor */
 574         for (i = 0; i < pctldev->desc->npins; i++) {
 575                 struct pin_desc *desc;
 576                 bool is_hog = false;
 577
 578                 pin = pctldev->desc->pins[i].number;
 579                 desc = pin_desc_get(pctldev, pin);
 580                 /* Skip if we cannot search the pin */
 581                 if (desc == NULL)
 582                         continue;
 583
 584                 if (desc->mux_owner &&
 585                     !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev)))
 586                         is_hog = true;
 587
 588                 if (pmxops->strict) {
 589                         if (desc->mux_owner)
 590                                 seq_printf(s, "pin %d (%s): device %s%s",
 591                                            pin, desc->name, desc->mux_owner,
 592                                            is_hog ? " (HOG)" : "");
 593                         else if (desc->gpio_owner)
 594                                 seq_printf(s, "pin %d (%s): GPIO %s",
 595                                            pin, desc->name, desc->gpio_owner);
 596                         else
 597                                 seq_printf(s, "pin %d (%s): UNCLAIMED",
 598                                            pin, desc->name);
 599                 } else {
 600                         /* For non-strict controllers */
 601                         seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name,
 602                                    desc->mux_owner ? desc->mux_owner
 603                                    : "(MUX UNCLAIMED)",
 604                                    desc->gpio_owner ? desc->gpio_owner
 605                                    : "(GPIO UNCLAIMED)",
 606                                    is_hog ? " (HOG)" : "");
 607                 }
 608
 609                 /* If mux: print function+group claiming the pin */
 610                 if (desc->mux_setting)
 611                         seq_printf(s, " function %s group %s\n",
 612                                    pmxops->get_function_name(pctldev,
 613                                         desc->mux_setting->func),
 614                                    pctlops->get_group_name(pctldev,
 615                                         desc->mux_setting->group));
 616                 else
 617                         seq_putc(s, '\n');
 618         }
 619
 620         mutex_unlock(&pctldev->mutex);
 621
 622         return 0;
 623 }
 624
 625 void pinmux_show_map(struct seq_file *s, const struct pinctrl_map *map)
 626 {
 627         seq_printf(s, "group %s\nfunction %s\n",
 628                 map->data.mux.group ? map->data.mux.group : "(default)",
 629                 map->data.mux.function);
 630 }
 631
 632 void pinmux_show_setting(struct seq_file *s,
 633                          const struct pinctrl_setting *setting)
 634 {
 635         struct pinctrl_dev *pctldev = setting->pctldev;
 636         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
 637         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 638
 639         seq_printf(s, "group: %s (%u) function: %s (%u)\n",
 640                    pctlops->get_group_name(pctldev, setting->data.mux.group),
 641                    setting->data.mux.group,
 642                    pmxops->get_function_name(pctldev, setting->data.mux.func),
 643                    setting->data.mux.func);
 644 }
 645
 646 DEFINE_SHOW_ATTRIBUTE(pinmux_functions);
 647 DEFINE_SHOW_ATTRIBUTE(pinmux_pins);
 648
 649 void pinmux_init_device_debugfs(struct dentry *devroot,
 650                          struct pinctrl_dev *pctldev)
 651 {
 652         debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
 653                             devroot, pctldev, &pinmux_functions_fops);
 654         debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
 655                             devroot, pctldev, &pinmux_pins_fops);
 656 }
 657
 658 #endif /* CONFIG_DEBUG_FS */
 659
 660 #ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS
 661
 662 /**
 663  * pinmux_generic_get_function_count() - returns number of functions
 664  * @pctldev: pin controller device
 665  */
 666 int pinmux_generic_get_function_count(struct pinctrl_dev *pctldev)
 667 {
 668         return pctldev->num_functions;
 669 }
 670 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_count);
 671
 672 /**
 673  * pinmux_generic_get_function_name() - returns the function name
 674  * @pctldev: pin controller device
 675  * @selector: function number
 676  */
 677 const char *
 678 pinmux_generic_get_function_name(struct pinctrl_dev *pctldev,
 679                                  unsigned int selector)
 680 {
 681         struct function_desc *function;
 682
 683         function = radix_tree_lookup(&pctldev->pin_function_tree,
 684                                      selector);
 685         if (!function)
 686                 return NULL;
 687
 688         return function->name;
 689 }
 690 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_name);
 691
 692 /**
 693  * pinmux_generic_get_function_groups() - gets the function groups
 694  * @pctldev: pin controller device
 695  * @selector: function number
 696  * @groups: array of pin groups
 697  * @num_groups: number of pin groups
 698  */
 699 int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev,
 700                                        unsigned int selector,
 701                                        const char * const **groups,
 702                                        unsigned * const num_groups)
 703 {
 704         struct function_desc *function;
 705
 706         function = radix_tree_lookup(&pctldev->pin_function_tree,
 707                                      selector);
 708         if (!function) {
 709                 dev_err(pctldev->dev, "%s could not find function%i\n",
 710                         __func__, selector);
 711                 return -EINVAL;
 712         }
 713         *groups = function->group_names;
 714         *num_groups = function->num_group_names;
 715
 716         return 0;
 717 }
 718 EXPORT_SYMBOL_GPL(pinmux_generic_get_function_groups);
 719
 720 /**
 721  * pinmux_generic_get_function() - returns a function based on the number
 722  * @pctldev: pin controller device
 723  * @group_selector: function number
 724  */
 725 struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev,
 726                                                   unsigned int selector)
 727 {
 728         struct function_desc *function;
 729
 730         function = radix_tree_lookup(&pctldev->pin_function_tree,
 731                                      selector);
 732         if (!function)
 733                 return NULL;
 734
 735         return function;
 736 }
 737 EXPORT_SYMBOL_GPL(pinmux_generic_get_function);
 738
 739 /**
 740  * pinmux_generic_add_function() - adds a function group
 741  * @pctldev: pin controller device
 742  * @name: name of the function
 743  * @groups: array of pin groups
 744  * @num_groups: number of pin groups
 745  * @data: pin controller driver specific data
 746  */
 747 int pinmux_generic_add_function(struct pinctrl_dev *pctldev,
 748                                 const char *name,
 749                                 const char **groups,
 750                                 const unsigned int num_groups,
 751                                 void *data)
 752 {
 753         struct function_desc *function;
 754         int selector;
 755
 756         if (!name)
 757                 return -EINVAL;
 758
 759         selector = pinmux_func_name_to_selector(pctldev, name);
 760         if (selector >= 0)
 761                 return selector;
 762
 763         selector = pctldev->num_functions;
 764
 765         function = devm_kzalloc(pctldev->dev, sizeof(*function), GFP_KERNEL);
 766         if (!function)
 767                 return -ENOMEM;
 768
 769         function->name = name;
 770         function->group_names = groups;
 771         function->num_group_names = num_groups;
 772         function->data = data;
 773
 774         radix_tree_insert(&pctldev->pin_function_tree, selector, function);
 775
 776         pctldev->num_functions++;
 777
 778         return selector;
 779 }
 780 EXPORT_SYMBOL_GPL(pinmux_generic_add_function);
 781
 782 /**
 783  * pinmux_generic_remove_function() - removes a numbered function
 784  * @pctldev: pin controller device
 785  * @selector: function number
 786  *
 787  * Note that the caller must take care of locking.
 788  */
 789 int pinmux_generic_remove_function(struct pinctrl_dev *pctldev,
 790                                    unsigned int selector)
 791 {
 792         struct function_desc *function;
 793
 794         function = radix_tree_lookup(&pctldev->pin_function_tree,
 795                                      selector);
 796         if (!function)
 797                 return -ENOENT;
 798
 799         radix_tree_delete(&pctldev->pin_function_tree, selector);
 800         devm_kfree(pctldev->dev, function);
 801
 802         pctldev->num_functions--;
 803
 804         return 0;
 805 }
 806 EXPORT_SYMBOL_GPL(pinmux_generic_remove_function);
 807
 808 /**
 809  * pinmux_generic_free_functions() - removes all functions
 810  * @pctldev: pin controller device
 811  *
 812  * Note that the caller must take care of locking. The pinctrl
 813  * functions are allocated with devm_kzalloc() so no need to free
 814  * them here.
 815  */
 816 void pinmux_generic_free_functions(struct pinctrl_dev *pctldev)
 817 {
 818         struct radix_tree_iter iter;
 819         void __rcu **slot;
 820
 821         radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0)
 822                 radix_tree_delete(&pctldev->pin_function_tree, iter.index);
 823
 824         pctldev->num_functions = 0;
 825 }
 826
 827 #endif /* CONFIG_GENERIC_PINMUX_FUNCTIONS */