pinctrl: refactor struct pinctrl handling in core.c vs pinmux.c
This change separates two aspects of struct pinctrl:
a) The data representation of the parsed mapping table, into:
1) The top-level struct pinctrl object, a single entity returned
by pinctrl_get().
2) The parsed version of each mapping table entry, struct
pinctrl_setting, of which there is one per mapping table entry.
b) The code that handles this; the code for (1) above is in core.c, and
the code to parse/execute each entry in (2) above is in pinmux.c, while
the iteration over multiple settings is lifted to core.c.
This will allow the following future changes:
1) pinctrl_get() API rework, so that struct pinctrl represents all states
for the device, and the device can select between them without calling
put()/get() again.
2) To support that, a struct pinctrl_state object will be inserted into
the data model between the struct pinctrl and struct pinctrl_setting.
3) The mapping table will be extended to allow specification of pin config
settings too. To support this, struct pinctrl_setting will be enhanced
to store either mux settings or config settings, and functions will be
added to pinconf.c to parse/execute pin configuration settings.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Acked-by: Dong Aisheng <dong.aisheng@linaro.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
This commit is contained in:
Stephen Warren
committed by
Linus Walleij
Linus Walleij
parent
57b676f9c1
commit
7ecdb16fe6
@@ -7,6 +7,8 @@
|
||||
*
|
||||
* 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
|
||||
@@ -28,19 +30,6 @@
|
||||
#include "core.h"
|
||||
#include "pinmux.h"
|
||||
|
||||
/**
|
||||
* struct pinmux_group - group list item for pinmux groups
|
||||
* @node: pinmux group list node
|
||||
* @func_selector: the function selector for the pinmux device handling
|
||||
* this pinmux
|
||||
* @group_selector: the group selector for this group
|
||||
*/
|
||||
struct pinmux_group {
|
||||
struct list_head node;
|
||||
unsigned func_selector;
|
||||
unsigned group_selector;
|
||||
};
|
||||
|
||||
int pinmux_check_ops(struct pinctrl_dev *pctldev)
|
||||
{
|
||||
const struct pinmux_ops *ops = pctldev->desc->pmxops;
|
||||
@@ -244,164 +233,8 @@ int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* acquire_pins() - acquire all the pins for a certain function on a pinmux
|
||||
* @pctldev: the device to take the pins on
|
||||
* @owner: a representation of the owner of this pin; typically the device
|
||||
* name that controls its mux function
|
||||
* @group_selector: the group selector containing the pins to acquire
|
||||
*/
|
||||
static int acquire_pins(struct pinctrl_dev *pctldev,
|
||||
const char *owner,
|
||||
unsigned group_selector)
|
||||
{
|
||||
const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
|
||||
const unsigned *pins;
|
||||
unsigned num_pins;
|
||||
int ret;
|
||||
int i;
|
||||
|
||||
ret = pctlops->get_group_pins(pctldev, group_selector,
|
||||
&pins, &num_pins);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
dev_dbg(pctldev->dev, "requesting the %u pins from group %u\n",
|
||||
num_pins, group_selector);
|
||||
|
||||
/* Try to allocate all pins in this group, one by one */
|
||||
for (i = 0; i < num_pins; i++) {
|
||||
ret = pin_request(pctldev, pins[i], owner, NULL);
|
||||
if (ret) {
|
||||
dev_err(pctldev->dev,
|
||||
"could not get request pin %d on device %s - conflicting mux mappings?\n",
|
||||
pins[i],
|
||||
pinctrl_dev_get_name(pctldev));
|
||||
/* On error release all taken pins */
|
||||
i--; /* this pin just failed */
|
||||
for (; i >= 0; i--)
|
||||
pin_free(pctldev, pins[i], NULL);
|
||||
return -ENODEV;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* release_pins() - release pins taken by earlier acquirement
|
||||
* @pctldev: the device to free the pins on
|
||||
* @group_selector: the group selector containing the pins to free
|
||||
*/
|
||||
static void release_pins(struct pinctrl_dev *pctldev,
|
||||
unsigned group_selector)
|
||||
{
|
||||
const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
|
||||
const unsigned *pins;
|
||||
unsigned num_pins;
|
||||
int ret;
|
||||
int i;
|
||||
|
||||
ret = pctlops->get_group_pins(pctldev, group_selector,
|
||||
&pins, &num_pins);
|
||||
if (ret) {
|
||||
dev_err(pctldev->dev, "could not get pins to release for group selector %d\n",
|
||||
group_selector);
|
||||
return;
|
||||
}
|
||||
for (i = 0; i < num_pins; i++)
|
||||
pin_free(pctldev, pins[i], NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* pinmux_check_pin_group() - check function and pin group combo
|
||||
* @pctldev: device to check the pin group vs function for
|
||||
* @func_selector: the function selector to check the pin group for, we have
|
||||
* already looked this up in the calling function
|
||||
* @pin_group: the pin group to match to the function
|
||||
*
|
||||
* This function will check that the pinmux driver can supply the
|
||||
* selected pin group for a certain function, returns the group selector if
|
||||
* the group and function selector will work fine together, else returns
|
||||
* negative
|
||||
*/
|
||||
static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
|
||||
unsigned func_selector,
|
||||
const char *pin_group)
|
||||
{
|
||||
const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
|
||||
const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* If the driver does not support different pin groups for the
|
||||
* functions, we only support group 0, and assume this exists.
|
||||
*/
|
||||
if (!pctlops || !pctlops->list_groups)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* Passing NULL (no specific group) will select the first and
|
||||
* hopefully only group of pins available for this function.
|
||||
*/
|
||||
if (!pin_group) {
|
||||
char const * const *groups;
|
||||
unsigned num_groups;
|
||||
|
||||
ret = pmxops->get_function_groups(pctldev, func_selector,
|
||||
&groups, &num_groups);
|
||||
if (ret)
|
||||
return ret;
|
||||
if (num_groups < 1)
|
||||
return -EINVAL;
|
||||
ret = pinctrl_get_group_selector(pctldev, groups[0]);
|
||||
if (ret < 0) {
|
||||
dev_err(pctldev->dev,
|
||||
"function %s wants group %s but the pin controller does not seem to have that group\n",
|
||||
pmxops->get_function_name(pctldev, func_selector),
|
||||
groups[0]);
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (num_groups > 1)
|
||||
dev_dbg(pctldev->dev,
|
||||
"function %s support more than one group, default-selecting first group %s (%d)\n",
|
||||
pmxops->get_function_name(pctldev, func_selector),
|
||||
groups[0],
|
||||
ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
dev_dbg(pctldev->dev,
|
||||
"check if we have pin group %s on controller %s\n",
|
||||
pin_group, pinctrl_dev_get_name(pctldev));
|
||||
|
||||
ret = pinctrl_get_group_selector(pctldev, pin_group);
|
||||
if (ret < 0) {
|
||||
dev_dbg(pctldev->dev,
|
||||
"%s does not support pin group %s with function %s\n",
|
||||
pinctrl_dev_get_name(pctldev),
|
||||
pin_group,
|
||||
pmxops->get_function_name(pctldev, func_selector));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* pinmux_search_function() - check pin control driver for a certain function
|
||||
* @pctldev: device to check for function and position
|
||||
* @map: function map containing the function and position to look for
|
||||
* @func_selector: returns the applicable function selector if found
|
||||
* @group_selector: returns the applicable group selector if found
|
||||
*
|
||||
* This will search the pinmux driver for an applicable
|
||||
* function with a specific pin group, returns 0 if these can be mapped
|
||||
* negative otherwise
|
||||
*/
|
||||
static int pinmux_search_function(struct pinctrl_dev *pctldev,
|
||||
struct pinctrl_map const *map,
|
||||
unsigned *func_selector,
|
||||
unsigned *group_selector)
|
||||
static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
|
||||
const char *function)
|
||||
{
|
||||
const struct pinmux_ops *ops = pctldev->desc->pmxops;
|
||||
unsigned selector = 0;
|
||||
@@ -410,155 +243,128 @@ static int pinmux_search_function(struct pinctrl_dev *pctldev,
|
||||
while (ops->list_functions(pctldev, selector) >= 0) {
|
||||
const char *fname = ops->get_function_name(pctldev,
|
||||
selector);
|
||||
int ret;
|
||||
|
||||
if (!strcmp(map->function, fname)) {
|
||||
/* Found the function, check pin group */
|
||||
ret = pinmux_check_pin_group(pctldev, selector,
|
||||
map->group);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (!strcmp(function, fname))
|
||||
return selector;
|
||||
|
||||
/* This function and group selector can be used */
|
||||
*func_selector = selector;
|
||||
*group_selector = ret;
|
||||
return 0;
|
||||
|
||||
}
|
||||
selector++;
|
||||
}
|
||||
|
||||
pr_err("%s does not support function %s\n",
|
||||
pinctrl_dev_get_name(pctldev), map->function);
|
||||
pinctrl_dev_get_name(pctldev), function);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* pinmux_enable_muxmap() - enable a map entry for a certain pinmux
|
||||
*/
|
||||
static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
|
||||
struct pinctrl *p,
|
||||
struct device *dev,
|
||||
const char *devname,
|
||||
struct pinctrl_map const *map)
|
||||
int pinmux_map_to_setting(struct pinctrl_map const *map,
|
||||
struct pinctrl_setting *setting)
|
||||
{
|
||||
unsigned func_selector;
|
||||
unsigned group_selector;
|
||||
struct pinmux_group *grp;
|
||||
struct pinctrl_dev *pctldev = setting->pctldev;
|
||||
const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
|
||||
const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
|
||||
char const * const *groups;
|
||||
unsigned num_groups;
|
||||
int ret;
|
||||
const char *group;
|
||||
int i;
|
||||
const unsigned *pins;
|
||||
unsigned num_pins;
|
||||
|
||||
/*
|
||||
* Note that we're not locking the pinmux mutex here, because
|
||||
* this is only called at pinmux initialization time when it
|
||||
* has not been added to any list and thus is not reachable
|
||||
* by anyone else.
|
||||
*/
|
||||
setting->func_selector =
|
||||
pinmux_func_name_to_selector(pctldev, map->function);
|
||||
if (setting->func_selector < 0)
|
||||
return setting->func_selector;
|
||||
|
||||
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;
|
||||
}
|
||||
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,
|
||||
&group_selector);
|
||||
ret = pmxops->get_function_groups(pctldev, setting->func_selector,
|
||||
&groups, &num_groups);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
if (!num_groups)
|
||||
return -EINVAL;
|
||||
|
||||
/* Now add this group selector, we may have many of them */
|
||||
grp = kmalloc(sizeof(*grp), GFP_KERNEL);
|
||||
if (!grp)
|
||||
return -ENOMEM;
|
||||
grp->func_selector = func_selector;
|
||||
grp->group_selector = group_selector;
|
||||
ret = acquire_pins(pctldev, devname, group_selector);
|
||||
if (map->group) {
|
||||
bool found = false;
|
||||
group = map->group;
|
||||
for (i = 0; i < num_groups; i++) {
|
||||
if (!strcmp(group, groups[i])) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found)
|
||||
return -EINVAL;
|
||||
} else {
|
||||
group = groups[0];
|
||||
}
|
||||
|
||||
setting->group_selector =
|
||||
pinctrl_get_group_selector(pctldev, group);
|
||||
if (setting->group_selector < 0)
|
||||
return setting->group_selector;
|
||||
|
||||
ret = pctlops->get_group_pins(pctldev, setting->group_selector,
|
||||
&pins, &num_pins);
|
||||
if (ret) {
|
||||
kfree(grp);
|
||||
return ret;
|
||||
dev_err(pctldev->dev,
|
||||
"could not get pins for device %s group selector %d\n",
|
||||
pinctrl_dev_get_name(pctldev), setting->group_selector);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
/* Try to allocate all pins in this group, one by one */
|
||||
for (i = 0; i < num_pins; i++) {
|
||||
ret = pin_request(pctldev, pins[i], map->dev_name, NULL);
|
||||
if (ret) {
|
||||
dev_err(pctldev->dev,
|
||||
"could not get request pin %d on device %s\n",
|
||||
pins[i], pinctrl_dev_get_name(pctldev));
|
||||
/* On error release all taken pins */
|
||||
i--; /* this pin just failed */
|
||||
for (; i >= 0; i--)
|
||||
pin_free(pctldev, pins[i], NULL);
|
||||
return -ENODEV;
|
||||
}
|
||||
}
|
||||
list_add_tail(&grp->node, &p->groups);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* pinmux_apply_muxmap() - apply a certain mux mapping entry
|
||||
*/
|
||||
int pinmux_apply_muxmap(struct pinctrl_dev *pctldev,
|
||||
struct pinctrl *p,
|
||||
struct device *dev,
|
||||
const char *devname,
|
||||
struct pinctrl_map const *map)
|
||||
void pinmux_free_setting(struct pinctrl_setting const *setting)
|
||||
{
|
||||
struct pinctrl_dev *pctldev = setting->pctldev;
|
||||
const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
|
||||
const unsigned *pins;
|
||||
unsigned num_pins;
|
||||
int ret;
|
||||
int i;
|
||||
|
||||
ret = pinmux_enable_muxmap(pctldev, p, dev,
|
||||
devname, map);
|
||||
ret = pctlops->get_group_pins(pctldev, setting->group_selector,
|
||||
&pins, &num_pins);
|
||||
if (ret) {
|
||||
pinmux_put(p);
|
||||
return ret;
|
||||
dev_err(pctldev->dev,
|
||||
"could not get pins for device %s group selector %d\n",
|
||||
pinctrl_dev_get_name(pctldev), setting->group_selector);
|
||||
return;
|
||||
}
|
||||
|
||||
return 0;
|
||||
for (i = 0; i < num_pins; i++)
|
||||
pin_free(pctldev, pins[i], NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* pinmux_put() - free up the pinmux portions of a pin controller handle
|
||||
*/
|
||||
void pinmux_put(struct pinctrl *p)
|
||||
int pinmux_enable_setting(struct pinctrl_setting const *setting)
|
||||
{
|
||||
struct list_head *node, *tmp;
|
||||
|
||||
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(p->pctldev, grp->group_selector);
|
||||
list_del(node);
|
||||
kfree(grp);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* pinmux_enable() - enable the pinmux portion of a pin control handle
|
||||
*/
|
||||
int pinmux_enable(struct pinctrl *p)
|
||||
{
|
||||
struct pinctrl_dev *pctldev = p->pctldev;
|
||||
struct pinctrl_dev *pctldev = setting->pctldev;
|
||||
const struct pinmux_ops *ops = pctldev->desc->pmxops;
|
||||
struct pinmux_group *grp;
|
||||
int ret;
|
||||
|
||||
list_for_each_entry(grp, &p->groups, node) {
|
||||
ret = ops->enable(pctldev, grp->func_selector,
|
||||
grp->group_selector);
|
||||
if (ret)
|
||||
/*
|
||||
* TODO: call disable() on all groups we called
|
||||
* enable() on to this point?
|
||||
*/
|
||||
return ret;
|
||||
}
|
||||
return 0;
|
||||
return ops->enable(pctldev, setting->func_selector,
|
||||
setting->group_selector);
|
||||
}
|
||||
|
||||
/**
|
||||
* pinmux_disable() - disable the pinmux portions of a pin control handle
|
||||
*/
|
||||
void pinmux_disable(struct pinctrl *p)
|
||||
void pinmux_disable_setting(struct pinctrl_setting const *setting)
|
||||
{
|
||||
struct pinctrl_dev *pctldev = p->pctldev;
|
||||
struct pinctrl_dev *pctldev = setting->pctldev;
|
||||
const struct pinmux_ops *ops = pctldev->desc->pmxops;
|
||||
struct pinmux_group *grp;
|
||||
|
||||
list_for_each_entry(grp, &p->groups, node) {
|
||||
ops->disable(pctldev, grp->func_selector,
|
||||
grp->group_selector);
|
||||
}
|
||||
ops->disable(pctldev, setting->func_selector, setting->group_selector);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_DEBUG_FS
|
||||
@@ -635,30 +441,18 @@ static int pinmux_pins_show(struct seq_file *s, void *what)
|
||||
return 0;
|
||||
}
|
||||
|
||||
void pinmux_dbg_show(struct seq_file *s, struct pinctrl *p)
|
||||
void pinmux_dbg_show(struct seq_file *s, struct pinctrl_setting const *setting)
|
||||
{
|
||||
struct pinctrl_dev *pctldev = p->pctldev;
|
||||
const struct pinmux_ops *pmxops;
|
||||
const struct pinctrl_ops *pctlops;
|
||||
struct pinmux_group *grp;
|
||||
const char *sep = "";
|
||||
struct pinctrl_dev *pctldev = setting->pctldev;
|
||||
const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
|
||||
const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
|
||||
|
||||
pmxops = pctldev->desc->pmxops;
|
||||
pctlops = pctldev->desc->pctlops;
|
||||
|
||||
seq_printf(s, " groups: [");
|
||||
list_for_each_entry(grp, &p->groups, node) {
|
||||
seq_printf(s, "%s%s (%u)=%s (%u)",
|
||||
sep,
|
||||
pctlops->get_group_name(pctldev,
|
||||
grp->group_selector),
|
||||
grp->group_selector,
|
||||
pmxops->get_function_name(pctldev,
|
||||
grp->func_selector),
|
||||
grp->func_selector);
|
||||
sep = ", ";
|
||||
}
|
||||
seq_printf(s, " ]");
|
||||
seq_printf(s, "controller: %s group: %s (%u) function: %s (%u)\n",
|
||||
pinctrl_dev_get_name(pctldev),
|
||||
pctlops->get_group_name(pctldev, setting->group_selector),
|
||||
setting->group_selector,
|
||||
pmxops->get_function_name(pctldev, setting->func_selector),
|
||||
setting->func_selector);
|
||||
}
|
||||
|
||||
static int pinmux_functions_open(struct inode *inode, struct file *file)
|
||||
|
||||
Reference in New Issue
Block a user