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