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/sysfs.h>
  26 #include <linux/debugfs.h>
  27 #include <linux/seq_file.h>
  28 #include <linux/pinctrl/machine.h>
  29 #include <linux/pinctrl/pinmux.h>
  30 #include "core.h"
  31 #include "pinmux.h"
  32
  33 int pinmux_check_ops(struct pinctrl_dev *pctldev)
  34 {
  35         const struct pinmux_ops *ops = pctldev->desc->pmxops;
  36         unsigned selector = 0;
  37
  38         /* Check that we implement required operations */
  39         if (!ops->list_functions ||
  40             !ops->get_function_name ||
  41             !ops->get_function_groups ||
  42             !ops->enable ||
  43             !ops->disable)
  44                 return -EINVAL;
  45
  46         /* Check that all functions registered have names */
  47         while (ops->list_functions(pctldev, selector) >= 0) {
  48                 const char *fname = ops->get_function_name(pctldev,
  49                                                            selector);
  50                 if (!fname) {
  51                         pr_err("pinmux ops has no name for function%u\n",
  52                                 selector);
  53                         return -EINVAL;
  54                 }
  55                 selector++;
  56         }
  57
  58         return 0;
  59 }
  60
  61 /**
  62  * pin_request() - request a single pin to be muxed in, typically for GPIO
  63  * @pin: the pin number in the global pin space
  64  * @owner: a representation of the owner of this pin; typically the device
  65  *      name that controls its mux function, or the requested GPIO name
  66  * @gpio_range: the range matching the GPIO pin if this is a request for a
  67  *      single GPIO pin
  68  */
  69 static int pin_request(struct pinctrl_dev *pctldev,
  70                        int pin, const char *owner,
  71                        struct pinctrl_gpio_range *gpio_range)
  72 {
  73         struct pin_desc *desc;
  74         const struct pinmux_ops *ops = pctldev->desc->pmxops;
  75         int status = -EINVAL;
  76
  77         dev_dbg(pctldev->dev, "request pin %d for %s\n", pin, owner);
  78
  79         desc = pin_desc_get(pctldev, pin);
  80         if (desc == NULL) {
  81                 dev_err(pctldev->dev,
  82                         "pin is not registered so it cannot be requested\n");
  83                 goto out;
  84         }
  85
  86         if (desc->usecount && strcmp(desc->owner, owner)) {
  87                 dev_err(pctldev->dev,
  88                         "pin already requested\n");
  89                 goto out;
  90         }
  91
  92         desc->usecount++;
  93         if (desc->usecount > 1)
  94                 return 0;
  95
  96         desc->owner = owner;
  97
  98         /* Let each pin increase references to this module */
  99         if (!try_module_get(pctldev->owner)) {
 100                 dev_err(pctldev->dev,
 101                         "could not increase module refcount for pin %d\n",
 102                         pin);
 103                 status = -EINVAL;
 104                 goto out_free_pin;
 105         }
 106
 107         /*
 108          * If there is no kind of request function for the pin we just assume
 109          * we got it by default and proceed.
 110          */
 111         if (gpio_range && ops->gpio_request_enable)
 112                 /* This requests and enables a single GPIO pin */
 113                 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
 114         else if (ops->request)
 115                 status = ops->request(pctldev, pin);
 116         else
 117                 status = 0;
 118
 119         if (status) {
 120                 dev_err(pctldev->dev, "->request on device %s failed for pin %d\n",
 121                        pctldev->desc->name, pin);
 122                 module_put(pctldev->owner);
 123         }
 124
 125 out_free_pin:
 126         if (status) {
 127                 desc->usecount--;
 128                 if (!desc->usecount)
 129                         desc->owner = NULL;
 130         }
 131 out:
 132         if (status)
 133                 dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
 134                        pin, owner, status);
 135
 136         return status;
 137 }
 138
 139 /**
 140  * pin_free() - release a single muxed in pin so something else can be muxed
 141  * @pctldev: pin controller device handling this pin
 142  * @pin: the pin to free
 143  * @gpio_range: the range matching the GPIO pin if this is a request for a
 144  *      single GPIO pin
 145  *
 146  * This function returns a pointer to the previous owner. This is used
 147  * for callers that dynamically allocate an owner name so it can be freed
 148  * once the pin is free. This is done for GPIO request functions.
 149  */
 150 static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
 151                             struct pinctrl_gpio_range *gpio_range)
 152 {
 153         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 154         struct pin_desc *desc;
 155         const char *owner;
 156
 157         desc = pin_desc_get(pctldev, pin);
 158         if (desc == NULL) {
 159                 dev_err(pctldev->dev,
 160                         "pin is not registered so it cannot be freed\n");
 161                 return NULL;
 162         }
 163
 164         desc->usecount--;
 165         if (desc->usecount)
 166                 return NULL;
 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_disable_free)
 173                 ops->gpio_disable_free(pctldev, gpio_range, pin);
 174         else if (ops->free)
 175                 ops->free(pctldev, pin);
 176
 177         owner = desc->owner;
 178         desc->owner = NULL;
 179         module_put(pctldev->owner);
 180
 181         return owner;
 182 }
 183
 184 /**
 185  * pinmux_request_gpio() - request pinmuxing for a GPIO pin
 186  * @pctldev: pin controller device affected
 187  * @pin: the pin to mux in for GPIO
 188  * @range: the applicable GPIO range
 189  */
 190 int pinmux_request_gpio(struct pinctrl_dev *pctldev,
 191                         struct pinctrl_gpio_range *range,
 192                         unsigned pin, unsigned gpio)
 193 {
 194         char gpiostr[16];
 195         const char *owner;
 196         int ret;
 197
 198         /* Conjure some name stating what chip and pin this is taken by */
 199         snprintf(gpiostr, 15, "%s:%d", range->name, gpio);
 200
 201         owner = kstrdup(gpiostr, GFP_KERNEL);
 202         if (!owner)
 203                 return -EINVAL;
 204
 205         ret = pin_request(pctldev, pin, owner, range);
 206         if (ret < 0)
 207                 kfree(owner);
 208
 209         return ret;
 210 }
 211
 212 /**
 213  * pinmux_free_gpio() - release a pin from GPIO muxing
 214  * @pctldev: the pin controller device for the pin
 215  * @pin: the affected currently GPIO-muxed in pin
 216  * @range: applicable GPIO range
 217  */
 218 void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
 219                       struct pinctrl_gpio_range *range)
 220 {
 221         const char *owner;
 222
 223         owner = pin_free(pctldev, pin, range);
 224         kfree(owner);
 225 }
 226
 227 /**
 228  * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin
 229  * @pctldev: the pin controller handling this pin
 230  * @range: applicable GPIO range
 231  * @pin: the affected GPIO pin in this controller
 232  * @input: true if we set the pin as input, false for output
 233  */
 234 int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
 235                           struct pinctrl_gpio_range *range,
 236                           unsigned pin, bool input)
 237 {
 238         const struct pinmux_ops *ops;
 239         int ret;
 240
 241         ops = pctldev->desc->pmxops;
 242
 243         if (ops->gpio_set_direction)
 244                 ret = ops->gpio_set_direction(pctldev, range, pin, input);
 245         else
 246                 ret = 0;
 247
 248         return ret;
 249 }
 250
 251 static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
 252                                         const char *function)
 253 {
 254         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 255         unsigned selector = 0;
 256
 257         /* See if this pctldev has this function */
 258         while (ops->list_functions(pctldev, selector) >= 0) {
 259                 const char *fname = ops->get_function_name(pctldev,
 260                                                            selector);
 261
 262                 if (!strcmp(function, fname))
 263                         return selector;
 264
 265                 selector++;
 266         }
 267
 268         pr_err("%s does not support function %s\n",
 269                pinctrl_dev_get_name(pctldev), function);
 270         return -EINVAL;
 271 }
 272
 273 int pinmux_map_to_setting(struct pinctrl_map const *map,
 274                           struct pinctrl_setting *setting)
 275 {
 276         struct pinctrl_dev *pctldev = setting->pctldev;
 277         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
 278         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 279         char const * const *groups;
 280         unsigned num_groups;
 281         int ret;
 282         const char *group;
 283         int i;
 284         const unsigned *pins;
 285         unsigned num_pins;
 286
 287         setting->func_selector =
 288                 pinmux_func_name_to_selector(pctldev, map->function);
 289         if (setting->func_selector < 0)
 290                 return setting->func_selector;
 291
 292         ret = pmxops->get_function_groups(pctldev, setting->func_selector,
 293                                           &groups, &num_groups);
 294         if (ret < 0)
 295                 return ret;
 296         if (!num_groups)
 297                 return -EINVAL;
 298
 299         if (map->group) {
 300                 bool found = false;
 301                 group = map->group;
 302                 for (i = 0; i < num_groups; i++) {
 303                         if (!strcmp(group, groups[i])) {
 304                                 found = true;
 305                                 break;
 306                         }
 307                 }
 308                 if (!found)
 309                         return -EINVAL;
 310         } else {
 311                 group = groups[0];
 312         }
 313
 314         setting->group_selector =
 315                 pinctrl_get_group_selector(pctldev, group);
 316         if (setting->group_selector < 0)
 317                 return setting->group_selector;
 318
 319         ret = pctlops->get_group_pins(pctldev, setting->group_selector,
 320                                       &pins, &num_pins);
 321         if (ret) {
 322                 dev_err(pctldev->dev,
 323                         "could not get pins for device %s group selector %d\n",
 324                         pinctrl_dev_get_name(pctldev), setting->group_selector);
 325                         return -ENODEV;
 326         }
 327
 328         /* Try to allocate all pins in this group, one by one */
 329         for (i = 0; i < num_pins; i++) {
 330                 ret = pin_request(pctldev, pins[i], map->dev_name, NULL);
 331                 if (ret) {
 332                         dev_err(pctldev->dev,
 333                                 "could not get request pin %d on device %s\n",
 334                                 pins[i], pinctrl_dev_get_name(pctldev));
 335                         /* On error release all taken pins */
 336                         i--; /* this pin just failed */
 337                         for (; i >= 0; i--)
 338                                 pin_free(pctldev, pins[i], NULL);
 339                         return -ENODEV;
 340                 }
 341         }
 342
 343         return 0;
 344 }
 345
 346 void pinmux_free_setting(struct pinctrl_setting const *setting)
 347 {
 348         struct pinctrl_dev *pctldev = setting->pctldev;
 349         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 350         const unsigned *pins;
 351         unsigned num_pins;
 352         int ret;
 353         int i;
 354
 355         ret = pctlops->get_group_pins(pctldev, setting->group_selector,
 356                                       &pins, &num_pins);
 357         if (ret) {
 358                 dev_err(pctldev->dev,
 359                         "could not get pins for device %s group selector %d\n",
 360                         pinctrl_dev_get_name(pctldev), setting->group_selector);
 361                 return;
 362         }
 363
 364         for (i = 0; i < num_pins; i++)
 365                 pin_free(pctldev, pins[i], NULL);
 366 }
 367
 368 int pinmux_enable_setting(struct pinctrl_setting const *setting)
 369 {
 370         struct pinctrl_dev *pctldev = setting->pctldev;
 371         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 372
 373         return ops->enable(pctldev, setting->func_selector,
 374                            setting->group_selector);
 375 }
 376
 377 void pinmux_disable_setting(struct pinctrl_setting const *setting)
 378 {
 379         struct pinctrl_dev *pctldev = setting->pctldev;
 380         const struct pinmux_ops *ops = pctldev->desc->pmxops;
 381
 382         ops->disable(pctldev, setting->func_selector, setting->group_selector);
 383 }
 384
 385 #ifdef CONFIG_DEBUG_FS
 386
 387 /* Called from pincontrol core */
 388 static int pinmux_functions_show(struct seq_file *s, void *what)
 389 {
 390         struct pinctrl_dev *pctldev = s->private;
 391         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
 392         unsigned func_selector = 0;
 393
 394         mutex_lock(&pinctrl_mutex);
 395
 396         while (pmxops->list_functions(pctldev, func_selector) >= 0) {
 397                 const char *func = pmxops->get_function_name(pctldev,
 398                                                           func_selector);
 399                 const char * const *groups;
 400                 unsigned num_groups;
 401                 int ret;
 402                 int i;
 403
 404                 ret = pmxops->get_function_groups(pctldev, func_selector,
 405                                                   &groups, &num_groups);
 406                 if (ret)
 407                         seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
 408                                    func);
 409
 410                 seq_printf(s, "function: %s, groups = [ ", func);
 411                 for (i = 0; i < num_groups; i++)
 412                         seq_printf(s, "%s ", groups[i]);
 413                 seq_puts(s, "]\n");
 414
 415                 func_selector++;
 416         }
 417
 418         mutex_unlock(&pinctrl_mutex);
 419
 420         return 0;
 421 }
 422
 423 static int pinmux_pins_show(struct seq_file *s, void *what)
 424 {
 425         struct pinctrl_dev *pctldev = s->private;
 426         unsigned i, pin;
 427
 428         seq_puts(s, "Pinmux settings per pin\n");
 429         seq_puts(s, "Format: pin (name): owner\n");
 430
 431         mutex_lock(&pinctrl_mutex);
 432
 433         /* The pin number can be retrived from the pin controller descriptor */
 434         for (i = 0; i < pctldev->desc->npins; i++) {
 435                 struct pin_desc *desc;
 436                 bool is_hog = false;
 437
 438                 pin = pctldev->desc->pins[i].number;
 439                 desc = pin_desc_get(pctldev, pin);
 440                 /* Skip if we cannot search the pin */
 441                 if (desc == NULL)
 442                         continue;
 443
 444                 if (desc->owner &&
 445                     !strcmp(desc->owner, pinctrl_dev_get_name(pctldev)))
 446                         is_hog = true;
 447
 448                 seq_printf(s, "pin %d (%s): %s%s\n", pin,
 449                            desc->name ? desc->name : "unnamed",
 450                            desc->owner ? desc->owner : "UNCLAIMED",
 451                            is_hog ? " (HOG)" : "");
 452         }
 453
 454         mutex_unlock(&pinctrl_mutex);
 455
 456         return 0;
 457 }
 458
 459 void pinmux_dbg_show(struct seq_file *s, struct pinctrl_setting const *setting)
 460 {
 461         struct pinctrl_dev *pctldev = setting->pctldev;
 462         const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
 463         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
 464
 465         seq_printf(s, "controller: %s group: %s (%u) function: %s (%u)\n",
 466                    pinctrl_dev_get_name(pctldev),
 467                    pctlops->get_group_name(pctldev, setting->group_selector),
 468                    setting->group_selector,
 469                    pmxops->get_function_name(pctldev, setting->func_selector),
 470                    setting->func_selector);
 471 }
 472
 473 static int pinmux_functions_open(struct inode *inode, struct file *file)
 474 {
 475         return single_open(file, pinmux_functions_show, inode->i_private);
 476 }
 477
 478 static int pinmux_pins_open(struct inode *inode, struct file *file)
 479 {
 480         return single_open(file, pinmux_pins_show, inode->i_private);
 481 }
 482
 483 static const struct file_operations pinmux_functions_ops = {
 484         .open           = pinmux_functions_open,
 485         .read           = seq_read,
 486         .llseek         = seq_lseek,
 487         .release        = single_release,
 488 };
 489
 490 static const struct file_operations pinmux_pins_ops = {
 491         .open           = pinmux_pins_open,
 492         .read           = seq_read,
 493         .llseek         = seq_lseek,
 494         .release        = single_release,
 495 };
 496
 497 void pinmux_init_device_debugfs(struct dentry *devroot,
 498                          struct pinctrl_dev *pctldev)
 499 {
 500         debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
 501                             devroot, pctldev, &pinmux_functions_ops);
 502         debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
 503                             devroot, pctldev, &pinmux_pins_ops);
 504 }
 505
 506 #endif /* CONFIG_DEBUG_FS */