/*
 * max77705-muic.c - MUIC driver for the Maxim 77705
 *
 *  Copyright (C) 2015 Samsung Electronics
 *  Insun Choi <insun77.choi@samsung.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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/>.
 */

 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/of_gpio.h>
#include <linux/workqueue.h>
#include <linux/switch.h>

/* MUIC header file */
#include <linux/mfd/max77705.h>
#include <linux/mfd/max77705-private.h>
#include <linux/muic/muic.h>
#include <linux/muic/max77705-muic.h>
#include <linux/ccic/max77705.h>
#include <linux/ccic/max77705_usbc.h>

#if defined(CONFIG_MUIC_NOTIFIER)
#include <linux/muic/muic_notifier.h>
#endif /* CONFIG_MUIC_NOTIFIER */

#if defined(CONFIG_VBUS_NOTIFIER)
#include <linux/vbus_notifier.h>
#endif /* CONFIG_VBUS_NOTIFIER */

#if defined(CONFIG_USB_EXTERNAL_NOTIFY)
#include <linux/usb_notify.h>
#endif

#include <linux/sec_debug.h>
#include <linux/sec_ext.h>
#include <linux/sec_batt.h>

#include "../battery_v2/include/sec_charging_common.h"

struct max77705_muic_data *g_muic_data;

/* for the bringup, should be fixed */
void __init_usbc_cmd_data(usbc_cmd_data *cmd_data)
{
	pr_warn("%s is not defined!\n", __func__);
}
void __max77705_usbc_opcode_write(struct max77705_usbc_platform_data *usbc_data,
	usbc_cmd_data *write_op)
{
	pr_warn("%s is not defined!\n", __func__);
}
void init_usbc_cmd_data(usbc_cmd_data *cmd_data)
	__attribute__((weak, alias("__init_usbc_cmd_data")));
void max77705_usbc_opcode_write(struct max77705_usbc_platform_data *usbc_data,
	usbc_cmd_data *write_op)
	__attribute__((weak, alias("__max77705_usbc_opcode_write")));

static bool debug_en_vps;
static void max77705_muic_detect_dev(struct max77705_muic_data *muic_data, int irq);

struct max77705_muic_vps_data {
	int				adc;
	int				vbvolt;
	int				chgtyp;
	int				muic_switch;
	const char			*vps_name;
	const muic_attached_dev_t	attached_dev;
};

static int max77705_muic_read_reg
		(struct i2c_client *i2c, u8 reg, u8 *value)
{
	int ret = max77705_read_reg(i2c, reg, value);

	return ret;
}

#if 0
static int max77705_muic_write_reg
		(struct i2c_client *i2c, u8 reg, u8 value, bool debug_en)
{
	int ret = max77705_write_reg(i2c, reg, value);

	if (debug_en)
		pr_info("%s Reg[0x%02x]: 0x%02x\n",
				__func__, reg, value);

	return ret;
}
#endif

#if defined(CONFIG_VBUS_NOTIFIER)
static void max77705_muic_handle_vbus(struct max77705_muic_data *muic_data)
{
	int vbvolt = muic_data->status3 & BC_STATUS_VBUSDET_MASK;
	vbus_status_t status = (vbvolt > 0) ?
		STATUS_VBUS_HIGH : STATUS_VBUS_LOW;

	pr_info("%s <%d>\n", __func__, status);

	vbus_notifier_handle(status);
}
#endif

static const struct max77705_muic_vps_data muic_vps_table[] = {
	{
		.adc		= MAX77705_UIADC_523K,
		.vbvolt		= VB_LOW,
		.chgtyp		= CHGTYP_NO_VOLTAGE,
		.muic_switch	= COM_UART,
		.vps_name	= "JIG UART OFF",
		.attached_dev	= ATTACHED_DEV_JIG_UART_OFF_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_523K,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DONTCARE,
		.muic_switch	= COM_UART,
		.vps_name	= "JIG UART OFF/VB",
		.attached_dev	= ATTACHED_DEV_JIG_UART_OFF_VB_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_619K,
		.vbvolt		= VB_LOW,
		.chgtyp		= CHGTYP_NO_VOLTAGE,
		.muic_switch	= COM_UART,
		.vps_name	= "JIG UART ON",
		.attached_dev	= ATTACHED_DEV_JIG_UART_ON_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_619K,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DONTCARE,
		.muic_switch	= COM_UART,
		.vps_name	= "JIG UART ON/VB",
		.attached_dev	= ATTACHED_DEV_JIG_UART_ON_VB_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_255K,
#if defined(CONFIG_SEC_FACTORY)
		.vbvolt		= VB_DONTCARE,
#else
		.vbvolt		= VB_HIGH,
#endif
		.chgtyp		= CHGTYP_DONTCARE,
		.muic_switch	= COM_USB,
		.vps_name	= "JIG USB OFF",
		.attached_dev	= ATTACHED_DEV_JIG_USB_OFF_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_301K,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DONTCARE,
		.muic_switch	= COM_USB,
		.vps_name	= "JIG USB ON",
		.attached_dev	= ATTACHED_DEV_JIG_USB_ON_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DEDICATED_CHARGER,
		.muic_switch	= COM_OPEN,
		.vps_name	= "TA",
		.attached_dev	= ATTACHED_DEV_TA_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_USB,
		.muic_switch	= COM_USB,
		.vps_name	= "USB",
		.attached_dev	= ATTACHED_DEV_USB_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_TIMEOUT_OPEN,
		.muic_switch	= COM_USB,
		.vps_name	= "DCD Timeout",
		.attached_dev	= ATTACHED_DEV_TIMEOUT_OPEN_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_CDP,
		.muic_switch	= COM_USB,
		.vps_name	= "CDP",
		.attached_dev	= ATTACHED_DEV_CDP_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_GND,
		.vbvolt		= VB_DONTCARE,
		.chgtyp		= CHGTYP_DONTCARE,
		.muic_switch	= COM_USB,
		.vps_name	= "OTG",
		.attached_dev	= ATTACHED_DEV_OTG_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_UNOFFICIAL_CHARGER,
		.muic_switch	= COM_OPEN,
		.vps_name	= "Unofficial TA",
		.attached_dev	= ATTACHED_DEV_UNOFFICIAL_TA_MUIC,
	},
#if defined(CONFIG_HICCUP_CHARGER)
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_DONTCARE,
		.chgtyp		= CHGTYP_HICCUP_MODE,
		.muic_switch	= COM_USB_CP,
		.vps_name	= "Hiccup mode",
		.attached_dev	= ATTACHED_DEV_HICCUP_MUIC,
	},
#endif
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DEDICATED_CHARGER,
		.muic_switch	= COM_OPEN,
		.vps_name	= "AFC Charger",
		.attached_dev	= ATTACHED_DEV_AFC_CHARGER_9V_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DEDICATED_CHARGER,
		.muic_switch	= COM_OPEN,
		.vps_name	= "AFC Charger",
		.attached_dev	= ATTACHED_DEV_AFC_CHARGER_5V_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DEDICATED_CHARGER,
		.muic_switch	= COM_OPEN,
		.vps_name	= "QC Charger",
		.attached_dev	= ATTACHED_DEV_QC_CHARGER_9V_MUIC,
	},
	{
		.adc		= MAX77705_UIADC_OPEN,
		.vbvolt		= VB_HIGH,
		.chgtyp		= CHGTYP_DEDICATED_CHARGER,
		.muic_switch	= COM_OPEN,
		.vps_name	= "QC Charger",
		.attached_dev	= ATTACHED_DEV_QC_CHARGER_5V_MUIC,
	},
#endif
};

static int muic_lookup_vps_table(muic_attached_dev_t new_dev,
	struct max77705_muic_data *muic_data)
{
	int i;
	struct i2c_client *i2c = muic_data->i2c;
	u8 reg_data;
	const struct max77705_muic_vps_data *tmp_vps;

	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_USBC_STATUS2, &reg_data);
	reg_data = reg_data & USBC_STATUS2_SYSMSG_MASK;
	pr_info("%s Last sysmsg = 0x%02x\n", __func__, reg_data);

	for (i = 0; i < (int)ARRAY_SIZE(muic_vps_table); i++) {
		tmp_vps = &(muic_vps_table[i]);

		if (tmp_vps->attached_dev != new_dev)
			continue;

		pr_info("%s (%d) vps table match found at i(%d), %s\n",
				__func__, new_dev, i,
				tmp_vps->vps_name);

		return i;
	}

	pr_info("%s can't find (%d) on vps table\n",
			__func__, new_dev);

	return -ENODEV;
}

static bool muic_check_support_dev(struct max77705_muic_data *muic_data,
			muic_attached_dev_t attached_dev)
{
	bool ret = muic_data->muic_support_list[attached_dev];

	if (debug_en_vps)
		pr_info("%s [%c]\n", __func__, ret ? 'T':'F');

	return ret;
}

static void max77705_switch_path(struct max77705_muic_data *muic_data,
	u8 reg_val)
{
	struct max77705_usbc_platform_data *usbc_pdata = muic_data->usbc_pdata;
	usbc_cmd_data write_data;

	pr_info("%s value(0x%x)\n", __func__, reg_val);

#if defined(CONFIG_CCIC_NOTIFIER)
	if (muic_data->usbc_pdata->fac_water_enable) {
		pr_info("%s fac_water_enable(%d), skip\n", __func__,
			muic_data->usbc_pdata->fac_water_enable);
		return;
	}
#endif

	init_usbc_cmd_data(&write_data);
	write_data.opcode = COMMAND_CONTROL1_WRITE;
	write_data.write_length = 1;
	write_data.write_data[0] = reg_val;
	write_data.read_length = 0;

	max77705_usbc_opcode_write(usbc_pdata, &write_data);
}

static void com_to_open(struct max77705_muic_data *muic_data)
{
	u8 reg_val;

	pr_info("%s\n", __func__);

	reg_val = COM_OPEN;

	/* write command - switch */
	max77705_switch_path(muic_data, reg_val);
}

static int com_to_usb_ap(struct max77705_muic_data *muic_data)
{
	u8 reg_val;
	int ret = 0;

	pr_info("%s\n", __func__);

	reg_val = COM_USB;

	/* write command - switch */
	max77705_switch_path(muic_data, reg_val);

	return ret;
}

static int com_to_usb_cp(struct max77705_muic_data *muic_data)
{
	u8 reg_val;
	int ret = 0;

	pr_info("%s\n", __func__);

	reg_val = COM_USB_CP;

	/* write command - switch */
	max77705_switch_path(muic_data, reg_val);

	return ret;
}

static void com_to_uart_ap(struct max77705_muic_data *muic_data)
{
	u8 reg_val;
#if defined(CONFIG_MUIC_MAX77705_CCIC)
	if ((muic_data->pdata->opmode == OPMODE_MUIC) && muic_data->pdata->rustproof_on)
#else
	if (muic_data->pdata->rustproof_on)
#endif
		reg_val = COM_OPEN;
	else
		reg_val = COM_UART;

	pr_info("%s(%d)\n", __func__, reg_val);

	/* write command - switch */
	max77705_switch_path(muic_data, reg_val);
}

static void com_to_uart_cp(struct max77705_muic_data *muic_data)
{
	u8 reg_val;

#if defined(CONFIG_MUIC_MAX77705_CCIC)
	if ((muic_data->pdata->opmode == OPMODE_MUIC) && muic_data->pdata->rustproof_on)
#else
	if (muic_data->pdata->rustproof_on)
#endif
		reg_val = COM_OPEN;
	else
		reg_val = COM_UART_CP;

	pr_info("%s(%d)\n", __func__, reg_val);

	/* write command - switch */
	max77705_switch_path(muic_data, reg_val);
}

