summaryrefslogtreecommitdiff
path: root/drivers/pinctrl/pinmux.c
diff options
context:
space:
mode:
authorLinus Walleij <linus.walleij@linaro.org>2012-02-09 10:23:28 +0400
committerLinus Walleij <linus.walleij@linaro.org>2012-02-11 00:33:02 +0400
commite93bcee00c43e2bd4037291262111016f4c05793 (patch)
treee69b5f7ffffb36096949eabdc0526173b25f695d /drivers/pinctrl/pinmux.c
parent28a8d14cc74a0180323d9150c3d3dbf9dd60d55a (diff)
downloadlinux-e93bcee00c43e2bd4037291262111016f4c05793.tar.xz
pinctrl: move generic functions to the pinctrl_ namespace
Since we want to use the former pinmux handles and mapping tables for generic control involving both muxing and configuration we begin refactoring by renaming them from pinmux_* to pinctrl_*. ChangeLog v1->v2: - Also rename the PINMUX_* macros in machine.h to PIN_ as indicated in the documentation so as to reflect the generic nature of these mapping entries from now on. Acked-by: Stephen Warren <swarren@nvidia.com> Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Diffstat (limited to 'drivers/pinctrl/pinmux.c')
-rw-r--r--drivers/pinctrl/pinmux.c351
1 files changed, 176 insertions, 175 deletions
diff --git a/drivers/pinctrl/pinmux.c b/drivers/pinctrl/pinmux.c
index 1311f1d22002..773835d18f55 100644
--- a/drivers/pinctrl/pinmux.c
+++ b/drivers/pinctrl/pinmux.c
@@ -1,7 +1,7 @@
/*
* Core driver for the pin muxing portions of the pin control subsystem
*
- * Copyright (C) 2011 ST-Ericsson SA
+ * 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
*
@@ -29,13 +29,13 @@
#include <linux/pinctrl/pinmux.h>
#include "core.h"
-/* List of pinmuxes */
-static DEFINE_MUTEX(pinmux_list_mutex);
-static LIST_HEAD(pinmux_list);
+/* List of pin controller handles */
+static DEFINE_MUTEX(pinctrl_list_mutex);
+static LIST_HEAD(pinctrl_list);
-/* Global pinmux maps */
-static struct pinmux_map *pinmux_maps;
-static unsigned pinmux_maps_num;
+/* Global pinctrl maps */
+static struct pinctrl_map *pinctrl_maps;
+static unsigned pinctrl_maps_num;
/**
* struct pinmux_group - group list item for pinmux groups
@@ -48,12 +48,12 @@ struct pinmux_group {
};
/**
- * struct pinmux - per-device pinmux state holder
+ * struct pinctrl - per-device pin control state holder
* @node: global list node
- * @dev: the device using this pinmux
- * @usecount: the number of active users of this mux setting, used to keep
- * track of nested use cases
- * @pctldev: pin control device handling this pinmux
+ * @dev: the device using this pin control handle
+ * @usecount: the number of active users of this pin controller setting, used
+ * to keep track of nested use cases
+ * @pctldev: pin control device handling this pin control handle
* @func_selector: the function selector for the pinmux device handling
* this pinmux
* @groups: the group selectors for the pinmux device and
@@ -62,7 +62,7 @@ struct pinmux_group {
* get/put/enable/disable
* @mutex: a lock for the pinmux state holder
*/
-struct pinmux {
+struct pinctrl {
struct list_head node;
struct device *dev;
unsigned usecount;
@@ -73,15 +73,15 @@ struct pinmux {
};
/**
- * struct pinmux_hog - a list item to stash mux hogs
- * @node: pinmux hog list node
+ * struct pinctrl_hog - a list item to stash control hogs
+ * @node: pin control hog list node
* @map: map entry responsible for this hogging
- * @pmx: the pinmux hogged by this item
+ * @pmx: the pin control hogged by this item
*/
-struct pinmux_hog {
+struct pinctrl_hog {
struct list_head node;
- struct pinmux_map const *map;
- struct pinmux *pmx;
+ struct pinctrl_map const *map;
+ struct pinctrl *p;
};
/**
@@ -207,14 +207,14 @@ static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
}
/**
- * pinmux_request_gpio() - request a single pin to be muxed in as GPIO
+ * pinctrl_request_gpio() - request a single pin to be used in as GPIO
* @gpio: the GPIO pin number from the GPIO subsystem number space
*
* This function should *ONLY* be used from gpiolib-based GPIO drivers,
* as part of their gpio_request() semantics, platforms and individual drivers
* shall *NOT* request GPIO pins to be muxed in.
*/
-int pinmux_request_gpio(unsigned gpio)
+int pinctrl_request_gpio(unsigned gpio)
{
char gpiostr[16];
const char *function;
@@ -243,17 +243,17 @@ int pinmux_request_gpio(unsigned gpio)
return ret;
}
-EXPORT_SYMBOL_GPL(pinmux_request_gpio);
+EXPORT_SYMBOL_GPL(pinctrl_request_gpio);
/**
- * pinmux_free_gpio() - free a single pin, currently used as GPIO
+ * pinctrl_free_gpio() - free control on a single pin, currently used as GPIO
* @gpio: the GPIO pin number from the GPIO subsystem number space
*
* This function should *ONLY* be used from gpiolib-based GPIO drivers,
* as part of their gpio_free() semantics, platforms and individual drivers
* shall *NOT* request GPIO pins to be muxed out.
*/
-void pinmux_free_gpio(unsigned gpio)
+void pinctrl_free_gpio(unsigned gpio)
{
struct pinctrl_dev *pctldev;
struct pinctrl_gpio_range *range;
@@ -271,9 +271,9 @@ void pinmux_free_gpio(unsigned gpio)
func = pin_free(pctldev, pin, range);
kfree(func);
}
-EXPORT_SYMBOL_GPL(pinmux_free_gpio);
+EXPORT_SYMBOL_GPL(pinctrl_free_gpio);
-static int pinmux_gpio_direction(unsigned gpio, bool input)
+static int pinctrl_gpio_direction(unsigned gpio, bool input)
{
struct pinctrl_dev *pctldev;
struct pinctrl_gpio_range *range;
@@ -299,36 +299,36 @@ static int pinmux_gpio_direction(unsigned gpio, bool input)
}
/**
- * pinmux_gpio_direction_input() - request a GPIO pin to go into input mode
+ * pinctrl_gpio_direction_input() - request a GPIO pin to go into input mode
* @gpio: the GPIO pin number from the GPIO subsystem number space
*
* This function should *ONLY* be used from gpiolib-based GPIO drivers,
* as part of their gpio_direction_input() semantics, platforms and individual
- * drivers shall *NOT* touch pinmux GPIO calls.
+ * drivers shall *NOT* touch pin control GPIO calls.
*/
-int pinmux_gpio_direction_input(unsigned gpio)
+int pinctrl_gpio_direction_input(unsigned gpio)
{
- return pinmux_gpio_direction(gpio, true);
+ return pinctrl_gpio_direction(gpio, true);
}
-EXPORT_SYMBOL_GPL(pinmux_gpio_direction_input);
+EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_input);
/**
- * pinmux_gpio_direction_output() - request a GPIO pin to go into output mode
+ * pinctrl_gpio_direction_output() - request a GPIO pin to go into output mode
* @gpio: the GPIO pin number from the GPIO subsystem number space
*
* This function should *ONLY* be used from gpiolib-based GPIO drivers,
* as part of their gpio_direction_output() semantics, platforms and individual
- * drivers shall *NOT* touch pinmux GPIO calls.
+ * drivers shall *NOT* touch pin control GPIO calls.
*/
-int pinmux_gpio_direction_output(unsigned gpio)
+int pinctrl_gpio_direction_output(unsigned gpio)
{
- return pinmux_gpio_direction(gpio, false);
+ return pinctrl_gpio_direction(gpio, false);
}
-EXPORT_SYMBOL_GPL(pinmux_gpio_direction_output);
+EXPORT_SYMBOL_GPL(pinctrl_gpio_direction_output);
/**
- * pinmux_register_mappings() - register a set of pinmux mappings
- * @maps: the pinmux mappings table to register, this should be marked with
+ * pinctrl_register_mappings() - register a set of pin controller mappings
+ * @maps: the pincontrol mappings table to register, this should be marked with
* __initdata so it can be discarded after boot, this function will
* perform a shallow copy for the mapping entries.
* @num_maps: the number of maps in the mapping table
@@ -338,8 +338,8 @@ EXPORT_SYMBOL_GPL(pinmux_gpio_direction_output);
* passed into this function will be owned by the pinmux core and cannot be
* freed.
*/
-int __init pinmux_register_mappings(struct pinmux_map const *maps,
- unsigned num_maps)
+int __init pinctrl_register_mappings(struct pinctrl_map const *maps,
+ unsigned num_maps)
{
void *tmp_maps;
int i;
@@ -380,26 +380,27 @@ int __init pinmux_register_mappings(struct pinmux_map const *maps,
* Make a copy of the map array - string pointers will end up in the
* kernel const section anyway so these do not need to be deep copied.
*/
- if (!pinmux_maps_num) {
+ if (!pinctrl_maps_num) {
/* On first call, just copy them */
tmp_maps = kmemdup(maps,
- sizeof(struct pinmux_map) * num_maps,
+ sizeof(struct pinctrl_map) * num_maps,
GFP_KERNEL);
if (!tmp_maps)
return -ENOMEM;
} else {
/* Subsequent calls, reallocate array to new size */
- size_t oldsize = sizeof(struct pinmux_map) * pinmux_maps_num;
- size_t newsize = sizeof(struct pinmux_map) * num_maps;
+ size_t oldsize = sizeof(struct pinctrl_map) * pinctrl_maps_num;
+ size_t newsize = sizeof(struct pinctrl_map) * num_maps;
- tmp_maps = krealloc(pinmux_maps, oldsize + newsize, GFP_KERNEL);
+ tmp_maps = krealloc(pinctrl_maps,
+ oldsize + newsize, GFP_KERNEL);
if (!tmp_maps)
return -ENOMEM;
memcpy((tmp_maps + oldsize), maps, newsize);
}
- pinmux_maps = tmp_maps;
- pinmux_maps_num += num_maps;
+ pinctrl_maps = tmp_maps;
+ pinctrl_maps_num += num_maps;
return 0;
}
@@ -560,7 +561,7 @@ static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
* negative otherwise
*/
static int pinmux_search_function(struct pinctrl_dev *pctldev,
- struct pinmux_map const *map,
+ struct pinctrl_map const *map,
unsigned *func_selector,
unsigned *group_selector)
{
@@ -598,10 +599,10 @@ static int pinmux_search_function(struct pinctrl_dev *pctldev,
* pinmux_enable_muxmap() - enable a map entry for a certain pinmux
*/
static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
- struct pinmux *pmx,
+ struct pinctrl *p,
struct device *dev,
const char *devname,
- struct pinmux_map const *map)
+ struct pinctrl_map const *map)
{
unsigned func_selector;
unsigned group_selector;
@@ -615,14 +616,14 @@ static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
* by anyone else.
*/
- if (pmx->pctldev && pmx->pctldev != pctldev) {
+ if (p->pctldev && p->pctldev != pctldev) {
dev_err(pctldev->dev,
"different pin control devices given for device %s, function %s\n",
devname, map->function);
return -EINVAL;
}
- pmx->dev = dev;
- pmx->pctldev = pctldev;
+ p->dev = dev;
+ p->pctldev = pctldev;
/* Now go into the driver and try to match a function and group */
ret = pinmux_search_function(pctldev, map, &func_selector,
@@ -635,14 +636,14 @@ static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
* we support several groups with one function but not several
* functions with one or several groups in the same pinmux.
*/
- if (pmx->func_selector != UINT_MAX &&
- pmx->func_selector != func_selector) {
+ if (p->func_selector != UINT_MAX &&
+ p->func_selector != func_selector) {
dev_err(pctldev->dev,
"dual function defines in the map for device %s\n",
devname);
return -EINVAL;
}
- pmx->func_selector = func_selector;
+ p->func_selector = func_selector;
/* Now add this group selector, we may have many of them */
grp = kmalloc(sizeof(struct pinmux_group), GFP_KERNEL);
@@ -654,38 +655,38 @@ static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
kfree(grp);
return ret;
}
- list_add(&grp->node, &pmx->groups);
+ list_add(&grp->node, &p->groups);
return 0;
}
-static void pinmux_free_groups(struct pinmux *pmx)
+static void pinmux_free_groups(struct pinctrl *p)
{
struct list_head *node, *tmp;
- list_for_each_safe(node, tmp, &pmx->groups) {
+ list_for_each_safe(node, tmp, &p->groups) {
struct pinmux_group *grp =
list_entry(node, struct pinmux_group, node);
/* Release all pins taken by this group */
- release_pins(pmx->pctldev, grp->group_selector);
+ release_pins(p->pctldev, grp->group_selector);
list_del(node);
kfree(grp);
}
}
/**
- * pinmux_get() - retrieves the pinmux for a certain device
- * @dev: the device to get the pinmux for
- * @name: an optional specific mux mapping name or NULL, the name is only
+ * pinctrl_get() - retrieves the pin controller handle for a certain device
+ * @dev: the device to get the pin controller handle for
+ * @name: an optional specific control mapping name or NULL, the name is only
* needed if you want to have more than one mapping per device, or if you
- * need an anonymous pinmux (not tied to any specific device)
+ * need an anonymous pin control (not tied to any specific device)
*/
-struct pinmux *pinmux_get(struct device *dev, const char *name)
+struct pinctrl *pinctrl_get(struct device *dev, const char *name)
{
- struct pinmux_map const *map = NULL;
+ struct pinctrl_map const *map = NULL;
struct pinctrl_dev *pctldev = NULL;
const char *devname = NULL;
- struct pinmux *pmx;
+ struct pinctrl *p;
bool found_map;
unsigned num_maps = 0;
int ret = -ENODEV;
@@ -706,16 +707,16 @@ struct pinmux *pinmux_get(struct device *dev, const char *name)
* mapping, this is what consumers will get when requesting
* a pinmux handle with pinmux_get()
*/
- pmx = kzalloc(sizeof(struct pinmux), GFP_KERNEL);
- if (pmx == NULL)
+ p = kzalloc(sizeof(struct pinctrl), GFP_KERNEL);
+ if (p == NULL)
return ERR_PTR(-ENOMEM);
- mutex_init(&pmx->mutex);
- pmx->func_selector = UINT_MAX;
- INIT_LIST_HEAD(&pmx->groups);
+ mutex_init(&p->mutex);
+ p->func_selector = UINT_MAX;
+ INIT_LIST_HEAD(&p->groups);
- /* Iterate over the pinmux maps to locate the right ones */
- for (i = 0; i < pinmux_maps_num; i++) {
- map = &pinmux_maps[i];
+ /* Iterate over the pin control maps to locate the right ones */
+ for (i = 0; i < pinctrl_maps_num; i++) {
+ map = &pinctrl_maps[i];
found_map = false;
/*
@@ -763,11 +764,11 @@ struct pinmux *pinmux_get(struct device *dev, const char *name)
/* If this map is applicable, then apply it */
if (found_map) {
- ret = pinmux_enable_muxmap(pctldev, pmx, dev,
+ ret = pinmux_enable_muxmap(pctldev, p, dev,
devname, map);
if (ret) {
- pinmux_free_groups(pmx);
- kfree(pmx);
+ pinmux_free_groups(p);
+ kfree(p);
return ERR_PTR(ret);
}
num_maps++;
@@ -780,7 +781,7 @@ struct pinmux *pinmux_get(struct device *dev, const char *name)
pr_err("could not find any mux maps for device %s, ID %s\n",
devname ? devname : "(anonymous)",
name ? name : "(undefined)");
- kfree(pmx);
+ kfree(p);
return ERR_PTR(-EINVAL);
}
@@ -790,96 +791,96 @@ struct pinmux *pinmux_get(struct device *dev, const char *name)
name ? name : "(undefined)");
/* Add the pinmux to the global list */
- mutex_lock(&pinmux_list_mutex);
- list_add(&pmx->node, &pinmux_list);
- mutex_unlock(&pinmux_list_mutex);
+ mutex_lock(&pinctrl_list_mutex);
+ list_add(&p->node, &pinctrl_list);
+ mutex_unlock(&pinctrl_list_mutex);
- return pmx;
+ return p;
}
-EXPORT_SYMBOL_GPL(pinmux_get);
+EXPORT_SYMBOL_GPL(pinctrl_get);
/**
- * pinmux_put() - release a previously claimed pinmux
- * @pmx: a pinmux previously claimed by pinmux_get()
+ * pinctrl_put() - release a previously claimed pin control handle
+ * @p: a pin control handle previously claimed by pinctrl_get()
*/
-void pinmux_put(struct pinmux *pmx)
+void pinctrl_put(struct pinctrl *p)
{
- if (pmx == NULL)
+ if (p == NULL)
return;
- mutex_lock(&pmx->mutex);
- if (pmx->usecount)
- pr_warn("releasing pinmux with active users!\n");
+ mutex_lock(&p->mutex);
+ if (p->usecount)
+ pr_warn("releasing pin control handle with active users!\n");
/* Free the groups and all acquired pins */
- pinmux_free_groups(pmx);
- mutex_unlock(&pmx->mutex);
+ pinmux_free_groups(p);
+ mutex_unlock(&p->mutex);
/* Remove from list */
- mutex_lock(&pinmux_list_mutex);
- list_del(&pmx->node);
- mutex_unlock(&pinmux_list_mutex);
+ mutex_lock(&pinctrl_list_mutex);
+ list_del(&p->node);
+ mutex_unlock(&pinctrl_list_mutex);
- kfree(pmx);
+ kfree(p);
}
-EXPORT_SYMBOL_GPL(pinmux_put);
+EXPORT_SYMBOL_GPL(pinctrl_put);
/**
- * pinmux_enable() - enable a certain pinmux setting
- * @pmx: the pinmux to enable, previously claimed by pinmux_get()
+ * pinctrl_enable() - enable a certain pin controller setting
+ * @p: the pin control handle to enable, previously claimed by pinctrl_get()
*/
-int pinmux_enable(struct pinmux *pmx)
+int pinctrl_enable(struct pinctrl *p)
{
int ret = 0;
- if (pmx == NULL)
+ if (p == NULL)
return -EINVAL;
- mutex_lock(&pmx->mutex);
- if (pmx->usecount++ == 0) {
- struct pinctrl_dev *pctldev = pmx->pctldev;
+ mutex_lock(&p->mutex);
+ if (p->usecount++ == 0) {
+ struct pinctrl_dev *pctldev = p->pctldev;
const struct pinmux_ops *ops = pctldev->desc->pmxops;
struct pinmux_group *grp;
- list_for_each_entry(grp, &pmx->groups, node) {
- ret = ops->enable(pctldev, pmx->func_selector,
+ list_for_each_entry(grp, &p->groups, node) {
+ ret = ops->enable(pctldev, p->func_selector,
grp->group_selector);
if (ret) {
/*
* TODO: call disable() on all groups we called
* enable() on to this point?
*/
- pmx->usecount--;
+ p->usecount--;
break;
}
}
}
- mutex_unlock(&pmx->mutex);
+ mutex_unlock(&p->mutex);
return ret;
}
-EXPORT_SYMBOL_GPL(pinmux_enable);
+EXPORT_SYMBOL_GPL(pinctrl_enable);
/**
- * pinmux_disable() - disable a certain pinmux setting
- * @pmx: the pinmux to disable, previously claimed by pinmux_get()
+ * pinctrl_disable() - disable a certain pin control setting
+ * @p: the pin control handle to disable, previously claimed by pinctrl_get()
*/
-void pinmux_disable(struct pinmux *pmx)
+void pinctrl_disable(struct pinctrl *p)
{
- if (pmx == NULL)
+ if (p == NULL)
return;
- mutex_lock(&pmx->mutex);
- if (--pmx->usecount == 0) {
- struct pinctrl_dev *pctldev = pmx->pctldev;
+ mutex_lock(&p->mutex);
+ if (--p->usecount == 0) {
+ struct pinctrl_dev *pctldev = p->pctldev;
const struct pinmux_ops *ops = pctldev->desc->pmxops;
struct pinmux_group *grp;
- list_for_each_entry(grp, &pmx->groups, node) {
- ops->disable(pctldev, pmx->func_selector,
+ list_for_each_entry(grp, &p->groups, node) {
+ ops->disable(pctldev, p->func_selector,
grp->group_selector);
}
}
- mutex_unlock(&pmx->mutex);
+ mutex_unlock(&p->mutex);
}
-EXPORT_SYMBOL_GPL(pinmux_disable);
+EXPORT_SYMBOL_GPL(pinctrl_disable);
int pinmux_check_ops(struct pinctrl_dev *pctldev)
{
@@ -910,11 +911,11 @@ int pinmux_check_ops(struct pinctrl_dev *pctldev)
}
/* Hog a single map entry and add to the hoglist */
-static int pinmux_hog_map(struct pinctrl_dev *pctldev,
- struct pinmux_map const *map)
+static int pinctrl_hog_map(struct pinctrl_dev *pctldev,
+ struct pinctrl_map const *map)
{
- struct pinmux_hog *hog;
- struct pinmux *pmx;
+ struct pinctrl_hog *hog;
+ struct pinctrl *p;
int ret;
if (map->dev_name) {
@@ -929,61 +930,61 @@ static int pinmux_hog_map(struct pinctrl_dev *pctldev,
return -EINVAL;
}
- hog = kzalloc(sizeof(struct pinmux_hog), GFP_KERNEL);
+ hog = kzalloc(sizeof(struct pinctrl_hog), GFP_KERNEL);
if (!hog)
return -ENOMEM;
- pmx = pinmux_get(NULL, map->name);
- if (IS_ERR(pmx)) {
+ p = pinctrl_get(NULL, map->name);
+ if (IS_ERR(p)) {
kfree(hog);
dev_err(pctldev->dev,
- "could not get the %s pinmux mapping for hogging\n",
+ "could not get the %s pin control mapping for hogging\n",
map->name);
- return PTR_ERR(pmx);
+ return PTR_ERR(p);
}
- ret = pinmux_enable(pmx);
+ ret = pinctrl_enable(p);
if (ret) {
- pinmux_put(pmx);
+ pinctrl_put(p);
kfree(hog);
dev_err(pctldev->dev,
- "could not enable the %s pinmux mapping for hogging\n",
+ "could not enable the %s pin control mapping for hogging\n",
map->name);
return ret;
}
hog->map = map;
- hog->pmx = pmx;
+ hog->p = p;
dev_info(pctldev->dev, "hogged map %s, function %s\n", map->name,
map->function);
- mutex_lock(&pctldev->pinmux_hogs_lock);
- list_add(&hog->node, &pctldev->pinmux_hogs);
- mutex_unlock(&pctldev->pinmux_hogs_lock);
+ mutex_lock(&pctldev->pinctrl_hogs_lock);
+ list_add(&hog->node, &pctldev->pinctrl_hogs);
+ mutex_unlock(&pctldev->pinctrl_hogs_lock);
return 0;
}
/**
- * pinmux_hog_maps() - hog specific map entries on controller device
+ * pinctrl_hog_maps() - hog specific map entries on controller device
* @pctldev: the pin control device to hog entries on
*
* When the pin controllers are registered, there may be some specific pinmux
* map entries that need to be hogged, i.e. get+enabled until the system shuts
* down.
*/
-int pinmux_hog_maps(struct pinctrl_dev *pctldev)
+int pinctrl_hog_maps(struct pinctrl_dev *pctldev)
{
struct device *dev = pctldev->dev;
const char *devname = dev_name(dev);
int ret;
int i;
- INIT_LIST_HEAD(&pctldev->pinmux_hogs);
- mutex_init(&pctldev->pinmux_hogs_lock);
+ INIT_LIST_HEAD(&pctldev->pinctrl_hogs);
+ mutex_init(&pctldev->pinctrl_hogs_lock);
- for (i = 0; i < pinmux_maps_num; i++) {
- struct pinmux_map const *map = &pinmux_maps[i];
+ for (i = 0; i < pinctrl_maps_num; i++) {
+ struct pinctrl_map const *map = &pinctrl_maps[i];
if (!map->hog_on_boot)
continue;
@@ -991,7 +992,7 @@ int pinmux_hog_maps(struct pinctrl_dev *pctldev)
if (map->ctrl_dev_name &&
!strcmp(map->ctrl_dev_name, devname)) {
/* OK time to hog! */
- ret = pinmux_hog_map(pctldev, map);
+ ret = pinctrl_hog_map(pctldev, map);
if (ret)
return ret;
}
@@ -1000,23 +1001,23 @@ int pinmux_hog_maps(struct pinctrl_dev *pctldev)
}
/**
- * pinmux_unhog_maps() - unhog specific map entries on controller device
+ * pinctrl_unhog_maps() - unhog specific map entries on controller device
* @pctldev: the pin control device to unhog entries on
*/
-void pinmux_unhog_maps(struct pinctrl_dev *pctldev)
+void pinctrl_unhog_maps(struct pinctrl_dev *pctldev)
{
struct list_head *node, *tmp;
- mutex_lock(&pctldev->pinmux_hogs_lock);
- list_for_each_safe(node, tmp, &pctldev->pinmux_hogs) {
- struct pinmux_hog *hog =
- list_entry(node, struct pinmux_hog, node);
- pinmux_disable(hog->pmx);
- pinmux_put(hog->pmx);
+ mutex_lock(&pctldev->pinctrl_hogs_lock);
+ list_for_each_safe(node, tmp, &pctldev->pinctrl_hogs) {
+ struct pinctrl_hog *hog =
+ list_entry(node, struct pinctrl_hog, node);
+ pinctrl_disable(hog->p);
+ pinctrl_put(hog->p);
list_del(node);
kfree(hog);
}
- mutex_unlock(&pctldev->pinmux_hogs_lock);
+ mutex_unlock(&pctldev->pinctrl_hogs_lock);
}
#ifdef CONFIG_DEBUG_FS
@@ -1085,11 +1086,11 @@ static int pinmux_pins_show(struct seq_file *s, void *what)
static int pinmux_hogs_show(struct seq_file *s, void *what)
{
struct pinctrl_dev *pctldev = s->private;
- struct pinmux_hog *hog;
+ struct pinctrl_hog *hog;
- seq_puts(s, "Pinmux map hogs held by device\n");
+ seq_puts(s, "Pin control map hogs held by device\n");
- list_for_each_entry(hog, &pctldev->pinmux_hogs, node)
+ list_for_each_entry(hog, &pctldev->pinctrl_hogs, node)
seq_printf(s, "%s\n", hog->map->name);
return 0;
@@ -1097,11 +1098,11 @@ static int pinmux_hogs_show(struct seq_file *s, void *what)
static int pinmux_show(struct seq_file *s, void *what)
{
- struct pinmux *pmx;
+ struct pinctrl *p;
seq_puts(s, "Requested pinmuxes and their maps:\n");
- list_for_each_entry(pmx, &pinmux_list, node) {
- struct pinctrl_dev *pctldev = pmx->pctldev;
+ list_for_each_entry(p, &pinctrl_list, node) {
+ struct pinctrl_dev *pctldev = p->pctldev;
const struct pinmux_ops *pmxops;
const struct pinctrl_ops *pctlops;
struct pinmux_group *grp;
@@ -1115,13 +1116,13 @@ static int pinmux_show(struct seq_file *s, void *what)
pctlops = pctldev->desc->pctlops;
seq_printf(s, "device: %s function: %s (%u),",
- pinctrl_dev_get_name(pmx->pctldev),
+ pinctrl_dev_get_name(p->pctldev),
pmxops->get_function_name(pctldev,
- pmx->func_selector),
- pmx->func_selector);
+ p->func_selector),
+ p->func_selector);
seq_printf(s, " groups: [");
- list_for_each_entry(grp, &pmx->groups, node) {
+ list_for_each_entry(grp, &p->groups, node) {
seq_printf(s, " %s (%u)",
pctlops->get_group_name(pctldev,
grp->group_selector),
@@ -1130,21 +1131,21 @@ static int pinmux_show(struct seq_file *s, void *what)
seq_printf(s, " ]");
seq_printf(s, " users: %u map-> %s\n",
- pmx->usecount,
- pmx->dev ? dev_name(pmx->dev) : "(system)");
+ p->usecount,
+ p->dev ? dev_name(p->dev) : "(system)");
}
return 0;
}
-static int pinmux_maps_show(struct seq_file *s, void *what)
+static int pinctrl_maps_show(struct seq_file *s, void *what)
{
int i;
- seq_puts(s, "Pinmux maps:\n");
+ seq_puts(s, "Pinctrl maps:\n");
- for (i = 0; i < pinmux_maps_num; i++) {
- struct pinmux_map const *map = &pinmux_maps[i];
+ for (i = 0; i < pinctrl_maps_num; i++) {
+ struct pinctrl_map const *map = &pinctrl_maps[i];
seq_printf(s, "%s:\n", map->name);
if (map->dev_name)
@@ -1181,9 +1182,9 @@ static int pinmux_open(struct inode *inode, struct file *file)
return single_open(file, pinmux_show, NULL);
}
-static int pinmux_maps_open(struct inode *inode, struct file *file)
+static int pinctrl_maps_open(struct inode *inode, struct file *file)
{
- return single_open(file, pinmux_maps_show, NULL);
+ return single_open(file, pinctrl_maps_show, NULL);
}
static const struct file_operations pinmux_functions_ops = {
@@ -1214,8 +1215,8 @@ static const struct file_operations pinmux_ops = {
.release = single_release,
};
-static const struct file_operations pinmux_maps_ops = {
- .open = pinmux_maps_open,
+static const struct file_operations pinctrl_maps_ops = {
+ .open = pinctrl_maps_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
@@ -1236,8 +1237,8 @@ void pinmux_init_debugfs(struct dentry *subsys_root)
{
debugfs_create_file("pinmuxes", S_IFREG | S_IRUGO,
subsys_root, NULL, &pinmux_ops);
- debugfs_create_file("pinmux-maps", S_IFREG | S_IRUGO,
- subsys_root, NULL, &pinmux_maps_ops);
+ debugfs_create_file("pinctrl-maps", S_IFREG | S_IRUGO,
+ subsys_root, NULL, &pinctrl_maps_ops);
}
#endif /* CONFIG_DEBUG_FS */