Commit 84564481 authored by Aswath Govindraju's avatar Aswath Govindraju Committed by Greg Kroah-Hartman
Browse files

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: default avatarAswath 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: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent b2fb28de

Documentation/driver-api/driver-model/devres.rst

+1 −0
Original line number Diff line number Diff line
@@ -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()

drivers/mux/core.c

+198 −21
Original line number Diff line number Diff line
@@ -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,14 +519,17 @@ static struct mux_chip *of_find_mux_chip_by_node(struct device_node *np) 
	return dev ? to_mux_chip(dev) : NULL;

}



/**

 * mux_control_get() - Get the mux-control for a device.

/*

 * 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.

 */

struct mux_control *mux_control_get(struct device *dev, const char *mux_name)

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;
@@ -458,6 +539,10 @@ struct mux_control *mux_control_get(struct device *dev, const char *mux_name) 
	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) {
@@ -467,12 +552,17 @@ struct mux_control *mux_control_get(struct device *dev, const char *mux_name) 
		}

	}



	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-control %s(%i)\n",

			np, mux_name ?: "", index);

		dev_err(dev, "%pOF: failed to get mux-%s %s(%i)\n",

			np, state ? "state" : "control", mux_name ?: "", index);

		return ERR_PTR(ret);

	}
@@ -481,17 +571,35 @@ struct mux_control *mux_control_get(struct device *dev, const char *mux_name) 
	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))) {

		    (!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",
@@ -502,6 +610,18 @@ struct mux_control *mux_control_get(struct device *dev, const char *mux_name) 


	return &mux_chip->mux[controller];

}



/**

 * mux_control_get() - Get the mux-control for a device.

 * @dev: The device that needs a mux-control.

 * @mux_name: The name identifying the mux-control.

 *

 * Return: A pointer to the mux-control, or an ERR_PTR with a negative errno.

 */

struct mux_control *mux_control_get(struct device *dev, const char *mux_name)

{

	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

include/linux/mux/consumer.h

+18 −0
Original line number Diff line number Diff line
@@ -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 */