static int write_vps_regs(struct max77705_muic_data *muic_data,
			muic_attached_dev_t new_dev)
{
	const struct max77705_muic_vps_data *tmp_vps;
	int vps_index;
	u8 prev_switch;

	vps_index = muic_lookup_vps_table(muic_data->attached_dev, muic_data);
	if (vps_index < 0) {
		pr_info("%s: prev cable is none.\n", __func__);
		prev_switch = COM_OPEN;
	} else {
		/* Prev cable information. */
		tmp_vps = &(muic_vps_table[vps_index]);
		prev_switch = tmp_vps->muic_switch;
	}

	if (prev_switch == muic_data->switch_val)
		pr_info("%s Duplicated(0x%02x), just ignore\n",
			__func__, muic_data->switch_val);
#if 0
	else {
		/* write command - switch */
		max77705_switch_path(muic_data, muic_data->switch_val);
	}
#endif

	return 0;
}

/* muic uart path control function */
static int switch_to_ap_uart(struct max77705_muic_data *muic_data,
						muic_attached_dev_t new_dev)
{
	int ret = 0;

	switch (new_dev) {
	case ATTACHED_DEV_JIG_UART_OFF_MUIC:
	case ATTACHED_DEV_JIG_UART_OFF_VB_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_VB_MUIC:
		com_to_uart_ap(muic_data);
		break;
	default:
		pr_warn("%s current attached is (%d) not Jig UART Off\n",
			__func__, muic_data->attached_dev);
		break;
	}

	return ret;
}

static int switch_to_cp_uart(struct max77705_muic_data *muic_data,
						muic_attached_dev_t new_dev)
{
	int ret = 0;

	switch (new_dev) {
	case ATTACHED_DEV_JIG_UART_OFF_MUIC:
	case ATTACHED_DEV_JIG_UART_OFF_VB_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_VB_MUIC:
		com_to_uart_cp(muic_data);
		break;
	default:
		pr_warn("%s current attached is (%d) not Jig UART Off\n",
			__func__, muic_data->attached_dev);
		break;
	}

	return ret;
}

static void max77705_muic_enable_detecting_short(struct max77705_muic_data *muic_data)
{
#if !defined(CONFIG_SEC_FACTORY)
	struct max77705_usbc_platform_data *usbc_pdata = muic_data->usbc_pdata;
	usbc_cmd_data write_data;

	pr_info("%s\n", __func__);

	init_usbc_cmd_data(&write_data);
	write_data.opcode = 0x56;
	write_data.write_length = 1;
	/*
	 * bit 0: Enable detecting vbus-cc short
	 * bit 1: Enable detecting sbu-gnd short
	 * bit 2: Enable detecting vbus-sbu short
	 */
	write_data.write_data[0] = 0x7;
	write_data.read_length = 1;

	max77705_usbc_opcode_write(usbc_pdata, &write_data);
#endif
}

static void max77705_muic_dp_reset(struct max77705_muic_data *muic_data)
{
	struct max77705_usbc_platform_data *usbc_pdata = muic_data->usbc_pdata;
	usbc_cmd_data update_data;

	pr_info("%s\n", __func__);

	init_usbc_cmd_data(&update_data);
	update_data.opcode = COMMAND_BC_CTRL2_READ;
	update_data.mask = BC_CTRL2_DPDNMan_MASK | BC_CTRL2_DPDrv_MASK;
	update_data.val = 0x10;

	max77705_usbc_opcode_update(usbc_pdata, &update_data);
}

static void max77705_muic_enable_chgdet(struct max77705_muic_data *muic_data)
{
	struct max77705_usbc_platform_data *usbc_pdata = muic_data->usbc_pdata;
	usbc_cmd_data update_data;

	pr_info("%s\n", __func__);

	init_usbc_cmd_data(&update_data);
	update_data.opcode = COMMAND_BC_CTRL1_READ;
	update_data.mask = BC_CTRL1_CHGDetEn_MASK | BC_CTRL1_CHGDetMan_MASK;
	update_data.val = 0xff;

	max77705_usbc_opcode_update(usbc_pdata, &update_data);
}

#if 0
static void max77705_muic_disable_chgdet(struct max77705_muic_data *muic_data)
{
	struct max77705_usbc_platform_data *usbc_pdata = muic_data->usbc_pdata;
	usbc_cmd_data update_data;

	pr_info("%s\n", __func__);

	init_usbc_cmd_data(&update_data);
	update_data.opcode = COMMAND_BC_CTRL1_READ;
	update_data.mask = BC_CTRL1_CHGDetEn_MASK;
	update_data.val = 0x0;

	max77705_usbc_opcode_update(usbc_pdata, &update_data);
}
#endif

static u8 max77705_muic_get_adc_value(struct max77705_muic_data *muic_data)
{
	u8 status;
	u8 adc = MAX77705_UIADC_ERROR;
	int ret;

	ret = max77705_muic_read_reg(muic_data->i2c,
			MAX77705_USBC_REG_USBC_STATUS1, &status);
	if (ret)
		pr_err("%s fail to read muic reg(%d)\n",
				__func__, ret);
	else
		adc = status & USBC_STATUS1_UIADC_MASK;

	return adc;
}

static u8 max77705_muic_get_vbadc_value(struct max77705_muic_data *muic_data)
{
	u8 status;
	u8 vbadc = 0;
	int ret;

	ret = max77705_muic_read_reg(muic_data->i2c,
			MAX77705_USBC_REG_USBC_STATUS1, &status);
	if (ret)
		pr_err("%s fail to read muic reg(%d)\n",
				__func__, ret);
	else
		vbadc = (status & USBC_STATUS1_VBADC_MASK) >> USBC_STATUS1_VBADC_SHIFT;

	return vbadc;
}

static ssize_t max77705_muic_show_uart_sel(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;
	const char *mode = "UNKNOWN\n";

	switch (pdata->uart_path) {
	case MUIC_PATH_UART_AP:
		mode = "AP\n";
		break;
	case MUIC_PATH_UART_CP:
		mode = "CP\n";
		break;
#if IS_ENABLED(CONFIG_MUIC_UART_SWITCH)
	case MUIC_PATH_UART_CP2:
		mode = "CP2\n";
		break;
#endif	/* CONFIG_MUIC_UART_SWITCH */
	default:
		break;
	}

	pr_info("%s %s", __func__, mode);
	return sprintf(buf, mode);
}

static ssize_t max77705_muic_set_uart_sel(struct device *dev,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;

	mutex_lock(&muic_data->muic_mutex);

	if (!strncasecmp(buf, "AP", 2)) {
		pdata->uart_path = MUIC_PATH_UART_AP;
		switch_to_ap_uart(muic_data, muic_data->attached_dev);
#if IS_ENABLED(CONFIG_MUIC_UART_SWITCH)
	} else if (!strncasecmp(buf, "CP2", 3)) {
		pdata->uart_path = MUIC_PATH_UART_CP2;
		muic_data->pdata->set_gpio_uart_sel(pdata->uart_path);
		switch_to_cp_uart(muic_data, muic_data->attached_dev);
#endif	/* CONFIG_MUIC_UART_SWITCH */
	} else if (!strncasecmp(buf, "CP", 2)) {
		pdata->uart_path = MUIC_PATH_UART_CP;
		switch_to_cp_uart(muic_data, muic_data->attached_dev);
	} else {
		pr_warn("%s invalid value\n", __func__);
	}

	pr_info("%s uart_path(%d)\n", __func__,
			pdata->uart_path);

	mutex_unlock(&muic_data->muic_mutex);

	return count;
}

static ssize_t max77705_muic_show_usb_sel(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;
	const char *mode = "UNKNOWN\n";

	switch (pdata->usb_path) {
	case MUIC_PATH_USB_AP:
		mode = "PDA\n";
		break;
	case MUIC_PATH_USB_CP:
		mode = "MODEM\n";
		break;
	default:
		break;
	}

	pr_debug("%s %s", __func__, mode);
	return sprintf(buf, mode);
}

static ssize_t max77705_muic_set_usb_sel(struct device *dev,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;

	if (!strncasecmp(buf, "PDA", 3))
		pdata->usb_path = MUIC_PATH_USB_AP;
	else if (!strncasecmp(buf, "MODEM", 5))
		pdata->usb_path = MUIC_PATH_USB_CP;
	else
		pr_warn("%s invalid value\n", __func__);

	pr_info("%s usb_path(%d)\n", __func__,
			pdata->usb_path);

	return count;
}

static ssize_t max77705_muic_show_uart_en(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;

	if (!pdata->rustproof_on) {
		pr_info("%s UART ENABLE\n", __func__);
		return sprintf(buf, "1\n");
	}

	pr_info("%s UART DISABLE", __func__);
	return sprintf(buf, "0\n");
}

static ssize_t max77705_muic_set_uart_en(struct device *dev,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;

	if (!strncasecmp(buf, "1", 1))
		pdata->rustproof_on = false;
	else if (!strncasecmp(buf, "0", 1))
		pdata->rustproof_on = true;
	else
		pr_warn("%s invalid value\n", __func__);

	pr_info("%s uart_en(%d)\n", __func__,
			!pdata->rustproof_on);

	return count;
}

static ssize_t max77705_muic_show_adc(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	u8 adc;

	adc = max77705_muic_get_adc_value(muic_data);
	pr_info("%s adc(0x%02x)\n", __func__, adc);

	if (adc == MAX77705_UIADC_ERROR) {
		pr_err("%s fail to read adc value\n",
				__func__);
		return sprintf(buf, "UNKNOWN\n");
	}

	switch (adc) {
	case MAX77705_UIADC_GND:
		adc = 0;
		break;
	case MAX77705_UIADC_255K:
		adc = 0x18;
		break;
	case MAX77705_UIADC_301K:
		adc = 0x19;
		break;
	case MAX77705_UIADC_523K:
		adc = 0x1c;
		break;
	case MAX77705_UIADC_619K:
		adc = 0x1d;
		break;
	case MAX77705_UIADC_OPEN:
		adc = 0x1f;
		break;
	default:
		adc = 0xff;
	}

	return sprintf(buf, "adc: 0x%x\n", adc);
}

static ssize_t max77705_muic_show_usb_state(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);

	pr_debug("%s attached_dev(%d)\n", __func__,
			muic_data->attached_dev);

	switch (muic_data->attached_dev) {
	case ATTACHED_DEV_USB_MUIC:
		return sprintf(buf, "USB_STATE_CONFIGURED\n");
	default:
		break;
	}

	return sprintf(buf, "USB_STATE_NOTCONFIGURED\n");
}

static ssize_t max77705_muic_show_attached_dev(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	const struct max77705_muic_vps_data *tmp_vps;
	int vps_index;

	vps_index = muic_lookup_vps_table(muic_data->attached_dev, muic_data);
	if (vps_index < 0)
		return sprintf(buf, "No VPS\n");

	tmp_vps = &(muic_vps_table[vps_index]);

	return sprintf(buf, "%s\n", tmp_vps->vps_name);
}

static ssize_t max77705_muic_show_otg_test(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	int ret = -ENODEV;

	if (muic_check_support_dev(muic_data, ATTACHED_DEV_OTG_MUIC)) {
		if (muic_data->is_otg_test == true)
			ret = 0;
		else
			ret = 1;
		pr_info("%s ret:%d buf:%s\n", __func__, ret, buf);
	}

	return ret;
}

