drivers/extcon/extcon-ptn5150.c - linux-imx - Git at Google

 /*
  * extcon-ptn5150.c - NXP CC logic for USB Type-C applications
  *
  * Copyright 2017 NXP
  * Author: Peter Chen <peter.chen@nxp.com>
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2  of
  * the License as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */

 #include <linux/err.h>
 #include <linux/extcon.h>
 #include <linux/gpio/consumer.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/regmap.h>
 #include <linux/usb/typec.h>

 /* PTN_REG_CONTROL */
 #define CONTROL_PORT_STATE_MASK (3 << 1)
 #define CONTROL_PORT_STATE_UFP (0 << 1)
 #define CONTROL_PORT_STATE_DFP (1 << 1)
 #define CONTROL_PORT_STATE_DRP (2 << 1)
 #define CONTROL_PORT_INT_MASK (1 << 0)
 /* PTN5150_REG_INT_STATUS */
 #define CABLE_ATTACHED (1 << 0)
 #define CABLE_DETACHED (1 << 1)
 /* PTN5150_REG_CC_STATUS */
 #define IS_DFP_ATTATCHED(val) (((val)&0x1c) == 0x4)
 #define IS_UFP_ATTATCHED(val) (((val)&0x1c) == 0x8)
 #define IS_NOT_CONNECTED(val) (((val)&0x1c) == 0x0)
 /* PTN5150_REG_CON_DET */
 #define DISABLE_CON_DET (1 << 0)
 /* PTN5150_REG_INT_MASK */
 #define MASK_COMP_CHANGE (1 << 4)
 #define MASK_ROLE_CHANGE (1 << 3)
 #define MASK_ORIENT_FOUND (1 << 2)
 #define MASK_DEBUG_FOUND (1 << 1)
 #define MASK_AUDIO_FOUND (1 << 0)

 struct ptn5150_info {
 	struct device *dev;
 	struct extcon_dev *edev;
 	struct typec_capability typec_caps;
 	struct typec_port *typec_port;
 	struct work_struct wq_detect_cable;
 	struct regmap *regmap;
 };

 /* List of detectable cables */
 static const unsigned int ptn5150_extcon_cable[] = {
 	EXTCON_USB,
 	EXTCON_USB_HOST,
 	EXTCON_NONE,
 };

 enum ptn5150_reg {
 	PTN5150_REG_DEVICE_ID = 0x1,
 	PTN5150_REG_CONTROL,
 	PTN5150_REG_INT_STATUS,
 	PTN5150_REG_CC_STATUS,
 	PTN5150_REG_RSVD_5,
 	PTN5150_REG_RSVD_6,
 	PTN5150_REG_RSVD_7,
 	PTN5150_REG_RSVD_8,
 	PTN5150_REG_CON_DET,
 	PTN5150_REG_VCONN_STATUS,
 	PTN5150_REG_RESET = 0x10,
 	PTN5150_REG_RSVD_11,
 	PTN5150_REG_RSVD_12,
 	PTN5150_REG_RSVD_13,
 	PTN5150_REG_RSVD_14,
 	PTN5150_REG_RSVD_15,
 	PTN5150_REG_RSVD_16,
 	PTN5150_REG_RSVD_17,
 	PTN5150_REG_INT_MASK,
 	PTN5150_REG_INT_REG_STATUS,

 	PTN5150_REG_END,
 };

 static const struct regmap_config ptn5150_regmap_config = {
 	.reg_bits = 8,
 	.val_bits = 8,
 	.max_register = PTN5150_REG_END,
 	.cache_type = REGCACHE_NONE,
 };

 static irqreturn_t ptn5150_i2c_irq_handler(int irq, void *dev_id)
 {
 	int ret;
 	unsigned int val = 0;
 	struct ptn5150_info *info = dev_id;

 	ret = regmap_read(info->regmap, PTN5150_REG_INT_REG_STATUS, &val);
 	if (ret) {
 		dev_err(info->dev, "Failed to read interrupt status: %d", ret);
 		return IRQ_NONE;
 	}

 	queue_work(system_power_efficient_wq, &info->wq_detect_cable);
 	return IRQ_HANDLED;
 }

 static void ptn5150_detect_cable(struct work_struct *work)
 {
 	struct ptn5150_info *info =
 		container_of(work, struct ptn5150_info, wq_detect_cable);
 	int ret;
 	unsigned int val;

 	ret = regmap_read(info->regmap, PTN5150_REG_CC_STATUS, &val);
 	if (ret) {
 		dev_err(info->dev, "failed to get CC status:%d\n", ret);
 	}

 	if (IS_UFP_ATTATCHED(val)) {
 		extcon_set_state_sync(info->edev, EXTCON_USB, false);
 		extcon_set_state_sync(info->edev, EXTCON_USB_HOST, true);
 	} else if (IS_DFP_ATTATCHED(val)) {
 		extcon_set_state_sync(info->edev, EXTCON_USB_HOST, false);
 		extcon_set_state_sync(info->edev, EXTCON_USB, true);
 	} else if (IS_NOT_CONNECTED(val)) {
 		extcon_set_state_sync(info->edev, EXTCON_USB, false);
 		extcon_set_state_sync(info->edev, EXTCON_USB_HOST, false);
 	} else {
 		dev_dbg(info->dev, "other CC status is :0x%x\n", val);
 	}
 }

 static int ptn5150_clear_interrupt(struct ptn5150_info *info)
 {
 	unsigned int val;
 	int ret;

 	ret = regmap_read(info->regmap, PTN5150_REG_INT_STATUS, &val);
 	if (ret) {
 		dev_err(info->dev, "failed to clear interrupt status:%d\n",
 			ret);
 	}

 	return (ret < 0) ? ret : (int)val;
 }

 static irqreturn_t ptn5150_connect_irq_handler(int irq, void *dev_id)
 {
 	struct ptn5150_info *info = dev_id;

 	if (ptn5150_clear_interrupt(info) > 0) {
 		queue_work(system_power_efficient_wq, &info->wq_detect_cable);
 	}

 	return IRQ_HANDLED;
 }

 static int ptn5150_setup_con_det(
 	struct ptn5150_info *info, struct gpio_desc *connect_gpiod)
 {
 	int ret, connect_irq, gpio_val, count = 1000;

 	connect_irq = gpiod_to_irq(connect_gpiod);
 	if (connect_irq < 0) {
 		dev_err(info->dev, "failed to get connect IRQ\n");
 		return connect_irq;
 	}

 	/* Clear the pending interrupts */
 	ret = ptn5150_clear_interrupt(info);
 	if (ret < 0) {
 		return ret;
 	}

 	gpio_val = gpiod_get_value(connect_gpiod);
 	/* Delay until the GPIO goes to high if it is low before */
 	while (gpio_val == 0 && count >= 0) {
 		gpio_val = gpiod_get_value(connect_gpiod);
 		usleep_range(10, 20);
 		count--;
 	}

 	if (count < 0) {
 		dev_err(info->dev, "timeout for waiting gpio becoming high\n");
 	}

 	ret = regmap_update_bits(info->regmap, PTN5150_REG_CON_DET,
 		DISABLE_CON_DET, ~DISABLE_CON_DET);
 	if (ret) {
 		dev_err(info->dev,
 			"failed to configure CON_DET output on pin 5:%d\n",
 			ret);
 		return ret;
 	}

 	ret = devm_request_threaded_irq(info->dev, connect_irq, NULL,
 		ptn5150_connect_irq_handler, IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 		dev_name(info->dev), info);
 	if (ret < 0) {
 		dev_err(info->dev, "failed to request connect IRQ\n");
 		return ret;
 	}

 	return 0;
 }

 static int ptn5150_setup_i2c_det(
 	struct ptn5150_info *info, struct i2c_client *i2c)
 {
 	int ret;

 	ret = regmap_update_bits(info->regmap, PTN5150_REG_INT_MASK,
 		(MASK_ROLE_CHANGE | MASK_COMP_CHANGE | MASK_ORIENT_FOUND),
 		~(MASK_ROLE_CHANGE | MASK_COMP_CHANGE | MASK_ORIENT_FOUND));
 	if (ret) {
 		dev_err(info->dev, "Failed to set I2C interrupt masks: %d",
 			ret);
 		return ret;
 	}

 	ret = regmap_update_bits(info->regmap, PTN5150_REG_CONTROL,
 		CONTROL_PORT_STATE_MASK | CONTROL_PORT_INT_MASK,
 		CONTROL_PORT_STATE_DRP | CONTROL_PORT_INT_MASK);
 	if (ret) {
 		dev_err(info->dev, "Failed to set port mode: %d", ret);
 		return ret;
 	}

 	ret = devm_request_threaded_irq(info->dev, i2c->irq, NULL,
 		ptn5150_i2c_irq_handler, IRQF_ONESHOT | IRQF_TRIGGER_LOW,
 		dev_name(info->dev), info);
 	if (ret < 0) {
 		dev_err(info->dev, "Failed to register i2c interrupt: %d", ret);
 		return ret;
 	}

 	return 0;
 }

 static int ptn5150_set_dr(
 	const struct typec_capability *caps, enum typec_data_role role)
 {
 	struct ptn5150_info *info =
 		container_of(caps, struct ptn5150_info, typec_caps);
 	int ret;

 	if (role == TYPEC_DEVICE) {
 		ret = regmap_update_bits(info->regmap, PTN5150_REG_CONTROL,
 			CONTROL_PORT_STATE_MASK | CONTROL_PORT_INT_MASK,
 			CONTROL_PORT_STATE_UFP | CONTROL_PORT_INT_MASK);

 		if (ret < 0) {
 			dev_err(info->dev,
 				"Failed to change data role to device: %d\n",
 				ret);
 			return ret;
 		}
 		typec_set_data_role(info->typec_port, TYPEC_DEVICE);
 		dev_dbg(info->dev, "Setting Type-C port to peripheral mode.\n");
 	}

 	else if (role == TYPEC_HOST) {
 		ret = regmap_update_bits(info->regmap, PTN5150_REG_CONTROL,
 			CONTROL_PORT_STATE_MASK | CONTROL_PORT_INT_MASK,
 			CONTROL_PORT_STATE_DFP | CONTROL_PORT_INT_MASK);

 		if (ret < 0) {
 			dev_err(info->dev,
 				"Failed to change data role to host: %d\n",
 				ret);
 			return ret;
 		}
 		typec_set_data_role(info->typec_port, TYPEC_HOST);
 		dev_dbg(info->dev, "Setting Type-C port to host mode.\n");
 	}

 	else {
 		dev_err(info->dev, "Unable to change Type-C data role\n.");
 		return -1;
 	}
 	return 0;
 }

 struct typec_port *ptn5150_register_port(struct ptn5150_info *info)
 {
 	info->typec_caps.type = TYPEC_PORT_DRP;
 	info->typec_caps.revision = 0x0110;
 	info->typec_caps.prefer_role = TYPEC_SINK;
 	info->typec_caps.dr_set = ptn5150_set_dr;

 	info->typec_port = typec_register_port(info->dev, &info->typec_caps);
 	if (!info->typec_port) {
 		dev_err(info->dev, "Unable to register Type-C port.\n");
 	}

 	return info->typec_port;
 }

 static int ptn5150_i2c_probe(
 	struct i2c_client *i2c, const struct i2c_device_id *id)
 {
 	struct device_node *np = i2c->dev.of_node;
 	struct ptn5150_info *info;
 	int ret;
 	unsigned int dev_id;
 	struct gpio_desc *connect_gpiod;
 	if (!np) {
 		return -EINVAL;
 	}

 	info = devm_kzalloc(&i2c->dev, sizeof(*info), GFP_KERNEL);
 	if (!info) {
 		return -ENOMEM;
 	}

 	i2c_set_clientdata(i2c, info);
 	info->dev = &i2c->dev;
 	info->regmap = devm_regmap_init_i2c(i2c, &ptn5150_regmap_config);
 	if (IS_ERR(info->regmap)) {
 		ret = PTR_ERR(info->regmap);
 		dev_err(info->dev, "failed to allocate register map: %d\n",
 			ret);
 		return ret;
 	}

 	ret = regmap_update_bits(info->regmap, PTN5150_REG_RESET, 1, 1);
 	usleep_range(500, 500);

 	/* Allocate extcon device */
 	info->edev = devm_extcon_dev_allocate(info->dev, ptn5150_extcon_cable);
 	if (IS_ERR(info->edev)) {
 		dev_err(info->dev, "failed to allocate memory for extcon\n");
 		return -ENOMEM;
 	}

 	/* Register extcon device */
 	ret = devm_extcon_dev_register(info->dev, info->edev);
 	if (ret) {
 		dev_err(info->dev, "failed to register extcon device\n");
 		return ret;
 	}

 	INIT_WORK(&info->wq_detect_cable, ptn5150_detect_cable);

 	connect_gpiod = devm_gpiod_get(info->dev, "connect", GPIOD_IN);
 	if (!IS_ERR(connect_gpiod)) {
 		ret = ptn5150_setup_con_det(info, connect_gpiod);
 		if (ret) {
 			dev_err(info->dev,
 				"Failed to setup connection detection feature\n");
 			return ret;
 		}
 	}

 	ret = regmap_read(info->regmap, PTN5150_REG_DEVICE_ID, &dev_id);
 	if (ret) {
 		dev_err(info->dev, "failed to read device id:%d\n", ret);
 		return ret;
 	}

 	dev_dbg(info->dev, "NXP PTN5150: Version ID:0x%x, Vendor ID:0x%x\n",
 		(dev_id >> 3), (dev_id & 0x3));

 	if (i2c->irq) {
 		ret = ptn5150_setup_i2c_det(info, i2c);
 		if (ret) {
 			dev_err(info->dev,
 				"Failed to configure i2c interrupts: %d\n",
 				ret);
 			return ret;
 		}
 	}

 	ret = ptn5150_clear_interrupt(info);
 	if (ret < 0) {
 		dev_err(info->dev, "Failed to clear interrupt: %d\n", ret);
 		return ret;
 	}

 	device_set_wakeup_capable(info->dev, true);

 	/* Do cable detect now */
 	ptn5150_detect_cable(&info->wq_detect_cable);

 	/* Register port to sysfs */
 	info->typec_port = ptn5150_register_port(info);

 	return ret;
 }

 static int ptn5150_i2c_remove(struct i2c_client *i2c)
 {
 	return 0;
 }

 static const struct i2c_device_id ptn5150_id[] = {
 	{ "ptn5150", 0 },
 	{},
 };
 MODULE_DEVICE_TABLE(i2c, ptn5150_id);

 #ifdef CONFIG_OF
 static const struct of_device_id ptn5150_of_match[] = {
 	{
 		.compatible = "nxp,ptn5150",
 	},
 	{
 		.compatible = "nxp,ptn5150a",
 	},
 	{},
 };
 MODULE_DEVICE_TABLE(of, ptn5150_of_match);
 #endif

 static struct i2c_driver ptn5150_i2c_driver = {
     .driver =
         {
             .name = "ptn5150",
             .of_match_table = of_match_ptr(ptn5150_of_match),
         },
     .probe = ptn5150_i2c_probe,
     .remove = ptn5150_i2c_remove,
     .id_table = ptn5150_id,
 };
 module_i2c_driver(ptn5150_i2c_driver);

 MODULE_DESCRIPTION("NXP PTN5150 CC logic driver for USB Type-C");
 MODULE_AUTHOR("Peter Chen <peter.chen@nxp.com>");
 MODULE_LICENSE("GPL v2");
	/*
	* extcon-ptn5150.c - NXP CC logic for USB Type-C applications
	*
	* Copyright 2017 NXP
	* Author: Peter Chen <peter.chen@nxp.com>
	*
	* This program is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 of
	* the License as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include <linux/err.h>
	#include <linux/extcon.h>
	#include <linux/gpio/consumer.h>
	#include <linux/i2c.h>
	#include <linux/interrupt.h>
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/regmap.h>
	#include <linux/usb/typec.h>

	/* PTN_REG_CONTROL */
	#define CONTROL_PORT_STATE_MASK (3 << 1)
	#define CONTROL_PORT_STATE_UFP (0 << 1)
	#define CONTROL_PORT_STATE_DFP (1 << 1)
	#define CONTROL_PORT_STATE_DRP (2 << 1)
	#define CONTROL_PORT_INT_MASK (1 << 0)
	/* PTN5150_REG_INT_STATUS */
	#define CABLE_ATTACHED (1 << 0)
	#define CABLE_DETACHED (1 << 1)
	/* PTN5150_REG_CC_STATUS */
	#define IS_DFP_ATTATCHED(val) (((val)&0x1c) == 0x4)
	#define IS_UFP_ATTATCHED(val) (((val)&0x1c) == 0x8)
	#define IS_NOT_CONNECTED(val) (((val)&0x1c) == 0x0)
	/* PTN5150_REG_CON_DET */
	#define DISABLE_CON_DET (1 << 0)
	/* PTN5150_REG_INT_MASK */
	#define MASK_COMP_CHANGE (1 << 4)
	#define MASK_ROLE_CHANGE (1 << 3)
	#define MASK_ORIENT_FOUND (1 << 2)
	#define MASK_DEBUG_FOUND (1 << 1)
	#define MASK_AUDIO_FOUND (1 << 0)

	struct ptn5150_info {
	struct device *dev;
	struct extcon_dev *edev;
	struct typec_capability typec_caps;
	struct typec_port *typec_port;
	struct work_struct wq_detect_cable;
	struct regmap *regmap;
	};

	/* List of detectable cables */
	static const unsigned int ptn5150_extcon_cable[] = {
	EXTCON_USB,
	EXTCON_USB_HOST,
	EXTCON_NONE,
	};

	enum ptn5150_reg {
	PTN5150_REG_DEVICE_ID = 0x1,
	PTN5150_REG_CONTROL,
	PTN5150_REG_INT_STATUS,
	PTN5150_REG_CC_STATUS,
	PTN5150_REG_RSVD_5,
	PTN5150_REG_RSVD_6,
	PTN5150_REG_RSVD_7,
	PTN5150_REG_RSVD_8,
	PTN5150_REG_CON_DET,
	PTN5150_REG_VCONN_STATUS,
	PTN5150_REG_RESET = 0x10,
	PTN5150_REG_RSVD_11,
	PTN5150_REG_RSVD_12,
	PTN5150_REG_RSVD_13,
	PTN5150_REG_RSVD_14,
	PTN5150_REG_RSVD_15,
	PTN5150_REG_RSVD_16,
	PTN5150_REG_RSVD_17,
	PTN5150_REG_INT_MASK,
	PTN5150_REG_INT_REG_STATUS,

	PTN5150_REG_END,
	};

	static const struct regmap_config ptn5150_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
	.max_register = PTN5150_REG_END,
	.cache_type = REGCACHE_NONE,
	};

	static irqreturn_t ptn5150_i2c_irq_handler(int irq, void *dev_id)
	{
	int ret;
	unsigned int val = 0;
	struct ptn5150_info *info = dev_id;

	ret = regmap_read(info->regmap, PTN5150_REG_INT_REG_STATUS, &val);
	if (ret) {
	dev_err(info->dev, "Failed to read interrupt status: %d", ret);
	return IRQ_NONE;
	}

	queue_work(system_power_efficient_wq, &info->wq_detect_cable);
	return IRQ_HANDLED;
	}

	static void ptn5150_detect_cable(struct work_struct *work)
	{
	struct ptn5150_info *info =
	container_of(work, struct ptn5150_info, wq_detect_cable);
	int ret;
	unsigned int val;

	ret = regmap_read(info->regmap, PTN5150_REG_CC_STATUS, &val);
	if (ret) {
	dev_err(info->dev, "failed to get CC status:%d\n", ret);
	}

	if (IS_UFP_ATTATCHED(val)) {
	extcon_set_state_sync(info->edev, EXTCON_USB, false);
	extcon_set_state_sync(info->edev, EXTCON_USB_HOST, true);
	} else if (IS_DFP_ATTATCHED(val)) {
	extcon_set_state_sync(info->edev, EXTCON_USB_HOST, false);
	extcon_set_state_sync(info->edev, EXTCON_USB, true);
	} else if (IS_NOT_CONNECTED(val)) {
	extcon_set_state_sync(info->edev, EXTCON_USB, false);
	extcon_set_state_sync(info->edev, EXTCON_USB_HOST, false);
	} else {
	dev_dbg(info->dev, "other CC status is :0x%x\n", val);
	}
	}

	static int ptn5150_clear_interrupt(struct ptn5150_info *info)
	{
	unsigned int val;
	int ret;

	ret = regmap_read(info->regmap, PTN5150_REG_INT_STATUS, &val);
	if (ret) {
	dev_err(info->dev, "failed to clear interrupt status:%d\n",
	ret);
	}

	return (ret < 0) ? ret : (int)val;
	}

	static irqreturn_t ptn5150_connect_irq_handler(int irq, void *dev_id)
	{
	struct ptn5150_info *info = dev_id;

	if (ptn5150_clear_interrupt(info) > 0) {
	queue_work(system_power_efficient_wq, &info->wq_detect_cable);
	}

	return IRQ_HANDLED;
	}

	static int ptn5150_setup_con_det(
	struct ptn5150_info info, struct gpio_desc connect_gpiod)
	{
	int ret, connect_irq, gpio_val, count = 1000;

	connect_irq = gpiod_to_irq(connect_gpiod);
	if (connect_irq < 0) {
	dev_err(info->dev, "failed to get connect IRQ\n");
	return connect_irq;
	}

	/* Clear the pending interrupts */
	ret = ptn5150_clear_interrupt(info);
	if (ret < 0) {
	return ret;
	}

	gpio_val = gpiod_get_value(connect_gpiod);
	/* Delay until the GPIO goes to high if it is low before */
	while (gpio_val == 0 && count >= 0) {
	gpio_val = gpiod_get_value(connect_gpiod);
	usleep_range(10, 20);
	count--;
	}

	if (count < 0) {
	dev_err(info->dev, "timeout for waiting gpio becoming high\n");
	}

	ret = regmap_update_bits(info->regmap, PTN5150_REG_CON_DET,
	DISABLE_CON_DET, ~DISABLE_CON_DET);
	if (ret) {
	dev_err(info->dev,
	"failed to configure CON_DET output on pin 5:%d\n",
	ret);
	return ret;
	}

	ret = devm_request_threaded_irq(info->dev, connect_irq, NULL,
	ptn5150_connect_irq_handler, IRQF_TRIGGER_LOW \| IRQF_ONESHOT,
	dev_name(info->dev), info);
	if (ret < 0) {
	dev_err(info->dev, "failed to request connect IRQ\n");
	return ret;
	}

	return 0;
	}

	static int ptn5150_setup_i2c_det(
	struct ptn5150_info info, struct i2c_client i2c)
	{
	int ret;

	ret = regmap_update_bits(info->regmap, PTN5150_REG_INT_MASK,
	(MASK_ROLE_CHANGE \| MASK_COMP_CHANGE \| MASK_ORIENT_FOUND),
	~(MASK_ROLE_CHANGE \| MASK_COMP_CHANGE \| MASK_ORIENT_FOUND));
	if (ret) {
	dev_err(info->dev, "Failed to set I2C interrupt masks: %d",
	ret);
	return ret;
	}

	ret = regmap_update_bits(info->regmap, PTN5150_REG_CONTROL,
	CONTROL_PORT_STATE_MASK \| CONTROL_PORT_INT_MASK,
	CONTROL_PORT_STATE_DRP \| CONTROL_PORT_INT_MASK);
	if (ret) {
	dev_err(info->dev, "Failed to set port mode: %d", ret);
	return ret;
	}

	ret = devm_request_threaded_irq(info->dev, i2c->irq, NULL,
	ptn5150_i2c_irq_handler, IRQF_ONESHOT \| IRQF_TRIGGER_LOW,
	dev_name(info->dev), info);
	if (ret < 0) {
	dev_err(info->dev, "Failed to register i2c interrupt: %d", ret);
	return ret;
	}

	return 0;
	}

	static int ptn5150_set_dr(
	const struct typec_capability *caps, enum typec_data_role role)
	{
	struct ptn5150_info *info =
	container_of(caps, struct ptn5150_info, typec_caps);
	int ret;

	if (role == TYPEC_DEVICE) {
	ret = regmap_update_bits(info->regmap, PTN5150_REG_CONTROL,
	CONTROL_PORT_STATE_MASK \| CONTROL_PORT_INT_MASK,
	CONTROL_PORT_STATE_UFP \| CONTROL_PORT_INT_MASK);

	if (ret < 0) {
	dev_err(info->dev,
	"Failed to change data role to device: %d\n",
	ret);
	return ret;
	}
	typec_set_data_role(info->typec_port, TYPEC_DEVICE);
	dev_dbg(info->dev, "Setting Type-C port to peripheral mode.\n");
	}

	else if (role == TYPEC_HOST) {
	ret = regmap_update_bits(info->regmap, PTN5150_REG_CONTROL,
	CONTROL_PORT_STATE_MASK \| CONTROL_PORT_INT_MASK,
	CONTROL_PORT_STATE_DFP \| CONTROL_PORT_INT_MASK);

	if (ret < 0) {
	dev_err(info->dev,
	"Failed to change data role to host: %d\n",
	ret);
	return ret;
	}
	typec_set_data_role(info->typec_port, TYPEC_HOST);
	dev_dbg(info->dev, "Setting Type-C port to host mode.\n");
	}

	else {
	dev_err(info->dev, "Unable to change Type-C data role\n.");
	return -1;
	}
	return 0;
	}

	struct typec_port ptn5150_register_port(struct ptn5150_info info)
	{
	info->typec_caps.type = TYPEC_PORT_DRP;
	info->typec_caps.revision = 0x0110;
	info->typec_caps.prefer_role = TYPEC_SINK;
	info->typec_caps.dr_set = ptn5150_set_dr;

	info->typec_port = typec_register_port(info->dev, &info->typec_caps);
	if (!info->typec_port) {
	dev_err(info->dev, "Unable to register Type-C port.\n");
	}

	return info->typec_port;
	}

	static int ptn5150_i2c_probe(
	struct i2c_client i2c, const struct i2c_device_id id)
	{
	struct device_node *np = i2c->dev.of_node;
	struct ptn5150_info *info;
	int ret;
	unsigned int dev_id;
	struct gpio_desc *connect_gpiod;
	if (!np) {
	return -EINVAL;
	}

	info = devm_kzalloc(&i2c->dev, sizeof(*info), GFP_KERNEL);
	if (!info) {
	return -ENOMEM;
	}

	i2c_set_clientdata(i2c, info);
	info->dev = &i2c->dev;
	info->regmap = devm_regmap_init_i2c(i2c, &ptn5150_regmap_config);
	if (IS_ERR(info->regmap)) {
	ret = PTR_ERR(info->regmap);
	dev_err(info->dev, "failed to allocate register map: %d\n",
	ret);
	return ret;
	}

	ret = regmap_update_bits(info->regmap, PTN5150_REG_RESET, 1, 1);
	usleep_range(500, 500);

	/* Allocate extcon device */
	info->edev = devm_extcon_dev_allocate(info->dev, ptn5150_extcon_cable);
	if (IS_ERR(info->edev)) {
	dev_err(info->dev, "failed to allocate memory for extcon\n");
	return -ENOMEM;
	}

	/* Register extcon device */
	ret = devm_extcon_dev_register(info->dev, info->edev);
	if (ret) {
	dev_err(info->dev, "failed to register extcon device\n");
	return ret;
	}

	INIT_WORK(&info->wq_detect_cable, ptn5150_detect_cable);

	connect_gpiod = devm_gpiod_get(info->dev, "connect", GPIOD_IN);
	if (!IS_ERR(connect_gpiod)) {
	ret = ptn5150_setup_con_det(info, connect_gpiod);
	if (ret) {
	dev_err(info->dev,
	"Failed to setup connection detection feature\n");
	return ret;
	}
	}

	ret = regmap_read(info->regmap, PTN5150_REG_DEVICE_ID, &dev_id);
	if (ret) {
	dev_err(info->dev, "failed to read device id:%d\n", ret);
	return ret;
	}

	dev_dbg(info->dev, "NXP PTN5150: Version ID:0x%x, Vendor ID:0x%x\n",
	(dev_id >> 3), (dev_id & 0x3));

	if (i2c->irq) {
	ret = ptn5150_setup_i2c_det(info, i2c);
	if (ret) {
	dev_err(info->dev,
	"Failed to configure i2c interrupts: %d\n",
	ret);
	return ret;
	}
	}

	ret = ptn5150_clear_interrupt(info);
	if (ret < 0) {
	dev_err(info->dev, "Failed to clear interrupt: %d\n", ret);
	return ret;
	}

	device_set_wakeup_capable(info->dev, true);

	/* Do cable detect now */
	ptn5150_detect_cable(&info->wq_detect_cable);

	/* Register port to sysfs */
	info->typec_port = ptn5150_register_port(info);

	return ret;
	}

	static int ptn5150_i2c_remove(struct i2c_client *i2c)
	{
	return 0;
	}

	static const struct i2c_device_id ptn5150_id[] = {
	{ "ptn5150", 0 },
	{},
	};
	MODULE_DEVICE_TABLE(i2c, ptn5150_id);

	#ifdef CONFIG_OF
	static const struct of_device_id ptn5150_of_match[] = {
	{
	.compatible = "nxp,ptn5150",
	},
	{
	.compatible = "nxp,ptn5150a",
	},
	{},
	};
	MODULE_DEVICE_TABLE(of, ptn5150_of_match);
	#endif

	static struct i2c_driver ptn5150_i2c_driver = {
	.driver =
	{
	.name = "ptn5150",
	.of_match_table = of_match_ptr(ptn5150_of_match),
	},
	.probe = ptn5150_i2c_probe,
	.remove = ptn5150_i2c_remove,
	.id_table = ptn5150_id,
	};
	module_i2c_driver(ptn5150_i2c_driver);

	MODULE_DESCRIPTION("NXP PTN5150 CC logic driver for USB Type-C");
	MODULE_AUTHOR("Peter Chen <peter.chen@nxp.com>");
	MODULE_LICENSE("GPL v2");