Initial file dump from open source releaseHEADmaster

1 files changed, 1375 insertions, 0 deletions

diff --git a/drivers/mfd/rt8973.c b/drivers/mfd/rt8973.c
new file mode 100644
index 00000000..43351ab3
--- /dev/null
+++ b/drivers/mfd/rt8973.c
@@ -0,0 +1,1375 @@
+/* drivers/mfd/rt8973.c
+ * Richtek RT8973 Multifunction Device / MUIC Driver
+ *
+ * Copyright (C) 2013
+ * Author: Patrick Chang <patrick_chang@richtek.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ */
+#include <linux/kernel.h>
+#include <linux/rtdefs.h>
+#include <linux/module.h>
+#include <linux/version.h>
+#include <linux/slab.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/wakelock.h>
+#include <linux/delay.h>
+#include <linux/power_supply.h>
+#include <linux/mfd/rt8973.h>
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+#include <linux/gpio-pxa.h>
+#include <linux/platform_data/mv_usb.h>
+#include <mach/gpio-edge.h>
+#endif
+
+#define RT8973_DEVICE_NAME "rt8973"
+#define ALIAS_NAME RT8973_DEVICE_NAME
+#define RT8973_DRV_VER "2.1.2G"
+#define RT8973_IRQF_MODE IRQF_TRIGGER_FALLING
+
+#define RT8973_REG_CHIP_ID          0x01
+#define RT8973_REG_CONTROL          0x02
+#define RT8973_REG_INT_FLAG1        0x03
+#define RT8973_REG_INT_FLAG2        0x04
+#define RT8973_REG_INTERRUPT_MASK1  0x05
+#define RT8973_REG_INTERRUPT_MASK2  0x06
+#define RT8973_REG_ADC              0x07
+#define RT8973_REG_DEVICE1          0x0A
+#define RT8973_REG_DEVICE2          0x0B
+#define RT8973_REG_MANUAL_SW1       0x13
+#define RT8973_REG_MANUAL_SW2       0x14
+#define RT8973_REG_RESET            0x1B
+
+#define DCD_T_RETRY 2
+
+#define RT8973_DEVICE1_OTG  0x01
+#define RT8973_DEVICE1_SDP  0x04
+#define RT8973_DEVICE1_UART 0x08
+#define RT8973_DEVICE1_CDPORT   0x20
+#define RT8973_DEVICE1_DCPORT   0x40
+
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+static struct gpio_edge_desc muic_int_gpio;
+#endif
+
+static irqreturn_t rt8973_irq_handler(int irq, void *data);
+
+struct device_desc {
+	char *name;
+	uint32_t reg_val;
+	int cable_type;
+};
+
+static const struct device_desc device_to_cable_type_mapping[] = {
+	{
+		.name = "OTG",
+		.reg_val = RT8973_DEVICE1_OTG,
+		.cable_type = MUIC_RT8973_CABLE_TYPE_OTG,
+	},
+	{
+		.name = "USB SDP",
+		.reg_val = RT8973_DEVICE1_SDP,
+		.cable_type = MUIC_RT8973_CABLE_TYPE_USB,
+	},
+	{
+		.name = "UART",
+		.reg_val = RT8973_DEVICE1_UART,
+		.cable_type = MUIC_RT8973_CABLE_TYPE_UART,
+	},
+	{
+		.name = "USB CDP",
+		.reg_val = RT8973_DEVICE1_CDPORT,
+		.cable_type = MUIC_RT8973_CABLE_TYPE_CDP,
+	},
+	{
+		.name = "USB DCP",
+		.reg_val = RT8973_DEVICE1_DCPORT,
+		.cable_type = MUIC_RT8973_CABLE_TYPE_REGULAR_TA,
+	},
+};
+
+struct id_desc {
+	char *name;
+	int cable_type_with_vbus;
+	int cable_type_without_vbus;
+};
+
+static const struct id_desc id_to_cable_type_mapping[] = {
+	{
+		/* 00000, 0 */
+		.name = "OTG",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_OTG,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_OTG,
+	},
+	{			/* 00001, 1 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 00010, 2 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 00011, 3 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 00100, 4 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 00101, 5 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 00110, 6 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 00111, 7 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01000, 8 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01001, 9 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01010, 10 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01011, 11 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01100, 12 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01101, 13 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01110, 14 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 01111, 15 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10000, 16 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10001, 17 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10010, 18 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10011, 19 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10100, 20 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10101, 21 */
+		.name = "ADC0x15 Charger/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_0x15,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10110, 22 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 10111, 23 */
+		.name = "Type 1 Charger/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_TYPE1_CHARGER,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 11000, 24 */
+		.name = "FM BOOT OFF USB/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 11001, 25 */
+		.name = "FM BOOT ON USB/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_USB_ON,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 11010, 26 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 11011, 27 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 11100, 28 */
+		.name = "JIG UART BOOT OFF",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF,
+	},
+	{			/* 11101, 29 */
+		.name = "JIG UART BOOT ON",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_JIG_UART_ON,
+	},
+	{			/* 11110, 30 */
+		.name = "AT&T TA/Unknown",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_UNKNOWN,
+	},
+	{			/* 11111, 31 */
+		.name = "AT&T TA/No cable",
+		.cable_type_with_vbus = MUIC_RT8973_CABLE_TYPE_ATT_TA,
+		.cable_type_without_vbus = MUIC_RT8973_CABLE_TYPE_NONE,
+	},
+};
+
+enum {
+	VBUS_SHIFT = 0,
+	ACCESSORY_SHIFT,
+	OCP_SHIFT,
+	OVP_SHIFT,
+	OTP_SHIFT,
+	ADC_CHG_SHIFT,
+	CABLE_CHG_SHIFT,
+	OTG_SHIFT,
+	DCDT_SHIFT,
+	USB_SHIFT,
+	UART_SHIFT,
+	JIG_SHIFT,
+	L_USB_SHIFT,
+};
+
+struct rt8973_status {
+	int cable_type;
+	int id_adc;
+	uint8_t irq_flags[2];
+	uint8_t device_reg[2];
+	/* Processed useful status
+	 * Compare previous and current regs
+	 * to get this information */
+	union {
+		struct {
+			uint32_t vbus_status:1;
+			uint32_t accessory_status:1;
+			uint32_t ocp_status:1;
+			uint32_t ovp_status:1;
+			uint32_t otp_status:1;
+			uint32_t adc_chg_status:1;
+			uint32_t cable_chg_status:1;
+			uint32_t otg_status:1;
+			uint32_t dcdt_status:1;
+			uint32_t usb_connect:1;
+			uint32_t uart_connect:1;
+			uint32_t jig_connect:1;
+			uint32_t l_usb_connect:1;
+		};
+		uint32_t status;
+	};
+};
+
+typedef struct rt8973_chip {
+	struct i2c_client *iic;
+	struct mutex io_lock;
+	struct rt8973_platform_data *pdata;
+	struct device *dev;
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+	struct device *switch_dev;
+#endif
+	struct workqueue_struct *wq;
+	struct delayed_work irq_work;
+	struct delayed_work init_work;
+	struct wake_lock muic_wake_lock;
+	struct rt8973_status prev_status;
+	struct rt8973_status curr_status;
+	int dcdt_retry_count;
+	int irq;
+	int adc_reg_addr;
+} rt8973_chip_t;
+
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+static struct rt8973_status *current_status;
+#endif
+
+static int32_t rt8973_read(struct rt8973_chip *chip, uint8_t reg,
+		uint8_t nbytes, uint8_t *buff)
+{
+	int ret;
+	mutex_lock(&chip->io_lock);
+	ret = i2c_smbus_read_i2c_block_data(chip->iic, reg, nbytes, buff);
+	mutex_unlock(&chip->io_lock);
+	return ret;
+}
+
+static int32_t rt8973_reg_read(struct rt8973_chip *chip, int reg)
+{
+	int ret;
+	mutex_lock(&chip->io_lock);
+	ret = i2c_smbus_read_byte_data(chip->iic, reg);
+	mutex_unlock(&chip->io_lock);
+	return ret;
+}
+
+int32_t rt8973_reg_write(struct rt8973_chip *chip, int reg, unsigned char data)
+{
+	int ret;
+	mutex_lock(&chip->io_lock);
+	ret = i2c_smbus_write_byte_data(chip->iic, reg, data);
+	mutex_unlock(&chip->io_lock);
+	return ret;
+}
+
+static int32_t rt8973_assign_bits(struct rt8973_chip *chip, int reg,
+		unsigned char mask, unsigned char data)
+{
+	struct i2c_client *iic;
+	int ret;
+	iic = chip->iic;
+	mutex_lock(&chip->io_lock);
+	ret = i2c_smbus_read_byte_data(iic, reg);
+	if (ret < 0)
+		goto out;
+	ret &= ~mask;
+	ret |= data;
+	ret = i2c_smbus_write_byte_data(iic, reg, ret);
+out:
+	mutex_unlock(&chip->io_lock);
+	return ret;
+}
+
+int32_t rt8973_set_bits(struct rt8973_chip *chip, int reg, unsigned char mask)
+{
+	return rt8973_assign_bits(chip, reg, mask, mask);
+}
+
+int32_t rt8973_clr_bits(struct rt8973_chip *chip, int reg, unsigned char mask)
+{
+	return rt8973_assign_bits(chip, reg, mask, 0);
+}
+
+static inline int rt8973_update_regs(rt8973_chip_t *chip)
+{
+	int ret;
+	ret = rt8973_read(chip, RT8973_REG_INT_FLAG1,
+			2, chip->curr_status.irq_flags);
+	if (ret < 0)
+		return ret;
+	ret = rt8973_read(chip, RT8973_REG_DEVICE1,
+			2, chip->curr_status.device_reg);
+	if (ret < 0)
+		return ret;
+	ret = rt8973_reg_read(chip, chip->adc_reg_addr);
+	if (ret < 0)
+		return ret;
+	chip->curr_status.id_adc = ret;
+	/* invalid id value */
+	if (ret >= ARRAY_SIZE(id_to_cable_type_mapping))
+		return -EINVAL;
+	return 0;
+}
+
+static int rt8973_get_cable_type_by_device_reg(rt8973_chip_t *chip)
+{
+	uint32_t device_reg = chip->curr_status.device_reg[1];
+	int i;
+	RTINFO("Device = 0x%x, 0x%x\n",
+			(int)chip->curr_status.device_reg[0],
+			(int)chip->curr_status.device_reg[1]);
+	device_reg <<= 8;
+	device_reg |= chip->curr_status.device_reg[0];
+	for (i = 0; i < ARRAY_SIZE(device_to_cable_type_mapping); i++) {
+		if (device_to_cable_type_mapping[i].reg_val == device_reg) {
+			if (chip->curr_status.dcdt_status == 1) {
+				/* USB ID ==> open, i.e., ADC reading = 0x1f */
+				return id_to_cable_type_mapping[0x1f].cable_type_with_vbus;
+			}
+			return device_to_cable_type_mapping[i].cable_type;
+		}
+	}
+	/* not found */
+	return -EINVAL;
+}
+
+static int rt8973_get_cable_type_by_id(rt8973_chip_t *chip)
+{
+	int id_val = chip->curr_status.id_adc;
+	int cable_type;
+	RTINFO("ID value = 0x%x\n", id_val);
+	if (chip->curr_status.vbus_status)
+		cable_type = id_to_cable_type_mapping[id_val].cable_type_with_vbus;
+	else
+		cable_type = id_to_cable_type_mapping[id_val].cable_type_without_vbus;
+	/* Special case for ID200K USB cable */
+	if (cable_type == MUIC_RT8973_CABLE_TYPE_TYPE1_CHARGER) {
+		/* ID = 200KOhm, VBUS = 1, DCD_T = 0 and CHGDET = 0 ==> 200k SDP*/
+		if ((chip->curr_status.irq_flags[0]&0x0C) == 0)
+			cable_type = MUIC_RT8973_CABLE_TYPE_L_USB;
+	}
+	/* To remove OTG accessory, VBUS would still exist*/
+	if ((chip->prev_status.cable_type ==
+				MUIC_RT8973_CABLE_TYPE_OTG) && id_val == 0x1f) {
+		cable_type = MUIC_RT8973_CABLE_TYPE_NONE;
+		chip->curr_status.dcdt_status = 0;
+	}
+
+	return cable_type;
+}
+
+#define USB_RETRY_CNT 10
+#define USB_RETRY_DELAY 50
+
+static int rt8973_get_cable_type(rt8973_chip_t *chip)
+{
+	int i, ret = -1;
+	int dev_type_retry = 1;
+	/* Check dangerous case first and
+	 * * it can make system stop charging */
+	if (chip->curr_status.ovp_status |
+			chip->curr_status.ocp_status)
+		return MUIC_RT8973_CABLE_TYPE_UNKNOWN;
+	/* Only for RT8973A */
+	if (chip->adc_reg_addr == 0x23) {
+		for (i = 0; i < USB_RETRY_CNT && dev_type_retry == 1;
+				i++) {
+			ret = rt8973_get_cable_type_by_device_reg(chip);
+			/* VBUS = 1 but no DCD_T,
+			 * * and not a SDP/CDP/DCP type cable
+			 * * and not a L-type USB cable (200k-Ohm) */
+			if (ret < 0 && chip->curr_status.vbus_status == 1 &&
+					chip->curr_status.dcdt_status == 0 &&
+					chip->curr_status.id_adc != 0x17) {
+				msleep(USB_RETRY_DELAY);
+				rt8973_read(chip, RT8973_REG_DEVICE1,
+						2, chip->curr_status.device_reg);
+				pr_info("%s : retry to read DEV1 = 0x%x, DEV2 = 0x%x\n",
+						__func__, (int)chip->curr_status.device_reg[0],
+						(int)chip->curr_status.device_reg[1]);
+			} else {
+				dev_type_retry = 0;
+			}
+		}
+	} else {
+		ret = rt8973_get_cable_type_by_device_reg(chip);
+	}
+	if (ret >= 0)
+		return ret;
+	else
+		return rt8973_get_cable_type_by_id(chip);
+}
+
+static void rt8973_preprocess_status(rt8973_chip_t *chip)
+{
+	chip->curr_status.ocp_status =
+		(chip->curr_status.irq_flags[1] & 0x60) ? 1 : 0;
+	chip->curr_status.ovp_status =
+		((chip->curr_status.irq_flags[1] & 0x10) ||
+		 (chip->curr_status.irq_flags[0] & 0x10)) ? 1 : 0;
+	chip->curr_status.otp_status =
+		((chip->curr_status.irq_flags[1] & 0x08) ||
+		 (chip->curr_status.irq_flags[0] & 0x80))  ? 1 : 0;
+	chip->curr_status.dcdt_status =
+		(chip->curr_status.irq_flags[0] & 0x08) ? 1 : 0;
+	chip->curr_status.vbus_status =
+		(chip->curr_status.irq_flags[1] & 0x02) ? 0 : 1;
+	chip->curr_status.cable_type = rt8973_get_cable_type(chip);
+	chip->curr_status.adc_chg_status =
+		(chip->prev_status.id_adc != chip->curr_status.id_adc) ? 1 : 0;
+	chip->curr_status.otg_status =
+		(chip->curr_status.cable_type ==
+		 MUIC_RT8973_CABLE_TYPE_OTG) ? 1 : 0;
+	chip->curr_status.accessory_status =
+		((chip->curr_status.cable_type !=
+		  MUIC_RT8973_CABLE_TYPE_NONE) &&
+		 (chip->curr_status.cable_type !=
+		  MUIC_RT8973_CABLE_TYPE_UNKNOWN)) ? 1 : 0;
+	chip->curr_status.cable_chg_status =
+		(chip->curr_status.cable_type !=
+		 chip->prev_status.cable_type) ? 1 : 0;
+	chip->curr_status.usb_connect =
+		((chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_USB) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_CDP) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_L_USB) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_USB_ON)) ? 1 : 0;
+	chip->curr_status.uart_connect =
+		((chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_UART) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_ON) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS)) ? 1 : 0;
+	chip->curr_status.jig_connect =
+		((chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_USB_ON) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_ON) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS) ||
+		 (chip->curr_status.cable_type ==
+		  MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS)) ? 1 : 0;
+	chip->curr_status.l_usb_connect = (chip->curr_status.cable_type ==
+			MUIC_RT8973_CABLE_TYPE_L_USB) ? 1 : 0;
+}
+
+#define FLAG_HIGH           (0x01)
+#define FLAG_LOW            (0x02)
+#define FLAG_LOW_TO_HIGH    (0x04)
+#define FLAG_HIGH_TO_LOW    (0x08)
+#define FLAG_RISING         FLAG_LOW_TO_HIGH
+#define FLAG_FALLING        FLAG_HIGH_TO_LOW
+#define FLAG_CHANGED        (FLAG_LOW_TO_HIGH | FLAG_HIGH_TO_LOW)
+
+static inline uint32_t state_check(unsigned int old_state,
+		unsigned int new_state,
+		unsigned int bit_mask)
+{
+	unsigned int ret = 0;
+	old_state &= bit_mask;
+	new_state &= bit_mask;
+	if (new_state)
+		ret |= FLAG_HIGH;
+	else
+		ret |= FLAG_LOW;
+	if (old_state != new_state) {
+		if (new_state)
+			ret |= FLAG_LOW_TO_HIGH;
+		else
+			ret |= FLAG_HIGH_TO_LOW;
+	}
+	return ret;
+}
+
+struct rt8973_event_handler {
+	char *name;
+	uint32_t bit_mask;
+	uint32_t type;
+	void (*handler) (struct rt8973_chip *chip,
+			const struct rt8973_event_handler *handler,
+			unsigned int old_status, unsigned int new_status);
+
+};
+
+static void rt8973_ocp_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler *handler,
+		unsigned int old_status, unsigned int new_status)
+{
+	RTERR("OCP event triggered\n");
+	if (chip->pdata->ocp_callback)
+		chip->pdata->ocp_callback();
+}
+
+static void rt8973_ovp_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler *handler,
+		unsigned int old_status, unsigned int new_status)
+{
+	RTERR("OVP event triggered\n");
+	if (chip->pdata->ovp_callback)
+		chip->pdata->ovp_callback();
+}
+
+static void rt8973_otp_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler *handler,
+		unsigned int old_status, unsigned int new_status)
+{
+	RTERR("OTP event triggered\n");
+	if (chip->pdata->otp_callback)
+		chip->pdata->otp_callback();
+}
+
+struct rt8973_event_handler urgent_event_handlers[] = {
+	{
+		.name = "OCP",
+		.bit_mask = (1 << OCP_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_ocp_handler,
+	},
+	{
+		.name = "OVP",
+		.bit_mask = (1 << OVP_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_ovp_handler,
+	},
+	{
+		.name = "OTP",
+		.bit_mask = (1 << OTP_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_otp_handler,
+	},
+};
+
+#if RTDBGINFO_LEVEL <= RTDBGLEVEL
+static char *rt8973_cable_names[] = {
+
+	"MUIC_RT8973_CABLE_TYPE_NONE",
+	"MUIC_RT8973_CABLE_TYPE_UART",
+	"MUIC_RT8973_CABLE_TYPE_USB",
+	"MUIC_RT8973_CABLE_TYPE_OTG",
+	/* TA Group */
+	"MUIC_RT8973_CABLE_TYPE_REGULAR_TA",
+	"MUIC_RT8973_CABLE_TYPE_ATT_TA",
+	"MUIC_RT8973_CABLE_TYPE_0x15",
+	"MUIC_RT8973_CABLE_TYPE_TYPE1_CHARGER",
+	"MUIC_RT8973_CABLE_TYPE_0x1A",
+	/* JIG Group */
+	"MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF",
+	"MUIC_RT8973_CABLE_TYPE_JIG_USB_ON",
+	"MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF",
+	"MUIC_RT8973_CABLE_TYPE_JIG_UART_ON",
+	/* JIG type with VBUS */
+	"MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS",
+	"MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS",
+
+	"MUIC_RT8973_CABLE_TYPE_CDP",
+	"MUIC_RT8973_CABLE_TYPE_L_USB",
+	"MUIC_RT8973_CABLE_TYPE_UNKNOWN",
+	"MUIC_RT8973_CABLE_TYPE_INVALID",
+};
+#endif /*RTDBGINFO_LEVEL<=RTDBGLEVEL */
+
+#if defined(CONFIG_BATTERY_SAMSUNG) || defined(CONFIG_RT_BATTERY)
+#define cable_change_callback sec_charger_cb
+extern void sec_charger_cb(u8 cable_type);
+#endif
+static void rt8973_cable_change_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("Cable change to %s\n",
+			rt8973_cable_names[chip->curr_status.cable_type]);
+
+#if defined(CONFIG_BATTERY_SAMSUNG) || defined(CONFIG_RT_BATTERY)
+	cable_change_callback(chip->curr_status.cable_type);
+#endif
+
+	if (chip->pdata->cable_chg_callback)
+		chip->pdata->cable_chg_callback(chip->curr_status.cable_type);
+
+}
+
+static void rt8973_otg_attach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("OTG attached\n");
+	rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x24);
+	/* Disable USBCHDEN and AutoConfig*/
+	rt8973_clr_bits(chip, RT8973_REG_CONTROL, (1 << 2) | (1 << 6));
+	if (chip->pdata->otg_callback)
+		chip->pdata->otg_callback(1);
+}
+
+static void rt8973_otg_detach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("OTG detached\n");
+	rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x00);
+	/* Enable USBCHDEN and AutoConfig*/
+	rt8973_set_bits(chip, RT8973_REG_CONTROL, (1 << 2) | (1 << 6));
+	if (chip->pdata->otg_callback)
+		chip->pdata->otg_callback(0);
+}
+
+extern void dwc_udc_startup(void);
+extern void dwc_udc_shutdown(void);
+static void rt8973_usb_attach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("USB attached\n");
+	if (chip->pdata->usb_callback) {
+		chip->pdata->usb_callback(1);
+	} else {
+		dwc_udc_startup();
+	}
+}
+
+static void rt8973_usb_detach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("USB detached\n");
+	if (chip->pdata->usb_callback) {
+		chip->pdata->usb_callback(0);
+	} else {
+		dwc_udc_shutdown();
+	}
+}
+
+static void rt8973_uart_attach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("UART attached\n");
+	if (chip->pdata->uart_callback)
+		chip->pdata->uart_callback(1);
+}
+
+static void rt8973_uart_detach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("UART detached\n");
+	if (chip->pdata->uart_callback)
+		chip->pdata->uart_callback(0);
+}
+
+static inline jig_type_t get_jig_type(int cable_type)
+{
+	jig_type_t type = JIG_USB_BOOT_ON;
+	switch (cable_type) {
+		case MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS:
+		case MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF:
+			type = JIG_UART_BOOT_OFF;
+			break;
+		case MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS:
+		case MUIC_RT8973_CABLE_TYPE_JIG_UART_ON:
+			type = JIG_UART_BOOT_ON;
+			break;
+		case MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF:
+			type = JIG_USB_BOOT_OFF;
+			break;
+		case MUIC_RT8973_CABLE_TYPE_JIG_USB_ON:
+			type = JIG_USB_BOOT_ON;
+			break;
+	}
+	return type;
+}
+
+static void rt8973_jig_attach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	jig_type_t type;
+	type = get_jig_type(chip->curr_status.cable_type);
+	RTINFO("JIG attached (type = %d)\n", (int)type);
+	if (chip->pdata->jig_callback)
+		chip->pdata->jig_callback(type, 1);
+}
+
+static void rt8973_jig_detach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	jig_type_t type;
+	type = get_jig_type(chip->prev_status.cable_type);
+	RTINFO("JIG detached (type = %d)\n", (int)type);
+	if (chip->pdata->jig_callback)
+		chip->pdata->jig_callback(type, 0);
+}
+
+static void rt8973_l_usb_attach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("200k special USB cable attached\n");
+	/* Make switch connect to USB path */
+	rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x24);
+	/* Change to manual-config */
+	rt8973_clr_bits(chip, RT8973_REG_CONTROL, 1 << 2);
+}
+
+static void rt8973_l_usb_detach_handler(struct rt8973_chip *chip,
+		const struct rt8973_event_handler
+		*handler, unsigned int old_status,
+		unsigned int new_status)
+{
+	RTINFO("200k special USB cable detached\n");
+	/* Make switch opened */
+	rt8973_reg_write(chip, RT8973_REG_MANUAL_SW1, 0x00);
+	/* Change to auto-config */
+	rt8973_set_bits(chip, RT8973_REG_CONTROL, 1 << 2);
+}
+
+
+struct rt8973_event_handler normal_event_handlers[] = {
+	{
+		.name = "200k special USB attached",
+		.bit_mask = (1 << L_USB_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_l_usb_attach_handler,
+	},
+	{
+		.name = "200k special USB detached",
+		.bit_mask = (1 << L_USB_SHIFT),
+		.type = FLAG_FALLING,
+		.handler = rt8973_l_usb_detach_handler,
+	},
+	{
+		.name = "Cable changed",
+		.bit_mask = (1 << CABLE_CHG_SHIFT),
+		.type = FLAG_HIGH,
+		.handler = rt8973_cable_change_handler,
+	},
+	{
+		.name = "OTG attached",
+		.bit_mask = (1 << OTG_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_otg_attach_handler,
+	},
+	{
+		.name = "OTG detached",
+		.bit_mask = (1 << OTG_SHIFT),
+		.type = FLAG_FALLING,
+		.handler = rt8973_otg_detach_handler,
+	},
+	{
+		.name = "USB attached",
+		.bit_mask = (1 << USB_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_usb_attach_handler,
+	},
+	{
+		.name = "USB detached",
+		.bit_mask = (1 << USB_SHIFT),
+		.type = FLAG_FALLING,
+		.handler = rt8973_usb_detach_handler,
+	},
+	{
+		.name = "UART attached",
+		.bit_mask = (1 << UART_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_uart_attach_handler,
+	},
+	{
+		.name = "UART detached",
+		.bit_mask = (1 << UART_SHIFT),
+		.type = FLAG_FALLING,
+		.handler = rt8973_uart_detach_handler,
+	},
+	{
+		.name = "JIG attached",
+		.bit_mask = (1 << JIG_SHIFT),
+		.type = FLAG_RISING,
+		.handler = rt8973_jig_attach_handler,
+	},
+	{
+		.name = "JIG detached",
+		.bit_mask = (1 << JIG_SHIFT),
+		.type = FLAG_FALLING,
+		.handler = rt8973_jig_detach_handler,
+	},
+};
+
+static void rt8973_process_urgent_evt(rt8973_chip_t *chip)
+{
+	unsigned int i;
+	unsigned int type, sta_chk;
+	uint32_t prev_status, curr_status;
+	prev_status = chip->prev_status.status;
+	curr_status = chip->curr_status.status;
+	for (i = 0; i < ARRAY_SIZE(urgent_event_handlers); i++) {
+		sta_chk = state_check(prev_status,
+				curr_status,
+				urgent_event_handlers[i].bit_mask);
+		type = urgent_event_handlers[i].type;
+		if (type & sta_chk) {
+
+			if (urgent_event_handlers[i].handler)
+				urgent_event_handlers[i].handler(chip,
+						urgent_event_handlers + i,
+						prev_status,
+						curr_status);
+		}
+	}
+}
+
+static void rt8973_process_normal_evt(rt8973_chip_t *chip)
+{
+	unsigned int i;
+	unsigned int type, sta_chk;
+	uint32_t prev_status, curr_status;
+	prev_status = chip->prev_status.status;
+	curr_status = chip->curr_status.status;
+	for (i = 0; i < ARRAY_SIZE(normal_event_handlers); i++) {
+		sta_chk = state_check(prev_status,
+				curr_status,
+				normal_event_handlers[i].bit_mask);
+		type = normal_event_handlers[i].type;
+		if (type & sta_chk) {
+			if (normal_event_handlers[i].handler)
+				normal_event_handlers[i].handler(chip,
+						normal_event_handlers + i,
+						prev_status,
+						curr_status);
+		}
+	}
+}
+
+static void rt8973_irq_work(struct work_struct *work)
+{
+	int ret;
+	rt8973_chip_t *chip = container_of(to_delayed_work(work),
+			rt8973_chip_t, irq_work);
+	chip->prev_status = chip->curr_status;
+	ret = rt8973_update_regs(chip);
+	if (ret < 0) {
+		RTERR("Error : can't update(read) register status:%d\n", ret);
+		/* roll back status */
+		chip->curr_status = chip->prev_status;
+		return;
+	}
+	/* for printing out registers -- start */
+	pr_info("%s : INTF1 = 0x%x, INTF2 = 0x%x\n", __FUNCTION__,
+			(int)chip->curr_status.irq_flags[0],
+			(int)chip->curr_status.irq_flags[1]);
+	pr_info("%s : DEV1 = 0x%x, DEV2 = 0x%x\n", __FUNCTION__,
+			(int)chip->curr_status.device_reg[0],
+			(int)chip->curr_status.device_reg[1]);
+	pr_info("%s : ADC = 0x%x\n", __FUNCTION__,
+			(int)chip->curr_status.id_adc);
+	/* for printint out registers -- end*/
+	rt8973_preprocess_status(chip);
+	RTINFO("Status : cable type = %d,\n"
+			"vbus = %d, accessory = %d\n"
+			"ocp = %d, ovp = %d, otp = %d,\n"
+			"adc_chg = %d, cable_chg = %d\n"
+			"otg = %d, dcdt = %d, usb = %d,\n"
+			"uart = %d, jig = %d\n"
+			"200k usb cable = %d\n",
+			chip->curr_status.cable_type,
+			chip->curr_status.vbus_status,
+			chip->curr_status.accessory_status,
+			chip->curr_status.ocp_status,
+			chip->curr_status.ovp_status,
+			chip->curr_status.otp_status,
+			chip->curr_status.adc_chg_status,
+			chip->curr_status.cable_chg_status,
+			chip->curr_status.otg_status,
+			chip->curr_status.dcdt_status,
+			chip->curr_status.usb_connect,
+			chip->curr_status.uart_connect,
+			chip->curr_status.jig_connect,
+			chip->curr_status.l_usb_connect);
+	rt8973_process_urgent_evt(chip);
+	if (chip->curr_status.dcdt_status) {
+		if (chip->dcdt_retry_count >= DCD_T_RETRY) {
+			chip->dcdt_retry_count = 0;	/* reset counter */
+			RTINFO("Exceeded maxima retry times\n");
+			/* continue to process event */
+		} else {
+			chip->dcdt_retry_count++;
+			/* DCD_T -> roll back previous status */
+			chip->curr_status = chip->prev_status;
+			RTINFO("DCD_T event triggered, do re-detect\n");
+			rt8973_clr_bits(chip, RT8973_REG_CONTROL, 0x60);
+			msleep_interruptible(1);
+			rt8973_set_bits(chip, RT8973_REG_CONTROL, 0x60);
+			return;
+		}
+	}
+	rt8973_process_normal_evt(chip);
+}
+
+static irqreturn_t rt8973_irq_handler(int irq, void *data)
+{
+	struct rt8973_chip *chip = data;
+	wake_lock_timeout(&(chip->muic_wake_lock), msecs_to_jiffies(500));
+	RTINFO("RT8973 interrupt triggered!\n");
+	queue_delayed_work(chip->wq, &chip->irq_work, msecs_to_jiffies(250));
+	return IRQ_HANDLED;
+}
+
+static const struct i2c_device_id rt8973_id_table[] = {
+	{"rt8973", 0},
+	{},
+};
+
+MODULE_DEVICE_TABLE(i2c, rt8973_id_table);
+
+static bool rt8973_reset_check(struct i2c_client *iic)
+{
+	int ret;
+	ret = i2c_smbus_read_byte_data(iic, RT8973_REG_CHIP_ID);
+	if (ret < 0) {
+		RTERR("Error : can't read device ID from IC(%d)\n", ret);
+		return false;
+	}
+	if ((ret & 0x07) != 0x02) {
+		RTERR("Error : vendor ID mismatch (0x%d)!\n", ret);
+		return false;
+	}
+
+	/* write default value instead of sending reset command*/
+	/* REG[0x02] = 0xE5, REG[0x14] = 0x01*/
+	i2c_smbus_write_byte_data(iic, RT8973_REG_CONTROL, 0xE5);
+	i2c_smbus_write_byte_data(iic, RT8973_REG_MANUAL_SW2, 0x01);
+	return true;
+}
+
+#define CHECK_PSY_READY 1
+
+#define BATTERY_PSY_NAME "battery"
+#define CHARGER_PSY_NAME "sec-charger"
+#define POLL_DELAY  50
+
+static void rt8973_init_work(struct work_struct *work)
+{
+	int ret;
+	rt8973_chip_t *chip = container_of(to_delayed_work(work),
+			rt8973_chip_t, init_work);
+
+#if CHECK_PSY_READY
+	/* make sure that Samsung battery and battery are ready to receive notification*/
+	struct power_supply *psy_battery = NULL;
+	struct power_supply *psy_charger = NULL;
+	do {
+		psy_battery = power_supply_get_by_name(BATTERY_PSY_NAME);
+		psy_charger = power_supply_get_by_name(CHARGER_PSY_NAME);
+		if (psy_battery == NULL || psy_charger == NULL) {
+			dev_info(&chip->iic->dev, "RT8973 : Battery and charger are not ready\r\n");
+			msleep(POLL_DELAY);
+		}
+	} while (psy_battery == NULL || psy_charger == NULL);
+	dev_info(&chip->iic->dev, "RT8973 : Battery and charger are ready\r\n");
+#endif
+	/* Dummy read */
+	rt8973_reg_read(chip, RT8973_REG_INT_FLAG1);
+	rt8973_clr_bits(chip, RT8973_REG_CONTROL, 0x60);
+	msleep_interruptible(1);
+	rt8973_set_bits(chip, RT8973_REG_CONTROL, 0x60);
+	/* enable interrupt */
+	ret = rt8973_clr_bits(chip, RT8973_REG_CONTROL, 0x01);
+	if (ret < 0) {
+		dev_err(&chip->iic->dev, "can't enable rt8973's INT (%d)\r\n",ret);
+	}
+	/* Execute 1st dectection and report cable type*/
+	queue_delayed_work(chip->wq, &chip->irq_work, msecs_to_jiffies(50));
+}
+
+static void rt8973_init_regs(rt8973_chip_t *chip)
+{
+	int chip_id = rt8973_reg_read(chip, RT8973_REG_CHIP_ID);
+	/* initialize with MUIC_RT8973_CABLE_TYPE_INVALID
+	 * to make 1st detection work always report cable type */
+	chip->curr_status.cable_type = MUIC_RT8973_CABLE_TYPE_INVALID;
+	chip->curr_status.id_adc = 0x1f;
+	/* for rev 0, turn off i2c reset function */
+	if (((chip_id & 0xf8) >> 3) == 0)
+		rt8973_set_bits(chip, RT8973_REG_CONTROL, 0x08);
+	/* Revision ID >=2 --> RT8973A, it should use Reg[0x23] instead of Reg[0x07] to read ADC */
+	if (((chip_id & 0xf8) >> 3) >= 2)
+		chip->adc_reg_addr = 0x23;
+	else
+		chip->adc_reg_addr = RT8973_REG_ADC;
+	/* Only mask Connect */
+	rt8973_reg_write(chip, RT8973_REG_INTERRUPT_MASK1, 0x20);
+	/* Only mask OCP_LATCH and POR */
+	rt8973_reg_write(chip, RT8973_REG_INTERRUPT_MASK2, 0x24);
+	queue_delayed_work(chip->wq, &chip->init_work, 0);
+}
+
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+static ssize_t adc_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	u8 adc_value[] = "1C";
+	u8 adc_fail = 0;
+
+	if (current_status->cable_type == MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF) {
+		RTINFO("adc_show JIG UART BOOT OFF\n");
+		return sprintf(buf, "%s\n", adc_value);
+	} else {
+		RTINFO("adc_show no detect\n");
+		return sprintf(buf, "%d\n", adc_fail);
+	}
+}
+
+static ssize_t usb_state_show_attrs(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	if (current_status->usb_connect)
+		return sprintf(buf, "USB_STATE_CONFIGURED\n");
+	else
+		return sprintf(buf, "USB_STATE_NOTCONFIGURED\n");
+}
+
+static ssize_t usb_sel_show_attrs(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	return sprintf(buf, "PDA");
+}
+
+static DEVICE_ATTR(adc, S_IRUGO | S_IWUSR | S_IWGRP | S_IXOTH /*0665 */ ,
+		adc_show, NULL);
+static DEVICE_ATTR(usb_state, S_IRUGO, usb_state_show_attrs, NULL);
+static DEVICE_ATTR(usb_sel, S_IRUGO, usb_sel_show_attrs, NULL);
+
+static int sec_get_usb_vbus(unsigned int *level)
+{
+	if (current_status->vbus_status) {
+		RTINFO("set VBUS_HIGH\n");
+		*level = VBUS_HIGH;
+	} else {
+		RTINFO("set VBUS_LOW\n");
+		*level = VBUS_LOW;
+	}
+	return 0;
+}
+#endif
+
+static int rt8973_parse_dt(struct device *dev,
+		struct rt8973_platform_data *pdata)
+{
+	struct device_node *np = dev->of_node;
+	enum of_gpio_flags irq_gpio_flags;
+
+	pdata->irq_gpio = of_get_named_gpio_flags(np, "rt8973,irq-gpio",
+			0, &irq_gpio_flags);
+	return 0;
+}
+
+static int __init rt8973_probe(struct i2c_client *client,
+		const struct i2c_device_id *id)
+{
+	struct rt8973_platform_data *pdata;
+	struct rt8973_chip *chip;
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+	struct device *switch_dev;
+#endif
+	int ret;
+	RTINFO("Richtek RT8973 driver %s probing...\n", RT8973_DRV_VER);
+	if (client->dev.of_node) {
+		pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
+		if (!pdata) {
+			dev_err(&client->dev, "Failed to allocate memory\n");
+			ret = -ENOMEM;
+			goto err_nomem;
+		}
+		ret = rt8973_parse_dt(&client->dev, pdata);
+		if (ret < 0)
+			goto err_parse_dt;
+	} else
+		pdata = client->dev.platform_data;
+
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+	pdata->irq_gpio = pxa_irq_to_gpio(client->irq);
+	RTINFO("GPIO MUIC INT No. = %d\n", pdata->irq_gpio);
+#endif
+	ret = i2c_check_functionality(client->adapter,
+			I2C_FUNC_SMBUS_BYTE_DATA |
+			I2C_FUNC_SMBUS_I2C_BLOCK);
+	if (ret < 0) {
+		RTERR("Error : i2c functionality check failed\n");
+		goto err_i2c_func;
+	}
+	if (!rt8973_reset_check(client)) {
+		ret = -ENODEV;
+		goto err_reset_rt8973_fail;
+	}
+
+	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+	if (chip == NULL) {
+		ret = -ENOMEM;
+		goto err_nomem;
+	}
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+	current_status = &chip->curr_status;
+#endif
+	wake_lock_init(&chip->muic_wake_lock, WAKE_LOCK_SUSPEND,
+			"rt8973_wakelock");
+	ret = gpio_request(pdata->irq_gpio, "RT8973_EINT");
+	RTWARN_IF(ret < 0,
+			"Warning : failed to request GPIO%d (retval = %d)\n",
+			pdata->irq_gpio, ret);
+	ret = gpio_direction_input(pdata->irq_gpio);
+	RTWARN_IF(ret < 0,
+			"Warning : failed to set GPIO%d as input pin(retval = %d)\n",
+			pdata->irq_gpio, ret);
+	chip->iic = client;
+	chip->dev = &client->dev;
+	chip->pdata = pdata;
+	i2c_set_clientdata(client, chip);
+	chip->wq = create_workqueue("rt8973_workqueue");
+	INIT_DELAYED_WORK(&chip->irq_work, rt8973_irq_work);
+	INIT_DELAYED_WORK(&chip->init_work, rt8973_init_work);
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+	pxa_usb_set_extern_call(PXA_USB_DEV_OTG, vbus, get_vbus,
+			sec_get_usb_vbus);
+#endif
+	mutex_init(&chip->io_lock);
+	chip->irq = gpio_to_irq(pdata->irq_gpio);
+	client->irq = chip->irq;
+	RTINFO("Request IRQ %d(GPIO %d)...\n",
+			chip->irq, pdata->irq_gpio);
+	ret = request_irq(chip->irq, rt8973_irq_handler,
+			RT8973_IRQF_MODE | IRQF_NO_SUSPEND,
+			RT8973_DEVICE_NAME, chip);
+	if (ret < 0) {
+		RTERR
+			("Error : failed to request irq %d (gpio=%d, retval=%d)\n",
+			 chip->irq, pdata->irq_gpio, ret);
+		goto err_request_irq_fail;
+	}
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+	switch_dev = device_create(sec_class, NULL, 0, NULL, "switch");
+	chip->switch_dev = switch_dev;
+	if (device_create_file(switch_dev, &dev_attr_adc) < 0)
+		pr_err("Failed to create device file(%s)!\n",
+				dev_attr_adc.attr.name);
+	if (device_create_file(switch_dev, &dev_attr_usb_state) < 0)
+		pr_err("Failed to create device file(%s)!\n",
+				dev_attr_usb_state.attr.name);
+	if (device_create_file(switch_dev, &dev_attr_usb_sel) < 0)
+		pr_err("Failed to create device file(%s)!\n",
+				dev_attr_usb_sel.attr.name);
+
+	muic_int_gpio.mfp = pdata->irq_gpio;
+	mmp_gpio_edge_add(&muic_int_gpio);
+#endif
+	rt8973_init_regs(chip);
+	pr_info("RT8973 : Richtek RT8973 MUIC driver %s initialize successfully\n", RT8973_DRV_VER);
+	return 0;
+err_request_irq_fail:
+	mutex_destroy(&chip->io_lock);
+	destroy_workqueue(chip->wq);
+	gpio_free(pdata->irq_gpio);
+	wake_lock_destroy(&chip->muic_wake_lock);
+	kfree(chip);
+err_nomem:
+err_reset_rt8973_fail:
+err_i2c_func:
+err_parse_dt:
+	return ret;
+}
+
+static int __exit rt8973_remove(struct i2c_client *client)
+{
+	struct rt8973_chip *chip;
+	RTINFO("Richtek RT8973 driver removing...\n");
+#ifdef SAMSUNG_MVRL_MUIC_RT8973
+	mmp_gpio_edge_del(&muic_int_gpio);
+#endif
+	chip = i2c_get_clientdata(client);
+	if (chip) {
+		free_irq(chip->irq, chip);
+		gpio_free(chip->pdata->irq_gpio);
+		mutex_destroy(&chip->io_lock);
+		if (chip->wq)
+			destroy_workqueue(chip->wq);
+		wake_lock_destroy(&chip->muic_wake_lock);
+		kfree(chip);
+	}
+	return 0;
+
+}
+
+static void rt8973_shutdown(struct i2c_client *iic)
+{
+	struct rt8973_chip *chip;
+	chip = i2c_get_clientdata(iic);
+	disable_irq(iic->irq);
+	cancel_delayed_work_sync(&chip->irq_work);
+	pr_info("RT8973 : Shutdown : set rt8973 regs to default setting...\n");
+	i2c_smbus_write_byte_data(iic, RT8973_REG_CONTROL, 0xE5);
+	i2c_smbus_write_byte_data(iic, RT8973_REG_MANUAL_SW2, 0x01);
+}
+
+#ifdef CONFIG_OF
+static struct of_device_id rt8973_match_table[] = {
+	{ .compatible = "richtek,rt8973",},
+	{},
+};
+#else
+#define rt8973_match_table NULL
+#endif
+
+
+static struct i2c_driver rt8973_driver = {
+	.driver = {
+		.name = RT8973_DEVICE_NAME,
+		.owner = THIS_MODULE,
+		.of_match_table = rt8973_match_table,
+	},
+	.probe = rt8973_probe,
+	.remove = rt8973_remove,
+	.shutdown = rt8973_shutdown,
+	.id_table = rt8973_id_table,
+};
+
+static int __init rt8973_i2c_init(void)
+{
+	int ret;
+	ret = i2c_add_driver(&rt8973_driver);
+	if (ret != 0)
+		pr_err("Failed to register RT8973 I2C driver: %d\n", ret);
+	return ret;
+}
+
+late_initcall(rt8973_i2c_init);
+
+static void __exit rt8973_i2c_exit(void)
+{
+	i2c_del_driver(&rt8973_driver);
+}
+
+module_exit(rt8973_i2c_exit);
+
+MODULE_DESCRIPTION("Richtek RT8973 MUIC Driver");
+MODULE_AUTHOR("Patrick Chang <patrick_chang@richtek.com>");
+MODULE_VERSION(RT8973_DRV_VER);
+MODULE_LICENSE("GPL");