static ssize_t max77705_muic_set_otg_test(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	int ret = -ENODEV;

	mutex_lock(&muic_data->muic_mutex);

	if (muic_check_support_dev(muic_data, ATTACHED_DEV_OTG_MUIC)) {
		pr_info("%s buf:%s\n", __func__, buf);
		if (!strncmp(buf, "0", 1)) {
			muic_data->is_otg_test = true;
			ret = 0;
		} else if (!strncmp(buf, "1", 1)) {
			muic_data->is_otg_test = false;
			ret = 1;
		} else {
			pr_warn("%s Wrong command\n", __func__);
			mutex_unlock(&muic_data->muic_mutex);
			return count;
		}

		pr_info("%s ret: %d\n", __func__, ret);

		mutex_unlock(&muic_data->muic_mutex);
		return count;
	}

	mutex_unlock(&muic_data->muic_mutex);
	return ret;
}

static ssize_t max77705_muic_show_apo_factory(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	const char *mode;

	/* true: Factory mode, false: not Factory mode */
	if (muic_data->is_factory_start)
		mode = "FACTORY_MODE";
	else
		mode = "NOT_FACTORY_MODE";

	pr_info("%s apo factory=%s\n", __func__, mode);

	return sprintf(buf, "%s\n", mode);
}

static ssize_t max77705_muic_set_apo_factory(struct device *dev,
					  struct device_attribute *attr,
					  const char *buf, size_t count)
{
#if defined(CONFIG_SEC_FACTORY)
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
#endif /* CONFIG_SEC_FACTORY */
	const char *mode;

	pr_info("%s buf:%s\n", __func__, buf);

	/* "FACTORY_START": factory mode */
	if (!strncmp(buf, "FACTORY_START", 13)) {
#if defined(CONFIG_SEC_FACTORY)
		muic_data->is_factory_start = true;
#endif /* CONFIG_SEC_FACTORY */
		mode = "FACTORY_MODE";
	} else {
		pr_warn("%s Wrong command\n", __func__);
		return count;
	}

	pr_info("%s apo factory=%s\n", __func__, mode);

	return count;
}

#if defined(CONFIG_HV_MUIC_MAX77705_AFC) || defined(CONFIG_SUPPORT_QC30)
static ssize_t max77705_muic_show_afc_disable(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;

	if (pdata->afc_disable) {
		pr_info("%s AFC DISABLE\n", __func__);
		return sprintf(buf, "1\n");
	}

	pr_info("%s AFC ENABLE", __func__);
	return sprintf(buf, "0\n");
}

static ssize_t max77705_muic_set_afc_disable(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf, size_t count)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	struct muic_platform_data *pdata = muic_data->pdata;
	int param_val, ret = 0;
	bool curr_val = pdata->afc_disable;
	union power_supply_propval psy_val;

	if (!strncasecmp(buf, "1", 1)) {
		/* Disable AFC */
		ret = sec_set_param(CM_OFFSET + 1, '1');
		pdata->afc_disable = true;
	} else if (!strncasecmp(buf, "0", 1)) {
	/* Enable AFC */
		ret = sec_set_param(CM_OFFSET + 1, '0');
		pdata->afc_disable = false;
	} else {
		pr_warn("%s invalid value\n", __func__);
	}

	param_val = pdata->afc_disable ? '1' : '0';
	pr_info("%s: param_val:%d\n", __func__, param_val);

	if (ret < 0) {
		pr_info("%s:set_param failed - %02x:%02x(%d)\n", __func__,
			param_val, curr_val, ret);

		pdata->afc_disable = curr_val;

		return -EIO;
	} else {
		pr_info("%s: afc_disable:%d (AFC %s)\n", __func__,
			pdata->afc_disable, pdata->afc_disable ? "Disabled" : "Enabled");

		if (pdata->afc_disabled_updated & 0x2)	
			pdata->afc_disabled_updated |= 0x1;
		else
			max77705_muic_check_afc_disabled(muic_data);
	}

#if defined(CONFIG_SEC_FACTORY)
	/* for factory self charging test (AFC-> NORMAL TA) */
	if (muic_data->attached_dev == ATTACHED_DEV_AFC_CHARGER_9V_MUIC)
		max77705_muic_afc_hv_set(muic_data, 5);
#endif
	pr_info("%s afc_disable(%d)\n", __func__, pdata->afc_disable);

	psy_val.intval = param_val;
	psy_do_property("battery", set, POWER_SUPPLY_EXT_PROP_HV_DISABLE, psy_val);

	return count;
}
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */

static ssize_t max77705_muic_show_vbus_value(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);
	u8 vbadc;

	vbadc = max77705_muic_get_vbadc_value(muic_data);
	pr_info("%s vbadc(0x%02x)\n", __func__, vbadc);

	switch (vbadc) {
	case MAX77705_VBADC_3_8V_UNDER:
		vbadc = 0;
		break;
	case MAX77705_VBADC_3_8V_TO_4_5V ... MAX77705_VBADC_6_5V_TO_7_5V:
		vbadc = 5;
		break;
	case MAX77705_VBADC_7_5V_TO_8_5V ... MAX77705_VBADC_8_5V_TO_9_5V:
		vbadc = 9;
		break;
	default:
		vbadc += 3;
	}

	return sprintf(buf, "%d\n", vbadc);
}

#if defined(CONFIG_HICCUP_CHARGER)
static ssize_t hiccup_show(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "ENABLE\n");
}

static ssize_t hiccup_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct max77705_muic_data *muic_data = dev_get_drvdata(dev);

	if (!strncasecmp(buf, "DISABLE", 7)) {
		pr_info("%s\n", __func__);
		pdic_manual_ccopen_request(0);
		com_to_open(muic_data);
		muic_data->is_hiccup_mode = MUIC_HICCUP_MODE_OFF;
	} else
		pr_warn("%s invalid com : %s\n", __func__, buf);

	return count;
}
#endif /* CONFIG_HICCUP_CHARGER */

static DEVICE_ATTR(uart_sel, 0664, max77705_muic_show_uart_sel,
		max77705_muic_set_uart_sel);
static DEVICE_ATTR(usb_sel, 0664, max77705_muic_show_usb_sel,
		max77705_muic_set_usb_sel);
static DEVICE_ATTR(uart_en, 0660, max77705_muic_show_uart_en,
		max77705_muic_set_uart_en);
static DEVICE_ATTR(adc, 0444, max77705_muic_show_adc, NULL);
static DEVICE_ATTR(usb_state, 0444, max77705_muic_show_usb_state, NULL);
static DEVICE_ATTR(attached_dev, 0444, max77705_muic_show_attached_dev, NULL);
static DEVICE_ATTR(otg_test, 0664,
		max77705_muic_show_otg_test, max77705_muic_set_otg_test);
static DEVICE_ATTR(apo_factory, 0664,
		max77705_muic_show_apo_factory, max77705_muic_set_apo_factory);
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
static DEVICE_ATTR(afc_disable, 0664,
		max77705_muic_show_afc_disable, max77705_muic_set_afc_disable);
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */
static DEVICE_ATTR(vbus_value, 0444, max77705_muic_show_vbus_value, NULL);
static DEVICE_ATTR(vbus_value_pd, 0444, max77705_muic_show_vbus_value, NULL);
#if defined(CONFIG_HICCUP_CHARGER)
static DEVICE_ATTR_RW(hiccup);
#endif /* CONFIG_HICCUP_CHARGER */

static struct attribute *max77705_muic_attributes[] = {
	&dev_attr_uart_sel.attr,
	&dev_attr_usb_sel.attr,
	&dev_attr_uart_en.attr,
	&dev_attr_adc.attr,
	&dev_attr_usb_state.attr,
	&dev_attr_attached_dev.attr,
	&dev_attr_otg_test.attr,
	&dev_attr_apo_factory.attr,
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
	&dev_attr_afc_disable.attr,
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */
	&dev_attr_vbus_value.attr,
	&dev_attr_vbus_value_pd.attr,
#if defined(CONFIG_HICCUP_CHARGER)
	&dev_attr_hiccup.attr,
#endif /* CONFIG_HICCUP_CHARGER */
	NULL
};

static const struct attribute_group max77705_muic_group = {
	.attrs = max77705_muic_attributes,
};

void max77705_muic_read_register(struct i2c_client *i2c)
{
	const enum max77705_usbc_reg regfile[] = {
		MAX77705_USBC_REG_UIC_HW_REV,
		MAX77705_USBC_REG_USBC_STATUS1,
		MAX77705_USBC_REG_USBC_STATUS2,
		MAX77705_USBC_REG_BC_STATUS,
		MAX77705_USBC_REG_UIC_INT_M,
	};
	u8 val;
	int i, ret;

	pr_info("%s read register--------------\n", __func__);
	for (i = 0; i < (int)ARRAY_SIZE(regfile); i++) {
		ret = max77705_muic_read_reg(i2c, regfile[i], &val);
		if (ret) {
			pr_err("%s fail to read muic reg(0x%02x), ret=%d\n",
					__func__, regfile[i], ret);
			continue;
		}

		pr_info("%s reg(0x%02x)=[0x%02x]\n",
			__func__, regfile[i], val);
	}
	pr_info("%s end register---------------\n", __func__);
}

static int max77705_muic_attach_uart_path(struct max77705_muic_data *muic_data,
					muic_attached_dev_t new_dev)
{
	struct muic_platform_data *pdata = muic_data->pdata;
	int ret = 0;

	pr_info("%s\n", __func__);

	if (pdata->uart_path == MUIC_PATH_UART_AP)
		ret = switch_to_ap_uart(muic_data, new_dev);
	else if (pdata->uart_path == MUIC_PATH_UART_CP)
		ret = switch_to_cp_uart(muic_data, new_dev);
#if IS_ENABLED(CONFIG_MUIC_UART_SWITCH)
	else if (pdata->uart_path == MUIC_PATH_UART_CP2)
		ret = switch_to_cp_uart(muic_data, new_dev);
#endif	/* CONFIG_MUIC_UART_SWITCH */
	else
		pr_warn("%s invalid uart_path\n", __func__);

	return ret;
}

static int max77705_muic_attach_usb_path(struct max77705_muic_data *muic_data,
					muic_attached_dev_t new_dev)
{
	struct muic_platform_data *pdata = muic_data->pdata;
	int ret = 0;

	pr_info("%s usb_path=%d\n", __func__, pdata->usb_path);

	if (pdata->usb_path == MUIC_PATH_USB_AP)
		ret = com_to_usb_ap(muic_data);
	else if (pdata->usb_path == MUIC_PATH_USB_CP)
		ret = com_to_usb_cp(muic_data);
	else
		pr_warn("%s invalid usb_path\n", __func__);

	return ret;
}

#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
void max77705_muic_disable_afc_protocol(struct max77705_muic_data *muic_data)
{
	struct i2c_client *pmic_i2c = muic_data->usbc_pdata->max77705->i2c;
	struct i2c_client *debug_i2c = muic_data->usbc_pdata->max77705->debug;

	pr_info("%s\n", __func__);

	/*
	 * MAXIM's request.
	 * This is workaround of D- high during AFC charging issue,
	 * set hidden register.
	 */
	max77705_write_reg(pmic_i2c, 0xFE, 0xC5); /* Unlock TKEY */
	max77705_write_reg(debug_i2c, 0x0F, 0x04); /* Force FC clock always ON */
	max77705_write_reg(debug_i2c, 0x0F, 0x00); /* Force FC clock always OFF */
	max77705_write_reg(pmic_i2c, 0xFE, 0x00); /* Lock TKEY */
}
#endif

