drivers/extcon/extcon-usbc-tusb320.c - third_party/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * drivers/extcon/extcon-tusb320.c - TUSB320 extcon driver
  *
  * Copyright (C) 2020 National Instruments Corporation
  * Author: Michael Auchter <michael.auchter@ni.com>
  */

 #include <linux/bitfield.h>
 #include <linux/extcon-provider.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/regmap.h>
 #include <linux/usb/typec.h>
 #include <linux/usb/typec_altmode.h>
 #include <linux/usb/role.h>
 #include <linux/irq.h>

 #define TUSB320_REG8				0x8
 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE	GENMASK(7, 6)
 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB	0x0
 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A	0x1
 #define TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A	0x2
 #define TUSB320_REG8_CURRENT_MODE_DETECT	GENMASK(5, 4)
 #define TUSB320_REG8_CURRENT_MODE_DETECT_DEF	0x0
 #define TUSB320_REG8_CURRENT_MODE_DETECT_MED	0x1
 #define TUSB320_REG8_CURRENT_MODE_DETECT_ACC	0x2
 #define TUSB320_REG8_CURRENT_MODE_DETECT_HI	0x3
 #define TUSB320_REG8_ACCESSORY_CONNECTED	GENMASK(3, 1)
 #define TUSB320_REG8_ACCESSORY_CONNECTED_NONE	0x0
 #define TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO	0x4
 #define TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG	0x5
 #define TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP	0x6
 #define TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP	0x7
 #define TUSB320_REG8_ACTIVE_CABLE_DETECTION	BIT(0)

 #define TUSB320_REG9				0x9
 #define TUSB320_REG9_ATTACHED_STATE		GENMASK(7, 6)
 #define TUSB320_REG9_CABLE_DIRECTION		BIT(5)
 #define TUSB320_REG9_INTERRUPT_STATUS		BIT(4)

 #define TUSB320_REGA				0xa
 #define TUSB320L_REGA_DISABLE_TERM		BIT(0)
 #define TUSB320_REGA_I2C_SOFT_RESET		BIT(3)
 #define TUSB320_REGA_MODE_SELECT_SHIFT		4
 #define TUSB320_REGA_MODE_SELECT_MASK		0x3

 #define TUSB320L_REGA0_REVISION			0xa0

 enum tusb320_attached_state {
 	TUSB320_ATTACHED_STATE_NONE,
 	TUSB320_ATTACHED_STATE_DFP,
 	TUSB320_ATTACHED_STATE_UFP,
 	TUSB320_ATTACHED_STATE_ACC,
 };

 enum tusb320_mode {
 	TUSB320_MODE_PORT,
 	TUSB320_MODE_UFP,
 	TUSB320_MODE_DFP,
 	TUSB320_MODE_DRP,
 };

 struct tusb320_priv;

 struct tusb320_ops {
 	int (*set_mode)(struct tusb320_priv *priv, enum tusb320_mode mode);
 	int (*get_revision)(struct tusb320_priv *priv, unsigned int *revision);
 };

 struct tusb320_priv {
 	struct device *dev;
 	struct regmap *regmap;
 	struct extcon_dev *edev;
 	struct tusb320_ops *ops;
 	enum tusb320_attached_state state;
 	struct typec_port *port;
 	struct typec_capability	cap;
 	enum typec_port_type port_type;
 	enum typec_pwr_opmode pwr_opmode;
 	struct fwnode_handle *connector_fwnode;
 	struct usb_role_switch *role_sw;
 };

 static const char * const tusb_attached_states[] = {
 	[TUSB320_ATTACHED_STATE_NONE] = "not attached",
 	[TUSB320_ATTACHED_STATE_DFP]  = "downstream facing port",
 	[TUSB320_ATTACHED_STATE_UFP]  = "upstream facing port",
 	[TUSB320_ATTACHED_STATE_ACC]  = "accessory",
 };

 static const unsigned int tusb320_extcon_cable[] = {
 	EXTCON_USB,
 	EXTCON_USB_HOST,
 	EXTCON_NONE,
 };

 static int tusb320_check_signature(struct tusb320_priv *priv)
 {
 	static const char sig[] = { '\0', 'T', 'U', 'S', 'B', '3', '2', '0' };
 	unsigned val;
 	int i, ret;

 	for (i = 0; i < sizeof(sig); i++) {
 		ret = regmap_read(priv->regmap, sizeof(sig) - 1 - i, &val);
 		if (ret < 0)
 			return ret;
 		if (val != sig[i]) {
 			dev_err(priv->dev, "signature mismatch!\n");
 			return -ENODEV;
 		}
 	}

 	return 0;
 }

 static int tusb320_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode)
 {
 	int ret;

 	/* Mode cannot be changed while cable is attached */
 	if (priv->state != TUSB320_ATTACHED_STATE_NONE)
 		return -EBUSY;

 	/* Write mode */
 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
 		TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT,
 		mode << TUSB320_REGA_MODE_SELECT_SHIFT);
 	if (ret) {
 		dev_err(priv->dev, "failed to write mode: %d\n", ret);
 		return ret;
 	}

 	return 0;
 }

 static int tusb320l_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode)
 {
 	int ret;

 	/* Disable CC state machine */
 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
 		TUSB320L_REGA_DISABLE_TERM, 1);
 	if (ret) {
 		dev_err(priv->dev,
 			"failed to disable CC state machine: %d\n", ret);
 		return ret;
 	}

 	/* Write mode */
 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
 		TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT,
 		mode << TUSB320_REGA_MODE_SELECT_SHIFT);
 	if (ret) {
 		dev_err(priv->dev, "failed to write mode: %d\n", ret);
 		goto err;
 	}

 	msleep(5);
 err:
 	/* Re-enable CC state machine */
 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
 		TUSB320L_REGA_DISABLE_TERM, 0);
 	if (ret)
 		dev_err(priv->dev,
 			"failed to re-enable CC state machine: %d\n", ret);

 	return ret;
 }

 static int tusb320_reset(struct tusb320_priv *priv)
 {
 	int ret;

 	/* Set mode to default (follow PORT pin) */
 	ret = priv->ops->set_mode(priv, TUSB320_MODE_PORT);
 	if (ret && ret != -EBUSY) {
 		dev_err(priv->dev,
 			"failed to set mode to PORT: %d\n", ret);
 		return ret;
 	}

 	/* Perform soft reset */
 	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
 			TUSB320_REGA_I2C_SOFT_RESET, 1);
 	if (ret) {
 		dev_err(priv->dev,
 			"failed to write soft reset bit: %d\n", ret);
 		return ret;
 	}

 	/* Wait for chip to go through reset */
 	msleep(95);

 	return 0;
 }

 static int tusb320l_get_revision(struct tusb320_priv *priv, unsigned int *revision)
 {
 	return regmap_read(priv->regmap, TUSB320L_REGA0_REVISION, revision);
 }

 static struct tusb320_ops tusb320_ops = {
 	.set_mode = tusb320_set_mode,
 };

 static struct tusb320_ops tusb320l_ops = {
 	.set_mode = tusb320l_set_mode,
 	.get_revision = tusb320l_get_revision,
 };

 static int tusb320_set_adv_pwr_mode(struct tusb320_priv *priv)
 {
 	u8 mode;

 	if (priv->pwr_opmode == TYPEC_PWR_MODE_USB)
 		mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB;
 	else if (priv->pwr_opmode == TYPEC_PWR_MODE_1_5A)
 		mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A;
 	else if (priv->pwr_opmode == TYPEC_PWR_MODE_3_0A)
 		mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A;
 	else	/* No other mode is supported. */
 		return -EINVAL;

 	return regmap_write_bits(priv->regmap, TUSB320_REG8,
 				 TUSB320_REG8_CURRENT_MODE_ADVERTISE,
 				 FIELD_PREP(TUSB320_REG8_CURRENT_MODE_ADVERTISE,
 					    mode));
 }

 static int tusb320_port_type_set(struct typec_port *port,
 				 enum typec_port_type type)
 {
 	struct tusb320_priv *priv = typec_get_drvdata(port);

 	if (type == TYPEC_PORT_SRC)
 		return priv->ops->set_mode(priv, TUSB320_MODE_DFP);
 	else if (type == TYPEC_PORT_SNK)
 		return priv->ops->set_mode(priv, TUSB320_MODE_UFP);
 	else if (type == TYPEC_PORT_DRP)
 		return priv->ops->set_mode(priv, TUSB320_MODE_DRP);
 	else
 		return priv->ops->set_mode(priv, TUSB320_MODE_PORT);
 }

 static const struct typec_operations tusb320_typec_ops = {
 	.port_type_set	= tusb320_port_type_set,
 };

 static void tusb320_extcon_irq_handler(struct tusb320_priv *priv, u8 reg)
 {
 	int state, polarity;

 	state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg);
 	polarity = !!(reg & TUSB320_REG9_CABLE_DIRECTION);

 	dev_dbg(priv->dev, "attached state: %s, polarity: %d\n",
 		tusb_attached_states[state], polarity);

 	extcon_set_state(priv->edev, EXTCON_USB,
 			 state == TUSB320_ATTACHED_STATE_UFP);
 	extcon_set_state(priv->edev, EXTCON_USB_HOST,
 			 state == TUSB320_ATTACHED_STATE_DFP);
 	extcon_set_property(priv->edev, EXTCON_USB,
 			    EXTCON_PROP_USB_TYPEC_POLARITY,
 			    (union extcon_property_value)polarity);
 	extcon_set_property(priv->edev, EXTCON_USB_HOST,
 			    EXTCON_PROP_USB_TYPEC_POLARITY,
 			    (union extcon_property_value)polarity);
 	extcon_sync(priv->edev, EXTCON_USB);
 	extcon_sync(priv->edev, EXTCON_USB_HOST);

 	priv->state = state;
 }

 static void tusb320_typec_irq_handler(struct tusb320_priv *priv, u8 reg9)
 {
 	struct typec_port *port = priv->port;
 	struct device *dev = priv->dev;
 	int typec_mode;
 	enum usb_role usb_role;
 	enum typec_role pwr_role;
 	enum typec_data_role data_role;
 	u8 state, mode, accessory;
 	int ret, reg8;
 	bool ori;

 	ret = regmap_read(priv->regmap, TUSB320_REG8, &reg8);
 	if (ret) {
 		dev_err(dev, "error during reg8 i2c read, ret=%d!\n", ret);
 		return;
 	}

 	ori = reg9 & TUSB320_REG9_CABLE_DIRECTION;
 	typec_set_orientation(port, ori ? TYPEC_ORIENTATION_REVERSE :
 					  TYPEC_ORIENTATION_NORMAL);

 	state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg9);
 	accessory = FIELD_GET(TUSB320_REG8_ACCESSORY_CONNECTED, reg8);

 	switch (state) {
 	case TUSB320_ATTACHED_STATE_DFP:
 		typec_mode = TYPEC_MODE_USB2;
 		usb_role = USB_ROLE_HOST;
 		pwr_role = TYPEC_SOURCE;
 		data_role = TYPEC_HOST;
 		break;
 	case TUSB320_ATTACHED_STATE_UFP:
 		typec_mode = TYPEC_MODE_USB2;
 		usb_role = USB_ROLE_DEVICE;
 		pwr_role = TYPEC_SINK;
 		data_role = TYPEC_DEVICE;
 		break;
 	case TUSB320_ATTACHED_STATE_ACC:
 		/*
 		 * Accessory detected. For debug accessories, just make some
 		 * qualified guesses as to the role for lack of a better option.
 		 */
 		if (accessory == TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO ||
 		    accessory == TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG) {
 			typec_mode = TYPEC_MODE_AUDIO;
 			usb_role = USB_ROLE_NONE;
 			pwr_role = TYPEC_SINK;
 			data_role = TYPEC_DEVICE;
 			break;
 		} else if (accessory ==
 			   TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP) {
 			typec_mode = TYPEC_MODE_DEBUG;
 			pwr_role = TYPEC_SOURCE;
 			usb_role = USB_ROLE_HOST;
 			data_role = TYPEC_HOST;
 			break;
 		} else if (accessory ==
 			   TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP) {
 			typec_mode = TYPEC_MODE_DEBUG;
 			pwr_role = TYPEC_SINK;
 			usb_role = USB_ROLE_DEVICE;
 			data_role = TYPEC_DEVICE;
 			break;
 		}

 		dev_warn(priv->dev, "unexpected ACCESSORY_CONNECTED state %d\n",
 			 accessory);

 		fallthrough;
 	default:
 		typec_mode = TYPEC_MODE_USB2;
 		usb_role = USB_ROLE_NONE;
 		pwr_role = TYPEC_SINK;
 		data_role = TYPEC_DEVICE;
 		break;
 	}

 	typec_set_vconn_role(port, pwr_role);
 	typec_set_pwr_role(port, pwr_role);
 	typec_set_data_role(port, data_role);
 	typec_set_mode(port, typec_mode);
 	usb_role_switch_set_role(priv->role_sw, usb_role);

 	mode = FIELD_GET(TUSB320_REG8_CURRENT_MODE_DETECT, reg8);
 	if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_DEF)
 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB);
 	else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_MED)
 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_1_5A);
 	else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_HI)
 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_3_0A);
 	else	/* Charge through accessory */
 		typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB);
 }

 static irqreturn_t tusb320_state_update_handler(struct tusb320_priv *priv,
 						bool force_update)
 {
 	unsigned int reg;

 	if (regmap_read(priv->regmap, TUSB320_REG9, &reg)) {
 		dev_err(priv->dev, "error during i2c read!\n");
 		return IRQ_NONE;
 	}

 	if (!force_update && !(reg & TUSB320_REG9_INTERRUPT_STATUS))
 		return IRQ_NONE;

 	tusb320_extcon_irq_handler(priv, reg);

 	/*
 	 * Type-C support is optional. Only call the Type-C handler if a
 	 * port had been registered previously.
 	 */
 	if (priv->port)
 		tusb320_typec_irq_handler(priv, reg);

 	regmap_write(priv->regmap, TUSB320_REG9, reg);

 	return IRQ_HANDLED;
 }

 static irqreturn_t tusb320_irq_handler(int irq, void *dev_id)
 {
 	struct tusb320_priv *priv = dev_id;

 	return tusb320_state_update_handler(priv, false);
 }

 static const struct regmap_config tusb320_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
 };

 static int tusb320_extcon_probe(struct tusb320_priv *priv)
 {
 	int ret;

 	priv->edev = devm_extcon_dev_allocate(priv->dev, tusb320_extcon_cable);
 	if (IS_ERR(priv->edev)) {
 		dev_err(priv->dev, "failed to allocate extcon device\n");
 		return PTR_ERR(priv->edev);
 	}

 	ret = devm_extcon_dev_register(priv->dev, priv->edev);
 	if (ret < 0) {
 		dev_err(priv->dev, "failed to register extcon device\n");
 		return ret;
 	}

 	extcon_set_property_capability(priv->edev, EXTCON_USB,
 				       EXTCON_PROP_USB_TYPEC_POLARITY);
 	extcon_set_property_capability(priv->edev, EXTCON_USB_HOST,
 				       EXTCON_PROP_USB_TYPEC_POLARITY);

 	return 0;
 }

 static int tusb320_typec_probe(struct i2c_client *client,
 			       struct tusb320_priv *priv)
 {
 	struct fwnode_handle *connector;
 	const char *cap_str;
 	int ret;

 	/* The Type-C connector is optional, for backward compatibility. */
 	connector = device_get_named_child_node(&client->dev, "connector");
 	if (!connector)
 		return 0;

 	/* Type-C connector found. */
 	ret = typec_get_fw_cap(&priv->cap, connector);
 	if (ret)
 		goto err_put;

 	priv->port_type = priv->cap.type;

 	/* This goes into register 0x8 field CURRENT_MODE_ADVERTISE */
 	ret = fwnode_property_read_string(connector, "typec-power-opmode", &cap_str);
 	if (ret)
 		goto err_put;

 	ret = typec_find_pwr_opmode(cap_str);
 	if (ret < 0)
 		goto err_put;

 	priv->pwr_opmode = ret;

 	/* Initialize the hardware with the devicetree settings. */
 	ret = tusb320_set_adv_pwr_mode(priv);
 	if (ret)
 		goto err_put;

 	priv->cap.revision		= USB_TYPEC_REV_1_1;
 	priv->cap.accessory[0]		= TYPEC_ACCESSORY_AUDIO;
 	priv->cap.accessory[1]		= TYPEC_ACCESSORY_DEBUG;
 	priv->cap.orientation_aware	= true;
 	priv->cap.driver_data		= priv;
 	priv->cap.ops			= &tusb320_typec_ops;
 	priv->cap.fwnode		= connector;

 	priv->port = typec_register_port(&client->dev, &priv->cap);
 	if (IS_ERR(priv->port)) {
 		ret = PTR_ERR(priv->port);
 		goto err_put;
 	}

 	/* Find any optional USB role switch that needs reporting to */
 	priv->role_sw = fwnode_usb_role_switch_get(connector);
 	if (IS_ERR(priv->role_sw)) {
 		ret = PTR_ERR(priv->role_sw);
 		goto err_unreg;
 	}

 	priv->connector_fwnode = connector;

 	return 0;

 err_unreg:
 	typec_unregister_port(priv->port);

 err_put:
 	fwnode_handle_put(connector);

 	return ret;
 }

 static void tusb320_typec_remove(struct tusb320_priv *priv)
 {
 	usb_role_switch_put(priv->role_sw);
 	typec_unregister_port(priv->port);
 	fwnode_handle_put(priv->connector_fwnode);
 }

 static int tusb320_probe(struct i2c_client *client)
 {
 	struct tusb320_priv *priv;
 	const void *match_data;
 	unsigned int revision;
 	int ret;
 	u32 irq_trigger_type = IRQF_TRIGGER_FALLING;
 	struct irq_data *irq_d;

 	priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;

 	priv->dev = &client->dev;
 	i2c_set_clientdata(client, priv);

 	priv->regmap = devm_regmap_init_i2c(client, &tusb320_regmap_config);
 	if (IS_ERR(priv->regmap))
 		return PTR_ERR(priv->regmap);

 	ret = tusb320_check_signature(priv);
 	if (ret)
 		return ret;

 	match_data = device_get_match_data(&client->dev);
 	if (!match_data)
 		return -EINVAL;

 	priv->ops = (struct tusb320_ops*)match_data;

 	if (priv->ops->get_revision) {
 		ret = priv->ops->get_revision(priv, &revision);
 		if (ret)
 			dev_warn(priv->dev,
 				"failed to read revision register: %d\n", ret);
 		else
 			dev_info(priv->dev, "chip revision %d\n", revision);
 	}

 	ret = tusb320_extcon_probe(priv);
 	if (ret)
 		return ret;

 	ret = tusb320_typec_probe(client, priv);
 	if (ret)
 		return ret;

 	/* update initial state */
 	tusb320_state_update_handler(priv, true);

 	/* Reset chip to its default state */
 	ret = tusb320_reset(priv);
 	if (ret)
 		dev_warn(priv->dev, "failed to reset chip: %d\n", ret);
 	else
 		/*
 		 * State and polarity might change after a reset, so update
 		 * them again and make sure the interrupt status bit is cleared.
 		 */
 		tusb320_state_update_handler(priv, true);

 	irq_d = irq_get_irq_data(client->irq);
 	if (irq_d)
 		irq_trigger_type = irqd_get_trigger_type(irq_d);

 	ret = devm_request_threaded_irq(priv->dev, client->irq, NULL,
 					tusb320_irq_handler,
 					IRQF_ONESHOT | irq_trigger_type,
 					client->name, priv);
 	if (ret)
 		tusb320_typec_remove(priv);

 	return ret;
 }

 static void tusb320_remove(struct i2c_client *client)
 {
 	struct tusb320_priv *priv = i2c_get_clientdata(client);

 	tusb320_typec_remove(priv);
 }

 static const struct of_device_id tusb320_extcon_dt_match[] = {
 	{ .compatible = "ti,tusb320", .data = &tusb320_ops, },
 	{ .compatible = "ti,tusb320l", .data = &tusb320l_ops, },
 	{ }
 };
 MODULE_DEVICE_TABLE(of, tusb320_extcon_dt_match);

 static struct i2c_driver tusb320_extcon_driver = {
 	.probe		= tusb320_probe,
 	.remove		= tusb320_remove,
 	.driver		= {
 		.name	= "extcon-tusb320",
 		.of_match_table = tusb320_extcon_dt_match,
 	},
 };

 static int __init tusb320_init(void)
 {
 	return i2c_add_driver(&tusb320_extcon_driver);
 }
 subsys_initcall(tusb320_init);

 static void __exit tusb320_exit(void)
 {
 	i2c_del_driver(&tusb320_extcon_driver);
 }
 module_exit(tusb320_exit);

 MODULE_AUTHOR("Michael Auchter <michael.auchter@ni.com>");
 MODULE_DESCRIPTION("TI TUSB320 extcon driver");
 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* drivers/extcon/extcon-tusb320.c - TUSB320 extcon driver
	*
	* Copyright (C) 2020 National Instruments Corporation
	* Author: Michael Auchter <michael.auchter@ni.com>
	*/

	#include <linux/bitfield.h>
	#include <linux/extcon-provider.h>
	#include <linux/i2c.h>
	#include <linux/init.h>
	#include <linux/interrupt.h>
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/regmap.h>
	#include <linux/usb/typec.h>
	#include <linux/usb/typec_altmode.h>
	#include <linux/usb/role.h>
	#include <linux/irq.h>

	#define TUSB320_REG8 0x8
	#define TUSB320_REG8_CURRENT_MODE_ADVERTISE GENMASK(7, 6)
	#define TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB 0x0
	#define TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A 0x1
	#define TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A 0x2
	#define TUSB320_REG8_CURRENT_MODE_DETECT GENMASK(5, 4)
	#define TUSB320_REG8_CURRENT_MODE_DETECT_DEF 0x0
	#define TUSB320_REG8_CURRENT_MODE_DETECT_MED 0x1
	#define TUSB320_REG8_CURRENT_MODE_DETECT_ACC 0x2
	#define TUSB320_REG8_CURRENT_MODE_DETECT_HI 0x3
	#define TUSB320_REG8_ACCESSORY_CONNECTED GENMASK(3, 1)
	#define TUSB320_REG8_ACCESSORY_CONNECTED_NONE 0x0
	#define TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO 0x4
	#define TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG 0x5
	#define TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP 0x6
	#define TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP 0x7
	#define TUSB320_REG8_ACTIVE_CABLE_DETECTION BIT(0)

	#define TUSB320_REG9 0x9
	#define TUSB320_REG9_ATTACHED_STATE GENMASK(7, 6)
	#define TUSB320_REG9_CABLE_DIRECTION BIT(5)
	#define TUSB320_REG9_INTERRUPT_STATUS BIT(4)

	#define TUSB320_REGA 0xa
	#define TUSB320L_REGA_DISABLE_TERM BIT(0)
	#define TUSB320_REGA_I2C_SOFT_RESET BIT(3)
	#define TUSB320_REGA_MODE_SELECT_SHIFT 4
	#define TUSB320_REGA_MODE_SELECT_MASK 0x3

	#define TUSB320L_REGA0_REVISION 0xa0

	enum tusb320_attached_state {
	TUSB320_ATTACHED_STATE_NONE,
	TUSB320_ATTACHED_STATE_DFP,
	TUSB320_ATTACHED_STATE_UFP,
	TUSB320_ATTACHED_STATE_ACC,
	};

	enum tusb320_mode {
	TUSB320_MODE_PORT,
	TUSB320_MODE_UFP,
	TUSB320_MODE_DFP,
	TUSB320_MODE_DRP,
	};

	struct tusb320_priv;

	struct tusb320_ops {
	int (set_mode)(struct tusb320_priv priv, enum tusb320_mode mode);
	int (get_revision)(struct tusb320_priv priv, unsigned int *revision);
	};

	struct tusb320_priv {
	struct device *dev;
	struct regmap *regmap;
	struct extcon_dev *edev;
	struct tusb320_ops *ops;
	enum tusb320_attached_state state;
	struct typec_port *port;
	struct typec_capability cap;
	enum typec_port_type port_type;
	enum typec_pwr_opmode pwr_opmode;
	struct fwnode_handle *connector_fwnode;
	struct usb_role_switch *role_sw;
	};

	static const char * const tusb_attached_states[] = {
	[TUSB320_ATTACHED_STATE_NONE] = "not attached",
	[TUSB320_ATTACHED_STATE_DFP] = "downstream facing port",
	[TUSB320_ATTACHED_STATE_UFP] = "upstream facing port",
	[TUSB320_ATTACHED_STATE_ACC] = "accessory",
	};

	static const unsigned int tusb320_extcon_cable[] = {
	EXTCON_USB,
	EXTCON_USB_HOST,
	EXTCON_NONE,
	};

	static int tusb320_check_signature(struct tusb320_priv *priv)
	{
	static const char sig[] = { '\0', 'T', 'U', 'S', 'B', '3', '2', '0' };
	unsigned val;
	int i, ret;

	for (i = 0; i < sizeof(sig); i++) {
	ret = regmap_read(priv->regmap, sizeof(sig) - 1 - i, &val);
	if (ret < 0)
	return ret;
	if (val != sig[i]) {
	dev_err(priv->dev, "signature mismatch!\n");
	return -ENODEV;
	}
	}

	return 0;
	}

	static int tusb320_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode)
	{
	int ret;

	/* Mode cannot be changed while cable is attached */
	if (priv->state != TUSB320_ATTACHED_STATE_NONE)
	return -EBUSY;

	/* Write mode */
	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
	TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT,
	mode << TUSB320_REGA_MODE_SELECT_SHIFT);
	if (ret) {
	dev_err(priv->dev, "failed to write mode: %d\n", ret);
	return ret;
	}

	return 0;
	}

	static int tusb320l_set_mode(struct tusb320_priv *priv, enum tusb320_mode mode)
	{
	int ret;

	/* Disable CC state machine */
	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
	TUSB320L_REGA_DISABLE_TERM, 1);
	if (ret) {
	dev_err(priv->dev,
	"failed to disable CC state machine: %d\n", ret);
	return ret;
	}

	/* Write mode */
	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
	TUSB320_REGA_MODE_SELECT_MASK << TUSB320_REGA_MODE_SELECT_SHIFT,
	mode << TUSB320_REGA_MODE_SELECT_SHIFT);
	if (ret) {
	dev_err(priv->dev, "failed to write mode: %d\n", ret);
	goto err;
	}

	msleep(5);
	err:
	/* Re-enable CC state machine */
	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
	TUSB320L_REGA_DISABLE_TERM, 0);
	if (ret)
	dev_err(priv->dev,
	"failed to re-enable CC state machine: %d\n", ret);

	return ret;
	}

	static int tusb320_reset(struct tusb320_priv *priv)
	{
	int ret;

	/* Set mode to default (follow PORT pin) */
	ret = priv->ops->set_mode(priv, TUSB320_MODE_PORT);
	if (ret && ret != -EBUSY) {
	dev_err(priv->dev,
	"failed to set mode to PORT: %d\n", ret);
	return ret;
	}

	/* Perform soft reset */
	ret = regmap_write_bits(priv->regmap, TUSB320_REGA,
	TUSB320_REGA_I2C_SOFT_RESET, 1);
	if (ret) {
	dev_err(priv->dev,
	"failed to write soft reset bit: %d\n", ret);
	return ret;
	}

	/* Wait for chip to go through reset */
	msleep(95);

	return 0;
	}

	static int tusb320l_get_revision(struct tusb320_priv priv, unsigned int revision)
	{
	return regmap_read(priv->regmap, TUSB320L_REGA0_REVISION, revision);
	}

	static struct tusb320_ops tusb320_ops = {
	.set_mode = tusb320_set_mode,
	};

	static struct tusb320_ops tusb320l_ops = {
	.set_mode = tusb320l_set_mode,
	.get_revision = tusb320l_get_revision,
	};

	static int tusb320_set_adv_pwr_mode(struct tusb320_priv *priv)
	{
	u8 mode;

	if (priv->pwr_opmode == TYPEC_PWR_MODE_USB)
	mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_USB;
	else if (priv->pwr_opmode == TYPEC_PWR_MODE_1_5A)
	mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_15A;
	else if (priv->pwr_opmode == TYPEC_PWR_MODE_3_0A)
	mode = TUSB320_REG8_CURRENT_MODE_ADVERTISE_30A;
	else /* No other mode is supported. */
	return -EINVAL;

	return regmap_write_bits(priv->regmap, TUSB320_REG8,
	TUSB320_REG8_CURRENT_MODE_ADVERTISE,
	FIELD_PREP(TUSB320_REG8_CURRENT_MODE_ADVERTISE,
	mode));
	}

	static int tusb320_port_type_set(struct typec_port *port,
	enum typec_port_type type)
	{
	struct tusb320_priv *priv = typec_get_drvdata(port);

	if (type == TYPEC_PORT_SRC)
	return priv->ops->set_mode(priv, TUSB320_MODE_DFP);
	else if (type == TYPEC_PORT_SNK)
	return priv->ops->set_mode(priv, TUSB320_MODE_UFP);
	else if (type == TYPEC_PORT_DRP)
	return priv->ops->set_mode(priv, TUSB320_MODE_DRP);
	else
	return priv->ops->set_mode(priv, TUSB320_MODE_PORT);
	}

	static const struct typec_operations tusb320_typec_ops = {
	.port_type_set = tusb320_port_type_set,
	};

	static void tusb320_extcon_irq_handler(struct tusb320_priv *priv, u8 reg)
	{
	int state, polarity;

	state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg);
	polarity = !!(reg & TUSB320_REG9_CABLE_DIRECTION);

	dev_dbg(priv->dev, "attached state: %s, polarity: %d\n",
	tusb_attached_states[state], polarity);

	extcon_set_state(priv->edev, EXTCON_USB,
	state == TUSB320_ATTACHED_STATE_UFP);
	extcon_set_state(priv->edev, EXTCON_USB_HOST,
	state == TUSB320_ATTACHED_STATE_DFP);
	extcon_set_property(priv->edev, EXTCON_USB,
	EXTCON_PROP_USB_TYPEC_POLARITY,
	(union extcon_property_value)polarity);
	extcon_set_property(priv->edev, EXTCON_USB_HOST,
	EXTCON_PROP_USB_TYPEC_POLARITY,
	(union extcon_property_value)polarity);
	extcon_sync(priv->edev, EXTCON_USB);
	extcon_sync(priv->edev, EXTCON_USB_HOST);

	priv->state = state;
	}

	static void tusb320_typec_irq_handler(struct tusb320_priv *priv, u8 reg9)
	{
	struct typec_port *port = priv->port;
	struct device *dev = priv->dev;
	int typec_mode;
	enum usb_role usb_role;
	enum typec_role pwr_role;
	enum typec_data_role data_role;
	u8 state, mode, accessory;
	int ret, reg8;
	bool ori;

	ret = regmap_read(priv->regmap, TUSB320_REG8, &reg8);
	if (ret) {
	dev_err(dev, "error during reg8 i2c read, ret=%d!\n", ret);
	return;
	}

	ori = reg9 & TUSB320_REG9_CABLE_DIRECTION;
	typec_set_orientation(port, ori ? TYPEC_ORIENTATION_REVERSE :
	TYPEC_ORIENTATION_NORMAL);

	state = FIELD_GET(TUSB320_REG9_ATTACHED_STATE, reg9);
	accessory = FIELD_GET(TUSB320_REG8_ACCESSORY_CONNECTED, reg8);

	switch (state) {
	case TUSB320_ATTACHED_STATE_DFP:
	typec_mode = TYPEC_MODE_USB2;
	usb_role = USB_ROLE_HOST;
	pwr_role = TYPEC_SOURCE;
	data_role = TYPEC_HOST;
	break;
	case TUSB320_ATTACHED_STATE_UFP:
	typec_mode = TYPEC_MODE_USB2;
	usb_role = USB_ROLE_DEVICE;
	pwr_role = TYPEC_SINK;
	data_role = TYPEC_DEVICE;
	break;
	case TUSB320_ATTACHED_STATE_ACC:
	/*
	* Accessory detected. For debug accessories, just make some
	* qualified guesses as to the role for lack of a better option.
	*/
	if (accessory == TUSB320_REG8_ACCESSORY_CONNECTED_AUDIO \|\|
	accessory == TUSB320_REG8_ACCESSORY_CONNECTED_ACHRG) {
	typec_mode = TYPEC_MODE_AUDIO;
	usb_role = USB_ROLE_NONE;
	pwr_role = TYPEC_SINK;
	data_role = TYPEC_DEVICE;
	break;
	} else if (accessory ==
	TUSB320_REG8_ACCESSORY_CONNECTED_DBGDFP) {
	typec_mode = TYPEC_MODE_DEBUG;
	pwr_role = TYPEC_SOURCE;
	usb_role = USB_ROLE_HOST;
	data_role = TYPEC_HOST;
	break;
	} else if (accessory ==
	TUSB320_REG8_ACCESSORY_CONNECTED_DBGUFP) {
	typec_mode = TYPEC_MODE_DEBUG;
	pwr_role = TYPEC_SINK;
	usb_role = USB_ROLE_DEVICE;
	data_role = TYPEC_DEVICE;
	break;
	}

	dev_warn(priv->dev, "unexpected ACCESSORY_CONNECTED state %d\n",
	accessory);

	fallthrough;
	default:
	typec_mode = TYPEC_MODE_USB2;
	usb_role = USB_ROLE_NONE;
	pwr_role = TYPEC_SINK;
	data_role = TYPEC_DEVICE;
	break;
	}

	typec_set_vconn_role(port, pwr_role);
	typec_set_pwr_role(port, pwr_role);
	typec_set_data_role(port, data_role);
	typec_set_mode(port, typec_mode);
	usb_role_switch_set_role(priv->role_sw, usb_role);

	mode = FIELD_GET(TUSB320_REG8_CURRENT_MODE_DETECT, reg8);
	if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_DEF)
	typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB);
	else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_MED)
	typec_set_pwr_opmode(port, TYPEC_PWR_MODE_1_5A);
	else if (mode == TUSB320_REG8_CURRENT_MODE_DETECT_HI)
	typec_set_pwr_opmode(port, TYPEC_PWR_MODE_3_0A);
	else /* Charge through accessory */
	typec_set_pwr_opmode(port, TYPEC_PWR_MODE_USB);
	}

	static irqreturn_t tusb320_state_update_handler(struct tusb320_priv *priv,
	bool force_update)
	{
	unsigned int reg;

	if (regmap_read(priv->regmap, TUSB320_REG9, &reg)) {
	dev_err(priv->dev, "error during i2c read!\n");
	return IRQ_NONE;
	}

	if (!force_update && !(reg & TUSB320_REG9_INTERRUPT_STATUS))
	return IRQ_NONE;

	tusb320_extcon_irq_handler(priv, reg);

	/*
	* Type-C support is optional. Only call the Type-C handler if a
	* port had been registered previously.
	*/
	if (priv->port)
	tusb320_typec_irq_handler(priv, reg);

	regmap_write(priv->regmap, TUSB320_REG9, reg);

	return IRQ_HANDLED;
	}

	static irqreturn_t tusb320_irq_handler(int irq, void *dev_id)
	{
	struct tusb320_priv *priv = dev_id;

	return tusb320_state_update_handler(priv, false);
	}

	static const struct regmap_config tusb320_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	};

	static int tusb320_extcon_probe(struct tusb320_priv *priv)
	{
	int ret;

	priv->edev = devm_extcon_dev_allocate(priv->dev, tusb320_extcon_cable);
	if (IS_ERR(priv->edev)) {
	dev_err(priv->dev, "failed to allocate extcon device\n");
	return PTR_ERR(priv->edev);
	}

	ret = devm_extcon_dev_register(priv->dev, priv->edev);
	if (ret < 0) {
	dev_err(priv->dev, "failed to register extcon device\n");
	return ret;
	}

	extcon_set_property_capability(priv->edev, EXTCON_USB,
	EXTCON_PROP_USB_TYPEC_POLARITY);
	extcon_set_property_capability(priv->edev, EXTCON_USB_HOST,
	EXTCON_PROP_USB_TYPEC_POLARITY);

	return 0;
	}

	static int tusb320_typec_probe(struct i2c_client *client,
	struct tusb320_priv *priv)
	{
	struct fwnode_handle *connector;
	const char *cap_str;
	int ret;

	/* The Type-C connector is optional, for backward compatibility. */
	connector = device_get_named_child_node(&client->dev, "connector");
	if (!connector)
	return 0;

	/* Type-C connector found. */
	ret = typec_get_fw_cap(&priv->cap, connector);
	if (ret)
	goto err_put;

	priv->port_type = priv->cap.type;

	/* This goes into register 0x8 field CURRENT_MODE_ADVERTISE */
	ret = fwnode_property_read_string(connector, "typec-power-opmode", &cap_str);
	if (ret)
	goto err_put;

	ret = typec_find_pwr_opmode(cap_str);
	if (ret < 0)
	goto err_put;

	priv->pwr_opmode = ret;

	/* Initialize the hardware with the devicetree settings. */
	ret = tusb320_set_adv_pwr_mode(priv);
	if (ret)
	goto err_put;

	priv->cap.revision = USB_TYPEC_REV_1_1;
	priv->cap.accessory[0] = TYPEC_ACCESSORY_AUDIO;
	priv->cap.accessory[1] = TYPEC_ACCESSORY_DEBUG;
	priv->cap.orientation_aware = true;
	priv->cap.driver_data = priv;
	priv->cap.ops = &tusb320_typec_ops;
	priv->cap.fwnode = connector;

	priv->port = typec_register_port(&client->dev, &priv->cap);
	if (IS_ERR(priv->port)) {
	ret = PTR_ERR(priv->port);
	goto err_put;
	}

	/* Find any optional USB role switch that needs reporting to */
	priv->role_sw = fwnode_usb_role_switch_get(connector);
	if (IS_ERR(priv->role_sw)) {
	ret = PTR_ERR(priv->role_sw);
	goto err_unreg;
	}

	priv->connector_fwnode = connector;

	return 0;

	err_unreg:
	typec_unregister_port(priv->port);

	err_put:
	fwnode_handle_put(connector);

	return ret;
	}

	static void tusb320_typec_remove(struct tusb320_priv *priv)
	{
	usb_role_switch_put(priv->role_sw);
	typec_unregister_port(priv->port);
	fwnode_handle_put(priv->connector_fwnode);
	}

	static int tusb320_probe(struct i2c_client *client)
	{
	struct tusb320_priv *priv;
	const void *match_data;
	unsigned int revision;
	int ret;
	u32 irq_trigger_type = IRQF_TRIGGER_FALLING;
	struct irq_data *irq_d;

	priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
	return -ENOMEM;

	priv->dev = &client->dev;
	i2c_set_clientdata(client, priv);

	priv->regmap = devm_regmap_init_i2c(client, &tusb320_regmap_config);
	if (IS_ERR(priv->regmap))
	return PTR_ERR(priv->regmap);

	ret = tusb320_check_signature(priv);
	if (ret)
	return ret;

	match_data = device_get_match_data(&client->dev);
	if (!match_data)
	return -EINVAL;

	priv->ops = (struct tusb320_ops*)match_data;

	if (priv->ops->get_revision) {
	ret = priv->ops->get_revision(priv, &revision);
	if (ret)
	dev_warn(priv->dev,
	"failed to read revision register: %d\n", ret);
	else
	dev_info(priv->dev, "chip revision %d\n", revision);
	}

	ret = tusb320_extcon_probe(priv);
	if (ret)
	return ret;

	ret = tusb320_typec_probe(client, priv);
	if (ret)
	return ret;

	/* update initial state */
	tusb320_state_update_handler(priv, true);

	/* Reset chip to its default state */
	ret = tusb320_reset(priv);
	if (ret)
	dev_warn(priv->dev, "failed to reset chip: %d\n", ret);
	else
	/*
	* State and polarity might change after a reset, so update
	* them again and make sure the interrupt status bit is cleared.
	*/
	tusb320_state_update_handler(priv, true);

	irq_d = irq_get_irq_data(client->irq);
	if (irq_d)
	irq_trigger_type = irqd_get_trigger_type(irq_d);

	ret = devm_request_threaded_irq(priv->dev, client->irq, NULL,
	tusb320_irq_handler,
	IRQF_ONESHOT \| irq_trigger_type,
	client->name, priv);
	if (ret)
	tusb320_typec_remove(priv);

	return ret;
	}

	static void tusb320_remove(struct i2c_client *client)
	{
	struct tusb320_priv *priv = i2c_get_clientdata(client);

	tusb320_typec_remove(priv);
	}

	static const struct of_device_id tusb320_extcon_dt_match[] = {
	{ .compatible = "ti,tusb320", .data = &tusb320_ops, },
	{ .compatible = "ti,tusb320l", .data = &tusb320l_ops, },
	{ }
	};
	MODULE_DEVICE_TABLE(of, tusb320_extcon_dt_match);

	static struct i2c_driver tusb320_extcon_driver = {
	.probe = tusb320_probe,
	.remove = tusb320_remove,
	.driver = {
	.name = "extcon-tusb320",
	.of_match_table = tusb320_extcon_dt_match,
	},
	};

	static int __init tusb320_init(void)
	{
	return i2c_add_driver(&tusb320_extcon_driver);
	}
	subsys_initcall(tusb320_init);

	static void __exit tusb320_exit(void)
	{
	i2c_del_driver(&tusb320_extcon_driver);
	}
	module_exit(tusb320_exit);

	MODULE_AUTHOR("Michael Auchter <michael.auchter@ni.com>");
	MODULE_DESCRIPTION("TI TUSB320 extcon driver");
	MODULE_LICENSE("GPL v2");