drivers/pinctrl/pinmux.c

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