static int max77705_muic_handle_detach(struct max77705_muic_data *muic_data, int irq)
{
	int ret = 0;
#if defined(CONFIG_MUIC_NOTIFIER)
	bool noti = true;
	muic_attached_dev_t attached_dev = muic_data->attached_dev;
#endif /* CONFIG_MUIC_NOTIFIER */

#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
	/* Do workaround if Vbusdet goes to low status */
	if (muic_data->is_check_hv && irq == muic_data->irq_vbusdet &&
			(muic_data->status3 & BC_STATUS_VBUSDET_MASK) == 0) {
		muic_data->is_check_hv = false;
		max77705_muic_disable_afc_protocol(muic_data);
	}
#if defined(CONFIG_HICCUP_CHARGER)
	muic_data->is_hiccup_mode = MUIC_HICCUP_MODE_OFF;
#endif
	muic_data->hv_voltage = 0;
	muic_data->afc_retry = 0;
	muic_data->is_afc_reset = false;
	muic_data->is_skip_bigdata = false;
#endif

	if (muic_data->attached_dev == ATTACHED_DEV_NONE_MUIC) {
		pr_info("%s Duplicated(%d), just ignore\n",
				__func__, muic_data->attached_dev);
		goto out_without_noti;
	}

	muic_data->dcdtmo_retry = 0;

#if 0
	/* Enable Charger Detection */
	max77705_muic_enable_chgdet(muic_data);
#endif

	muic_lookup_vps_table(muic_data->attached_dev, muic_data);

	switch (muic_data->attached_dev) {
	case ATTACHED_DEV_TA_MUIC:
	case ATTACHED_DEV_UNOFFICIAL_TA_MUIC:
	case ATTACHED_DEV_AFC_CHARGER_5V_MUIC:
	case ATTACHED_DEV_AFC_CHARGER_9V_MUIC:
	case ATTACHED_DEV_QC_CHARGER_5V_MUIC:
	case ATTACHED_DEV_QC_CHARGER_9V_MUIC:
		if ((muic_data->status3 & BC_STATUS_VBUSDET_MASK) > 0) {
			/* W/A for chgtype 0 irq when CC pin is only detached */
			pr_info("%s Vbus is high, keep the current state(%d)\n", __func__,
					muic_data->attached_dev);
			return 0;
		}
		break;
	case ATTACHED_DEV_JIG_UART_OFF_MUIC:
	case ATTACHED_DEV_JIG_UART_OFF_VB_MUIC:
	case ATTACHED_DEV_JIG_UART_OFF_VB_OTG_MUIC:
	case ATTACHED_DEV_JIG_UART_OFF_VB_FG_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_VB_MUIC:
	case ATTACHED_DEV_JIG_USB_OFF_MUIC:
	case ATTACHED_DEV_JIG_USB_ON_MUIC:
	case ATTACHED_DEV_NONE_MUIC:
		com_to_open(muic_data);
		break;
	case ATTACHED_DEV_USB_MUIC:
	case ATTACHED_DEV_CDP_MUIC:
	case ATTACHED_DEV_OTG_MUIC:
	case ATTACHED_DEV_TIMEOUT_OPEN_MUIC:
		if (muic_data->ccic_info_data.ccic_evt_attached == MUIC_CCIC_NOTI_DETACH)
			com_to_open(muic_data);
		break;
	case ATTACHED_DEV_UNOFFICIAL_ID_MUIC:
		goto out_without_noti;
	default:
		break;
	}

#if defined(CONFIG_MUIC_NOTIFIER)
	if (noti) {
		muic_data->attached_dev = ATTACHED_DEV_NONE_MUIC;
		muic_notifier_detach_attached_dev(attached_dev);
	}
#endif /* CONFIG_MUIC_NOTIFIER */

out_without_noti:
	muic_data->attached_dev = ATTACHED_DEV_NONE_MUIC;

	return ret;
}

static int max77705_muic_logically_detach(struct max77705_muic_data *muic_data,
						muic_attached_dev_t new_dev)
{
#if defined(CONFIG_MUIC_NOTIFIER)
	bool noti = true;
#endif /* CONFIG_MUIC_NOTIFIER */
	bool force_path_open = true;
	int ret = 0;

	switch (muic_data->attached_dev) {
	case ATTACHED_DEV_OTG_MUIC:
		break;
	case ATTACHED_DEV_USB_MUIC:
	case ATTACHED_DEV_CDP_MUIC:
	case ATTACHED_DEV_TIMEOUT_OPEN_MUIC:
		if (new_dev == ATTACHED_DEV_OTG_MUIC) {
			pr_info("%s: data role changed, not detach\n", __func__);
			force_path_open = false;
			goto out;
		}
		break;
	case ATTACHED_DEV_UNDEFINED_CHARGING_MUIC:
	case ATTACHED_DEV_JIG_USB_OFF_MUIC:
	case ATTACHED_DEV_JIG_USB_ON_MUIC:
		break;
	case ATTACHED_DEV_JIG_UART_OFF_MUIC:
	case ATTACHED_DEV_JIG_UART_OFF_VB_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_VB_MUIC:
	case ATTACHED_DEV_UNKNOWN_MUIC:
		if (new_dev == ATTACHED_DEV_JIG_UART_OFF_MUIC ||
				new_dev == ATTACHED_DEV_JIG_UART_OFF_VB_MUIC ||
				new_dev == ATTACHED_DEV_JIG_UART_ON_MUIC ||
				new_dev == ATTACHED_DEV_JIG_UART_ON_VB_MUIC)
			force_path_open = false;
		break;
	case ATTACHED_DEV_TA_MUIC:
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
	case ATTACHED_DEV_AFC_CHARGER_9V_MUIC:
	case ATTACHED_DEV_AFC_CHARGER_5V_MUIC:
	case ATTACHED_DEV_QC_CHARGER_9V_MUIC:
	case ATTACHED_DEV_QC_CHARGER_5V_MUIC:
#endif
#if defined(CONFIG_HICCUP_CHARGER)
		if (new_dev == ATTACHED_DEV_HICCUP_MUIC) {
			pr_info("%s hiccup charger, do not logically detach\n", __func__);
			force_path_open = false;
			goto out;
		}
#endif
		break;
	case ATTACHED_DEV_UNOFFICIAL_TA_MUIC:
		break;
#if defined(CONFIG_HICCUP_CHARGER)
	case ATTACHED_DEV_HICCUP_MUIC:
		break;
#endif /* CONFIG_HICCUP_CHARGER */
	case ATTACHED_DEV_NONE_MUIC:
		force_path_open = false;
		goto out;
	default:
		pr_warn("%s try to attach without logically detach\n",
				__func__);
		goto out;
	}

	pr_info("%s attached(%d)!=new(%d), assume detach\n",
			__func__, muic_data->attached_dev, new_dev);

#if defined(CONFIG_MUIC_NOTIFIER)
	if (noti) {
		muic_notifier_detach_attached_dev(muic_data->attached_dev);
		muic_data->attached_dev = ATTACHED_DEV_NONE_MUIC;
	}
#endif /* CONFIG_MUIC_NOTIFIER */

out:
	if (force_path_open)
		com_to_open(muic_data);

	return ret;
}

static int max77705_muic_handle_attach(struct max77705_muic_data *muic_data,
		muic_attached_dev_t new_dev, int irq)
{
#if defined(CONFIG_MUIC_NOTIFIER)
	bool notify_skip = false;
#endif /* CONFIG_MUIC_NOTIFIER */
#if defined(CONFIG_CCIC_MAX77705)
	int fw_update_state = muic_data->usbc_pdata->max77705->fw_update_state;
#endif /* CONFIG_CCIC_MAX77705 */
	int ret = 0;

	pr_info("%s\n", __func__);

	if (new_dev == muic_data->attached_dev) {
		if (new_dev == ATTACHED_DEV_OTG_MUIC) {
 			/* W/A for setting usb path */
 			pr_info("%s:%s Duplicated(%d), Not ignore\n",
 				MUIC_DEV_NAME, __func__, muic_data->attached_dev);
 			goto handle_attach;
 		}

		if (new_dev == ATTACHED_DEV_HICCUP_MUIC)
			goto handle_attach;

		pr_info("%s Duplicated(%d), just ignore\n",
				__func__, muic_data->attached_dev);
		return ret;
	}

	ret = max77705_muic_logically_detach(muic_data, new_dev);
	if (ret)
		pr_warn("%s fail to logically detach(%d)\n",
				__func__, ret);

handle_attach:
	switch (new_dev) {
	case ATTACHED_DEV_OTG_MUIC:
		ret = com_to_usb_ap(muic_data);
		break;
	case ATTACHED_DEV_JIG_UART_OFF_MUIC:
	case ATTACHED_DEV_JIG_UART_OFF_VB_MUIC:
		ret = max77705_muic_attach_uart_path(muic_data, new_dev);
		break;
	case ATTACHED_DEV_JIG_UART_ON_MUIC:
	case ATTACHED_DEV_JIG_UART_ON_VB_MUIC:
		ret = max77705_muic_attach_uart_path(muic_data, new_dev);
		break;
	case ATTACHED_DEV_TA_MUIC:
	case ATTACHED_DEV_UNDEFINED_CHARGING_MUIC:
	case ATTACHED_DEV_UNOFFICIAL_TA_MUIC:
		ret = write_vps_regs(muic_data, new_dev);
		break;
	case ATTACHED_DEV_JIG_USB_ON_MUIC:
	case ATTACHED_DEV_JIG_USB_OFF_MUIC:
	case ATTACHED_DEV_USB_MUIC:
	case ATTACHED_DEV_CDP_MUIC:
		ret = max77705_muic_attach_usb_path(muic_data, new_dev);
		break;
	case ATTACHED_DEV_TIMEOUT_OPEN_MUIC:
		pr_info("%s DCD_TIMEOUT system_state = 0x%x\n", __func__, system_state);
#if defined(CONFIG_CCIC_MAX77705)
		if (fw_update_state == FW_UPDATE_END && system_state < SYSTEM_RUNNING) {
			/* TA Reset, D+ gnd */
			max77705_muic_dp_reset(muic_data);

			max77705_muic_enable_chgdet(muic_data);
			goto out;
		}
#endif /* CONFIG_CCIC_MAX77705 */
		ret = max77705_muic_attach_usb_path(muic_data, new_dev);
		break;
#if defined(CONFIG_HICCUP_CHARGER)
	case ATTACHED_DEV_HICCUP_MUIC:
		ret = com_to_usb_cp(muic_data);
		if (!(muic_data->status3 & BC_STATUS_VBUSDET_MASK))
			notify_skip = true;
		break;
#endif /* CONFIG_HICCUP_CHARGER */
	default:
		pr_warn("%s unsupported dev(%d)\n", __func__,
				new_dev);
		ret = -ENODEV;
		goto out;
	}

#if defined(CONFIG_MUIC_NOTIFIER)
	if (notify_skip) {
		pr_info("%s: noti\n", __func__);
	} else {
		muic_notifier_attach_attached_dev(new_dev);
		muic_data->attached_dev = new_dev;
	}
#endif /* CONFIG_MUIC_NOTIFIER */

	muic_data->attached_dev = new_dev;

#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
	if (max77705_muic_check_is_enable_afc(muic_data, new_dev)) {
		/* Maxim's request, wait 500ms for checking HVDCP */
		pr_info("%s afc work after 500ms\n", __func__);
		cancel_delayed_work_sync(&(muic_data->afc_work));
		schedule_delayed_work(&(muic_data->afc_work), msecs_to_jiffies(500));
	}
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */

out:
	return ret;
}

static bool muic_check_vps_adc
			(const struct max77705_muic_vps_data *tmp_vps, u8 adc)
{
	bool ret = false;

	if (tmp_vps->adc == adc) {
		ret = true;
		goto out;
	}

	if (tmp_vps->adc == MAX77705_UIADC_DONTCARE)
		ret = true;

out:
	if (debug_en_vps) {
		pr_info("%s vps(%s) adc(0x%02x) ret(%c)\n",
				__func__, tmp_vps->vps_name,
				adc, ret ? 'T' : 'F');
	}

	return ret;
}

