leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

mux: Add support for reading mux state from consumer DT node

Browse Source 
In some cases, we might need to provide the state of the mux to be set for
the operation of a given peripheral. Therefore, pass this information using
mux-states property.

Link: https://lore.kernel.org/lkml/20211123081222.27979-1-a-govindraju@ti.com
Signed-off-by: Aswath Govindraju <a-govindraju@ti.com>
Signed-off-by: Peter Rosin <peda@axentia.se> (minor edits)
Link: https://lore.kernel.org/r/aac25be8-9515-a980-f7cb-709938c84822@axentia.se
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Aswath Govindraju 2022-01-07 08:44:25 +01:00 committed by Greg Kroah-Hartman
parent b2fb28dedd
commit 84564481bc
3 changed files with 248 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Documentation/driver-api/driver-model/devres.rst
View File

@ -368,6 +368,7 @@ MUX
devm_mux_chip_alloc()
devm_mux_chip_register()
devm_mux_control_get()
devm_mux_state_get()
NET
devm_alloc_etherdev()

281
drivers/mux/core.c
View File

@ -29,6 +29,20 @@
*/
#define MUX_CACHE_UNKNOWN MUX_IDLE_AS_IS
/**
* struct mux_state - Represents a mux controller state specific to a given
* consumer.
* @mux: Pointer to a mux controller.
* @state State of the mux to be selected.
*
* This structure is specific to the consumer that acquires it and has
* information specific to that consumer.
*/
struct mux_state {
struct mux_control *mux;
unsigned int state;
};
static struct class mux_class = {
.name = "mux",
.owner = THIS_MODULE,
@ -341,7 +355,8 @@ static void mux_control_delay(struct mux_control *mux, unsigned int delay_us)
* On successfully selecting the mux-control state, it will be locked until
* there is a call to mux_control_deselect(). If the mux-control is already
* selected when mux_control_select() is called, the caller will be blocked
* until mux_control_deselect() is called (by someone else).
* until mux_control_deselect() or mux_state_deselect() is called (by someone
* else).
*
* Therefore, make sure to call mux_control_deselect() when the operation is
* complete and the mux-control is free for others to use, but do not call
@ -370,6 +385,30 @@ int mux_control_select_delay(struct mux_control *mux, unsigned int state,
}
EXPORT_SYMBOL_GPL(mux_control_select_delay);
/**
* mux_state_select_delay() - Select the given multiplexer state.
* @mstate: The mux-state to select.
* @delay_us: The time to delay (in microseconds) if the mux state is changed.
*
* On successfully selecting the mux-state, its mux-control will be locked
* until there is a call to mux_state_deselect(). If the mux-control is already
* selected when mux_state_select() is called, the caller will be blocked
* until mux_state_deselect() or mux_control_deselect() is called (by someone
* else).
*
* Therefore, make sure to call mux_state_deselect() when the operation is
* complete and the mux-control is free for others to use, but do not call
* mux_state_deselect() if mux_state_select() fails.
*
* Return: 0 when the mux-state has been selected or a negative
* errno on error.
*/
int mux_state_select_delay(struct mux_state *mstate, unsigned int delay_us)
{
return mux_control_select_delay(mstate->mux, mstate->state, delay_us);
}
EXPORT_SYMBOL_GPL(mux_state_select_delay);
/**
* mux_control_try_select_delay() - Try to select the given multiplexer state.
* @mux: The mux-control to request a change of state from.
@ -405,6 +444,27 @@ int mux_control_try_select_delay(struct mux_control *mux, unsigned int state,
}
EXPORT_SYMBOL_GPL(mux_control_try_select_delay);
/**
* mux_state_try_select_delay() - Try to select the given multiplexer state.
* @mstate: The mux-state to select.
* @delay_us: The time to delay (in microseconds) if the mux state is changed.
*
* On successfully selecting the mux-state, its mux-control will be locked
* until mux_state_deselect() is called.
*
* Therefore, make sure to call mux_state_deselect() when the operation is
* complete and the mux-control is free for others to use, but do not call
* mux_state_deselect() if mux_state_try_select() fails.
*
* Return: 0 when the mux-state has been selected or a negative errno on
* error. Specifically -EBUSY if the mux-control is contended.
*/
int mux_state_try_select_delay(struct mux_state *mstate, unsigned int delay_us)
{
return mux_control_try_select_delay(mstate->mux, mstate->state, delay_us);
}
EXPORT_SYMBOL_GPL(mux_state_try_select_delay);
/**
* mux_control_deselect() - Deselect the previously selected multiplexer state.
* @mux: The mux-control to deselect.
@ -431,6 +491,24 @@ int mux_control_deselect(struct mux_control *mux)
}
EXPORT_SYMBOL_GPL(mux_control_deselect);
/**
* mux_state_deselect() - Deselect the previously selected multiplexer state.
* @mstate: The mux-state to deselect.
*
* It is required that a single call is made to mux_state_deselect() for
* each and every successful call made to either of mux_state_select() or
* mux_state_try_select().
*
* Return: 0 on success and a negative errno on error. An error can only
* occur if the mux has an idle state. Note that even if an error occurs, the
* mux-control is unlocked and is thus free for the next access.
*/
int mux_state_deselect(struct mux_state *mstate)
{
return mux_control_deselect(mstate->mux);
}
EXPORT_SYMBOL_GPL(mux_state_deselect);
/* Note this function returns a reference to the mux_chip dev. */
static struct mux_chip *of_find_mux_chip_by_node(struct device_node *np)
{
@ -441,6 +519,98 @@ static struct mux_chip *of_find_mux_chip_by_node(struct device_node *np)
return dev ? to_mux_chip(dev) : NULL;
}
/*
* mux_get() - Get the mux-control for a device.
* @dev: The device that needs a mux-control.
* @mux_name: The name identifying the mux-control.
* @state: Pointer to where the requested state is returned, or NULL when
* the required multiplexer states are handled by other means.
*
* Return: A pointer to the mux-control, or an ERR_PTR with a negative errno.
*/
static struct mux_control *mux_get(struct device *dev, const char *mux_name,
unsigned int *state)
{
struct device_node *np = dev->of_node;
struct of_phandle_args args;
struct mux_chip *mux_chip;
unsigned int controller;
int index = 0;
int ret;
if (mux_name) {
if (state)
index = of_property_match_string(np, "mux-state-names",
mux_name);
else
index = of_property_match_string(np, "mux-control-names",
mux_name);
if (index < 0) {
dev_err(dev, "mux controller '%s' not found\n",
mux_name);
return ERR_PTR(index);
}
}
if (state)
ret = of_parse_phandle_with_args(np,
"mux-states", "#mux-state-cells",
index, &args);
else
ret = of_parse_phandle_with_args(np,
"mux-controls", "#mux-control-cells",
index, &args);
if (ret) {
dev_err(dev, "%pOF: failed to get mux-%s %s(%i)\n",
np, state ? "state" : "control", mux_name ?: "", index);
return ERR_PTR(ret);
}
mux_chip = of_find_mux_chip_by_node(args.np);
of_node_put(args.np);
if (!mux_chip)
return ERR_PTR(-EPROBE_DEFER);
controller = 0;
if (state) {
if (args.args_count > 2 || args.args_count == 0 ||
(args.args_count < 2 && mux_chip->controllers > 1)) {
dev_err(dev, "%pOF: wrong #mux-state-cells for %pOF\n",
np, args.np);
put_device(&mux_chip->dev);
return ERR_PTR(-EINVAL);
}
if (args.args_count == 2) {
controller = args.args[0];
*state = args.args[1];
} else {
*state = args.args[0];
}
} else {
if (args.args_count > 1 ||
(!args.args_count && mux_chip->controllers > 1)) {
dev_err(dev, "%pOF: wrong #mux-control-cells for %pOF\n",
np, args.np);
put_device(&mux_chip->dev);
return ERR_PTR(-EINVAL);
}
if (args.args_count)
controller = args.args[0];
}
if (controller >= mux_chip->controllers) {
dev_err(dev, "%pOF: bad mux controller %u specified in %pOF\n",
np, controller, args.np);
put_device(&mux_chip->dev);
return ERR_PTR(-EINVAL);
}
return &mux_chip->mux[controller];
}
/**
* mux_control_get() - Get the mux-control for a device.
* @dev: The device that needs a mux-control.
@ -450,57 +620,7 @@ static struct mux_chip *of_find_mux_chip_by_node(struct device_node *np)
*/
struct mux_control *mux_control_get(struct device *dev, const char *mux_name)
{
struct device_node *np = dev->of_node;
struct of_phandle_args args;
struct mux_chip *mux_chip;
unsigned int controller;
int index = 0;
int ret;
if (mux_name) {
index = of_property_match_string(np, "mux-control-names",
mux_name);
if (index < 0) {
dev_err(dev, "mux controller '%s' not found\n",
mux_name);
return ERR_PTR(index);
}
}
ret = of_parse_phandle_with_args(np,
"mux-controls", "#mux-control-cells",
index, &args);
if (ret) {
dev_err(dev, "%pOF: failed to get mux-control %s(%i)\n",
np, mux_name ?: "", index);
return ERR_PTR(ret);
}
mux_chip = of_find_mux_chip_by_node(args.np);
of_node_put(args.np);
if (!mux_chip)
return ERR_PTR(-EPROBE_DEFER);
if (args.args_count > 1 ||
(!args.args_count && (mux_chip->controllers > 1))) {
dev_err(dev, "%pOF: wrong #mux-control-cells for %pOF\n",
np, args.np);
put_device(&mux_chip->dev);
return ERR_PTR(-EINVAL);
}
controller = 0;
if (args.args_count)
controller = args.args[0];
if (controller >= mux_chip->controllers) {
dev_err(dev, "%pOF: bad mux controller %u specified in %pOF\n",
np, controller, args.np);
put_device(&mux_chip->dev);
return ERR_PTR(-EINVAL);
}
return &mux_chip->mux[controller];
return mux_get(dev, mux_name, NULL);
}
EXPORT_SYMBOL_GPL(mux_control_get);
@ -553,6 +673,63 @@ struct mux_control *devm_mux_control_get(struct device *dev,
}
EXPORT_SYMBOL_GPL(devm_mux_control_get);
/*
* mux_state_put() - Put away the mux-state for good.
* @mstate: The mux-state to put away.
*
* mux_state_put() reverses the effects of mux_state_get().
*/
static void mux_state_put(struct mux_state *mstate)
{
mux_control_put(mstate->mux);
kfree(mstate);
}
static void devm_mux_state_release(struct device *dev, void *res)
{
struct mux_state *mstate = *(struct mux_state **)res;
mux_state_put(mstate);
}
/**
* devm_mux_state_get() - Get the mux-state for a device, with resource
* management.
* @dev: The device that needs a mux-control.
* @mux_name: The name identifying the mux-control.
*
* Return: Pointer to the mux-state, or an ERR_PTR with a negative errno.
*/
struct mux_state *devm_mux_state_get(struct device *dev,
const char *mux_name)
{
struct mux_state **ptr, *mstate;
struct mux_control *mux_ctrl;
int state;
mstate = devm_kzalloc(dev, sizeof(struct mux_state), GFP_KERNEL);
if (!mstate)
return ERR_PTR(-ENOMEM);
ptr = devres_alloc(devm_mux_state_release, sizeof(*ptr), GFP_KERNEL);
if (!ptr)
return ERR_PTR(-ENOMEM);
mux_ctrl = mux_get(dev, mux_name, &state);
if (IS_ERR(mux_ctrl)) {
devres_free(ptr);
return (struct mux_state *)mux_ctrl;
}
mstate->mux = mux_ctrl;
mstate->state = state;
*ptr = mstate;
devres_add(dev, ptr);
return mstate;
}
EXPORT_SYMBOL_GPL(devm_mux_state_get);
/*
* Using subsys_initcall instead of module_init here to try to ensure - for
* the non-modular case - that the subsystem is initialized when mux consumers

18
include/linux/mux/consumer.h
View File

@ -14,14 +14,19 @@
struct device;
struct mux_control;
struct mux_state;
unsigned int mux_control_states(struct mux_control *mux);
int __must_check mux_control_select_delay(struct mux_control *mux,
unsigned int state,
unsigned int delay_us);
int __must_check mux_state_select_delay(struct mux_state *mstate,
unsigned int delay_us);
int __must_check mux_control_try_select_delay(struct mux_control *mux,
unsigned int state,
unsigned int delay_us);
int __must_check mux_state_try_select_delay(struct mux_state *mstate,
unsigned int delay_us);
static inline int __must_check mux_control_select(struct mux_control *mux,
unsigned int state)
@ -29,18 +34,31 @@ static inline int __must_check mux_control_select(struct mux_control *mux,
return mux_control_select_delay(mux, state, 0);
}
static inline int __must_check mux_state_select(struct mux_state *mstate)
{
return mux_state_select_delay(mstate, 0);
}
static inline int __must_check mux_control_try_select(struct mux_control *mux,
unsigned int state)
{
return mux_control_try_select_delay(mux, state, 0);
}
static inline int __must_check mux_state_try_select(struct mux_state *mstate)
{
return mux_state_try_select_delay(mstate, 0);
}
int mux_control_deselect(struct mux_control *mux);
int mux_state_deselect(struct mux_state *mstate);
struct mux_control *mux_control_get(struct device *dev, const char *mux_name);
void mux_control_put(struct mux_control *mux);
struct mux_control *devm_mux_control_get(struct device *dev,
const char *mux_name);
struct mux_state *devm_mux_state_get(struct device *dev,
const char *mux_name);
#endif /* _LINUX_MUX_CONSUMER_H */