fusb302.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * Copyright 2016-2017 Google, Inc
   4 *
   5 * Fairchild FUSB302 Type-C Chip Driver
   6 */
   7
   8#include <linux/debugfs.h>
   9#include <linux/delay.h>
  10#include <linux/errno.h>
  11#include <linux/extcon.h>
  12#include <linux/gpio/consumer.h>
  13#include <linux/i2c.h>
  14#include <linux/interrupt.h>
  15#include <linux/kernel.h>
  16#include <linux/module.h>
  17#include <linux/mutex.h>
  18#include <linux/of.h>
  19#include <linux/pinctrl/consumer.h>
  20#include <linux/proc_fs.h>
  21#include <linux/regulator/consumer.h>
  22#include <linux/sched/clock.h>
  23#include <linux/seq_file.h>
  24#include <linux/slab.h>
  25#include <linux/spinlock.h>
  26#include <linux/string.h>
  27#include <linux/string_choices.h>
  28#include <linux/types.h>
  29#include <linux/usb.h>
  30#include <linux/usb/typec.h>
  31#include <linux/usb/tcpm.h>
  32#include <linux/usb/pd.h>
  33#include <linux/workqueue.h>
  34
  35#include "fusb302_reg.h"
  36
  37/*
  38 * When the device is SNK, BC_LVL interrupt is used to monitor cc pins
  39 * for the current capability offered by the SRC. As FUSB302 chip fires
  40 * the BC_LVL interrupt on PD signalings, cc lvl should be handled after
  41 * a delay to avoid measuring on PD activities. The delay is slightly
  42 * longer than PD_T_PD_DEBPUNCE (10-20ms).
  43 */
  44#define T_BC_LVL_DEBOUNCE_DELAY_MS 30
  45
  46enum toggling_mode {
  47	TOGGLING_MODE_OFF,
  48	TOGGLING_MODE_DRP,
  49	TOGGLING_MODE_SNK,
  50	TOGGLING_MODE_SRC,
  51};
  52
  53enum src_current_status {
  54	SRC_CURRENT_DEFAULT,
  55	SRC_CURRENT_MEDIUM,
  56	SRC_CURRENT_HIGH,
  57};
  58
  59static const u8 ra_mda_value[] = {
  60	[SRC_CURRENT_DEFAULT] = 4,	/* 210mV */
  61	[SRC_CURRENT_MEDIUM] = 9,	/* 420mV */
  62	[SRC_CURRENT_HIGH] = 18,	/* 798mV */
  63};
  64
  65static const u8 rd_mda_value[] = {
  66	[SRC_CURRENT_DEFAULT] = 38,	/* 1638mV */
  67	[SRC_CURRENT_MEDIUM] = 38,	/* 1638mV */
  68	[SRC_CURRENT_HIGH] = 61,	/* 2604mV */
  69};
  70
  71#define LOG_BUFFER_ENTRIES	1024
  72#define LOG_BUFFER_ENTRY_SIZE	128
  73
  74struct fusb302_chip {
  75	struct device *dev;
  76	struct i2c_client *i2c_client;
  77	struct tcpm_port *tcpm_port;
  78	struct tcpc_dev tcpc_dev;
  79
  80	struct regulator *vbus;
  81
  82	spinlock_t irq_lock;
  83	struct work_struct irq_work;
  84	bool irq_suspended;
  85	bool irq_while_suspended;
  86	struct gpio_desc *gpio_int_n;
  87	int gpio_int_n_irq;
  88	struct extcon_dev *extcon;
  89
  90	struct workqueue_struct *wq;
  91	struct delayed_work bc_lvl_handler;
  92
  93	/* lock for sharing chip states */
  94	struct mutex lock;
  95
  96	/* chip status */
  97	enum toggling_mode toggling_mode;
  98	enum src_current_status src_current_status;
  99	bool intr_togdone;
 100	bool intr_bc_lvl;
 101	bool intr_comp_chng;
 102
 103	/* port status */
 104	bool vconn_on;
 105	bool vbus_on;
 106	bool charge_on;
 107	bool pd_rx_on;
 108	bool vbus_present;
 109	enum typec_cc_polarity cc_polarity;
 110	enum typec_cc_status cc1;
 111	enum typec_cc_status cc2;
 112	u32 snk_pdo[PDO_MAX_OBJECTS];
 113
 114#ifdef CONFIG_DEBUG_FS
 115	struct dentry *dentry;
 116	/* lock for log buffer access */
 117	struct mutex logbuffer_lock;
 118	int logbuffer_head;
 119	int logbuffer_tail;
 120	u8 *logbuffer[LOG_BUFFER_ENTRIES];
 121#endif
 122};
 123
 124/*
 125 * Logging
 126 */
 127
 128#ifdef CONFIG_DEBUG_FS
 129static bool fusb302_log_full(struct fusb302_chip *chip)
 130{
 131	return chip->logbuffer_tail ==
 132		(chip->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
 133}
 134
 135__printf(2, 0)
 136static void _fusb302_log(struct fusb302_chip *chip, const char *fmt,
 137			 va_list args)
 138{
 139	char tmpbuffer[LOG_BUFFER_ENTRY_SIZE];
 140	u64 ts_nsec = local_clock();
 141	unsigned long rem_nsec;
 142
 143	if (!chip->logbuffer[chip->logbuffer_head]) {
 144		chip->logbuffer[chip->logbuffer_head] =
 145				kzalloc(LOG_BUFFER_ENTRY_SIZE, GFP_KERNEL);
 146		if (!chip->logbuffer[chip->logbuffer_head])
 147			return;
 148	}
 149
 150	vsnprintf(tmpbuffer, sizeof(tmpbuffer), fmt, args);
 151
 152	mutex_lock(&chip->logbuffer_lock);
 153
 154	if (fusb302_log_full(chip)) {
 155		chip->logbuffer_head = max(chip->logbuffer_head - 1, 0);
 156		strscpy(tmpbuffer, "overflow", sizeof(tmpbuffer));
 157	}
 158
 159	if (chip->logbuffer_head < 0 ||
 160	    chip->logbuffer_head >= LOG_BUFFER_ENTRIES) {
 161		dev_warn(chip->dev,
 162			 "Bad log buffer index %d\n", chip->logbuffer_head);
 163		goto abort;
 164	}
 165
 166	if (!chip->logbuffer[chip->logbuffer_head]) {
 167		dev_warn(chip->dev,
 168			 "Log buffer index %d is NULL\n", chip->logbuffer_head);
 169		goto abort;
 170	}
 171
 172	rem_nsec = do_div(ts_nsec, 1000000000);
 173	scnprintf(chip->logbuffer[chip->logbuffer_head],
 174		  LOG_BUFFER_ENTRY_SIZE, "[%5lu.%06lu] %s",
 175		  (unsigned long)ts_nsec, rem_nsec / 1000,
 176		  tmpbuffer);
 177	chip->logbuffer_head = (chip->logbuffer_head + 1) % LOG_BUFFER_ENTRIES;
 178
 179abort:
 180	mutex_unlock(&chip->logbuffer_lock);
 181}
 182
 183__printf(2, 3)
 184static void fusb302_log(struct fusb302_chip *chip, const char *fmt, ...)
 185{
 186	va_list args;
 187
 188	va_start(args, fmt);
 189	_fusb302_log(chip, fmt, args);
 190	va_end(args);
 191}
 192
 193static int fusb302_debug_show(struct seq_file *s, void *v)
 194{
 195	struct fusb302_chip *chip = s->private;
 196	int tail;
 197
 198	mutex_lock(&chip->logbuffer_lock);
 199	tail = chip->logbuffer_tail;
 200	while (tail != chip->logbuffer_head) {
 201		seq_printf(s, "%s\n", chip->logbuffer[tail]);
 202		tail = (tail + 1) % LOG_BUFFER_ENTRIES;
 203	}
 204	if (!seq_has_overflowed(s))
 205		chip->logbuffer_tail = tail;
 206	mutex_unlock(&chip->logbuffer_lock);
 207
 208	return 0;
 209}
 210DEFINE_SHOW_ATTRIBUTE(fusb302_debug);
 211
 212static void fusb302_debugfs_init(struct fusb302_chip *chip)
 213{
 214	char name[NAME_MAX];
 215
 216	mutex_init(&chip->logbuffer_lock);
 217	snprintf(name, NAME_MAX, "fusb302-%s", dev_name(chip->dev));
 218	chip->dentry = debugfs_create_dir(name, usb_debug_root);
 219	debugfs_create_file("log", S_IFREG | 0444, chip->dentry, chip,
 220			    &fusb302_debug_fops);
 221}
 222
 223static void fusb302_debugfs_exit(struct fusb302_chip *chip)
 224{
 225	debugfs_remove(chip->dentry);
 226}
 227
 228#else
 229
 230static void fusb302_log(const struct fusb302_chip *chip,
 231			const char *fmt, ...) { }
 232static void fusb302_debugfs_init(const struct fusb302_chip *chip) { }
 233static void fusb302_debugfs_exit(const struct fusb302_chip *chip) { }
 234
 235#endif
 236
 237static int fusb302_i2c_write(struct fusb302_chip *chip,
 238			     u8 address, u8 data)
 239{
 240	int ret = 0;
 241
 242	ret = i2c_smbus_write_byte_data(chip->i2c_client, address, data);
 243	if (ret < 0)
 244		fusb302_log(chip, "cannot write 0x%02x to 0x%02x, ret=%d",
 245			    data, address, ret);
 246
 247	return ret;
 248}
 249
 250static int fusb302_i2c_block_write(struct fusb302_chip *chip, u8 address,
 251				   u8 length, const u8 *data)
 252{
 253	int ret = 0;
 254
 255	if (length <= 0)
 256		return ret;
 257
 258	ret = i2c_smbus_write_i2c_block_data(chip->i2c_client, address,
 259					     length, data);
 260	if (ret < 0)
 261		fusb302_log(chip, "cannot block write 0x%02x, len=%d, ret=%d",
 262			    address, length, ret);
 263
 264	return ret;
 265}
 266
 267static int fusb302_i2c_read(struct fusb302_chip *chip,
 268			    u8 address, u8 *data)
 269{
 270	int ret = 0;
 271
 272	ret = i2c_smbus_read_byte_data(chip->i2c_client, address);
 273	*data = (u8)ret;
 274	if (ret < 0)
 275		fusb302_log(chip, "cannot read %02x, ret=%d", address, ret);
 276
 277	return ret;
 278}
 279
 280static int fusb302_i2c_block_read(struct fusb302_chip *chip, u8 address,
 281				  u8 length, u8 *data)
 282{
 283	int ret = 0;
 284
 285	if (length <= 0)
 286		return ret;
 287
 288	ret = i2c_smbus_read_i2c_block_data(chip->i2c_client, address,
 289					    length, data);
 290	if (ret < 0) {
 291		fusb302_log(chip, "cannot block read 0x%02x, len=%d, ret=%d",
 292			    address, length, ret);
 293		goto done;
 294	}
 295	if (ret != length) {
 296		fusb302_log(chip, "only read %d/%d bytes from 0x%02x",
 297			    ret, length, address);
 298		ret = -EIO;
 299	}
 300
 301done:
 302	return ret;
 303}
 304
 305static int fusb302_i2c_mask_write(struct fusb302_chip *chip, u8 address,
 306				  u8 mask, u8 value)
 307{
 308	int ret = 0;
 309	u8 data;
 310
 311	ret = fusb302_i2c_read(chip, address, &data);
 312	if (ret < 0)
 313		return ret;
 314	data &= ~mask;
 315	data |= value;
 316	ret = fusb302_i2c_write(chip, address, data);
 317	if (ret < 0)
 318		return ret;
 319
 320	return ret;
 321}
 322
 323static int fusb302_i2c_set_bits(struct fusb302_chip *chip, u8 address,
 324				u8 set_bits)
 325{
 326	return fusb302_i2c_mask_write(chip, address, 0x00, set_bits);
 327}
 328
 329static int fusb302_i2c_clear_bits(struct fusb302_chip *chip, u8 address,
 330				  u8 clear_bits)
 331{
 332	return fusb302_i2c_mask_write(chip, address, clear_bits, 0x00);
 333}
 334
 335static int fusb302_sw_reset(struct fusb302_chip *chip)
 336{
 337	int ret = 0;
 338
 339	ret = fusb302_i2c_write(chip, FUSB_REG_RESET,
 340				FUSB_REG_RESET_SW_RESET);
 341	if (ret < 0)
 342		fusb302_log(chip, "cannot sw reset the chip, ret=%d", ret);
 343	else
 344		fusb302_log(chip, "sw reset");
 345
 346	return ret;
 347}
 348
 349static int fusb302_enable_tx_auto_retries(struct fusb302_chip *chip, u8 retry_count)
 350{
 351	int ret = 0;
 352
 353	ret = fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL3, retry_count |
 354				   FUSB_REG_CONTROL3_AUTO_RETRY);
 355
 356	return ret;
 357}
 358
 359/*
 360 * initialize interrupt on the chip
 361 * - unmasked interrupt: VBUS_OK
 362 */
 363static int fusb302_init_interrupt(struct fusb302_chip *chip)
 364{
 365	int ret = 0;
 366
 367	ret = fusb302_i2c_write(chip, FUSB_REG_MASK,
 368				0xFF & ~FUSB_REG_MASK_VBUSOK);
 369	if (ret < 0)
 370		return ret;
 371	ret = fusb302_i2c_write(chip, FUSB_REG_MASKA, 0xFF);
 372	if (ret < 0)
 373		return ret;
 374	ret = fusb302_i2c_write(chip, FUSB_REG_MASKB, 0xFF);
 375	if (ret < 0)
 376		return ret;
 377	ret = fusb302_i2c_clear_bits(chip, FUSB_REG_CONTROL0,
 378				     FUSB_REG_CONTROL0_INT_MASK);
 379	if (ret < 0)
 380		return ret;
 381
 382	return ret;
 383}
 384
 385static int fusb302_set_power_mode(struct fusb302_chip *chip, u8 power_mode)
 386{
 387	int ret = 0;
 388
 389	ret = fusb302_i2c_write(chip, FUSB_REG_POWER, power_mode);
 390
 391	return ret;
 392}
 393
 394static int tcpm_init(struct tcpc_dev *dev)
 395{
 396	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 397						 tcpc_dev);
 398	int ret = 0;
 399	u8 data;
 400
 401	ret = fusb302_sw_reset(chip);
 402	if (ret < 0)
 403		return ret;
 404	ret = fusb302_enable_tx_auto_retries(chip, FUSB_REG_CONTROL3_N_RETRIES_3);
 405	if (ret < 0)
 406		return ret;
 407	ret = fusb302_init_interrupt(chip);
 408	if (ret < 0)
 409		return ret;
 410	ret = fusb302_set_power_mode(chip, FUSB_REG_POWER_PWR_ALL);
 411	if (ret < 0)
 412		return ret;
 413	ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &data);
 414	if (ret < 0)
 415		return ret;
 416	chip->vbus_present = !!(data & FUSB_REG_STATUS0_VBUSOK);
 417	ret = fusb302_i2c_read(chip, FUSB_REG_DEVICE_ID, &data);
 418	if (ret < 0)
 419		return ret;
 420	fusb302_log(chip, "fusb302 device ID: 0x%02x", data);
 421
 422	return ret;
 423}
 424
 425static int tcpm_get_vbus(struct tcpc_dev *dev)
 426{
 427	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 428						 tcpc_dev);
 429	int ret = 0;
 430
 431	mutex_lock(&chip->lock);
 432	ret = chip->vbus_present ? 1 : 0;
 433	mutex_unlock(&chip->lock);
 434
 435	return ret;
 436}
 437
 438static int tcpm_get_current_limit(struct tcpc_dev *dev)
 439{
 440	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 441						 tcpc_dev);
 442	int current_limit = 0;
 443	unsigned long timeout;
 444
 445	if (!chip->extcon)
 446		return 0;
 447
 448	/*
 449	 * USB2 Charger detection may still be in progress when we get here,
 450	 * this can take upto 600ms, wait 800ms max.
 451	 */
 452	timeout = jiffies + msecs_to_jiffies(800);
 453	do {
 454		if (extcon_get_state(chip->extcon, EXTCON_CHG_USB_SDP) == 1)
 455			current_limit = 500;
 456
 457		if (extcon_get_state(chip->extcon, EXTCON_CHG_USB_CDP) == 1 ||
 458		    extcon_get_state(chip->extcon, EXTCON_CHG_USB_ACA) == 1)
 459			current_limit = 1500;
 460
 461		if (extcon_get_state(chip->extcon, EXTCON_CHG_USB_DCP) == 1)
 462			current_limit = 2000;
 463
 464		msleep(50);
 465	} while (current_limit == 0 && time_before(jiffies, timeout));
 466
 467	return current_limit;
 468}
 469
 470static int fusb302_set_src_current(struct fusb302_chip *chip,
 471				   enum src_current_status status)
 472{
 473	int ret = 0;
 474
 475	chip->src_current_status = status;
 476	switch (status) {
 477	case SRC_CURRENT_DEFAULT:
 478		ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL0,
 479					     FUSB_REG_CONTROL0_HOST_CUR_MASK,
 480					     FUSB_REG_CONTROL0_HOST_CUR_DEF);
 481		break;
 482	case SRC_CURRENT_MEDIUM:
 483		ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL0,
 484					     FUSB_REG_CONTROL0_HOST_CUR_MASK,
 485					     FUSB_REG_CONTROL0_HOST_CUR_MED);
 486		break;
 487	case SRC_CURRENT_HIGH:
 488		ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL0,
 489					     FUSB_REG_CONTROL0_HOST_CUR_MASK,
 490					     FUSB_REG_CONTROL0_HOST_CUR_HIGH);
 491		break;
 492	default:
 493		break;
 494	}
 495
 496	return ret;
 497}
 498
 499static int fusb302_set_toggling(struct fusb302_chip *chip,
 500				enum toggling_mode mode)
 501{
 502	int ret = 0;
 503
 504	/* first disable toggling */
 505	ret = fusb302_i2c_clear_bits(chip, FUSB_REG_CONTROL2,
 506				     FUSB_REG_CONTROL2_TOGGLE);
 507	if (ret < 0)
 508		return ret;
 509	/* mask interrupts for SRC or SNK */
 510	ret = fusb302_i2c_set_bits(chip, FUSB_REG_MASK,
 511				   FUSB_REG_MASK_BC_LVL |
 512				   FUSB_REG_MASK_COMP_CHNG);
 513	if (ret < 0)
 514		return ret;
 515	chip->intr_bc_lvl = false;
 516	chip->intr_comp_chng = false;
 517	/* configure toggling mode: none/snk/src/drp */
 518	switch (mode) {
 519	case TOGGLING_MODE_OFF:
 520		ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 521					     FUSB_REG_CONTROL2_MODE_MASK,
 522					     FUSB_REG_CONTROL2_MODE_NONE);
 523		if (ret < 0)
 524			return ret;
 525		break;
 526	case TOGGLING_MODE_SNK:
 527		ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 528					     FUSB_REG_CONTROL2_MODE_MASK,
 529					     FUSB_REG_CONTROL2_MODE_UFP);
 530		if (ret < 0)
 531			return ret;
 532		break;
 533	case TOGGLING_MODE_SRC:
 534		ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 535					     FUSB_REG_CONTROL2_MODE_MASK,
 536					     FUSB_REG_CONTROL2_MODE_DFP);
 537		if (ret < 0)
 538			return ret;
 539		break;
 540	case TOGGLING_MODE_DRP:
 541		ret = fusb302_i2c_mask_write(chip, FUSB_REG_CONTROL2,
 542					     FUSB_REG_CONTROL2_MODE_MASK,
 543					     FUSB_REG_CONTROL2_MODE_DRP);
 544		if (ret < 0)
 545			return ret;
 546		break;
 547	default:
 548		break;
 549	}
 550
 551	if (mode == TOGGLING_MODE_OFF) {
 552		/* mask TOGDONE interrupt */
 553		ret = fusb302_i2c_set_bits(chip, FUSB_REG_MASKA,
 554					   FUSB_REG_MASKA_TOGDONE);
 555		if (ret < 0)
 556			return ret;
 557		chip->intr_togdone = false;
 558	} else {
 559		/* Datasheet says vconn MUST be off when toggling */
 560		WARN(chip->vconn_on, "Vconn is on during toggle start");
 561		/* unmask TOGDONE interrupt */
 562		ret = fusb302_i2c_clear_bits(chip, FUSB_REG_MASKA,
 563					     FUSB_REG_MASKA_TOGDONE);
 564		if (ret < 0)
 565			return ret;
 566		chip->intr_togdone = true;
 567		/* start toggling */
 568		ret = fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL2,
 569					   FUSB_REG_CONTROL2_TOGGLE);
 570		if (ret < 0)
 571			return ret;
 572		/* during toggling, consider cc as Open */
 573		chip->cc1 = TYPEC_CC_OPEN;
 574		chip->cc2 = TYPEC_CC_OPEN;
 575	}
 576	chip->toggling_mode = mode;
 577
 578	return ret;
 579}
 580
 581static const char * const typec_cc_status_name[] = {
 582	[TYPEC_CC_OPEN]		= "Open",
 583	[TYPEC_CC_RA]		= "Ra",
 584	[TYPEC_CC_RD]		= "Rd",
 585	[TYPEC_CC_RP_DEF]	= "Rp-def",
 586	[TYPEC_CC_RP_1_5]	= "Rp-1.5",
 587	[TYPEC_CC_RP_3_0]	= "Rp-3.0",
 588};
 589
 590static const enum src_current_status cc_src_current[] = {
 591	[TYPEC_CC_OPEN]		= SRC_CURRENT_DEFAULT,
 592	[TYPEC_CC_RA]		= SRC_CURRENT_DEFAULT,
 593	[TYPEC_CC_RD]		= SRC_CURRENT_DEFAULT,
 594	[TYPEC_CC_RP_DEF]	= SRC_CURRENT_DEFAULT,
 595	[TYPEC_CC_RP_1_5]	= SRC_CURRENT_MEDIUM,
 596	[TYPEC_CC_RP_3_0]	= SRC_CURRENT_HIGH,
 597};
 598
 599static int tcpm_set_cc(struct tcpc_dev *dev, enum typec_cc_status cc)
 600{
 601	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 602						 tcpc_dev);
 603	u8 switches0_mask = FUSB_REG_SWITCHES0_CC1_PU_EN |
 604			    FUSB_REG_SWITCHES0_CC2_PU_EN |
 605			    FUSB_REG_SWITCHES0_CC1_PD_EN |
 606			    FUSB_REG_SWITCHES0_CC2_PD_EN;
 607	u8 rd_mda, switches0_data = 0x00;
 608	int ret = 0;
 609
 610	mutex_lock(&chip->lock);
 611	switch (cc) {
 612	case TYPEC_CC_OPEN:
 613		break;
 614	case TYPEC_CC_RD:
 615		switches0_data |= FUSB_REG_SWITCHES0_CC1_PD_EN |
 616				  FUSB_REG_SWITCHES0_CC2_PD_EN;
 617		break;
 618	case TYPEC_CC_RP_DEF:
 619	case TYPEC_CC_RP_1_5:
 620	case TYPEC_CC_RP_3_0:
 621		switches0_data |= (chip->cc_polarity == TYPEC_POLARITY_CC1) ?
 622				  FUSB_REG_SWITCHES0_CC1_PU_EN :
 623				  FUSB_REG_SWITCHES0_CC2_PU_EN;
 624		break;
 625	default:
 626		fusb302_log(chip, "unsupported cc value %s",
 627			    typec_cc_status_name[cc]);
 628		ret = -EINVAL;
 629		goto done;
 630	}
 631
 632	fusb302_log(chip, "cc := %s", typec_cc_status_name[cc]);
 633
 634	ret = fusb302_set_toggling(chip, TOGGLING_MODE_OFF);
 635	if (ret < 0) {
 636		fusb302_log(chip, "cannot set toggling mode, ret=%d", ret);
 637		goto done;
 638	}
 639
 640	ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES0,
 641				     switches0_mask, switches0_data);
 642	if (ret < 0) {
 643		fusb302_log(chip, "cannot set pull-up/-down, ret = %d", ret);
 644		goto done;
 645	}
 646	/* reset the cc status */
 647	chip->cc1 = TYPEC_CC_OPEN;
 648	chip->cc2 = TYPEC_CC_OPEN;
 649
 650	/* adjust current for SRC */
 651	ret = fusb302_set_src_current(chip, cc_src_current[cc]);
 652	if (ret < 0) {
 653		fusb302_log(chip, "cannot set src current %s, ret=%d",
 654			    typec_cc_status_name[cc], ret);
 655		goto done;
 656	}
 657
 658	/* enable/disable interrupts, BC_LVL for SNK and COMP_CHNG for SRC */
 659	switch (cc) {
 660	case TYPEC_CC_RP_DEF:
 661	case TYPEC_CC_RP_1_5:
 662	case TYPEC_CC_RP_3_0:
 663		rd_mda = rd_mda_value[cc_src_current[cc]];
 664		ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, rd_mda);
 665		if (ret < 0) {
 666			fusb302_log(chip,
 667				    "cannot set SRC measure value, ret=%d",
 668				    ret);
 669			goto done;
 670		}
 671		ret = fusb302_i2c_mask_write(chip, FUSB_REG_MASK,
 672					     FUSB_REG_MASK_BC_LVL |
 673					     FUSB_REG_MASK_COMP_CHNG,
 674					     FUSB_REG_MASK_BC_LVL);
 675		if (ret < 0) {
 676			fusb302_log(chip, "cannot set SRC interrupt, ret=%d",
 677				    ret);
 678			goto done;
 679		}
 680		chip->intr_comp_chng = true;
 681		chip->intr_bc_lvl = false;
 682		break;
 683	case TYPEC_CC_RD:
 684		ret = fusb302_i2c_mask_write(chip, FUSB_REG_MASK,
 685					     FUSB_REG_MASK_BC_LVL |
 686					     FUSB_REG_MASK_COMP_CHNG,
 687					     FUSB_REG_MASK_COMP_CHNG);
 688		if (ret < 0) {
 689			fusb302_log(chip, "cannot set SRC interrupt, ret=%d",
 690				    ret);
 691			goto done;
 692		}
 693		chip->intr_bc_lvl = true;
 694		chip->intr_comp_chng = false;
 695		break;
 696	default:
 697		break;
 698	}
 699done:
 700	mutex_unlock(&chip->lock);
 701
 702	return ret;
 703}
 704
 705static int tcpm_get_cc(struct tcpc_dev *dev, enum typec_cc_status *cc1,
 706		       enum typec_cc_status *cc2)
 707{
 708	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 709						 tcpc_dev);
 710
 711	mutex_lock(&chip->lock);
 712	*cc1 = chip->cc1;
 713	*cc2 = chip->cc2;
 714	fusb302_log(chip, "cc1=%s, cc2=%s", typec_cc_status_name[*cc1],
 715		    typec_cc_status_name[*cc2]);
 716	mutex_unlock(&chip->lock);
 717
 718	return 0;
 719}
 720
 721static int tcpm_set_polarity(struct tcpc_dev *dev,
 722			     enum typec_cc_polarity polarity)
 723{
 724	return 0;
 725}
 726
 727static int tcpm_set_vconn(struct tcpc_dev *dev, bool on)
 728{
 729	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 730						 tcpc_dev);
 731	int ret = 0;
 732	u8 switches0_data = 0x00;
 733	u8 switches0_mask = FUSB_REG_SWITCHES0_VCONN_CC1 |
 734			    FUSB_REG_SWITCHES0_VCONN_CC2;
 735
 736	mutex_lock(&chip->lock);
 737	if (chip->vconn_on == on) {
 738		fusb302_log(chip, "vconn is already %s", str_on_off(on));
 739		goto done;
 740	}
 741	if (on) {
 742		switches0_data = (chip->cc_polarity == TYPEC_POLARITY_CC1) ?
 743				 FUSB_REG_SWITCHES0_VCONN_CC2 :
 744				 FUSB_REG_SWITCHES0_VCONN_CC1;
 745	}
 746	ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES0,
 747				     switches0_mask, switches0_data);
 748	if (ret < 0)
 749		goto done;
 750	chip->vconn_on = on;
 751	fusb302_log(chip, "vconn := %s", str_on_off(on));
 752done:
 753	mutex_unlock(&chip->lock);
 754
 755	return ret;
 756}
 757
 758static int tcpm_set_vbus(struct tcpc_dev *dev, bool on, bool charge)
 759{
 760	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 761						 tcpc_dev);
 762	int ret = 0;
 763
 764	mutex_lock(&chip->lock);
 765	if (chip->vbus_on == on) {
 766		fusb302_log(chip, "vbus is already %s", str_on_off(on));
 767	} else {
 768		if (on)
 769			ret = regulator_enable(chip->vbus);
 770		else
 771			ret = regulator_disable(chip->vbus);
 772		if (ret < 0) {
 773			fusb302_log(chip, "cannot %s vbus regulator, ret=%d",
 774				    str_enable_disable(on), ret);
 775			goto done;
 776		}
 777		chip->vbus_on = on;
 778		fusb302_log(chip, "vbus := %s", str_on_off(on));
 779	}
 780	if (chip->charge_on == charge)
 781		fusb302_log(chip, "charge is already %s", str_on_off(charge));
 782	else
 783		chip->charge_on = charge;
 784
 785done:
 786	mutex_unlock(&chip->lock);
 787
 788	return ret;
 789}
 790
 791static int fusb302_pd_tx_flush(struct fusb302_chip *chip)
 792{
 793	return fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL0,
 794				    FUSB_REG_CONTROL0_TX_FLUSH);
 795}
 796
 797static int fusb302_pd_rx_flush(struct fusb302_chip *chip)
 798{
 799	return fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL1,
 800				    FUSB_REG_CONTROL1_RX_FLUSH);
 801}
 802
 803static int fusb302_pd_set_auto_goodcrc(struct fusb302_chip *chip, bool on)
 804{
 805	if (on)
 806		return fusb302_i2c_set_bits(chip, FUSB_REG_SWITCHES1,
 807					    FUSB_REG_SWITCHES1_AUTO_GCRC);
 808	return fusb302_i2c_clear_bits(chip, FUSB_REG_SWITCHES1,
 809					    FUSB_REG_SWITCHES1_AUTO_GCRC);
 810}
 811
 812static int fusb302_pd_set_interrupts(struct fusb302_chip *chip, bool on)
 813{
 814	int ret = 0;
 815	u8 mask_interrupts = FUSB_REG_MASK_COLLISION;
 816	u8 maska_interrupts = FUSB_REG_MASKA_RETRYFAIL |
 817			      FUSB_REG_MASKA_HARDSENT |
 818			      FUSB_REG_MASKA_TX_SUCCESS |
 819			      FUSB_REG_MASKA_HARDRESET;
 820	u8 maskb_interrupts = FUSB_REG_MASKB_GCRCSENT;
 821
 822	ret = on ?
 823		fusb302_i2c_clear_bits(chip, FUSB_REG_MASK, mask_interrupts) :
 824		fusb302_i2c_set_bits(chip, FUSB_REG_MASK, mask_interrupts);
 825	if (ret < 0)
 826		return ret;
 827	ret = on ?
 828		fusb302_i2c_clear_bits(chip, FUSB_REG_MASKA, maska_interrupts) :
 829		fusb302_i2c_set_bits(chip, FUSB_REG_MASKA, maska_interrupts);
 830	if (ret < 0)
 831		return ret;
 832	ret = on ?
 833		fusb302_i2c_clear_bits(chip, FUSB_REG_MASKB, maskb_interrupts) :
 834		fusb302_i2c_set_bits(chip, FUSB_REG_MASKB, maskb_interrupts);
 835	return ret;
 836}
 837
 838static int tcpm_set_pd_rx(struct tcpc_dev *dev, bool on)
 839{
 840	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 841						 tcpc_dev);
 842	int ret = 0;
 843
 844	mutex_lock(&chip->lock);
 845	if (chip->pd_rx_on == on) {
 846		fusb302_log(chip, "pd is already %s", str_on_off(on));
 847		goto done;
 848	}
 849
 850	ret = fusb302_pd_rx_flush(chip);
 851	if (ret < 0) {
 852		fusb302_log(chip, "cannot flush pd rx buffer, ret=%d", ret);
 853		goto done;
 854	}
 855	ret = fusb302_pd_tx_flush(chip);
 856	if (ret < 0) {
 857		fusb302_log(chip, "cannot flush pd tx buffer, ret=%d", ret);
 858		goto done;
 859	}
 860	ret = fusb302_pd_set_auto_goodcrc(chip, on);
 861	if (ret < 0) {
 862		fusb302_log(chip, "cannot turn %s auto GCRC, ret=%d",
 863			    str_on_off(on), ret);
 864		goto done;
 865	}
 866	ret = fusb302_pd_set_interrupts(chip, on);
 867	if (ret < 0) {
 868		fusb302_log(chip, "cannot turn %s pd interrupts, ret=%d",
 869			    str_on_off(on), ret);
 870		goto done;
 871	}
 872
 873	chip->pd_rx_on = on;
 874	fusb302_log(chip, "pd := %s", str_on_off(on));
 875done:
 876	mutex_unlock(&chip->lock);
 877
 878	return ret;
 879}
 880
 881static const char * const typec_role_name[] = {
 882	[TYPEC_SINK]		= "Sink",
 883	[TYPEC_SOURCE]		= "Source",
 884};
 885
 886static const char * const typec_data_role_name[] = {
 887	[TYPEC_DEVICE]		= "Device",
 888	[TYPEC_HOST]		= "Host",
 889};
 890
 891static int tcpm_set_roles(struct tcpc_dev *dev, bool attached,
 892			  enum typec_role pwr, enum typec_data_role data)
 893{
 894	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 895						 tcpc_dev);
 896	int ret = 0;
 897	u8 switches1_mask = FUSB_REG_SWITCHES1_POWERROLE |
 898			    FUSB_REG_SWITCHES1_DATAROLE;
 899	u8 switches1_data = 0x00;
 900
 901	mutex_lock(&chip->lock);
 902	if (pwr == TYPEC_SOURCE)
 903		switches1_data |= FUSB_REG_SWITCHES1_POWERROLE;
 904	if (data == TYPEC_HOST)
 905		switches1_data |= FUSB_REG_SWITCHES1_DATAROLE;
 906	ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES1,
 907				     switches1_mask, switches1_data);
 908	if (ret < 0) {
 909		fusb302_log(chip, "unable to set pd header %s, %s, ret=%d",
 910			    typec_role_name[pwr], typec_data_role_name[data],
 911			    ret);
 912		goto done;
 913	}
 914	fusb302_log(chip, "pd header := %s, %s", typec_role_name[pwr],
 915		    typec_data_role_name[data]);
 916done:
 917	mutex_unlock(&chip->lock);
 918
 919	return ret;
 920}
 921
 922static int tcpm_start_toggling(struct tcpc_dev *dev,
 923			       enum typec_port_type port_type,
 924			       enum typec_cc_status cc)
 925{
 926	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
 927						 tcpc_dev);
 928	enum toggling_mode mode = TOGGLING_MODE_OFF;
 929	int ret = 0;
 930
 931	switch (port_type) {
 932	case TYPEC_PORT_SRC:
 933		mode = TOGGLING_MODE_SRC;
 934		break;
 935	case TYPEC_PORT_SNK:
 936		mode = TOGGLING_MODE_SNK;
 937		break;
 938	case TYPEC_PORT_DRP:
 939		mode = TOGGLING_MODE_DRP;
 940		break;
 941	}
 942
 943	mutex_lock(&chip->lock);
 944	ret = fusb302_set_src_current(chip, cc_src_current[cc]);
 945	if (ret < 0) {
 946		fusb302_log(chip, "unable to set src current %s, ret=%d",
 947			    typec_cc_status_name[cc], ret);
 948		goto done;
 949	}
 950	ret = fusb302_set_toggling(chip, mode);
 951	if (ret < 0) {
 952		fusb302_log(chip,
 953			    "unable to start drp toggling, ret=%d", ret);
 954		goto done;
 955	}
 956	fusb302_log(chip, "start drp toggling");
 957done:
 958	mutex_unlock(&chip->lock);
 959
 960	return ret;
 961}
 962
 963static int fusb302_pd_send_message(struct fusb302_chip *chip,
 964				   const struct pd_message *msg)
 965{
 966	int ret = 0;
 967	u8 buf[40];
 968	u8 pos = 0;
 969	int len;
 970
 971	/* SOP tokens */
 972	buf[pos++] = FUSB302_TKN_SYNC1;
 973	buf[pos++] = FUSB302_TKN_SYNC1;
 974	buf[pos++] = FUSB302_TKN_SYNC1;
 975	buf[pos++] = FUSB302_TKN_SYNC2;
 976
 977	len = pd_header_cnt_le(msg->header) * 4;
 978	/* plug 2 for header */
 979	len += 2;
 980	if (len > 0x1F) {
 981		fusb302_log(chip,
 982			    "PD message too long %d (incl. header)", len);
 983		return -EINVAL;
 984	}
 985	/* packsym tells the FUSB302 chip that the next X bytes are payload */
 986	buf[pos++] = FUSB302_TKN_PACKSYM | (len & 0x1F);
 987	memcpy(&buf[pos], &msg->header, sizeof(msg->header));
 988	pos += sizeof(msg->header);
 989
 990	len -= 2;
 991	memcpy(&buf[pos], msg->payload, len);
 992	pos += len;
 993
 994	/* CRC */
 995	buf[pos++] = FUSB302_TKN_JAMCRC;
 996	/* EOP */
 997	buf[pos++] = FUSB302_TKN_EOP;
 998	/* turn tx off after sending message */
 999	buf[pos++] = FUSB302_TKN_TXOFF;
1000	/* start transmission */
1001	buf[pos++] = FUSB302_TKN_TXON;
1002
1003	ret = fusb302_i2c_block_write(chip, FUSB_REG_FIFOS, pos, buf);
1004	if (ret < 0)
1005		return ret;
1006	fusb302_log(chip, "sending PD message header: %x", msg->header);
1007	fusb302_log(chip, "sending PD message len: %d", len);
1008
1009	return ret;
1010}
1011
1012static int fusb302_pd_send_hardreset(struct fusb302_chip *chip)
1013{
1014	return fusb302_i2c_set_bits(chip, FUSB_REG_CONTROL3,
1015				    FUSB_REG_CONTROL3_SEND_HARDRESET);
1016}
1017
1018static const char * const transmit_type_name[] = {
1019	[TCPC_TX_SOP]			= "SOP",
1020	[TCPC_TX_SOP_PRIME]		= "SOP'",
1021	[TCPC_TX_SOP_PRIME_PRIME]	= "SOP''",
1022	[TCPC_TX_SOP_DEBUG_PRIME]	= "DEBUG'",
1023	[TCPC_TX_SOP_DEBUG_PRIME_PRIME]	= "DEBUG''",
1024	[TCPC_TX_HARD_RESET]		= "HARD_RESET",
1025	[TCPC_TX_CABLE_RESET]		= "CABLE_RESET",
1026	[TCPC_TX_BIST_MODE_2]		= "BIST_MODE_2",
1027};
1028
1029static int tcpm_pd_transmit(struct tcpc_dev *dev, enum tcpm_transmit_type type,
1030			    const struct pd_message *msg, unsigned int negotiated_rev)
1031{
1032	struct fusb302_chip *chip = container_of(dev, struct fusb302_chip,
1033						 tcpc_dev);
1034	int ret = 0;
1035
1036	mutex_lock(&chip->lock);
1037	switch (type) {
1038	case TCPC_TX_SOP:
1039		/* nRetryCount 3 in P2.0 spec, whereas 2 in PD3.0 spec */
1040		ret = fusb302_enable_tx_auto_retries(chip, negotiated_rev > PD_REV20 ?
1041						     FUSB_REG_CONTROL3_N_RETRIES_2 :
1042						     FUSB_REG_CONTROL3_N_RETRIES_3);
1043		if (ret < 0)
1044			fusb302_log(chip, "Cannot update retry count ret=%d", ret);
1045
1046		ret = fusb302_pd_send_message(chip, msg);
1047		if (ret < 0)
1048			fusb302_log(chip,
1049				    "cannot send PD message, ret=%d", ret);
1050		break;
1051	case TCPC_TX_HARD_RESET:
1052		ret = fusb302_pd_send_hardreset(chip);
1053		if (ret < 0)
1054			fusb302_log(chip,
1055				    "cannot send hardreset, ret=%d", ret);
1056		break;
1057	default:
1058		fusb302_log(chip, "type %s not supported",
1059			    transmit_type_name[type]);
1060		ret = -EINVAL;
1061	}
1062	mutex_unlock(&chip->lock);
1063
1064	return ret;
1065}
1066
1067static enum typec_cc_status fusb302_bc_lvl_to_cc(u8 bc_lvl)
1068{
1069	if (bc_lvl == FUSB_REG_STATUS0_BC_LVL_1230_MAX)
1070		return TYPEC_CC_RP_3_0;
1071	if (bc_lvl == FUSB_REG_STATUS0_BC_LVL_600_1230)
1072		return TYPEC_CC_RP_1_5;
1073	if (bc_lvl == FUSB_REG_STATUS0_BC_LVL_200_600)
1074		return TYPEC_CC_RP_DEF;
1075	return TYPEC_CC_OPEN;
1076}
1077
1078static void fusb302_bc_lvl_handler_work(struct work_struct *work)
1079{
1080	struct fusb302_chip *chip = container_of(work, struct fusb302_chip,
1081						 bc_lvl_handler.work);
1082	int ret = 0;
1083	u8 status0;
1084	u8 bc_lvl;
1085	enum typec_cc_status cc_status;
1086
1087	mutex_lock(&chip->lock);
1088	if (!chip->intr_bc_lvl) {
1089		fusb302_log(chip, "BC_LVL interrupt is turned off, abort");
1090		goto done;
1091	}
1092	ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1093	if (ret < 0)
1094		goto done;
1095	fusb302_log(chip, "BC_LVL handler, status0=0x%02x", status0);
1096	if (status0 & FUSB_REG_STATUS0_ACTIVITY) {
1097		fusb302_log(chip, "CC activities detected, delay handling");
1098		mod_delayed_work(chip->wq, &chip->bc_lvl_handler,
1099				 msecs_to_jiffies(T_BC_LVL_DEBOUNCE_DELAY_MS));
1100		goto done;
1101	}
1102	bc_lvl = status0 & FUSB_REG_STATUS0_BC_LVL_MASK;
1103	cc_status = fusb302_bc_lvl_to_cc(bc_lvl);
1104	if (chip->cc_polarity == TYPEC_POLARITY_CC1) {
1105		if (chip->cc1 != cc_status) {
1106			fusb302_log(chip, "cc1: %s -> %s",
1107				    typec_cc_status_name[chip->cc1],
1108				    typec_cc_status_name[cc_status]);
1109			chip->cc1 = cc_status;
1110			tcpm_cc_change(chip->tcpm_port);
1111		}
1112	} else {
1113		if (chip->cc2 != cc_status) {
1114			fusb302_log(chip, "cc2: %s -> %s",
1115				    typec_cc_status_name[chip->cc2],
1116				    typec_cc_status_name[cc_status]);
1117			chip->cc2 = cc_status;
1118			tcpm_cc_change(chip->tcpm_port);
1119		}
1120	}
1121
1122done:
1123	mutex_unlock(&chip->lock);
1124}
1125
1126static void init_tcpc_dev(struct tcpc_dev *fusb302_tcpc_dev)
1127{
1128	fusb302_tcpc_dev->init = tcpm_init;
1129	fusb302_tcpc_dev->get_vbus = tcpm_get_vbus;
1130	fusb302_tcpc_dev->get_current_limit = tcpm_get_current_limit;
1131	fusb302_tcpc_dev->set_cc = tcpm_set_cc;
1132	fusb302_tcpc_dev->get_cc = tcpm_get_cc;
1133	fusb302_tcpc_dev->set_polarity = tcpm_set_polarity;
1134	fusb302_tcpc_dev->set_vconn = tcpm_set_vconn;
1135	fusb302_tcpc_dev->set_vbus = tcpm_set_vbus;
1136	fusb302_tcpc_dev->set_pd_rx = tcpm_set_pd_rx;
1137	fusb302_tcpc_dev->set_roles = tcpm_set_roles;
1138	fusb302_tcpc_dev->start_toggling = tcpm_start_toggling;
1139	fusb302_tcpc_dev->pd_transmit = tcpm_pd_transmit;
1140}
1141
1142static const char * const cc_polarity_name[] = {
1143	[TYPEC_POLARITY_CC1]	= "Polarity_CC1",
1144	[TYPEC_POLARITY_CC2]	= "Polarity_CC2",
1145};
1146
1147static int fusb302_set_cc_polarity_and_pull(struct fusb302_chip *chip,
1148					    enum typec_cc_polarity cc_polarity,
1149					    bool pull_up, bool pull_down)
1150{
1151	int ret = 0;
1152	u8 switches0_data = 0x00;
1153	u8 switches1_mask = FUSB_REG_SWITCHES1_TXCC1_EN |
1154			    FUSB_REG_SWITCHES1_TXCC2_EN;
1155	u8 switches1_data = 0x00;
1156
1157	if (pull_down)
1158		switches0_data |= FUSB_REG_SWITCHES0_CC1_PD_EN |
1159				  FUSB_REG_SWITCHES0_CC2_PD_EN;
1160
1161	if (cc_polarity == TYPEC_POLARITY_CC1) {
1162		switches0_data |= FUSB_REG_SWITCHES0_MEAS_CC1;
1163		if (chip->vconn_on)
1164			switches0_data |= FUSB_REG_SWITCHES0_VCONN_CC2;
1165		if (pull_up)
1166			switches0_data |= FUSB_REG_SWITCHES0_CC1_PU_EN;
1167		switches1_data = FUSB_REG_SWITCHES1_TXCC1_EN;
1168	} else {
1169		switches0_data |= FUSB_REG_SWITCHES0_MEAS_CC2;
1170		if (chip->vconn_on)
1171			switches0_data |= FUSB_REG_SWITCHES0_VCONN_CC1;
1172		if (pull_up)
1173			switches0_data |= FUSB_REG_SWITCHES0_CC2_PU_EN;
1174		switches1_data = FUSB_REG_SWITCHES1_TXCC2_EN;
1175	}
1176	ret = fusb302_i2c_write(chip, FUSB_REG_SWITCHES0, switches0_data);
1177	if (ret < 0)
1178		return ret;
1179	ret = fusb302_i2c_mask_write(chip, FUSB_REG_SWITCHES1,
1180				     switches1_mask, switches1_data);
1181	if (ret < 0)
1182		return ret;
1183	chip->cc_polarity = cc_polarity;
1184
1185	return ret;
1186}
1187
1188static int fusb302_handle_togdone_snk(struct fusb302_chip *chip,
1189				      u8 togdone_result)
1190{
1191	int ret = 0;
1192	u8 status0;
1193	u8 bc_lvl;
1194	enum typec_cc_polarity cc_polarity;
1195	enum typec_cc_status cc_status_active, cc1, cc2;
1196
1197	/* set polarity and pull_up, pull_down */
1198	cc_polarity = (togdone_result == FUSB_REG_STATUS1A_TOGSS_SNK1) ?
1199		      TYPEC_POLARITY_CC1 : TYPEC_POLARITY_CC2;
1200	ret = fusb302_set_cc_polarity_and_pull(chip, cc_polarity, false, true);
1201	if (ret < 0) {
1202		fusb302_log(chip, "cannot set cc polarity %s, ret=%d",
1203			    cc_polarity_name[cc_polarity], ret);
1204		return ret;
1205	}
1206	/* fusb302_set_cc_polarity() has set the correct measure block */
1207	ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1208	if (ret < 0)
1209		return ret;
1210	bc_lvl = status0 & FUSB_REG_STATUS0_BC_LVL_MASK;
1211	cc_status_active = fusb302_bc_lvl_to_cc(bc_lvl);
1212	/* restart toggling if the cc status on the active line is OPEN */
1213	if (cc_status_active == TYPEC_CC_OPEN) {
1214		fusb302_log(chip, "restart toggling as CC_OPEN detected");
1215		ret = fusb302_set_toggling(chip, chip->toggling_mode);
1216		return ret;
1217	}
1218	/* update tcpm with the new cc value */
1219	cc1 = (cc_polarity == TYPEC_POLARITY_CC1) ?
1220	      cc_status_active : TYPEC_CC_OPEN;
1221	cc2 = (cc_polarity == TYPEC_POLARITY_CC2) ?
1222	      cc_status_active : TYPEC_CC_OPEN;
1223	if ((chip->cc1 != cc1) || (chip->cc2 != cc2)) {
1224		chip->cc1 = cc1;
1225		chip->cc2 = cc2;
1226		tcpm_cc_change(chip->tcpm_port);
1227	}
1228	/* turn off toggling */
1229	ret = fusb302_set_toggling(chip, TOGGLING_MODE_OFF);
1230	if (ret < 0) {
1231		fusb302_log(chip,
1232			    "cannot set toggling mode off, ret=%d", ret);
1233		return ret;
1234	}
1235	/* unmask bc_lvl interrupt */
1236	ret = fusb302_i2c_clear_bits(chip, FUSB_REG_MASK, FUSB_REG_MASK_BC_LVL);
1237	if (ret < 0) {
1238		fusb302_log(chip,
1239			    "cannot unmask bc_lcl interrupt, ret=%d", ret);
1240		return ret;
1241	}
1242	chip->intr_bc_lvl = true;
1243	fusb302_log(chip, "detected cc1=%s, cc2=%s",
1244		    typec_cc_status_name[cc1],
1245		    typec_cc_status_name[cc2]);
1246
1247	return ret;
1248}
1249
1250/* On error returns < 0, otherwise a typec_cc_status value */
1251static int fusb302_get_src_cc_status(struct fusb302_chip *chip,
1252				     enum typec_cc_polarity cc_polarity,
1253				     enum typec_cc_status *cc)
1254{
1255	u8 ra_mda = ra_mda_value[chip->src_current_status];
1256	u8 rd_mda = rd_mda_value[chip->src_current_status];
1257	u8 switches0_data, status0;
1258	int ret;
1259
1260	/* Step 1: Set switches so that we measure the right CC pin */
1261	switches0_data = (cc_polarity == TYPEC_POLARITY_CC1) ?
1262		FUSB_REG_SWITCHES0_CC1_PU_EN | FUSB_REG_SWITCHES0_MEAS_CC1 :
1263		FUSB_REG_SWITCHES0_CC2_PU_EN | FUSB_REG_SWITCHES0_MEAS_CC2;
1264	ret = fusb302_i2c_write(chip, FUSB_REG_SWITCHES0, switches0_data);
1265	if (ret < 0)
1266		return ret;
1267
1268	fusb302_i2c_read(chip, FUSB_REG_SWITCHES0, &status0);
1269	fusb302_log(chip, "get_src_cc_status switches: 0x%0x", status0);
1270
1271	/* Step 2: Set compararator volt to differentiate between Open and Rd */
1272	ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, rd_mda);
1273	if (ret < 0)
1274		return ret;
1275
1276	usleep_range(50, 100);
1277	ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1278	if (ret < 0)
1279		return ret;
1280
1281	fusb302_log(chip, "get_src_cc_status rd_mda status0: 0x%0x", status0);
1282	if (status0 & FUSB_REG_STATUS0_COMP) {
1283		*cc = TYPEC_CC_OPEN;
1284		return 0;
1285	}
1286
1287	/* Step 3: Set compararator input to differentiate between Rd and Ra. */
1288	ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, ra_mda);
1289	if (ret < 0)
1290		return ret;
1291
1292	usleep_range(50, 100);
1293	ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1294	if (ret < 0)
1295		return ret;
1296
1297	fusb302_log(chip, "get_src_cc_status ra_mda status0: 0x%0x", status0);
1298	if (status0 & FUSB_REG_STATUS0_COMP)
1299		*cc = TYPEC_CC_RD;
1300	else
1301		*cc = TYPEC_CC_RA;
1302
1303	return 0;
1304}
1305
1306static int fusb302_handle_togdone_src(struct fusb302_chip *chip,
1307				      u8 togdone_result)
1308{
1309	/*
1310	 * - set polarity (measure cc, vconn, tx)
1311	 * - set pull_up, pull_down
1312	 * - set cc1, cc2, and update to tcpm_port
1313	 * - set I_COMP interrupt on
1314	 */
1315	int ret = 0;
1316	u8 rd_mda = rd_mda_value[chip->src_current_status];
1317	enum toggling_mode toggling_mode = chip->toggling_mode;
1318	enum typec_cc_polarity cc_polarity;
1319	enum typec_cc_status cc1, cc2;
1320
1321	/*
1322	 * The toggle-engine will stop in a src state if it sees either Ra or
1323	 * Rd. Determine the status for both CC pins, starting with the one
1324	 * where toggling stopped, as that is where the switches point now.
1325	 */
1326	if (togdone_result == FUSB_REG_STATUS1A_TOGSS_SRC1)
1327		ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC1, &cc1);
1328	else
1329		ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC2, &cc2);
1330	if (ret < 0)
1331		return ret;
1332	/* we must turn off toggling before we can measure the other pin */
1333	ret = fusb302_set_toggling(chip, TOGGLING_MODE_OFF);
1334	if (ret < 0) {
1335		fusb302_log(chip, "cannot set toggling mode off, ret=%d", ret);
1336		return ret;
1337	}
1338	/* get the status of the other pin */
1339	if (togdone_result == FUSB_REG_STATUS1A_TOGSS_SRC1)
1340		ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC2, &cc2);
1341	else
1342		ret = fusb302_get_src_cc_status(chip, TYPEC_POLARITY_CC1, &cc1);
1343	if (ret < 0)
1344		return ret;
1345
1346	/* determine polarity based on the status of both pins */
1347	if (cc1 == TYPEC_CC_RD &&
1348			(cc2 == TYPEC_CC_OPEN || cc2 == TYPEC_CC_RA)) {
1349		cc_polarity = TYPEC_POLARITY_CC1;
1350	} else if (cc2 == TYPEC_CC_RD &&
1351		    (cc1 == TYPEC_CC_OPEN || cc1 == TYPEC_CC_RA)) {
1352		cc_polarity = TYPEC_POLARITY_CC2;
1353	} else {
1354		fusb302_log(chip, "unexpected CC status cc1=%s, cc2=%s, restarting toggling",
1355			    typec_cc_status_name[cc1],
1356			    typec_cc_status_name[cc2]);
1357		return fusb302_set_toggling(chip, toggling_mode);
1358	}
1359	/* set polarity and pull_up, pull_down */
1360	ret = fusb302_set_cc_polarity_and_pull(chip, cc_polarity, true, false);
1361	if (ret < 0) {
1362		fusb302_log(chip, "cannot set cc polarity %s, ret=%d",
1363			    cc_polarity_name[cc_polarity], ret);
1364		return ret;
1365	}
1366	/* update tcpm with the new cc value */
1367	if ((chip->cc1 != cc1) || (chip->cc2 != cc2)) {
1368		chip->cc1 = cc1;
1369		chip->cc2 = cc2;
1370		tcpm_cc_change(chip->tcpm_port);
1371	}
1372	/* set MDAC to Rd threshold, and unmask I_COMP for unplug detection */
1373	ret = fusb302_i2c_write(chip, FUSB_REG_MEASURE, rd_mda);
1374	if (ret < 0)
1375		return ret;
1376	/* unmask comp_chng interrupt */
1377	ret = fusb302_i2c_clear_bits(chip, FUSB_REG_MASK,
1378				     FUSB_REG_MASK_COMP_CHNG);
1379	if (ret < 0) {
1380		fusb302_log(chip,
1381			    "cannot unmask comp_chng interrupt, ret=%d", ret);
1382		return ret;
1383	}
1384	chip->intr_comp_chng = true;
1385	fusb302_log(chip, "detected cc1=%s, cc2=%s",
1386		    typec_cc_status_name[cc1],
1387		    typec_cc_status_name[cc2]);
1388
1389	return ret;
1390}
1391
1392static int fusb302_handle_togdone(struct fusb302_chip *chip)
1393{
1394	int ret = 0;
1395	u8 status1a;
1396	u8 togdone_result;
1397
1398	ret = fusb302_i2c_read(chip, FUSB_REG_STATUS1A, &status1a);
1399	if (ret < 0)
1400		return ret;
1401	togdone_result = (status1a >> FUSB_REG_STATUS1A_TOGSS_POS) &
1402			 FUSB_REG_STATUS1A_TOGSS_MASK;
1403	switch (togdone_result) {
1404	case FUSB_REG_STATUS1A_TOGSS_SNK1:
1405	case FUSB_REG_STATUS1A_TOGSS_SNK2:
1406		return fusb302_handle_togdone_snk(chip, togdone_result);
1407	case FUSB_REG_STATUS1A_TOGSS_SRC1:
1408	case FUSB_REG_STATUS1A_TOGSS_SRC2:
1409		return fusb302_handle_togdone_src(chip, togdone_result);
1410	case FUSB_REG_STATUS1A_TOGSS_AA:
1411		/* doesn't support */
1412		fusb302_log(chip, "AudioAccessory not supported");
1413		fusb302_set_toggling(chip, chip->toggling_mode);
1414		break;
1415	default:
1416		fusb302_log(chip, "TOGDONE with an invalid state: %d",
1417			    togdone_result);
1418		fusb302_set_toggling(chip, chip->toggling_mode);
1419		break;
1420	}
1421	return ret;
1422}
1423
1424static int fusb302_pd_reset(struct fusb302_chip *chip)
1425{
1426	return fusb302_i2c_set_bits(chip, FUSB_REG_RESET,
1427				    FUSB_REG_RESET_PD_RESET);
1428}
1429
1430static int fusb302_pd_read_message(struct fusb302_chip *chip,
1431				   struct pd_message *msg)
1432{
1433	int ret = 0;
1434	u8 token;
1435	u8 crc[4];
1436	int len;
1437
1438	/* first SOP token */
1439	ret = fusb302_i2c_read(chip, FUSB_REG_FIFOS, &token);
1440	if (ret < 0)
1441		return ret;
1442	ret = fusb302_i2c_block_read(chip, FUSB_REG_FIFOS, 2,
1443				     (u8 *)&msg->header);
1444	if (ret < 0)
1445		return ret;
1446	len = pd_header_cnt_le(msg->header) * 4;
1447	/* add 4 to length to include the CRC */
1448	if (len > PD_MAX_PAYLOAD * 4) {
1449		fusb302_log(chip, "PD message too long %d", len);
1450		return -EINVAL;
1451	}
1452	if (len > 0) {
1453		ret = fusb302_i2c_block_read(chip, FUSB_REG_FIFOS, len,
1454					     (u8 *)msg->payload);
1455		if (ret < 0)
1456			return ret;
1457	}
1458	/* another 4 bytes to read CRC out */
1459	ret = fusb302_i2c_block_read(chip, FUSB_REG_FIFOS, 4, crc);
1460	if (ret < 0)
1461		return ret;
1462	fusb302_log(chip, "PD message header: %x", msg->header);
1463	fusb302_log(chip, "PD message len: %d", len);
1464
1465	/*
1466	 * Check if we've read off a GoodCRC message. If so then indicate to
1467	 * TCPM that the previous transmission has completed. Otherwise we pass
1468	 * the received message over to TCPM for processing.
1469	 *
1470	 * We make this check here instead of basing the reporting decision on
1471	 * the IRQ event type, as it's possible for the chip to report the
1472	 * TX_SUCCESS and GCRCSENT events out of order on occasion, so we need
1473	 * to check the message type to ensure correct reporting to TCPM.
1474	 */
1475	if ((!len) && (pd_header_type_le(msg->header) == PD_CTRL_GOOD_CRC))
1476		tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_SUCCESS);
1477	else
1478		tcpm_pd_receive(chip->tcpm_port, msg, TCPC_TX_SOP);
1479
1480	return ret;
1481}
1482
1483static irqreturn_t fusb302_irq_intn(int irq, void *dev_id)
1484{
1485	struct fusb302_chip *chip = dev_id;
1486	unsigned long flags;
1487
1488	/* Disable our level triggered IRQ until our irq_work has cleared it */
1489	disable_irq_nosync(chip->gpio_int_n_irq);
1490
1491	spin_lock_irqsave(&chip->irq_lock, flags);
1492	if (chip->irq_suspended)
1493		chip->irq_while_suspended = true;
1494	else
1495		schedule_work(&chip->irq_work);
1496	spin_unlock_irqrestore(&chip->irq_lock, flags);
1497
1498	return IRQ_HANDLED;
1499}
1500
1501static void fusb302_irq_work(struct work_struct *work)
1502{
1503	struct fusb302_chip *chip = container_of(work, struct fusb302_chip,
1504						 irq_work);
1505	int ret = 0;
1506	u8 interrupt;
1507	u8 interrupta;
1508	u8 interruptb;
1509	u8 status0;
1510	bool vbus_present;
1511	bool comp_result;
1512	bool intr_togdone;
1513	bool intr_bc_lvl;
1514	bool intr_comp_chng;
1515	struct pd_message pd_msg;
1516
1517	mutex_lock(&chip->lock);
1518	/* grab a snapshot of intr flags */
1519	intr_togdone = chip->intr_togdone;
1520	intr_bc_lvl = chip->intr_bc_lvl;
1521	intr_comp_chng = chip->intr_comp_chng;
1522
1523	ret = fusb302_i2c_read(chip, FUSB_REG_INTERRUPT, &interrupt);
1524	if (ret < 0)
1525		goto done;
1526	ret = fusb302_i2c_read(chip, FUSB_REG_INTERRUPTA, &interrupta);
1527	if (ret < 0)
1528		goto done;
1529	ret = fusb302_i2c_read(chip, FUSB_REG_INTERRUPTB, &interruptb);
1530	if (ret < 0)
1531		goto done;
1532	ret = fusb302_i2c_read(chip, FUSB_REG_STATUS0, &status0);
1533	if (ret < 0)
1534		goto done;
1535	fusb302_log(chip,
1536		    "IRQ: 0x%02x, a: 0x%02x, b: 0x%02x, status0: 0x%02x",
1537		    interrupt, interrupta, interruptb, status0);
1538
1539	if (interrupt & FUSB_REG_INTERRUPT_VBUSOK) {
1540		vbus_present = !!(status0 & FUSB_REG_STATUS0_VBUSOK);
1541		fusb302_log(chip, "IRQ: VBUS_OK, vbus=%s",
1542			    str_on_off(vbus_present));
1543		if (vbus_present != chip->vbus_present) {
1544			chip->vbus_present = vbus_present;
1545			tcpm_vbus_change(chip->tcpm_port);
1546		}
1547	}
1548
1549	if ((interrupta & FUSB_REG_INTERRUPTA_TOGDONE) && intr_togdone) {
1550		fusb302_log(chip, "IRQ: TOGDONE");
1551		ret = fusb302_handle_togdone(chip);
1552		if (ret < 0) {
1553			fusb302_log(chip,
1554				    "handle togdone error, ret=%d", ret);
1555			goto done;
1556		}
1557	}
1558
1559	if ((interrupt & FUSB_REG_INTERRUPT_BC_LVL) && intr_bc_lvl) {
1560		fusb302_log(chip, "IRQ: BC_LVL, handler pending");
1561		/*
1562		 * as BC_LVL interrupt can be affected by PD activity,
1563		 * apply delay to for the handler to wait for the PD
1564		 * signaling to finish.
1565		 */
1566		mod_delayed_work(chip->wq, &chip->bc_lvl_handler,
1567				 msecs_to_jiffies(T_BC_LVL_DEBOUNCE_DELAY_MS));
1568	}
1569
1570	if ((interrupt & FUSB_REG_INTERRUPT_COMP_CHNG) && intr_comp_chng) {
1571		comp_result = !!(status0 & FUSB_REG_STATUS0_COMP);
1572		fusb302_log(chip, "IRQ: COMP_CHNG, comp=%s",
1573			    str_true_false(comp_result));
1574		if (comp_result) {
1575			/* cc level > Rd_threshold, detach */
1576			chip->cc1 = TYPEC_CC_OPEN;
1577			chip->cc2 = TYPEC_CC_OPEN;
1578			tcpm_cc_change(chip->tcpm_port);
1579		}
1580	}
1581
1582	if (interrupt & FUSB_REG_INTERRUPT_COLLISION) {
1583		fusb302_log(chip, "IRQ: PD collision");
1584		tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_FAILED);
1585	}
1586
1587	if (interrupta & FUSB_REG_INTERRUPTA_RETRYFAIL) {
1588		fusb302_log(chip, "IRQ: PD retry failed");
1589		tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_FAILED);
1590	}
1591
1592	if (interrupta & FUSB_REG_INTERRUPTA_HARDSENT) {
1593		fusb302_log(chip, "IRQ: PD hardreset sent");
1594		ret = fusb302_pd_reset(chip);
1595		if (ret < 0) {
1596			fusb302_log(chip, "cannot PD reset, ret=%d", ret);
1597			goto done;
1598		}
1599		tcpm_pd_transmit_complete(chip->tcpm_port, TCPC_TX_SUCCESS);
1600	}
1601
1602	if (interrupta & FUSB_REG_INTERRUPTA_TX_SUCCESS) {
1603		fusb302_log(chip, "IRQ: PD tx success");
1604		ret = fusb302_pd_read_message(chip, &pd_msg);
1605		if (ret < 0) {
1606			fusb302_log(chip,
1607				    "cannot read in PD message, ret=%d", ret);
1608			goto done;
1609		}
1610	}
1611
1612	if (interrupta & FUSB_REG_INTERRUPTA_HARDRESET) {
1613		fusb302_log(chip, "IRQ: PD received hardreset");
1614		ret = fusb302_pd_reset(chip);
1615		if (ret < 0) {
1616			fusb302_log(chip, "cannot PD reset, ret=%d", ret);
1617			goto done;
1618		}
1619		tcpm_pd_hard_reset(chip->tcpm_port);
1620	}
1621
1622	if (interruptb & FUSB_REG_INTERRUPTB_GCRCSENT) {
1623		fusb302_log(chip, "IRQ: PD sent good CRC");
1624		ret = fusb302_pd_read_message(chip, &pd_msg);
1625		if (ret < 0) {
1626			fusb302_log(chip,
1627				    "cannot read in PD message, ret=%d", ret);
1628			goto done;
1629		}
1630	}
1631done:
1632	mutex_unlock(&chip->lock);
1633	enable_irq(chip->gpio_int_n_irq);
1634}
1635
1636static int init_gpio(struct fusb302_chip *chip)
1637{
1638	struct device *dev = chip->dev;
1639	int ret = 0;
1640
1641	chip->gpio_int_n = devm_gpiod_get(dev, "fcs,int_n", GPIOD_IN);
1642	if (IS_ERR(chip->gpio_int_n)) {
1643		dev_err(dev, "failed to request gpio_int_n\n");
1644		return PTR_ERR(chip->gpio_int_n);
1645	}
1646	ret = gpiod_to_irq(chip->gpio_int_n);
1647	if (ret < 0) {
1648		dev_err(dev,
1649			"cannot request IRQ for GPIO Int_N, ret=%d", ret);
1650		return ret;
1651	}
1652	chip->gpio_int_n_irq = ret;
1653	return 0;
1654}
1655
1656#define PDO_FIXED_FLAGS \
1657	(PDO_FIXED_DUAL_ROLE | PDO_FIXED_DATA_SWAP | PDO_FIXED_USB_COMM)
1658
1659static const u32 src_pdo[] = {
1660	PDO_FIXED(5000, 400, PDO_FIXED_FLAGS)
1661};
1662
1663static const u32 snk_pdo[] = {
1664	PDO_FIXED(5000, 400, PDO_FIXED_FLAGS)
1665};
1666
1667static const struct property_entry port_props[] = {
1668	PROPERTY_ENTRY_STRING("data-role", "dual"),
1669	PROPERTY_ENTRY_STRING("power-role", "dual"),
1670	PROPERTY_ENTRY_STRING("try-power-role", "sink"),
1671	PROPERTY_ENTRY_U32_ARRAY("source-pdos", src_pdo),
1672	PROPERTY_ENTRY_U32_ARRAY("sink-pdos", snk_pdo),
1673	PROPERTY_ENTRY_U32("op-sink-microwatt", 2500000),
1674	{ }
1675};
1676
1677static struct fwnode_handle *fusb302_fwnode_get(struct device *dev)
1678{
1679	struct fwnode_handle *fwnode;
1680
1681	fwnode = device_get_named_child_node(dev, "connector");
1682	if (!fwnode)
1683		fwnode = fwnode_create_software_node(port_props, NULL);
1684
1685	return fwnode;
1686}
1687
1688static int fusb302_probe(struct i2c_client *client)
1689{
1690	struct fusb302_chip *chip;
1691	struct i2c_adapter *adapter = client->adapter;
1692	struct device *dev = &client->dev;
1693	const char *name;
1694	int ret = 0;
1695
1696	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
1697		dev_err(&client->dev,
1698			"I2C/SMBus block functionality not supported!\n");
1699		return -ENODEV;
1700	}
1701	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
1702	if (!chip)
1703		return -ENOMEM;
1704
1705	chip->i2c_client = client;
1706	chip->dev = &client->dev;
1707	mutex_init(&chip->lock);
1708
1709	/*
1710	 * Devicetree platforms should get extcon via phandle (not yet
1711	 * supported). On ACPI platforms, we get the name from a device prop.
1712	 * This device prop is for kernel internal use only and is expected
1713	 * to be set by the platform code which also registers the i2c client
1714	 * for the fusb302.
1715	 */
1716	if (device_property_read_string(dev, "linux,extcon-name", &name) == 0) {
1717		chip->extcon = extcon_get_extcon_dev(name);
1718		if (IS_ERR(chip->extcon))
1719			return PTR_ERR(chip->extcon);
1720	}
1721
1722	chip->vbus = devm_regulator_get(chip->dev, "vbus");
1723	if (IS_ERR(chip->vbus))
1724		return PTR_ERR(chip->vbus);
1725
1726	chip->wq = create_singlethread_workqueue(dev_name(chip->dev));
1727	if (!chip->wq)
1728		return -ENOMEM;
1729
1730	spin_lock_init(&chip->irq_lock);
1731	INIT_WORK(&chip->irq_work, fusb302_irq_work);
1732	INIT_DELAYED_WORK(&chip->bc_lvl_handler, fusb302_bc_lvl_handler_work);
1733	init_tcpc_dev(&chip->tcpc_dev);
1734	fusb302_debugfs_init(chip);
1735
1736	if (client->irq) {
1737		chip->gpio_int_n_irq = client->irq;
1738	} else {
1739		ret = init_gpio(chip);
1740		if (ret < 0)
1741			goto destroy_workqueue;
1742	}
1743
1744	chip->tcpc_dev.fwnode = fusb302_fwnode_get(dev);
1745	if (IS_ERR(chip->tcpc_dev.fwnode)) {
1746		ret = PTR_ERR(chip->tcpc_dev.fwnode);
1747		goto destroy_workqueue;
1748	}
1749
1750	chip->tcpm_port = tcpm_register_port(&client->dev, &chip->tcpc_dev);
1751	if (IS_ERR(chip->tcpm_port)) {
1752		fwnode_handle_put(chip->tcpc_dev.fwnode);
1753		ret = dev_err_probe(dev, PTR_ERR(chip->tcpm_port),
1754				    "cannot register tcpm port\n");
1755		goto destroy_workqueue;
1756	}
1757
1758	ret = request_threaded_irq(chip->gpio_int_n_irq, NULL, fusb302_irq_intn,
1759				   IRQF_ONESHOT | IRQF_TRIGGER_LOW,
1760				   "fsc_interrupt_int_n", chip);
1761	if (ret < 0) {
1762		dev_err(dev, "cannot request IRQ for GPIO Int_N, ret=%d", ret);
1763		goto tcpm_unregister_port;
1764	}
1765	enable_irq_wake(chip->gpio_int_n_irq);
1766	i2c_set_clientdata(client, chip);
1767
1768	return ret;
1769
1770tcpm_unregister_port:
1771	tcpm_unregister_port(chip->tcpm_port);
1772	fwnode_handle_put(chip->tcpc_dev.fwnode);
1773destroy_workqueue:
1774	fusb302_debugfs_exit(chip);
1775	destroy_workqueue(chip->wq);
1776
1777	return ret;
1778}
1779
1780static void fusb302_remove(struct i2c_client *client)
1781{
1782	struct fusb302_chip *chip = i2c_get_clientdata(client);
1783
1784	disable_irq_wake(chip->gpio_int_n_irq);
1785	free_irq(chip->gpio_int_n_irq, chip);
1786	cancel_work_sync(&chip->irq_work);
1787	cancel_delayed_work_sync(&chip->bc_lvl_handler);
1788	tcpm_unregister_port(chip->tcpm_port);
1789	fwnode_handle_put(chip->tcpc_dev.fwnode);
1790	destroy_workqueue(chip->wq);
1791	fusb302_debugfs_exit(chip);
1792}
1793
1794static int fusb302_pm_suspend(struct device *dev)
1795{
1796	struct fusb302_chip *chip = dev->driver_data;
1797	unsigned long flags;
1798
1799	spin_lock_irqsave(&chip->irq_lock, flags);
1800	chip->irq_suspended = true;
1801	spin_unlock_irqrestore(&chip->irq_lock, flags);
1802
1803	/* Make sure any pending irq_work is finished before the bus suspends */
1804	flush_work(&chip->irq_work);
1805	return 0;
1806}
1807
1808static int fusb302_pm_resume(struct device *dev)
1809{
1810	struct fusb302_chip *chip = dev->driver_data;
1811	unsigned long flags;
1812
1813	spin_lock_irqsave(&chip->irq_lock, flags);
1814	if (chip->irq_while_suspended) {
1815		schedule_work(&chip->irq_work);
1816		chip->irq_while_suspended = false;
1817	}
1818	chip->irq_suspended = false;
1819	spin_unlock_irqrestore(&chip->irq_lock, flags);
1820
1821	return 0;
1822}
1823
1824static const struct of_device_id fusb302_dt_match[] __maybe_unused = {
1825	{.compatible = "fcs,fusb302"},
1826	{},
1827};
1828MODULE_DEVICE_TABLE(of, fusb302_dt_match);
1829
1830static const struct i2c_device_id fusb302_i2c_device_id[] = {
1831	{ "typec_fusb302" },
1832	{}
1833};
1834MODULE_DEVICE_TABLE(i2c, fusb302_i2c_device_id);
1835
1836static const struct dev_pm_ops fusb302_pm_ops = {
1837	.suspend = fusb302_pm_suspend,
1838	.resume = fusb302_pm_resume,
1839};
1840
1841static struct i2c_driver fusb302_driver = {
1842	.driver = {
1843		   .name = "typec_fusb302",
1844		   .pm = &fusb302_pm_ops,
1845		   .of_match_table = of_match_ptr(fusb302_dt_match),
1846		   },
1847	.probe = fusb302_probe,
1848	.remove = fusb302_remove,
1849	.id_table = fusb302_i2c_device_id,
1850};
1851module_i2c_driver(fusb302_driver);
1852
1853MODULE_AUTHOR("Yueyao Zhu <yueyao.zhu@gmail.com>");
1854MODULE_DESCRIPTION("Fairchild FUSB302 Type-C Chip Driver");
1855MODULE_LICENSE("GPL");