static bool muic_check_vps_vbvolt(const struct max77705_muic_vps_data *tmp_vps,
	u8 vbvolt)
{
	bool ret = false;

	if (tmp_vps->vbvolt == vbvolt) {
		ret = true;
		goto out;
	}

	if (tmp_vps->vbvolt == VB_DONTCARE)
		ret = true;

out:
	if (debug_en_vps) {
		pr_debug("%s vps(%s) vbvolt(0x%02x) ret(%c)\n",
				__func__, tmp_vps->vps_name,
				vbvolt, ret ? 'T' : 'F');
	}

	return ret;
}

static bool muic_check_vps_chgtyp(const struct max77705_muic_vps_data *tmp_vps,
	u8 chgtyp)
{
	bool ret = false;

	if (tmp_vps->chgtyp == chgtyp) {
		ret = true;
		goto out;
	}

	if (tmp_vps->chgtyp == CHGTYP_ANY) {
		if (chgtyp > CHGTYP_NO_VOLTAGE) {
			ret = true;
			goto out;
		}
	}

	if (tmp_vps->chgtyp == CHGTYP_DONTCARE)
		ret = true;

out:
	if (debug_en_vps) {
		pr_info("%s vps(%s) chgtyp(0x%02x) ret(%c)\n",
				__func__, tmp_vps->vps_name,
				chgtyp, ret ? 'T' : 'F');
	}

	return ret;
}

#if defined(CONFIG_MUIC_MAX77705_CCIC)
static u8 max77705_muic_update_adc_with_rid(struct max77705_muic_data *muic_data,
	u8 adc)
{
	u8 new_adc = adc;

	if (muic_data->pdata->opmode & OPMODE_CCIC) {
		switch (muic_data->ccic_info_data.ccic_evt_rid) {
		case RID_000K:
			new_adc = MAX77705_UIADC_GND;
			break;
		case RID_255K:
			new_adc = MAX77705_UIADC_255K;
			break;
		case RID_301K:
			new_adc = MAX77705_UIADC_301K;
			break;
		case RID_523K:
			new_adc = MAX77705_UIADC_523K;
			break;
		case RID_619K:
			new_adc = MAX77705_UIADC_619K;
			break;
		default:
			new_adc = MAX77705_UIADC_OPEN;
			break;
		}

		if (muic_data->ccic_info_data.ccic_evt_rprd)
			new_adc = MAX77705_UIADC_GND;

		pr_info("%s: adc(0x%x->0x%x) rid(%d) rprd(%d)\n",
			__func__, adc, new_adc,
			muic_data->ccic_info_data.ccic_evt_rid,
			muic_data->ccic_info_data.ccic_evt_rprd);
	}

	return new_adc;
}
#endif /* CONFIG_MUIC_MAX77705_CCIC */

static u8 max77705_resolve_chgtyp(struct max77705_muic_data *muic_data, u8 chgtyp,
		u8 spchgtyp, u8 dcdtmo, int irq)
{
	u8 ret = chgtyp;

#if defined(CONFIG_HICCUP_CHARGER)
	/* Check hiccup mode */
	if (muic_data->is_hiccup_mode > MUIC_HICCUP_MODE_OFF) {
		pr_info("%s is_hiccup_mode(%d)\n", __func__, muic_data->is_hiccup_mode);
		return CHGTYP_HICCUP_MODE;
	}
#endif /* CONFIG_HICCUP_CHARGER */

#if defined(CONFIG_MUIC_MAX77705_CCIC)
	/* Check chgtype and ccic attach don't exist */
	if (irq == MUIC_IRQ_VBUS_WA && chgtyp == CHGTYP_NO_VOLTAGE && spchgtyp == CHGTYP_NO_VOLTAGE
			&& muic_data->ccic_info_data.ccic_evt_attached != MUIC_CCIC_NOTI_ATTACH) {
		ret = CHGTYP_TIMEOUT_OPEN;
		goto out;
	}
#endif /* CONFIG_MUIC_MAX77705_CCIC */

	/* Check DCD timeout */
	if (dcdtmo && chgtyp == CHGTYP_USB &&
			(irq == muic_data->irq_chgtyp || irq == MUIC_IRQ_INIT_DETECT)) {
		if (irq == MUIC_IRQ_INIT_DETECT)
			ret = CHGTYP_TIMEOUT_OPEN;
		else
			ret = (muic_data->dcdtmo_retry >= muic_data->bc1p2_retry_count) ? CHGTYP_TIMEOUT_OPEN : CHGTYP_NO_VOLTAGE;
	}

	/* Check Special chgtyp */
	switch (spchgtyp) {
	case PRCHGTYP_SAMSUNG_2A:
	case PRCHGTYP_APPLE_500MA:
	case PRCHGTYP_APPLE_1A:
	case PRCHGTYP_APPLE_2A:
	case PRCHGTYP_APPLE_12W:
		if (chgtyp == CHGTYP_USB || chgtyp == CHGTYP_CDP) {
			ret = CHGTYP_UNOFFICIAL_CHARGER;
			goto out;
		}
		break;
	default:
		break;
	}

out:
	if (ret != chgtyp)
		pr_info("%s chgtyp(0x%x) spchgtyp(0x%x) dcdtmo(0x%x) -> chgtyp(0x%x)",
				__func__, chgtyp, spchgtyp, dcdtmo, ret);

	return ret;
}

muic_attached_dev_t max77705_muic_check_new_dev(struct max77705_muic_data *muic_data,
	int *intr, int irq)
{
	const struct max77705_muic_vps_data *tmp_vps;
	muic_attached_dev_t new_dev = ATTACHED_DEV_NONE_MUIC;
	u8 adc = muic_data->status1 & USBC_STATUS1_UIADC_MASK;
	u8 vbvolt = muic_data->status3 & BC_STATUS_VBUSDET_MASK;
	u8 chgtyp = muic_data->status3 & BC_STATUS_CHGTYP_MASK;
	u8 spchgtyp = (muic_data->status3 & BC_STATUS_PRCHGTYP_MASK) >> BC_STATUS_PRCHGTYP_SHIFT;
	u8 dcdtmo = (muic_data->status3 & BC_STATUS_DCDTMO_MASK) >> BC_STATUS_DCDTMO_SHIFT;
	unsigned long i;

	chgtyp = max77705_resolve_chgtyp(muic_data, chgtyp, spchgtyp, dcdtmo, irq);

#if defined(CONFIG_MUIC_MAX77705_CCIC)
	adc = max77705_muic_update_adc_with_rid(muic_data, adc);
	/* Do not check vbus if CCIC RID is 523K */
	if ((muic_data->pdata->opmode & OPMODE_CCIC) && (adc == MAX77705_UIADC_523K))
		vbvolt = 0;
#endif /* CONFIG_MUIC_MAX77705_CCIC */

	for (i = 0; i < (int)ARRAY_SIZE(muic_vps_table); i++) {
		tmp_vps = &(muic_vps_table[i]);

		if (!(muic_check_vps_adc(tmp_vps, adc)))
			continue;

		if (!(muic_check_vps_vbvolt(tmp_vps, vbvolt)))
			continue;

		if (!(muic_check_vps_chgtyp(tmp_vps, chgtyp)))
			continue;

#if defined(CONFIG_SEC_FACTORY)
		if (muic_data->pdata->opmode & OPMODE_CCIC) {
			if (tmp_vps->attached_dev == ATTACHED_DEV_JIG_USB_OFF_MUIC &&
				!vbvolt) {
				pr_info("%s 255k w/o vbus\n", __func__);
				continue;
			}
		}
#endif

		pr_info("%s vps table match found at i(%lu), %s\n",
			__func__, i, tmp_vps->vps_name);

		new_dev = tmp_vps->attached_dev;
		muic_data->switch_val = tmp_vps->muic_switch;

		*intr = MUIC_INTR_ATTACH;
		break;
	}

	pr_info("%s %d->%d switch_val[0x%02x]\n", __func__,
		muic_data->attached_dev, new_dev, muic_data->switch_val);

	return new_dev;
}

