Commit 713fd49b authored by Bjorn Andersson's avatar Bjorn Andersson Committed by Greg Kroah-Hartman
Browse files

usb: typec: mux: Introduce indirection 



Rather than directly exposing the implementation's representation of the
typec muxes to the controller/clients, introduce an indirection object.

This enables the introduction of turning this relationship into a
one-to-many in the following patch.

Acked-by: default avatarHeikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: default avatarBjorn Andersson <bjorn.andersson@linaro.org>
Link: https://lore.kernel.org/r/20220422222351.1297276-5-bjorn.andersson@linaro.org


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent b9fa0292

drivers/usb/typec/bus.c

+1 −1
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ typec_altmode_set_mux(struct altmode *alt, unsigned long conf, void *data) 
	state.mode = conf;

	state.data = data;



	return alt->mux->set(alt->mux, &state);

	return typec_mux_set(alt->mux, &state);

}



static int typec_altmode_set_state(struct typec_altmode *adev,

drivers/usb/typec/mux.c

+121 −72
Original line number Diff line number Diff line
@@ -17,9 +17,13 @@ 
#include "class.h"

#include "mux.h"



struct typec_switch {

	struct typec_switch_dev *sw_dev;

};



static int switch_fwnode_match(struct device *dev, const void *fwnode)

{

	if (!is_typec_switch(dev))

	if (!is_typec_switch_dev(dev))

		return 0;



	return dev_fwnode(dev) == fwnode;
@@ -49,7 +53,7 @@ static void *typec_switch_match(struct fwnode_handle *fwnode, const char *id, 
	dev = class_find_device(&typec_mux_class, NULL, fwnode,

				switch_fwnode_match);



	return dev ? to_typec_switch(dev) : ERR_PTR(-EPROBE_DEFER);

	return dev ? to_typec_switch_dev(dev) : ERR_PTR(-EPROBE_DEFER);

}



/**
@@ -63,12 +67,23 @@ static void *typec_switch_match(struct fwnode_handle *fwnode, const char *id, 
 */

struct typec_switch *fwnode_typec_switch_get(struct fwnode_handle *fwnode)

{

	struct typec_switch_dev *sw_dev;

	struct typec_switch *sw;



	sw = fwnode_connection_find_match(fwnode, "orientation-switch", NULL,

	sw = kzalloc(sizeof(*sw), GFP_KERNEL);

	if (!sw)

		return ERR_PTR(-ENOMEM);



	sw_dev = fwnode_connection_find_match(fwnode, "orientation-switch", NULL,

					      typec_switch_match);

	if (!IS_ERR_OR_NULL(sw))

		WARN_ON(!try_module_get(sw->dev.parent->driver->owner));

	if (IS_ERR_OR_NULL(sw_dev)) {

		kfree(sw);

		return ERR_CAST(sw_dev);

	}



	WARN_ON(!try_module_get(sw_dev->dev.parent->driver->owner));



	sw->sw_dev = sw_dev;



	return sw;

}
@@ -82,16 +97,22 @@ EXPORT_SYMBOL_GPL(fwnode_typec_switch_get); 
 */

void typec_switch_put(struct typec_switch *sw)

{

	if (!IS_ERR_OR_NULL(sw)) {

		module_put(sw->dev.parent->driver->owner);

		put_device(&sw->dev);

	}

	struct typec_switch_dev *sw_dev;



	if (IS_ERR_OR_NULL(sw))

		return;



	sw_dev = sw->sw_dev;



	module_put(sw_dev->dev.parent->driver->owner);

	put_device(&sw_dev->dev);

	kfree(sw);

}

EXPORT_SYMBOL_GPL(typec_switch_put);



static void typec_switch_release(struct device *dev)

{

	kfree(to_typec_switch(dev));

	kfree(to_typec_switch_dev(dev));

}



const struct device_type typec_switch_dev_type = {
@@ -109,85 +130,93 @@ const struct device_type typec_switch_dev_type = { 
 * connector to the USB controllers. USB Type-C plugs can be inserted

 * right-side-up or upside-down.

 */

struct typec_switch *

struct typec_switch_dev *

typec_switch_register(struct device *parent,

		      const struct typec_switch_desc *desc)

{

	struct typec_switch *sw;

	struct typec_switch_dev *sw_dev;

	int ret;



	if (!desc || !desc->set)

		return ERR_PTR(-EINVAL);



	sw = kzalloc(sizeof(*sw), GFP_KERNEL);

	if (!sw)

	sw_dev = kzalloc(sizeof(*sw_dev), GFP_KERNEL);

	if (!sw_dev)

		return ERR_PTR(-ENOMEM);



	sw->set = desc->set;

	sw_dev->set = desc->set;



	device_initialize(&sw->dev);

	sw->dev.parent = parent;

	sw->dev.fwnode = desc->fwnode;

	sw->dev.class = &typec_mux_class;

	sw->dev.type = &typec_switch_dev_type;

	sw->dev.driver_data = desc->drvdata;

	ret = dev_set_name(&sw->dev, "%s-switch", desc->name ? desc->name : dev_name(parent));

	device_initialize(&sw_dev->dev);

	sw_dev->dev.parent = parent;

	sw_dev->dev.fwnode = desc->fwnode;

	sw_dev->dev.class = &typec_mux_class;

	sw_dev->dev.type = &typec_switch_dev_type;

	sw_dev->dev.driver_data = desc->drvdata;

	ret = dev_set_name(&sw_dev->dev, "%s-switch", desc->name ? desc->name : dev_name(parent));

	if (ret) {

		put_device(&sw->dev);

		put_device(&sw_dev->dev);

		return ERR_PTR(ret);

	}



	ret = device_add(&sw->dev);

	ret = device_add(&sw_dev->dev);

	if (ret) {

		dev_err(parent, "failed to register switch (%d)\n", ret);

		put_device(&sw->dev);

		put_device(&sw_dev->dev);

		return ERR_PTR(ret);

	}



	return sw;

	return sw_dev;

}

EXPORT_SYMBOL_GPL(typec_switch_register);



int typec_switch_set(struct typec_switch *sw,

		     enum typec_orientation orientation)

{

	struct typec_switch_dev *sw_dev;



	if (IS_ERR_OR_NULL(sw))

		return 0;



	return sw->set(sw, orientation);

	sw_dev = sw->sw_dev;



	return sw_dev->set(sw_dev, orientation);

}

EXPORT_SYMBOL_GPL(typec_switch_set);



/**

 * typec_switch_unregister - Unregister USB Type-C orientation switch

 * @sw: USB Type-C orientation switch

 * @sw_dev: USB Type-C orientation switch

 *

 * Unregister switch that was registered with typec_switch_register().

 */

void typec_switch_unregister(struct typec_switch *sw)

void typec_switch_unregister(struct typec_switch_dev *sw_dev)

{

	if (!IS_ERR_OR_NULL(sw))

		device_unregister(&sw->dev);

	if (!IS_ERR_OR_NULL(sw_dev))

		device_unregister(&sw_dev->dev);

}

EXPORT_SYMBOL_GPL(typec_switch_unregister);



void typec_switch_set_drvdata(struct typec_switch *sw, void *data)

void typec_switch_set_drvdata(struct typec_switch_dev *sw_dev, void *data)

{

	dev_set_drvdata(&sw->dev, data);

	dev_set_drvdata(&sw_dev->dev, data);

}

EXPORT_SYMBOL_GPL(typec_switch_set_drvdata);



void *typec_switch_get_drvdata(struct typec_switch *sw)

void *typec_switch_get_drvdata(struct typec_switch_dev *sw_dev)

{

	return dev_get_drvdata(&sw->dev);

	return dev_get_drvdata(&sw_dev->dev);

}

EXPORT_SYMBOL_GPL(typec_switch_get_drvdata);



/* ------------------------------------------------------------------------- */



struct typec_mux {

	struct typec_mux_dev *mux_dev;

};



static int mux_fwnode_match(struct device *dev, const void *fwnode)

{

	if (!is_typec_mux(dev))

	if (!is_typec_mux_dev(dev))

		return 0;



	return dev_fwnode(dev) == fwnode;
@@ -249,7 +278,7 @@ static void *typec_mux_match(struct fwnode_handle *fwnode, const char *id, 
	dev = class_find_device(&typec_mux_class, NULL, fwnode,

				mux_fwnode_match);



	return dev ? to_typec_mux(dev) : ERR_PTR(-EPROBE_DEFER);

	return dev ? to_typec_mux_dev(dev) : ERR_PTR(-EPROBE_DEFER);

}



/**
@@ -265,12 +294,23 @@ static void *typec_mux_match(struct fwnode_handle *fwnode, const char *id, 
struct typec_mux *fwnode_typec_mux_get(struct fwnode_handle *fwnode,

				       const struct typec_altmode_desc *desc)

{

	struct typec_mux_dev *mux_dev;

	struct typec_mux *mux;



	mux = fwnode_connection_find_match(fwnode, "mode-switch", (void *)desc,

	mux = kzalloc(sizeof(*mux), GFP_KERNEL);

	if (!mux)

		return ERR_PTR(-ENOMEM);



	mux_dev = fwnode_connection_find_match(fwnode, "mode-switch", (void *)desc,

					       typec_mux_match);

	if (!IS_ERR_OR_NULL(mux))

		WARN_ON(!try_module_get(mux->dev.parent->driver->owner));

	if (IS_ERR_OR_NULL(mux_dev)) {

		kfree(mux);

		return ERR_CAST(mux_dev);

	}



	WARN_ON(!try_module_get(mux_dev->dev.parent->driver->owner));



	mux->mux_dev = mux_dev;



	return mux;

}
@@ -284,25 +324,34 @@ EXPORT_SYMBOL_GPL(fwnode_typec_mux_get); 
 */

void typec_mux_put(struct typec_mux *mux)

{

	if (!IS_ERR_OR_NULL(mux)) {

		module_put(mux->dev.parent->driver->owner);

		put_device(&mux->dev);

	}

	struct typec_mux_dev *mux_dev;



	if (IS_ERR_OR_NULL(mux))

		return;



	mux_dev = mux->mux_dev;

	module_put(mux_dev->dev.parent->driver->owner);

	put_device(&mux_dev->dev);

	kfree(mux);

}

EXPORT_SYMBOL_GPL(typec_mux_put);



int typec_mux_set(struct typec_mux *mux, struct typec_mux_state *state)

{

	struct typec_mux_dev *mux_dev;



	if (IS_ERR_OR_NULL(mux))

		return 0;



	return mux->set(mux, state);

	mux_dev = mux->mux_dev;



	return mux_dev->set(mux_dev, state);

}

EXPORT_SYMBOL_GPL(typec_mux_set);



static void typec_mux_release(struct device *dev)

{

	kfree(to_typec_mux(dev));

	kfree(to_typec_mux_dev(dev));

}



const struct device_type typec_mux_dev_type = {
@@ -320,66 +369,66 @@ const struct device_type typec_mux_dev_type = { 
 * the pins on the connector need to be reconfigured. This function registers

 * multiplexer switches routing the pins on the connector.

 */

struct typec_mux *

struct typec_mux_dev *

typec_mux_register(struct device *parent, const struct typec_mux_desc *desc)

{

	struct typec_mux *mux;

	struct typec_mux_dev *mux_dev;

	int ret;



	if (!desc || !desc->set)

		return ERR_PTR(-EINVAL);



	mux = kzalloc(sizeof(*mux), GFP_KERNEL);

	if (!mux)

	mux_dev = kzalloc(sizeof(*mux_dev), GFP_KERNEL);

	if (!mux_dev)

		return ERR_PTR(-ENOMEM);



	mux->set = desc->set;

	mux_dev->set = desc->set;



	device_initialize(&mux->dev);

	mux->dev.parent = parent;

	mux->dev.fwnode = desc->fwnode;

	mux->dev.class = &typec_mux_class;

	mux->dev.type = &typec_mux_dev_type;

	mux->dev.driver_data = desc->drvdata;

	ret = dev_set_name(&mux->dev, "%s-mux", desc->name ? desc->name : dev_name(parent));

	device_initialize(&mux_dev->dev);

	mux_dev->dev.parent = parent;

	mux_dev->dev.fwnode = desc->fwnode;

	mux_dev->dev.class = &typec_mux_class;

	mux_dev->dev.type = &typec_mux_dev_type;

	mux_dev->dev.driver_data = desc->drvdata;

	ret = dev_set_name(&mux_dev->dev, "%s-mux", desc->name ? desc->name : dev_name(parent));

	if (ret) {

		put_device(&mux->dev);

		put_device(&mux_dev->dev);

		return ERR_PTR(ret);

	}



	ret = device_add(&mux->dev);

	ret = device_add(&mux_dev->dev);

	if (ret) {

		dev_err(parent, "failed to register mux (%d)\n", ret);

		put_device(&mux->dev);

		put_device(&mux_dev->dev);

		return ERR_PTR(ret);

	}



	return mux;

	return mux_dev;

}

EXPORT_SYMBOL_GPL(typec_mux_register);



/**

 * typec_mux_unregister - Unregister Multiplexer Switch

 * @mux: USB Type-C Connector Multiplexer/DeMultiplexer

 * @mux_dev: USB Type-C Connector Multiplexer/DeMultiplexer

 *

 * Unregister mux that was registered with typec_mux_register().

 */

void typec_mux_unregister(struct typec_mux *mux)

void typec_mux_unregister(struct typec_mux_dev *mux_dev)

{

	if (!IS_ERR_OR_NULL(mux))

		device_unregister(&mux->dev);

	if (!IS_ERR_OR_NULL(mux_dev))

		device_unregister(&mux_dev->dev);

}

EXPORT_SYMBOL_GPL(typec_mux_unregister);



void typec_mux_set_drvdata(struct typec_mux *mux, void *data)

void typec_mux_set_drvdata(struct typec_mux_dev *mux_dev, void *data)

{

	dev_set_drvdata(&mux->dev, data);

	dev_set_drvdata(&mux_dev->dev, data);

}

EXPORT_SYMBOL_GPL(typec_mux_set_drvdata);



void *typec_mux_get_drvdata(struct typec_mux *mux)

void *typec_mux_get_drvdata(struct typec_mux_dev *mux_dev)

{

	return dev_get_drvdata(&mux->dev);

	return dev_get_drvdata(&mux_dev->dev);

}

EXPORT_SYMBOL_GPL(typec_mux_get_drvdata);

drivers/usb/typec/mux.h

+6 −6
Original line number Diff line number Diff line
@@ -5,23 +5,23 @@ 


#include <linux/usb/typec_mux.h>



struct typec_switch {

struct typec_switch_dev {

	struct device dev;

	typec_switch_set_fn_t set;

};



struct typec_mux {

struct typec_mux_dev {

	struct device dev;

	typec_mux_set_fn_t set;

};



#define to_typec_switch(_dev_) container_of(_dev_, struct typec_switch, dev)

#define to_typec_mux(_dev_) container_of(_dev_, struct typec_mux, dev)

#define to_typec_switch_dev(_dev_) container_of(_dev_, struct typec_switch_dev, dev)

#define to_typec_mux_dev(_dev_) container_of(_dev_, struct typec_mux_dev, dev)



extern const struct device_type typec_switch_dev_type;

extern const struct device_type typec_mux_dev_type;



#define is_typec_switch(dev) ((dev)->type == &typec_switch_dev_type)

#define is_typec_mux(dev) ((dev)->type == &typec_mux_dev_type)

#define is_typec_switch_dev(dev) ((dev)->type == &typec_switch_dev_type)

#define is_typec_mux_dev(dev) ((dev)->type == &typec_mux_dev_type)



#endif /* __USB_TYPEC_MUX__ */

drivers/usb/typec/mux/intel_pmc_mux.c

+4 −4
Original line number Diff line number Diff line
@@ -121,8 +121,8 @@ struct pmc_usb_port { 
	int num;

	u32 iom_status;

	struct pmc_usb *pmc;

	struct typec_mux *typec_mux;

	struct typec_switch *typec_sw;

	struct typec_mux_dev *typec_mux;

	struct typec_switch_dev *typec_sw;

	struct usb_role_switch *usb_sw;



	enum typec_orientation orientation;
@@ -433,7 +433,7 @@ static int pmc_usb_connect(struct pmc_usb_port *port, enum usb_role role) 
}



static int

pmc_usb_mux_set(struct typec_mux *mux, struct typec_mux_state *state)

pmc_usb_mux_set(struct typec_mux_dev *mux, struct typec_mux_state *state)

{

	struct pmc_usb_port *port = typec_mux_get_drvdata(mux);
@@ -469,7 +469,7 @@ pmc_usb_mux_set(struct typec_mux *mux, struct typec_mux_state *state) 
	return -EOPNOTSUPP;

}



static int pmc_usb_set_orientation(struct typec_switch *sw,

static int pmc_usb_set_orientation(struct typec_switch_dev *sw,

				   enum typec_orientation orientation)

{

	struct pmc_usb_port *port = typec_switch_get_drvdata(sw);

drivers/usb/typec/mux/pi3usb30532.c

+4 −4
Original line number Diff line number Diff line
@@ -23,8 +23,8 @@ 
struct pi3usb30532 {

	struct i2c_client *client;

	struct mutex lock; /* protects the cached conf register */

	struct typec_switch *sw;

	struct typec_mux *mux;

	struct typec_switch_dev *sw;

	struct typec_mux_dev *mux;

	u8 conf;

};
@@ -45,7 +45,7 @@ static int pi3usb30532_set_conf(struct pi3usb30532 *pi, u8 new_conf) 
	return 0;

}



static int pi3usb30532_sw_set(struct typec_switch *sw,

static int pi3usb30532_sw_set(struct typec_switch_dev *sw,

			      enum typec_orientation orientation)

{

	struct pi3usb30532 *pi = typec_switch_get_drvdata(sw);
@@ -74,7 +74,7 @@ static int pi3usb30532_sw_set(struct typec_switch *sw, 
}



static int

pi3usb30532_mux_set(struct typec_mux *mux, struct typec_mux_state *state)

pi3usb30532_mux_set(struct typec_mux_dev *mux, struct typec_mux_state *state)

{

	struct pi3usb30532 *pi = typec_mux_get_drvdata(mux);

	u8 new_conf;