mux: Add support for reading mux state from consumer DT node
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
Greg Kroah-Hartman
parent
b2fb28dedd
commit
84564481bc
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
Loading…
Reference in New Issue