static void max77705_muic_detect_dev(struct max77705_muic_data *muic_data,
	int irq)
{
	struct i2c_client *i2c = muic_data->i2c;
#if defined(CONFIG_USB_HW_PARAM)
	struct otg_notify *o_notify = get_otg_notify();
#endif
	muic_attached_dev_t new_dev = ATTACHED_DEV_NONE_MUIC;
	int intr = MUIC_INTR_DETACH;
	u8 status[5];
	u8 adc, vbvolt, chgtyp, spchgtyp, sysmsg, vbadc, dcdtmo, ccstat, fakvb;
	int ret;
#ifdef CONFIG_USB_NOTIFY_PROC_LOG
	int event;
#endif

	ret = max77705_bulk_read(i2c,
		MAX77705_USBC_REG_USBC_STATUS1, 5, status);
	if (ret) {
		pr_err("%s fail to read muic reg(%d)\n",
				__func__, ret);
		return;
	}

	pr_info("%s USBC1:0x%02x, USBC2:0x%02x, BC:0x%02x\n",
			__func__, status[0], status[1], status[2]);

	/* attached status */
	muic_data->status1 = status[0];
	muic_data->status2 = status[1];
	muic_data->status3 = status[2];

	adc = status[0] & USBC_STATUS1_UIADC_MASK;
	sysmsg = status[1] & USBC_STATUS2_SYSMSG_MASK;
	vbvolt = (status[2] & BC_STATUS_VBUSDET_MASK) >> BC_STATUS_VBUSDET_SHIFT;
	chgtyp = status[2] & BC_STATUS_CHGTYP_MASK;
	spchgtyp = (status[2] & BC_STATUS_PRCHGTYP_MASK) >> BC_STATUS_PRCHGTYP_SHIFT;
	vbadc = (status[0] & USBC_STATUS1_VBADC_MASK) >> USBC_STATUS1_VBADC_SHIFT;
	dcdtmo = (status[2] & BC_STATUS_DCDTMO_MASK) >> BC_STATUS_DCDTMO_SHIFT;
	ccstat = (status[4] & BIT_CCStat) >> FFS(BIT_CCStat);
	fakvb = (status[0] & USBC_STATUS1_FAKVB_MASK) >> USBC_STATUS1_FAKVB_SHIFT;

	pr_info("%s adc:0x%x vbvolt:0x%x chgtyp:0x%x spchgtyp:0x%x sysmsg:0x%x vbadc:0x%x dcdtmo:0x%x fakvb:0x%x\n",
		__func__, adc, vbvolt, chgtyp, spchgtyp, sysmsg, vbadc, dcdtmo, fakvb);

	if (irq == muic_data->irq_vbadc) {
		if (vbadc == MAX77705_VBADC_3_8V_TO_4_5V &&
				ccstat == cc_No_Connection) {
			/* W/A of CC is detached but Vbus is valid(3.8~4.5V) */
			vbvolt = 0;
			muic_data->status3 = muic_data->status3 & ~(BC_STATUS_VBUSDET_MASK);
			pr_info("%s vbadc(0x%x), ccstat(0x%x), set vbvolt to 0 => BC(0x%x)\n",
					__func__, vbadc, ccstat, muic_data->status3);
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
		} else if (vbadc > MAX77705_VBADC_3_8V_TO_4_5V &&
				vbadc <= MAX77705_VBADC_6_5V_TO_7_5V &&
				muic_data->is_afc_reset) {
			muic_data->is_afc_reset = false;
			pr_info("%s afc reset is done\n", __func__);

			switch (muic_data->attached_dev) {
			case ATTACHED_DEV_AFC_CHARGER_5V_MUIC:
			case ATTACHED_DEV_AFC_CHARGER_9V_MUIC:
				muic_data->attached_dev = ATTACHED_DEV_AFC_CHARGER_5V_MUIC;
#if defined(CONFIG_MUIC_NOTIFIER)
				muic_notifier_attach_attached_dev(muic_data->attached_dev);
#endif /* CONFIG_MUIC_NOTIFIER */
				break;
			case ATTACHED_DEV_QC_CHARGER_5V_MUIC:
			case ATTACHED_DEV_QC_CHARGER_9V_MUIC:
				muic_data->attached_dev = ATTACHED_DEV_QC_CHARGER_5V_MUIC;
#if defined(CONFIG_MUIC_NOTIFIER)
				muic_notifier_attach_attached_dev(muic_data->attached_dev);
#endif /* CONFIG_MUIC_NOTIFIER */
				break;
			default:
				break;
			}
			return;
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */
		} else {
			pr_info("%s vbadc irq(%d), return\n",
					__func__, muic_data->irq_vbadc);
			return;
		}
	}

	if (irq == muic_data->irq_fakvb) {
		pr_info("%s fake vbus status : %s\n", __func__, fakvb? "enable":"disable");
		if (fakvb) {
#ifdef CONFIG_USB_NOTIFY_PROC_LOG
			event = NOTIFY_EXTRA_USBKILLER;
			store_usblog_notify(NOTIFY_EXTRA, (void *)&event, NULL);
#endif
#if defined(CONFIG_USB_HW_PARAM)
			if (o_notify)
				inc_hw_param(o_notify, USB_CCIC_USB_KILLER_COUNT);
#endif
		}
	}

	if (irq == muic_data->irq_dcdtmo && dcdtmo) {
		muic_data->dcdtmo_retry++;
		pr_info("%s:%s DCD_TIMEOUT retry count: %d\n", MUIC_DEV_NAME, __func__, muic_data->dcdtmo_retry);
	}

#if !defined(CONFIG_SEC_FACTORY)
	/* W/A of defect cable(Vbus is valid and CC is invalid), set or cancel vbus_wa_work */
	if (irq == muic_data->irq_vbusdet || irq == MUIC_IRQ_INIT_DETECT) {
		wake_unlock(&muic_data->muic_wake_lock);
		cancel_delayed_work(&(muic_data->vbus_wa_work));
		if (vbvolt > 0) {
			wake_lock_timeout(&muic_data->muic_wake_lock, 2100);
			schedule_delayed_work(&(muic_data->vbus_wa_work), msecs_to_jiffies(2000));
		}
	} else if (irq == muic_data->irq_chgtyp && chgtyp > 0) {
		wake_unlock(&muic_data->muic_wake_lock);
		cancel_delayed_work(&(muic_data->vbus_wa_work));
	}
#endif

#if defined(CONFIG_MUIC_MAX77705_CCIC)
	if (!lpcharge && !muic_data->is_factory_start) {
		if ((irq == MUIC_IRQ_CCIC_HANDLER) &&
				(muic_data->ccic_evt_id == CCIC_NOTIFY_ID_WATER)) {
			/* Force path open once at water state */
			if (muic_data->afc_water_disable)
				com_to_open(muic_data);
		}

#if defined(CONFIG_HICCUP_CHARGER)
		if (muic_data->afc_water_disable && !muic_data->is_hiccup_mode) {
			if (vbvolt > 0) {
				pr_info("%s water hiccup mode, Aux USB path\n", __func__);
				com_to_usb_cp(muic_data);
			} else {
				/* Clear muic deive type and hiccup at water state (booting with water) */
				if (muic_data->attached_dev != ATTACHED_DEV_NONE_MUIC) {
					pr_info("%s initialize hiccup state and device type(%d) at hiccup booting\n",
							__func__, muic_data->attached_dev);
					muic_notifier_detach_attached_dev(muic_data->attached_dev);
					muic_data->attached_dev = ATTACHED_DEV_NONE_MUIC;
					com_to_open(muic_data);
				}
			}
			max77705_muic_handle_vbus(muic_data);

			return;
		}
#endif /* CONFIG_HICCUP_CHARGER */
	}
#endif /* CONFIG_MUIC_MAX77705_CCIC */

	new_dev = max77705_muic_check_new_dev(muic_data, &intr, irq);

	if (intr == MUIC_INTR_ATTACH) {
		pr_info("%s ATTACHED\n", __func__);

		ret = max77705_muic_handle_attach(muic_data, new_dev, irq);
		if (ret)
			pr_err("%s cannot handle attach(%d)\n", __func__, ret);
	} else {
		pr_info("%s DETACHED\n", __func__);

		if (vbvolt == 0 && chgtyp == CHGTYP_DEDICATED_CHARGER)
			pr_info("%s catch the Fake Vbus type\n", __func__);

		ret = max77705_muic_handle_detach(muic_data, irq);
		if (ret)
			pr_err("%s cannot handle detach(%d)\n", __func__, ret);
	}

	max77705_muic_handle_vbus(muic_data);
}

static irqreturn_t max77705_muic_irq(int irq, void *data)
{
	struct max77705_muic_data *muic_data = data;
	struct irq_desc *desc = irq_to_desc(irq);

	pr_info("%s irq:%d (%s)\n", __func__, irq, desc->action->name);

	if (!muic_data) {
		pr_err("%s irq data is null\n", desc->action->name);
		goto out;
	}

	mutex_lock(&muic_data->muic_mutex);
	if (muic_data->is_muic_ready == true)
		max77705_muic_detect_dev(muic_data, irq);
	else
		pr_info("%s MUIC is not ready, just return\n", __func__);
	mutex_unlock(&muic_data->muic_mutex);

out:
	return IRQ_HANDLED;
}

static void max77705_muic_vbus_wa_work(struct work_struct *work)
{
	struct max77705_muic_data *muic_data =
		container_of(work, struct max77705_muic_data, vbus_wa_work.work);
	u8 vbvolt = (muic_data->status3 & BC_STATUS_VBUSDET_MASK) >> BC_STATUS_VBUSDET_SHIFT;
	int ccic_attach = muic_data->ccic_info_data.ccic_evt_attached;

	pr_info("%s vbvolt(%d) ccic_attach(%d)\n", __func__, vbvolt, ccic_attach);

	mutex_lock(&muic_data->muic_mutex);
	if (muic_data->is_muic_ready == true) {
		if (vbvolt > 0 && ccic_attach != MUIC_CCIC_NOTI_ATTACH)
			max77705_muic_detect_dev(muic_data, MUIC_IRQ_VBUS_WA);
	} else {
		pr_info("%s MUIC is not ready, just return\n", __func__);
	}
	mutex_unlock(&muic_data->muic_mutex);
}

#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
static void max77705_muic_afc_work(struct work_struct *work)
{
	struct max77705_muic_data *muic_data =
		container_of(work, struct max77705_muic_data, afc_work.work);

	pr_info("%s\n", __func__);

	if (max77705_muic_check_is_enable_afc(muic_data, muic_data->attached_dev)) {
		muic_data->pdata->afc_disabled_updated |= 0x2;

		if (!muic_data->pdata->afc_disable) {
			muic_data->is_check_hv = true;
			muic_data->hv_voltage = 9;
			max77705_muic_afc_hv_set(muic_data, 9);
		} else {
			muic_data->is_check_hv = true;
			muic_data->hv_voltage = 5;
			max77705_muic_afc_hv_set(muic_data, 5);
		}	
	}
}

static int max77705_muic_hv_charger_disable(bool en)
{
	struct max77705_muic_data *muic_data = g_muic_data;

	muic_data->is_charger_mode = en;

	schedule_delayed_work(&(muic_data->afc_work), msecs_to_jiffies(0));

	return 0;
}

static int max77705_muic_afc_set_voltage(int voltage)
{
	struct max77705_muic_data *muic_data = g_muic_data;
	int now_voltage = 0;

	switch (voltage) {
	case 5:
	case 9:
		break;
	default:
		pr_err("%s: invalid value %d, return\n", __func__, voltage);
		return -EINVAL;
	}

	switch (muic_data->attached_dev) {
	case ATTACHED_DEV_AFC_CHARGER_5V_MUIC:
	case ATTACHED_DEV_QC_CHARGER_5V_MUIC:
		now_voltage = 5;
		break;
	case ATTACHED_DEV_AFC_CHARGER_9V_MUIC:
	case ATTACHED_DEV_QC_CHARGER_9V_MUIC:
		now_voltage = 9;
		break;
	default:
		break;
	}

	if (voltage == now_voltage) {
		pr_err("%s: same with current voltage, return\n", __func__);
		return -EINVAL;
	}

	muic_data->hv_voltage = voltage;

	switch (muic_data->attached_dev) {
	case ATTACHED_DEV_AFC_CHARGER_5V_MUIC:
	case ATTACHED_DEV_AFC_CHARGER_9V_MUIC:
		max77705_muic_afc_hv_set(muic_data, voltage);
		break;
	case ATTACHED_DEV_QC_CHARGER_5V_MUIC:
	case ATTACHED_DEV_QC_CHARGER_9V_MUIC:
		max77705_muic_qc_hv_set(muic_data, voltage);
		break;
	default:
		pr_err("%s: not a HV Charger %d, return\n", __func__, muic_data->attached_dev);
		return -EINVAL;
	}

	return 0;
}

static int max77705_muic_hv_charger_init(void)
{
	struct max77705_muic_data *muic_data = g_muic_data;

	if (muic_data->is_charger_ready) {
		pr_info("%s: charger is already ready(%d), return\n",
				__func__, muic_data->is_charger_ready);
		return -EINVAL;
	}

	muic_data->is_charger_ready = true;

	if (max77705_muic_check_is_enable_afc(muic_data, muic_data->attached_dev)) {
		pr_info("%s afc work start\n", __func__);
		cancel_delayed_work_sync(&(muic_data->afc_work));
		schedule_delayed_work(&(muic_data->afc_work), msecs_to_jiffies(0));
	}

	return 0;
}

static void max77705_muic_detect_dev_hv_work(struct work_struct *work)
{
	struct max77705_muic_data *muic_data = container_of(work,
		struct max77705_muic_data, afc_handle_work);
	unsigned char opcode = muic_data->afc_op_dataout[0];

	mutex_lock(&muic_data->muic_mutex);
	if (!max77705_muic_check_is_enable_afc(muic_data, muic_data->attached_dev)) {
		switch (muic_data->attached_dev) {
		case ATTACHED_DEV_AFC_CHARGER_5V_MUIC:
		case ATTACHED_DEV_AFC_CHARGER_9V_MUIC:
		case ATTACHED_DEV_QC_CHARGER_5V_MUIC:
		case ATTACHED_DEV_QC_CHARGER_9V_MUIC:
			pr_info("%s high voltage value is changed\n", __func__);
			break;
		default:
			pr_info("%s status is changed, return\n", __func__);
			goto out;
		}
	}

	if (opcode == COMMAND_AFC_RESULT_READ)
		max77705_muic_handle_detect_dev_afc(muic_data, muic_data->afc_op_dataout);
	else if (opcode == COMMAND_QC_2_0_SET)
		max77705_muic_handle_detect_dev_qc(muic_data, muic_data->afc_op_dataout);
	else
		pr_info("%s undefined opcode(%d)\n", __func__, opcode);

out:
	mutex_unlock(&muic_data->muic_mutex);
}

void max77705_muic_handle_detect_dev_hv(struct max77705_muic_data *muic_data, unsigned char *data)
{
	int i;

	for (i = 0; i < AFC_OP_OUT_LEN; i++)
		muic_data->afc_op_dataout[i] = data[i];

	schedule_work(&(muic_data->afc_handle_work));
}
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */

