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