cregit-Linux how code gets into the kernel

Release 4.17 drivers/pinctrl/pinmux.c

Directory: drivers/pinctrl
/*
 * Core driver for the pin muxing portions of the pin control subsystem
 *
 * Copyright (C) 2011-2012 ST-Ericsson SA
 * Written on behalf of Linaro for ST-Ericsson
 * Based on bits of regulator core, gpio core and clk core
 *
 * Author: Linus Walleij <linus.walleij@linaro.org>
 *
 * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
 *
 * License terms: GNU General Public License (GPL) version 2
 */

#define pr_fmt(fmt) "pinmux core: " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/radix-tree.h>
#include <linux/err.h>
#include <linux/list.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/pinctrl/machine.h>
#include <linux/pinctrl/pinmux.h>
#include "core.h"
#include "pinmux.h"


int pinmux_check_ops(struct pinctrl_dev *pctldev) { const struct pinmux_ops *ops = pctldev->desc->pmxops; unsigned nfuncs; unsigned selector = 0; /* Check that we implement required operations */ if (!ops || !ops->get_functions_count || !ops->get_function_name || !ops->get_function_groups || !ops->set_mux) { dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n"); return -EINVAL; } /* Check that all functions registered have names */ nfuncs = ops->get_functions_count(pctldev); while (selector < nfuncs) { const char *fname = ops->get_function_name(pctldev, selector); if (!fname) { dev_err(pctldev->dev, "pinmux ops has no name for function%u\n", selector); return -EINVAL; } selector++; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Stephen Warren9673.28%120.00%
Dong Aisheng1712.98%120.00%
John Crispin118.40%120.00%
Viresh Kumar64.58%120.00%
Linus Walleij10.76%120.00%
Total131100.00%5100.00%


int pinmux_validate_map(const struct pinctrl_map *map, int i) { if (!map->data.mux.function) { pr_err("failed to register map %s (%d): no function given\n", map->name, i); return -EINVAL; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Stephen Warren4497.78%150.00%
Masahiro Yamada12.22%150.00%
Total45100.00%2100.00%

/** * pin_request() - request a single pin to be muxed in, typically for GPIO * @pin: the pin number in the global pin space * @owner: a representation of the owner of this pin; typically the device * name that controls its mux function, or the requested GPIO name * @gpio_range: the range matching the GPIO pin if this is a request for a * single GPIO pin */
static int pin_request(struct pinctrl_dev *pctldev, int pin, const char *owner, struct pinctrl_gpio_range *gpio_range) { struct pin_desc *desc; const struct pinmux_ops *ops = pctldev->desc->pmxops; int status = -EINVAL; desc = pin_desc_get(pctldev, pin); if (desc == NULL) { dev_err(pctldev->dev, "pin %d is not registered so it cannot be requested\n", pin); goto out; } dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n", pin, desc->name, owner); if ((!gpio_range || ops->strict) && desc->mux_usecount && strcmp(desc->mux_owner, owner)) { dev_err(pctldev->dev, "pin %s already requested by %s; cannot claim for %s\n", desc->name, desc->mux_owner, owner); goto out; } if ((gpio_range || ops->strict) && desc->gpio_owner) { dev_err(pctldev->dev, "pin %s already requested by %s; cannot claim for %s\n", desc->name, desc->gpio_owner, owner); goto out; } if (gpio_range) { desc->gpio_owner = owner; } else { desc->mux_usecount++; if (desc->mux_usecount > 1) return 0; desc->mux_owner = owner; } /* Let each pin increase references to this module */ if (!try_module_get(pctldev->owner)) { dev_err(pctldev->dev, "could not increase module refcount for pin %d\n", pin); status = -EINVAL; goto out_free_pin; } /* * If there is no kind of request function for the pin we just assume * we got it by default and proceed. */ if (gpio_range && ops->gpio_request_enable) /* This requests and enables a single GPIO pin */ status = ops->gpio_request_enable(pctldev, gpio_range, pin); else if (ops->request) status = ops->request(pctldev, pin); else status = 0; if (status) { dev_err(pctldev->dev, "request() failed for pin %d\n", pin); module_put(pctldev->owner); } out_free_pin: if (status) { if (gpio_range) { desc->gpio_owner = NULL; } else { desc->mux_usecount--; if (!desc->mux_usecount) desc->mux_owner = NULL; } } out: if (status) dev_err(pctldev->dev, "pin-%d (%s) status %d\n", pin, owner, status); return status; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij20653.51%216.67%
Stephen Warren8421.82%650.00%
Sonic Zhang5012.99%18.33%
Dong Aisheng174.42%18.33%
Vladimir Zapolskiy164.16%18.33%
Marek Belisko123.12%18.33%
Total385100.00%12100.00%

/** * pin_free() - release a single muxed in pin so something else can be muxed * @pctldev: pin controller device handling this pin * @pin: the pin to free * @gpio_range: the range matching the GPIO pin if this is a request for a * single GPIO pin * * This function returns a pointer to the previous owner. This is used * for callers that dynamically allocate an owner name so it can be freed * once the pin is free. This is done for GPIO request functions. */
static const char *pin_free(struct pinctrl_dev *pctldev, int pin, struct pinctrl_gpio_range *gpio_range) { const struct pinmux_ops *ops = pctldev->desc->pmxops; struct pin_desc *desc; const char *owner; desc = pin_desc_get(pctldev, pin); if (desc == NULL) { dev_err(pctldev->dev, "pin is not registered so it cannot be freed\n"); return NULL; } if (!gpio_range) { /* * A pin should not be freed more times than allocated. */ if (WARN_ON(!desc->mux_usecount)) return NULL; desc->mux_usecount--; if (desc->mux_usecount) return NULL; } /* * If there is no kind of request function for the pin we just assume * we got it by default and proceed. */ if (gpio_range && ops->gpio_disable_free) ops->gpio_disable_free(pctldev, gpio_range, pin); else if (ops->free) ops->free(pctldev, pin); if (gpio_range) { owner = desc->gpio_owner; desc->gpio_owner = NULL; } else { owner = desc->mux_owner; desc->mux_owner = NULL; desc->mux_setting = NULL; } module_put(pctldev->owner); return owner; }

Contributors

PersonTokensPropCommitsCommitProp
Stephen Warren9348.44%675.00%
Linus Walleij8544.27%112.50%
Richard Genoud147.29%112.50%
Total192100.00%8100.00%

/** * pinmux_request_gpio() - request pinmuxing for a GPIO pin * @pctldev: pin controller device affected * @pin: the pin to mux in for GPIO * @range: the applicable GPIO range */
int pinmux_request_gpio(struct pinctrl_dev *pctldev, struct pinctrl_gpio_range *range, unsigned pin, unsigned gpio) { const char *owner; int ret; /* Conjure some name stating what chip and pin this is taken by */ owner = kasprintf(GFP_KERNEL, "%s:%d", range->name, gpio); if (!owner) return -ENOMEM; ret = pin_request(pctldev, pin, owner, range); if (ret < 0) kfree(owner); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij4758.02%233.33%
Stephen Warren2935.80%233.33%
Thomas Petazzoni44.94%116.67%
Masahiro Yamada11.23%116.67%
Total81100.00%6100.00%

/** * pinmux_free_gpio() - release a pin from GPIO muxing * @pctldev: the pin controller device for the pin * @pin: the affected currently GPIO-muxed in pin * @range: applicable GPIO range */
void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin, struct pinctrl_gpio_range *range) { const char *owner; owner = pin_free(pctldev, pin, range); kfree(owner); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij2564.10%240.00%
Stephen Warren1435.90%360.00%
Total39100.00%5100.00%

/** * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin * @pctldev: the pin controller handling this pin * @range: applicable GPIO range * @pin: the affected GPIO pin in this controller * @input: true if we set the pin as input, false for output */
int pinmux_gpio_direction(struct pinctrl_dev *pctldev, struct pinctrl_gpio_range *range, unsigned pin, bool input) { const struct pinmux_ops *ops; int ret; ops = pctldev->desc->pmxops; if (ops->gpio_set_direction) ret = ops->gpio_set_direction(pctldev, range, pin, input); else ret = 0; return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij67100.00%2100.00%
Total67100.00%2100.00%


static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev, const char *function) { const struct pinmux_ops *ops = pctldev->desc->pmxops; unsigned nfuncs = ops->get_functions_count(pctldev); unsigned selector = 0; /* See if this pctldev has this function */ while (selector < nfuncs) { const char *fname = ops->get_function_name(pctldev, selector); if (!strcmp(function, fname)) return selector; selector++; } dev_err(pctldev->dev, "function '%s' not supported\n", function); return -EINVAL; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij4041.24%555.56%
Stephen Warren4041.24%222.22%
Viresh Kumar1212.37%111.11%
Masahiro Yamada55.15%111.11%
Total97100.00%9100.00%


int pinmux_map_to_setting(const struct pinctrl_map *map, struct pinctrl_setting *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinmux_ops *pmxops = pctldev->desc->pmxops; char const * const *groups; unsigned num_groups; int ret; const char *group; if (!pmxops) { dev_err(pctldev->dev, "does not support mux function\n"); return -EINVAL; } ret = pinmux_func_name_to_selector(pctldev, map->data.mux.function); if (ret < 0) { dev_err(pctldev->dev, "invalid function %s in map table\n", map->data.mux.function); return ret; } setting->data.mux.func = ret; ret = pmxops->get_function_groups(pctldev, setting->data.mux.func, &groups, &num_groups); if (ret < 0) { dev_err(pctldev->dev, "can't query groups for function %s\n", map->data.mux.function); return ret; } if (!num_groups) { dev_err(pctldev->dev, "function %s can't be selected on any group\n", map->data.mux.function); return -EINVAL; } if (map->data.mux.group) { group = map->data.mux.group; ret = match_string(groups, num_groups, group); if (ret < 0) { dev_err(pctldev->dev, "invalid group \"%s\" for function \"%s\"\n", group, map->data.mux.function); return ret; } } else { group = groups[0]; } ret = pinctrl_get_group_selector(pctldev, group); if (ret < 0) { dev_err(pctldev->dev, "invalid group %s in map table\n", map->data.mux.group); return ret; } setting->data.mux.group = ret; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
John Crispin11133.64%222.22%
Stephen Warren11133.64%222.22%
Linus Walleij7723.33%222.22%
Dong Aisheng206.06%111.11%
Andy Shevchenko103.03%111.11%
Masahiro Yamada10.30%111.11%
Total330100.00%9100.00%


void pinmux_free_setting(const struct pinctrl_setting *setting) { /* This function is currently unused */ }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij866.67%250.00%
Stephen Warren325.00%125.00%
Masahiro Yamada18.33%125.00%
Total12100.00%4100.00%


int pinmux_enable_setting(const struct pinctrl_setting *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinmux_ops *ops = pctldev->desc->pmxops; int ret = 0; const unsigned *pins = NULL; unsigned num_pins = 0; int i; struct pin_desc *desc; if (pctlops->get_group_pins) ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins, &num_pins); if (ret) { const char *gname; /* errors only affect debug data, so just warn */ gname = pctlops->get_group_name(pctldev, setting->data.mux.group); dev_warn(pctldev->dev, "could not get pins for group %s\n", gname); num_pins = 0; } /* Try to allocate all pins in this group, one by one */ for (i = 0; i < num_pins; i++) { ret = pin_request(pctldev, pins[i], setting->dev_name, NULL); if (ret) { const char *gname; const char *pname; desc = pin_desc_get(pctldev, pins[i]); pname = desc ? desc->name : "non-existing"; gname = pctlops->get_group_name(pctldev, setting->data.mux.group); dev_err(pctldev->dev, "could not request pin %d (%s) from group %s " " on device %s\n", pins[i], pname, gname, pinctrl_dev_get_name(pctldev)); goto err_pin_request; } } /* Now that we have acquired the pins, encode the mux setting */ for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc == NULL) { dev_warn(pctldev->dev, "could not get pin desc for pin %d\n", pins[i]); continue; } desc->mux_setting = &(setting->data.mux); } ret = ops->set_mux(pctldev, setting->data.mux.func, setting->data.mux.group); if (ret) goto err_set_mux; return 0; err_set_mux: for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc) desc->mux_setting = NULL; } err_pin_request: /* On error release all taken pins */ while (--i >= 0) pin_free(pctldev, pins[i], NULL); return ret; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij17541.57%545.45%
Stephen Warren15637.05%327.27%
Axel Lin7718.29%19.09%
Antoine Ténart122.85%19.09%
Masahiro Yamada10.24%19.09%
Total421100.00%11100.00%


void pinmux_disable_setting(const struct pinctrl_setting *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; int ret = 0; const unsigned *pins = NULL; unsigned num_pins = 0; int i; struct pin_desc *desc; if (pctlops->get_group_pins) ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, &pins, &num_pins); if (ret) { const char *gname; /* errors only affect debug data, so just warn */ gname = pctlops->get_group_name(pctldev, setting->data.mux.group); dev_warn(pctldev->dev, "could not get pins for group %s\n", gname); num_pins = 0; } /* Flag the descs that no setting is active */ for (i = 0; i < num_pins; i++) { desc = pin_desc_get(pctldev, pins[i]); if (desc == NULL) { dev_warn(pctldev->dev, "could not get pin desc for pin %d\n", pins[i]); continue; } if (desc->mux_setting == &(setting->data.mux)) { pin_free(pctldev, pins[i], NULL); } else { const char *gname; gname = pctlops->get_group_name(pctldev, setting->data.mux.group); dev_warn(pctldev->dev, "not freeing pin %d (%s) as part of " "deactivating group %s - it is already " "used for some other setting", pins[i], desc->name, gname); } } }

Contributors

PersonTokensPropCommitsCommitProp
Stephen Warren12849.81%220.00%
Linus Walleij9536.96%440.00%
Sonic Zhang187.00%110.00%
Antoine Ténart124.67%110.00%
Michael Opdenacker31.17%110.00%
Masahiro Yamada10.39%110.00%
Total257100.00%10100.00%

#ifdef CONFIG_DEBUG_FS /* Called from pincontrol core */
static int pinmux_functions_show(struct seq_file *s, void *what) { struct pinctrl_dev *pctldev = s->private; const struct pinmux_ops *pmxops = pctldev->desc->pmxops; unsigned nfuncs; unsigned func_selector = 0; if (!pmxops) return 0; mutex_lock(&pctldev->mutex); nfuncs = pmxops->get_functions_count(pctldev); while (func_selector < nfuncs) { const char *func = pmxops->get_function_name(pctldev, func_selector); const char * const *groups; unsigned num_groups; int ret; int i; ret = pmxops->get_function_groups(pctldev, func_selector, &groups, &num_groups); if (ret) { seq_printf(s, "function %s: COULD NOT GET GROUPS\n", func); func_selector++; continue; } seq_printf(s, "function: %s, groups = [ ", func); for (i = 0; i < num_groups; i++) seq_printf(s, "%s ", groups[i]); seq_puts(s, "]\n"); func_selector++; } mutex_unlock(&pctldev->mutex); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij15477.78%116.67%
Dong Aisheng178.59%116.67%
Stephen Warren105.05%116.67%
Patrice Chotard63.03%116.67%
Ludovic Desroches63.03%116.67%
Viresh Kumar52.53%116.67%
Total198100.00%6100.00%


static int pinmux_pins_show(struct seq_file *s, void *what) { struct pinctrl_dev *pctldev = s->private; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; const struct pinmux_ops *pmxops = pctldev->desc->pmxops; unsigned i, pin; if (!pmxops) return 0; seq_puts(s, "Pinmux settings per pin\n"); if (pmxops->strict) seq_puts(s, "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n"); else seq_puts(s, "Format: pin (name): mux_owner gpio_owner hog?\n"); mutex_lock(&pctldev->mutex); /* The pin number can be retrived from the pin controller descriptor */ for (i = 0; i < pctldev->desc->npins; i++) { struct pin_desc *desc; bool is_hog = false; pin = pctldev->desc->pins[i].number; desc = pin_desc_get(pctldev, pin); /* Skip if we cannot search the pin */ if (desc == NULL) continue; if (desc->mux_owner && !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev))) is_hog = true; if (pmxops->strict) { if (desc->mux_owner) seq_printf(s, "pin %d (%s): device %s%s", pin, desc->name, desc->mux_owner, is_hog ? " (HOG)" : ""); else if (desc->gpio_owner) seq_printf(s, "pin %d (%s): GPIO %s", pin, desc->name, desc->gpio_owner); else seq_printf(s, "pin %d (%s): UNCLAIMED", pin, desc->name); } else { /* For non-strict controllers */ seq_printf(s, "pin %d (%s): %s %s%s", pin, desc->name, desc->mux_owner ? desc->mux_owner : "(MUX UNCLAIMED)", desc->gpio_owner ? desc->gpio_owner : "(GPIO UNCLAIMED)", is_hog ? " (HOG)" : ""); } /* If mux: print function+group claiming the pin */ if (desc->mux_setting) seq_printf(s, " function %s group %s\n", pmxops->get_function_name(pctldev, desc->mux_setting->func), pctlops->get_group_name(pctldev, desc->mux_setting->group)); else seq_putc(s, '\n'); } mutex_unlock(&pctldev->mutex); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij22362.46%330.00%
Stephen Warren9626.89%330.00%
Chanho Park226.16%110.00%
Dong Aisheng82.24%110.00%
Patrice Chotard61.68%110.00%
SF Markus Elfring20.56%110.00%
Total357100.00%10100.00%


void pinmux_show_map(struct seq_file *s, const struct pinctrl_map *map) { seq_printf(s, "group %s\nfunction %s\n", map->data.mux.group ? map->data.mux.group : "(default)", map->data.mux.function); }

Contributors

PersonTokensPropCommitsCommitProp
Stephen Warren4795.92%133.33%
Linus Walleij12.04%133.33%
Masahiro Yamada12.04%133.33%
Total49100.00%3100.00%


void pinmux_show_setting(struct seq_file *s, const struct pinctrl_setting *setting) { struct pinctrl_dev *pctldev = setting->pctldev; const struct pinmux_ops *pmxops = pctldev->desc->pmxops; const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; seq_printf(s, "group: %s (%u) function: %s (%u)\n", pctlops->get_group_name(pctldev, setting->data.mux.group), setting->data.mux.group, pmxops->get_function_name(pctldev, setting->data.mux.func), setting->data.mux.func); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij5150.00%233.33%
Stephen Warren5049.02%350.00%
Masahiro Yamada10.98%116.67%
Total102100.00%6100.00%


static int pinmux_functions_open(struct inode *inode, struct file *file) { return single_open(file, pinmux_functions_show, inode->i_private); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij28100.00%1100.00%
Total28100.00%1100.00%


static int pinmux_pins_open(struct inode *inode, struct file *file) { return single_open(file, pinmux_pins_show, inode->i_private); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij28100.00%1100.00%
Total28100.00%1100.00%

static const struct file_operations pinmux_functions_ops = { .open = pinmux_functions_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, }; static const struct file_operations pinmux_pins_ops = { .open = pinmux_pins_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, };
void pinmux_init_device_debugfs(struct dentry *devroot, struct pinctrl_dev *pctldev) { debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO, devroot, pctldev, &pinmux_functions_ops); debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO, devroot, pctldev, &pinmux_pins_ops); }

Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij47100.00%1100.00%
Total47100.00%1100.00%

#endif /* CONFIG_DEBUG_FS */ #ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS /** * pinmux_generic_get_function_count() - returns number of functions * @pctldev: pin controller device */
int pinmux_generic_get_function_count(struct pinctrl_dev *pctldev) { return pctldev->num_functions; }

Contributors

PersonTokensPropCommitsCommitProp
Tony Lindgren15100.00%1100.00%
Total15100.00%1100.00%

EXPORT_SYMBOL_GPL(pinmux_generic_get_function_count); /** * pinmux_generic_get_function_name() - returns the function name * @pctldev: pin controller device * @selector: function number */
const char * pinmux_generic_get_function_name(struct pinctrl_dev *pctldev, unsigned int selector) { struct function_desc *function; function = radix_tree_lookup(&pctldev->pin_function_tree, selector); if (!function) return NULL; return function->name; }

Contributors

PersonTokensPropCommitsCommitProp
Tony Lindgren46100.00%1100.00%
Total46100.00%1100.00%

EXPORT_SYMBOL_GPL(pinmux_generic_get_function_name); /** * pinmux_generic_get_function_groups() - gets the function groups * @pctldev: pin controller device * @selector: function number * @groups: array of pin groups * @num_groups: number of pin groups */
int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev, unsigned int selector, const char * const **groups, unsigned * const num_groups) { struct function_desc *function; function = radix_tree_lookup(&pctldev->pin_function_tree, selector); if (!function) { dev_err(pctldev->dev, "%s could not find function%i\n", __func__, selector); return -EINVAL; } *groups = function->group_names; *num_groups = function->num_group_names; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Tony Lindgren85100.00%1100.00%
Total85100.00%1100.00%

EXPORT_SYMBOL_GPL(pinmux_generic_get_function_groups); /** * pinmux_generic_get_function() - returns a function based on the number * @pctldev: pin controller device * @group_selector: function number */
struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev, unsigned int selector) { struct function_desc *function; function = radix_tree_lookup(&pctldev->pin_function_tree, selector); if (!function) return NULL; return function; }

Contributors

PersonTokensPropCommitsCommitProp
Tony Lindgren44100.00%1100.00%
Total44100.00%1100.00%

EXPORT_SYMBOL_GPL(pinmux_generic_get_function); /** * pinmux_generic_add_function() - adds a function group * @pctldev: pin controller device * @name: name of the function * @groups: array of pin groups * @num_groups: number of pin groups * @data: pin controller driver specific data */
int pinmux_generic_add_function(struct pinctrl_dev *pctldev, const char *name, const char **groups, const unsigned int num_groups, void *data) { struct function_desc *function; function = devm_kzalloc(pctldev->dev, sizeof(*function), GFP_KERNEL); if (!function) return -ENOMEM; function->name = name; function->group_names = groups; function->num_group_names = num_groups; function->data = data; radix_tree_insert(&pctldev->pin_function_tree, pctldev->num_functions, function); pctldev->num_functions++; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Tony Lindgren107100.00%1100.00%
Total107100.00%1100.00%

EXPORT_SYMBOL_GPL(pinmux_generic_add_function); /** * pinmux_generic_remove_function() - removes a numbered function * @pctldev: pin controller device * @selector: function number * * Note that the caller must take care of locking. */
int pinmux_generic_remove_function(struct pinctrl_dev *pctldev, unsigned int selector) { struct function_desc *function; function = radix_tree_lookup(&pctldev->pin_function_tree, selector); if (!function) return -ENOENT; radix_tree_delete(&pctldev->pin_function_tree, selector); devm_kfree(pctldev->dev, function); pctldev->num_functions--; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Tony Lindgren67100.00%1100.00%
Total67100.00%1100.00%

EXPORT_SYMBOL_GPL(pinmux_generic_remove_function); /** * pinmux_generic_free_functions() - removes all functions * @pctldev: pin controller device * * Note that the caller must take care of locking. The pinctrl * functions are allocated with devm_kzalloc() so no need to free * them here. */
void pinmux_generic_free_functions(struct pinctrl_dev *pctldev) { struct radix_tree_iter iter; void __rcu **slot; radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0) radix_tree_delete(&pctldev->pin_function_tree, iter.index); pctldev->num_functions = 0; }

Contributors

PersonTokensPropCommitsCommitProp
Tony Lindgren4797.92%266.67%
Masahiro Yamada12.08%133.33%
Total48100.00%3100.00%

#endif /* CONFIG_GENERIC_PINMUX_FUNCTIONS */

Overall Contributors

PersonTokensPropCommitsCommitProp
Linus Walleij147942.93%1122.00%
Stephen Warren100429.14%1224.00%
Tony Lindgren45313.15%24.00%
John Crispin1223.54%24.00%
Dong Aisheng792.29%36.00%
Axel Lin772.24%12.00%
Sonic Zhang681.97%24.00%
Antoine Ténart240.70%12.00%
Viresh Kumar230.67%12.00%
Chanho Park220.64%12.00%
Vladimir Zapolskiy160.46%12.00%
Masahiro Yamada140.41%48.00%
Richard Genoud140.41%12.00%
Marek Belisko120.35%12.00%
Patrice Chotard120.35%12.00%
Andy Shevchenko100.29%12.00%
Ludovic Desroches60.17%12.00%
Thomas Petazzoni40.12%12.00%
Michael Opdenacker30.09%12.00%
SF Markus Elfring20.06%12.00%
Geert Uytterhoeven10.03%12.00%
Total3445100.00%50100.00%
Directory: drivers/pinctrl
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.