#if defined(CONFIG_HICCUP_CHARGER)
static int max77705_muic_set_hiccup_mode(int on_off)
{
	struct max77705_muic_data *muic_data = g_muic_data;

	pr_info("%s (%d)\n", __func__, on_off);

	switch (on_off) {
	case MUIC_HICCUP_MODE_OFF:
	case MUIC_HICCUP_MODE_ON:
	case MUIC_HICCUP_MODE_NOTY:
		if (muic_data->is_hiccup_mode != on_off) {
			muic_data->is_hiccup_mode = on_off;
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
			if (muic_data->is_check_hv)
				max77705_muic_clear_hv_control(muic_data);
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */
#if defined(CONFIG_MUIC_MAX77705_CCIC)
			schedule_work(&(muic_data->ccic_info_data_work));
#endif /* CONFIG_MUIC_MAX77705_CCIC */
		}
		break;
	default:
		pr_err("%s undefined value(%d), return\n", __func__, on_off);
		return -EINVAL;
	}

	return 0;
}
#endif /* CONFIG_HICCUP_CHARGER */

static void max77705_muic_print_reg_log(struct work_struct *work)
{
	struct max77705_muic_data *muic_data =
		container_of(work, struct max77705_muic_data, debug_work.work);
	struct i2c_client *i2c = muic_data->i2c;
	struct i2c_client *pmic_i2c = muic_data->usbc_pdata->i2c;
	u8 status[12] = {0, };

	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_USBC_STATUS1, &status[0]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_USBC_STATUS2, &status[1]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_BC_STATUS, &status[2]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_CC_STATUS0, &status[3]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_CC_STATUS1, &status[4]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_PD_STATUS0, &status[5]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_PD_STATUS1, &status[6]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_UIC_INT_M, &status[7]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_CC_INT_M, &status[8]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_PD_INT_M, &status[9]);
	max77705_muic_read_reg(i2c, MAX77705_USBC_REG_VDM_INT_M, &status[10]);
	max77705_muic_read_reg(pmic_i2c, MAX77705_PMIC_REG_INTSRC_MASK, &status[11]);

	pr_info("%s USBC1:0x%02x, USBC2:0x%02x, BC:0x%02x, CC0:0x%x, CC1:0x%x, PD0:0x%x, PD1:0x%x attached_dev:%d\n",
		__func__, status[0], status[1], status[2], status[3], status[4], status[5], status[6],
		muic_data->attached_dev);
	pr_info("%s UIC_INT_M:0x%x, CC_INT_M:0x%x, PD_INT_M:0x%x, VDM_INT_M:0x%x, PMIC_MASK:0x%x, WDT:%d, POR:%d\n",
		__func__, status[7], status[8], status[9], status[10], status[11],
		muic_data->usbc_pdata->watchdog_count, muic_data->usbc_pdata->por_count);

	schedule_delayed_work(&(muic_data->debug_work),
		msecs_to_jiffies(60000));
}

#if defined(CONFIG_MUIC_MAX77705_CCIC)
static void max77705_muic_handle_ccic_event(struct work_struct *work)
{
	struct max77705_muic_data *muic_data = container_of(work,
		struct max77705_muic_data, ccic_info_data_work);

	pr_info("%s\n", __func__);

	mutex_lock(&muic_data->muic_mutex);
	if (muic_data->is_muic_ready == true)
		max77705_muic_detect_dev(muic_data, MUIC_IRQ_CCIC_HANDLER);
	else
		pr_info("%s MUIC is not ready, just return\n", __func__);
	mutex_unlock(&muic_data->muic_mutex);
}
#endif /* CONFIG_MUIC_MAX77705_CCIC */

#define REQUEST_IRQ(_irq, _dev_id, _name)				\
do {									\
	ret = request_threaded_irq(_irq, NULL, max77705_muic_irq,	\
				IRQF_NO_SUSPEND, _name, _dev_id);	\
	if (ret < 0) {							\
		pr_err("%s Failed to request IRQ #%d: %d\n",		\
			__func__, _irq, ret);	\
		_irq = 0;						\
	}								\
} while (0)

static int max77705_muic_irq_init(struct max77705_muic_data *muic_data)
{
	int ret = 0;

	pr_info("%s\n", __func__);

	if (muic_data->mfd_pdata && (muic_data->mfd_pdata->irq_base > 0)) {
		int irq_base = muic_data->mfd_pdata->irq_base;

		/* request MUIC IRQ */
		muic_data->irq_uiadc = irq_base + MAX77705_USBC_IRQ_UIDADC_INT;
		REQUEST_IRQ(muic_data->irq_uiadc, muic_data, "muic-uiadc");

		muic_data->irq_chgtyp = irq_base + MAX77705_USBC_IRQ_CHGT_INT;
		REQUEST_IRQ(muic_data->irq_chgtyp, muic_data, "muic-chgtyp");

		muic_data->irq_fakvb = irq_base + MAX77705_USBC_IRQ_FAKVB_INT;
		REQUEST_IRQ(muic_data->irq_fakvb, muic_data, "muic-fakvb");

		muic_data->irq_dcdtmo = irq_base + MAX77705_USBC_IRQ_DCD_INT;
		REQUEST_IRQ(muic_data->irq_dcdtmo, muic_data, "muic-dcdtmo");

		muic_data->irq_vbadc = irq_base + MAX77705_USBC_IRQ_VBADC_INT;
		REQUEST_IRQ(muic_data->irq_vbadc, muic_data, "muic-vbadc");

		muic_data->irq_vbusdet = irq_base + MAX77705_USBC_IRQ_VBUS_INT;
		REQUEST_IRQ(muic_data->irq_vbusdet, muic_data, "muic-vbusdet");
	}

	pr_info("%s uiadc(%d), chgtyp(%d), fakvb(%d), dcdtmo(%d), vbadc(%d), vbusdet(%d)\n",
			__func__,
			muic_data->irq_uiadc, muic_data->irq_chgtyp,
			muic_data->irq_fakvb, muic_data->irq_dcdtmo,
			muic_data->irq_vbadc, muic_data->irq_vbusdet);
	return ret;
}

#define FREE_IRQ(_irq, _dev_id, _name)					\
do {									\
	if (_irq) {							\
		free_irq(_irq, _dev_id);				\
		pr_info("%s IRQ(%d):%s free done\n",	\
				__func__, _irq, _name);			\
	}								\
} while (0)

static void max77705_muic_free_irqs(struct max77705_muic_data *muic_data)
{
	pr_info("%s\n", __func__);

	disable_irq(muic_data->irq_uiadc);
	disable_irq(muic_data->irq_chgtyp);
	disable_irq(muic_data->irq_fakvb);
	disable_irq(muic_data->irq_dcdtmo);
	disable_irq(muic_data->irq_vbadc);
	disable_irq(muic_data->irq_vbusdet);

	/* free MUIC IRQ */
	FREE_IRQ(muic_data->irq_uiadc, muic_data, "muic-uiadc");
	FREE_IRQ(muic_data->irq_chgtyp, muic_data, "muic-chgtyp");
	FREE_IRQ(muic_data->irq_fakvb, muic_data, "muic-fakvb");
	FREE_IRQ(muic_data->irq_dcdtmo, muic_data, "muic-dcdtmo");
	FREE_IRQ(muic_data->irq_vbadc, muic_data, "muic-vbadc");
	FREE_IRQ(muic_data->irq_vbusdet, muic_data, "muic-vbusdet");
}

static void max77705_muic_init_detect(struct max77705_muic_data *muic_data)
{
	pr_info("%s\n", __func__);

	mutex_lock(&muic_data->muic_mutex);
	muic_data->is_muic_ready = true;

	max77705_muic_detect_dev(muic_data, MUIC_IRQ_INIT_DETECT);
	max77705_muic_enable_detecting_short(muic_data);

	mutex_unlock(&muic_data->muic_mutex);
}

static void max77705_set_bc1p2_retry_count(struct max77705_muic_data *muic_data)
{
	struct device_node *np = NULL;
	int count;

	np = of_find_compatible_node(NULL, NULL, "maxim,max77705");

	if (np && !of_property_read_u32(np, "max77705,bc1p2_retry_count", &count))
		muic_data->bc1p2_retry_count = count;
	else
		muic_data->bc1p2_retry_count = 1; /* default retry count */

	pr_info("%s:%s BC1p2 Retry count: %d\n", MUIC_DEV_NAME,
				__func__, muic_data->bc1p2_retry_count);
}

#if IS_ENABLED(CONFIG_MUIC_UART_SWITCH)
int max77705_muic_set_gpio_uart_sel(int uart_sel)
{
	int gpio = g_muic_data->pdata->gpio_uart_sel;
	int ret;

	pr_info("%s %d\n", __func__, uart_sel);

	ret = gpio_request(gpio, "GPIO_UART_CTRL");
	if (ret) {
		pr_err("failed to gpio_request GPIO_UART_CTRL\n");
		return ret;
	}

	if (!gpio_is_valid(gpio))
		return -ENXIO;

	if (uart_sel == MUIC_PATH_UART_CP2)
		gpio_direction_output(gpio, 1);
	else
		gpio_direction_output(gpio, 0);

	gpio_free(gpio);

	return 0;
}
#endif	/* CONFIG_MUIC_UART_SWITCH */

#if defined(CONFIG_OF)
static int of_max77705_muic_dt(struct max77705_muic_data *muic_data)
{
	struct device_node *np_muic;
	const char *prop_support_list;
	int i, j, prop_num;
	int ret = 0;

	np_muic = of_find_node_by_path("/muic");
	if (np_muic == NULL)
		return -EINVAL;

	prop_num = of_property_count_strings(np_muic, "muic,support-list");
	if (prop_num < 0) {
		pr_warn("%s Cannot parse 'muic support list dt node'[%d]\n",
				__func__, prop_num);
		ret = prop_num;
		goto err;
	}

	/* for debug */
	for (i = 0; i < prop_num; i++) {
		ret = of_property_read_string_index(np_muic,
				"muic,support-list", i, &prop_support_list);
		if (ret) {
			pr_err("%s Cannot find string at [%d], ret[%d]\n",
					__func__, i, ret);
			goto err;
		}

		pr_debug("%s prop_support_list[%d] is %s\n", __func__,
				i, prop_support_list);

		for (j = 0; j < (int)ARRAY_SIZE(muic_vps_table); j++) {
			if (!strcmp(muic_vps_table[j].vps_name, prop_support_list)) {
				muic_data->muic_support_list[(muic_vps_table[j].attached_dev)] = true;
				break;
			}
		}
	}

#if IS_ENABLED(CONFIG_MUIC_UART_SWITCH)
	muic_data->pdata->gpio_uart_sel =
		of_get_named_gpio(np_muic, "uart_ctrl", 0);
	pr_info("%s uart_ctrl[%d]\n", __func__,
		muic_data->pdata->gpio_uart_sel);
#endif

	/* for debug */
	for (i = 0; i < ATTACHED_DEV_NUM; i++)
		pr_debug("%s pmuic_support_list[%d] = %c\n", __func__,
			i, (muic_data->muic_support_list[i] ? 'T' : 'F'));

err:
	of_node_put(np_muic);

	return ret;
}
#endif /* CONFIG_OF */

static void max77705_muic_clear_interrupt(struct max77705_muic_data *muic_data)
{
	struct i2c_client *i2c = muic_data->i2c;
	u8 interrupt;
	int ret;

	pr_info("%s\n", __func__);

	ret = max77705_muic_read_reg(i2c,
			MAX77705_USBC_REG_UIC_INT, &interrupt);
	if (ret)
		pr_err("%s fail to read muic INT1 reg(%d)\n",
			__func__, ret);

	pr_info("%s CLEAR!! UIC_INT:0x%02x\n",
		__func__, interrupt);
}

static int max77705_muic_init_regs(struct max77705_muic_data *muic_data)
{
	int ret;

	pr_info("%s\n", __func__);

	max77705_muic_clear_interrupt(muic_data);

	ret = max77705_muic_irq_init(muic_data);
	if (ret < 0) {
		pr_err("%s Failed to initialize MUIC irq:%d\n",
				__func__, ret);
		max77705_muic_free_irqs(muic_data);
	}

	return ret;
}

#if defined(CONFIG_USB_EXTERNAL_NOTIFY)
static int muic_handle_usb_notification(struct notifier_block *nb,
				unsigned long action, void *data)
{
	struct max77705_muic_data *pmuic =
		container_of(nb, struct max77705_muic_data, usb_nb);

	switch (action) {
	/* Abnormal device */
	case EXTERNAL_NOTIFY_3S_NODEVICE:
		pr_info("%s: 3S_NODEVICE(USB HOST Connection timeout)\n",
				__func__);
		if (pmuic->attached_dev == ATTACHED_DEV_HMT_MUIC)
			muic_send_dock_intent(MUIC_DOCK_ABNORMAL);
		break;

	/* Gamepad device connected */
	case EXTERNAL_NOTIFY_DEVICE_CONNECT:
		pr_info("%s: DEVICE_CONNECT(Gamepad)\n", __func__);
		break;

	default:
		break;
	}

	return NOTIFY_DONE;
}


static void muic_register_usb_notifier(struct max77705_muic_data *pmuic)
{
	int ret = 0;

	pr_info("%s\n", __func__);


	ret = usb_external_notify_register(&pmuic->usb_nb,
		muic_handle_usb_notification, EXTERNAL_NOTIFY_DEV_MUIC);
	if (ret < 0) {
		pr_info("%s: USB Noti. is not ready.\n", __func__);
		return;
	}

	pr_info("%s: done.\n", __func__);
}

static void muic_unregister_usb_notifier(struct max77705_muic_data *pmuic)
{
	int ret = 0;

	pr_info("%s\n", __func__);

	ret = usb_external_notify_unregister(&pmuic->usb_nb);
	if (ret < 0) {
		pr_info("%s: USB Noti. unregister error.\n", __func__);
		return;
	}

	pr_info("%s: done.\n", __func__);
}
#else
static void muic_register_usb_notifier(struct max77705_muic_data *pmuic) {}
static void muic_unregister_usb_notifier(struct max77705_muic_data *pmuic) {}
#endif

int max77705_muic_probe(struct max77705_usbc_platform_data *usbc_data)
{
	struct max77705_platform_data *mfd_pdata = usbc_data->max77705_data;
	struct max77705_muic_data *muic_data;
	int ret = 0;

	pr_info("%s\n", __func__);

	muic_data = devm_kzalloc(usbc_data->dev, sizeof(struct max77705_muic_data), GFP_KERNEL);
	if (!muic_data) {
		ret = -ENOMEM;
		goto err_return;
	}

	if (!mfd_pdata) {
		pr_err("%s: failed to get mfd platform data\n", __func__);
		ret = -ENOMEM;
		goto err_return;
	}

	muic_data->pdata = &muic_pdata;
#if defined(CONFIG_OF)
	ret = of_max77705_muic_dt(muic_data);
	if (ret < 0)
		pr_err("%s not found muic dt! ret[%d]\n", __func__, ret);
#endif /* CONFIG_OF */

	mutex_init(&muic_data->muic_mutex);
	wake_lock_init(&muic_data->muic_wake_lock, WAKE_LOCK_SUSPEND, "muic-irq");
	muic_data->i2c = usbc_data->muic;
	muic_data->mfd_pdata = mfd_pdata;
	muic_data->usbc_pdata = usbc_data;
	muic_data->attached_dev = ATTACHED_DEV_NONE_MUIC;
	muic_data->is_muic_ready = false;
	muic_data->is_otg_test = false;
	muic_data->is_factory_start = false;
	muic_data->switch_val = COM_OPEN;
	muic_data->is_charger_mode = false;
	muic_data->dcdtmo_retry = 0;

	usbc_data->muic_data = muic_data;
	g_muic_data = muic_data;

#if IS_ENABLED(CONFIG_MUIC_UART_SWITCH)
	muic_data->pdata->set_gpio_uart_sel = max77705_muic_set_gpio_uart_sel;
#endif

	if (muic_data->pdata->init_gpio_cb) {
		ret = muic_data->pdata->init_gpio_cb(get_switch_sel());
		if (ret)
			pr_err("%s: failed to init gpio(%d)\n", __func__, ret);
	}

	mutex_lock(&muic_data->muic_mutex);

	/* create sysfs group */
	ret = sysfs_create_group(&switch_device->kobj, &max77705_muic_group);
	if (ret) {
		pr_err("%s: failed to create attribute group\n",
				__func__);
		goto fail_sysfs_create;
	}
	dev_set_drvdata(switch_device, muic_data);

	if (muic_data->pdata->init_switch_dev_cb)
		muic_data->pdata->init_switch_dev_cb();

	ret = max77705_muic_init_regs(muic_data);
	if (ret < 0) {
		pr_err("%s Failed to initialize MUIC irq:%d\n",
				__func__, ret);
		goto fail_init_irq;
	}

	mutex_unlock(&muic_data->muic_mutex);

	INIT_DELAYED_WORK(&(muic_data->vbus_wa_work), max77705_muic_vbus_wa_work);

#if defined(CONFIG_MUIC_MAX77705_CCIC)
	muic_data->pdata->opmode = get_ccic_info() & 0x0f;
	if (muic_data->pdata->opmode & OPMODE_CCIC) {
		max77705_muic_register_ccic_notifier(muic_data);
		INIT_WORK(&(muic_data->ccic_info_data_work),
			max77705_muic_handle_ccic_event);
	}

	muic_data->afc_water_disable = false;
#endif /* CONFIG_MUIC_MAX77705_CCIC */

#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
	if (get_afc_mode() == CH_MODE_AFC_DISABLE_VAL) {
		pr_info("%s: afc_disable: AFC disabled\n", __func__);
		muic_data->pdata->afc_disable = true;
	} else {
		pr_info("%s: afc_disable: AFC enabled\n", __func__);
		muic_data->pdata->afc_disable = false;
	}

	muic_data->pdata->afc_disabled_updated = 0;

	INIT_DELAYED_WORK(&(muic_data->afc_work),
		max77705_muic_afc_work);
	INIT_WORK(&(muic_data->afc_handle_work),
		max77705_muic_detect_dev_hv_work);

	/* set MUIC afc voltage switching function */
	muic_data->pdata->muic_afc_set_voltage_cb = max77705_muic_afc_set_voltage;
	muic_data->pdata->muic_hv_charger_disable_cb = max77705_muic_hv_charger_disable;

	/* set MUIC check charger init function */
	muic_data->pdata->muic_hv_charger_init_cb = max77705_muic_hv_charger_init;
	muic_data->is_charger_ready = false;
	muic_data->is_check_hv = false;
	muic_data->hv_voltage = 0;
	muic_data->afc_retry = 0;
	muic_data->is_afc_reset = false;
	muic_data->is_skip_bigdata = false;
#endif /* CONFIG_HV_MUIC_MAX77705_AFC */

#if defined(CONFIG_HICCUP_CHARGER)
	muic_data->is_hiccup_mode = 0;
	muic_data->pdata->muic_set_hiccup_mode_cb = max77705_muic_set_hiccup_mode;
#endif /* CONFIG_HICCUP_CHARGER */

	/* initial cable detection */
	max77705_muic_init_detect(muic_data);

	/* set bc1p2 retry count */
	max77705_set_bc1p2_retry_count(muic_data);

	/* register usb external notifier */
	muic_register_usb_notifier(muic_data);

	INIT_DELAYED_WORK(&(muic_data->debug_work),
		max77705_muic_print_reg_log);
	schedule_delayed_work(&(muic_data->debug_work),
		msecs_to_jiffies(10000));

	return 0;

fail_init_irq:
	if (muic_data->pdata->cleanup_switch_dev_cb)
		muic_data->pdata->cleanup_switch_dev_cb();
	sysfs_remove_group(&switch_device->kobj, &max77705_muic_group);
fail_sysfs_create:
	mutex_unlock(&muic_data->muic_mutex);
	mutex_destroy(&muic_data->muic_mutex);
err_return:
	return ret;
}

int max77705_muic_remove(struct max77705_usbc_platform_data *usbc_data)
{
	struct max77705_muic_data *muic_data = usbc_data->muic_data;

	sysfs_remove_group(&switch_device->kobj, &max77705_muic_group);

	if (muic_data) {
		pr_info("%s\n", __func__);

		max77705_muic_free_irqs(muic_data);

		cancel_delayed_work(&(muic_data->vbus_wa_work));

#if defined(CONFIG_MUIC_MAX77705_CCIC)
		if (muic_data->pdata->opmode & OPMODE_CCIC) {
			max77705_muic_unregister_ccic_notifier(muic_data);
			cancel_work_sync(&(muic_data->ccic_info_data_work));
		}
#endif
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
		cancel_delayed_work_sync(&(muic_data->afc_work));
		cancel_work_sync(&(muic_data->afc_handle_work));
#endif

		muic_unregister_usb_notifier(muic_data);
		cancel_delayed_work_sync(&(muic_data->debug_work));

		if (muic_data->pdata->cleanup_switch_dev_cb)
			muic_data->pdata->cleanup_switch_dev_cb();

		mutex_destroy(&muic_data->muic_mutex);
		wake_lock_destroy(&muic_data->muic_wake_lock);
	}

	return 0;
}

void max77705_muic_shutdown(struct max77705_usbc_platform_data *usbc_data)
{
	struct max77705_muic_data *muic_data = usbc_data->muic_data;

	pr_info("%s +\n", __func__);

	sysfs_remove_group(&switch_device->kobj, &max77705_muic_group);

	if (!muic_data) {
		pr_err("%s no drvdata\n", __func__);
		goto out;
	}

	com_to_open(muic_data);

	max77705_muic_free_irqs(muic_data);

	cancel_delayed_work(&(muic_data->vbus_wa_work));

#if defined(CONFIG_MUIC_MAX77705_CCIC)
	if ((muic_data->pdata) && (muic_data->pdata->opmode & OPMODE_CCIC)) {
		max77705_muic_unregister_ccic_notifier(muic_data);
		cancel_work_sync(&(muic_data->ccic_info_data_work));
	}
#endif
#if defined(CONFIG_HV_MUIC_MAX77705_AFC)
	/* clear MUIC afc voltage switching function */
	muic_data->pdata->muic_afc_set_voltage_cb = NULL;
	/* clear MUIC check charger init function */
	muic_data->pdata->muic_hv_charger_init_cb = NULL;
	cancel_delayed_work_sync(&(muic_data->afc_work));
	cancel_work_sync(&(muic_data->afc_handle_work));
#endif
#if defined(CONFIG_HICCUP_CHARGER)
	muic_data->pdata->muic_set_hiccup_mode_cb = NULL;
#endif /* CONFIG_HICCUP_CHARGER */
	muic_unregister_usb_notifier(muic_data);
	cancel_delayed_work_sync(&(muic_data->debug_work));

out:
	pr_info("%s -\n", __func__);
}

int max77705_muic_suspend(struct max77705_usbc_platform_data *usbc_data)
{
	struct max77705_muic_data *muic_data = usbc_data->muic_data;

	pr_info("%s\n", __func__);
	cancel_delayed_work(&(muic_data->debug_work));

	return 0;
}

int max77705_muic_resume(struct max77705_usbc_platform_data *usbc_data)
{
	struct max77705_muic_data *muic_data = usbc_data->muic_data;

	pr_info("%s\n", __func__);
	schedule_delayed_work(&(muic_data->debug_work), msecs_to_jiffies(1000));

	return 0;
}