[PATCH] power_supply: Add support for Richtek rt9455 battery charger

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 




Based on the datasheet found here:
http://www.richtek.com/download_ds.jsp?p=RT9455

Signed-off-by: Anda-Maria Nicolae <anda-maria.nicolae@xxxxxxxxx>
---
 .../devicetree/bindings/power/rt9455_charger.txt   |   38 +
 .../devicetree/bindings/vendor-prefixes.txt        |    1 +
 drivers/power/Kconfig                              |    6 +
 drivers/power/Makefile                             |    1 +
 drivers/power/rt9455_charger.c                     | 1770 ++++++++++++++++++++
 5 files changed, 1816 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/power/rt9455_charger.txt
 create mode 100644 drivers/power/rt9455_charger.c

diff --git a/Documentation/devicetree/bindings/power/rt9455_charger.txt b/Documentation/devicetree/bindings/power/rt9455_charger.txt
new file mode 100644
index 0000000..f716cf6
--- /dev/null
+++ b/Documentation/devicetree/bindings/power/rt9455_charger.txt
@@ -0,0 +1,38 @@
+Binding for RT rt9455 battery charger
+
+Required properties:
+- compatible: Should contain one of the following:
+ * "rt,rt9455"
+
+- reg:			integer, i2c address of the device.
+- rt,ICHRG:		integer, output charge current in uA.
+- rt,IEOC_PERCENTAGE:	integer, the percent of the output charge current (ICHRG).
+			When the current in constant-voltage phase drops below
+			ICHRG x IEOC_PERCENTAGE, charge is terminated.
+- rt,VOREG:		integer, battery regulation voltage in uV.
+
+Optional properties:
+- rt,VMIVR:		integer, minimum input voltage regulation in uV.
+			Prevents input voltage drop due to insufficient current
+			provided by the power source.
+- rt,IAICR:		integer, input current regulation in uA.
+
+Example:
+
+rt9455@22 {
+	compatible = "rt,rt9455";
+	reg = <0x22>;
+
+	interrupt-parent = <&gpio1>;
+	interrupts = <0 1>;
+
+	interrupt-gpio = <&gpio1 0 1>;
+	reset-gpio = <&gpio1 1 1>;
+
+	rt,ICHRG = <500000>;
+	rt,IEOC_PERCENTAGE = <10>;
+	rt,VOREG = <4200000>;
+
+	rt,VMIVR = <4500000>;
+	rt,IAICR = <500000>;
+};
diff --git a/Documentation/devicetree/bindings/vendor-prefixes.txt b/Documentation/devicetree/bindings/vendor-prefixes.txt
index 389ca13..dc868ed 100644
--- a/Documentation/devicetree/bindings/vendor-prefixes.txt
+++ b/Documentation/devicetree/bindings/vendor-prefixes.txt
@@ -148,6 +148,7 @@ raidsonic	RaidSonic Technology GmbH
 ralink	Mediatek/Ralink Technology Corp.
 ramtron	Ramtron International
 realtek Realtek Semiconductor Corp.
+rt	Richtek Technology Corporation
 renesas	Renesas Electronics Corporation
 ricoh	Ricoh Co. Ltd.
 rockchip	Fuzhou Rockchip Electronics Co., Ltd
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 4091fb0..39f208d 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -439,6 +439,12 @@ config BATTERY_RT5033
 	  The fuelgauge calculates and determines the battery state of charge
 	  according to battery open circuit voltage.
 
+config CHARGER_RT9455
+	tristate "Richtek RT9455 battery charger driver"
+	depends on I2C && GPIOLIB
+	help
+	Say Y to enable support for the Richtek RT9455 battery charger.
+
 source "drivers/power/reset/Kconfig"
 
 endif # POWER_SUPPLY
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index b7b0181..e49abbf 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -37,6 +37,7 @@ obj-$(CONFIG_BATTERY_MAX17040)	+= max17040_battery.o
 obj-$(CONFIG_BATTERY_MAX17042)	+= max17042_battery.o
 obj-$(CONFIG_BATTERY_Z2)	+= z2_battery.o
 obj-$(CONFIG_BATTERY_RT5033)	+= rt5033_battery.o
+obj-$(CONFIG_CHARGER_RT9455)	+= rt9455_charger.o
 obj-$(CONFIG_BATTERY_S3C_ADC)	+= s3c_adc_battery.o
 obj-$(CONFIG_BATTERY_TWL4030_MADC)	+= twl4030_madc_battery.o
 obj-$(CONFIG_CHARGER_88PM860X)	+= 88pm860x_charger.o
diff --git a/drivers/power/rt9455_charger.c b/drivers/power/rt9455_charger.c
new file mode 100644
index 0000000..57bb97d
--- /dev/null
+++ b/drivers/power/rt9455_charger.c
@@ -0,0 +1,1770 @@
+/*
+ * Driver for Richtek RT9455WSC battery charger.
+ *
+ * Copyright (C) 2015 Intel Corporation
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/of_irq.h>
+#include <linux/of_device.h>
+#include <linux/pm_runtime.h>
+#include <linux/power_supply.h>
+#include <linux/gpio.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/acpi.h>
+#include <linux/usb/phy.h>
+
+#define RT9455_MANUFACTURER			"Richtek"
+#define RT9455_MODEL_NAME			"RT9455"
+#define RT9455_DRIVER_NAME			"rt9455-charger"
+
+#define RT9455_IRQ_NAME				"interrupt"
+
+#define RT9455_PWR_RDY_DELAY			1 /* 1 second */
+#define RT9455_MAX_CHARGING_TIME		21600 /* 6 hrs */
+#define RT9455_BATT_PRESENCE_DELAY		60 /* 60 seconds */
+
+#define RT9455_CHARGE_MODE			0x00
+#define RT9455_BOOST_MODE			0x01
+
+#define RT9455_FAULT				0x03
+
+#define RT9455_IAICR_100MA			0x00
+#define RT9455_IAICR_500MA			0x01
+#define RT9455_IAICR_NO_LIMIT			0x03
+
+#define RT9455_CHARGE_DISABLE			0x00
+#define RT9455_CHARGE_ENABLE			0x01
+
+#define RT9455_PWR_FAULT			0x00
+#define RT9455_PWR_GOOD				0x01
+
+#define RT9455_REG_CTRL1			0x00 /* Control1 */
+#define RT9455_REG_CTRL1_STAT_MASK		(BIT(5) | BIT(4))
+#define RT9455_REG_CTRL1_STAT_SHIFT		4
+#define RT9455_REG_CTRL1_BOOST_MASK		BIT(3)
+#define RT9455_REG_CTRL1_BOOST_SHIFT		3
+#define RT9455_REG_CTRL1_PWR_RDY_MASK		BIT(2)
+#define RT9455_REG_CTRL1_PWR_RDY_SHIFT		2
+#define RT9455_REG_CTRL1_OTG_PIN_POLARITY_MASK	BIT(1)
+#define RT9455_REG_CTRL1_OTG_PIN_POLARITY_SHIFT	1
+
+#define RT9455_REG_CTRL2			0x01 /* Control2 */
+#define RT9455_REG_CTRL2_IAICR_MASK		(BIT(7) | BIT(6))
+#define RT9455_REG_CTRL2_IAICR_SHIFT		6
+#define RT9455_REG_CTRL2_TE_SHDN_EN_MASK	BIT(5)
+#define RT9455_REG_CTRL2_TE_SHDN_EN_SHIFT	5
+#define RT9455_REG_CTRL2_HIGHER_OCP_MASK	BIT(4)
+#define RT9455_REG_CTRL2_HIGHER_OCP_SHIFT	4
+#define RT9455_REG_CTRL2_TE_MASK		BIT(3)
+#define RT9455_REG_CTRL2_TE_SHIFT		3
+#define RT9455_REG_CTRL2_IAICR_INT_MASK		BIT(2)
+#define RT9455_REG_CTRL2_IAICR_INT_SHIFT	2
+#define RT9455_REG_CTRL2_HIZ_MASK		BIT(1)
+#define RT9455_REG_CTRL2_HIZ_SHIFT		1
+#define RT9455_REG_CTRL2_OPA_MODE_MASK		BIT(0)
+#define RT9455_REG_CTRL2_OPA_MODE_SHIFT		0
+
+#define RT9455_REG_CTRL3			0x02 /* Control3 */
+#define RT9455_REG_CTRL3_VOREG_MASK		(BIT(7) | BIT(6) | BIT(5) | \
+						 BIT(4) | BIT(3) | BIT(2))
+#define RT9455_REG_CTRL3_VOREG_SHIFT		2
+#define RT9455_REG_CTRL3_OTG_PL_MASK		BIT(1)
+#define RT9455_REG_CTRL3_OTG_PL_SHIFT		1
+#define RT9455_REG_CTRL3_OTG_EN_MASK		BIT(0)
+#define RT9455_REG_CTRL3_OTG_EN_SHIFT		0
+
+#define RT9455_REG_DEV_ID			0x03 /* Device ID */
+#define RT9455_REG_DEV_ID_VENDOR_ID_MASK	(BIT(7) | BIT(6) | BIT(5) | \
+						 BIT(4))
+#define RT9455_REG_DEV_ID_VENDOR_ID_SHIFT	4
+#define RT9455_REG_DEV_ID_CHIP_REV_MASK		(BIT(3) | BIT(2) | BIT(1) | \
+						 BIT(0))
+#define RT9455_REG_DEV_ID_CHIP_REV_SHIFT		0
+
+#define RT9455_REG_CTRL4			0x04 /* Control4 */
+#define RT9455_REG_CTRL4_RST_MASK		BIT(7)
+#define RT9455_REG_CTRL4_RST_SHIFT		7
+
+#define RT9455_REG_CTRL5			0x05 /* Control5 */
+#define RT9455_REG_CTRL5_TMR_EN_MASK		BIT(7)
+#define RT9455_REG_CTRL5_TMR_EN_SHIFT		7
+#define RT9455_REG_CTRL5_VMIVR_MASK		(BIT(5) | BIT(4))
+#define RT9455_REG_CTRL5_VMIVR_SHIFT		4
+#define RT9455_REG_CTRL5_IPREC_MASK		(BIT(3) | BIT(2))
+#define RT9455_REG_CTRL5_IPREC_SHIFT		2
+#define RT9455_REG_CTRL5_IEOC_PERCENTAGE_MASK	(BIT(1) | BIT(0))
+#define RT9455_REG_CTRL5_IEOC_PERCENTAGE_SHIFT	0
+
+#define RT9455_REG_CTRL6			0x06 /* Control6 */
+#define RT9455_REG_CTRL6_IAICR_SEL_MASK		BIT(7)
+#define RT9455_REG_CTRL6_IAICR_SEL_SHIFT	7
+#define RT9455_REG_CTRL6_ICHRG_MASK		(BIT(6) | BIT(5) | BIT(4))
+#define RT9455_REG_CTRL6_ICHRG_SHIFT		4
+#define RT9455_REG_CTRL6_VPREC_MASK		(BIT(2) | BIT(1) | BIT(0))
+#define RT9455_REG_CTRL6_VPREC_SHIFT		0
+
+#define RT9455_REG_CTRL7			0x07 /* Control7 */
+#define RT9455_REG_CTRL7_BATD_EN_MASK		BIT(6)
+#define RT9455_REG_CTRL7_BATD_EN_SHIFT		6
+#define RT9455_REG_CTRL7_CHG_EN_MASK		BIT(4)
+#define RT9455_REG_CTRL7_CHG_EN_SHIFT		4
+#define RT9455_REG_CTRL7_VMREG_MASK		(BIT(3) | BIT(2) | BIT(1) | \
+						 BIT(0))
+#define RT9455_REG_CTRL7_VMREG_SHIFT		0
+
+#define RT9455_REG_IRQ1				0x08 /* IRQ1 */
+#define RT9455_REG_IRQ1_TSDI_MASK		BIT(7)
+#define RT9455_REG_IRQ1_TSDI_SHIFT		7
+#define RT9455_REG_IRQ1_VINOVPI_MASK		BIT(6)
+#define RT9455_REG_IRQ1_VINOVPI_SHIFT		6
+#define RT9455_REG_IRQ1_BATAB_MASK		BIT(0)
+#define RT9455_REG_IRQ1_BATAB_SHIFT		0
+
+#define RT9455_REG_IRQ2				0x09 /* IRQ2 */
+#define RT9455_REG_IRQ2_CHRVPI_MASK		BIT(7)
+#define RT9455_REG_IRQ2_CHRVPI_SHIFT		7
+#define RT9455_REG_IRQ2_CHBATOVI_MASK		BIT(5)
+#define RT9455_REG_IRQ2_CHBATOVI_SHIFT		5
+#define RT9455_REG_IRQ2_CHTERMI_MASK		BIT(4)
+#define RT9455_REG_IRQ2_CHTERMI_SHIFT		4
+#define RT9455_REG_IRQ2_CHRCHGI_MASK		BIT(3)
+#define RT9455_REG_IRQ2_CHRCHGI_SHIFT		3
+#define RT9455_REG_IRQ2_CH32MI_MASK		BIT(2)
+#define RT9455_REG_IRQ2_CH32MI_SHIFT		2
+#define RT9455_REG_IRQ2_CHTREGI_MASK		BIT(1)
+#define RT9455_REG_IRQ2_CHTREGI_SHIFT		1
+#define RT9455_REG_IRQ2_CHMIVRI_MASK		BIT(0)
+#define RT9455_REG_IRQ2_CHMIVRI_SHIFT		0
+
+#define RT9455_REG_IRQ3				0x0A /* IRQ3 */
+#define RT9455_REG_IRQ3_BSTBUSOVI_MASK		BIT(7)
+#define RT9455_REG_IRQ3_BSTBUSOVI_SHIFT		7
+#define RT9455_REG_IRQ3_BSTOLI_MASK		BIT(6)
+#define RT9455_REG_IRQ3_BSTOLI_SHIFT		6
+#define RT9455_REG_IRQ3_BSTLOWVI_MASK		BIT(5)
+#define RT9455_REG_IRQ3_BSTLOWVI_SHIFT		5
+#define RT9455_REG_IRQ3_BST32SI_MASK		BIT(3)
+#define RT9455_REG_IRQ3_BST32SI_SHIFT		3
+
+#define RT9455_REG_MASK1			0x0B /* MASK1 */
+#define RT9455_REG_MASK1_TSDM_MASK		BIT(7)
+#define RT9455_REG_MASK1_TSDM_SHIFT		7
+#define RT9455_REG_MASK1_VINOVPIM_MASK		BIT(6)
+#define RT9455_REG_MASK1_VINOVPIM_SHIFT		6
+#define RT9455_REG_MASK1_BATABM_MASK		BIT(0)
+#define RT9455_REG_MASK1_BATABM_SHIFT		0
+
+#define RT9455_REG_MASK2			0x0C /* MASK2 */
+#define RT9455_REG_MASK2_CHRVPIM_MASK		BIT(7)
+#define RT9455_REG_MASK2_CHRVPIM_SHIFT		7
+#define RT9455_REG_MASK2_CHBATOVIM_MASK		BIT(5)
+#define RT9455_REG_MASK2_CHBATOVIM_SHIFT	5
+#define RT9455_REG_MASK2_CHTERMIM_MASK		BIT(4)
+#define RT9455_REG_MASK2_CHTERMIM_SHIFT		4
+#define RT9455_REG_MASK2_CHRCHGIM_MASK		BIT(3)
+#define RT9455_REG_MASK2_CHRCHGIM_SHIFT		3
+#define RT9455_REG_MASK2_CH32MIM_MASK		BIT(2)
+#define RT9455_REG_MASK2_CH32MIM_SHIFT		2
+#define RT9455_REG_MASK2_CHTREGIM_MASK		BIT(1)
+#define RT9455_REG_MASK2_CHTREGIM_SHIFT		1
+#define RT9455_REG_MASK2_CHMIVRIM_MASK		BIT(0)
+#define RT9455_REG_MASK2_CHMIVRIM_SHIFT		0
+
+#define RT9455_REG_MASK3			0x0D /* MASK3 */
+#define RT9455_REG_MASK3_BSTVINOVIM_MASK	BIT(7)
+#define RT9455_REG_MASK3_BSTVINOVIM_SHIFT	7
+#define RT9455_REG_MASK3_BSTOLIM_MASK		BIT(6)
+#define RT9455_REG_MASK3_BSTOLIM_SHIFT		6
+#define RT9455_REG_MASK3_BSTLOWVIM_MASK		BIT(5)
+#define RT9455_REG_MASK3_BSTLOWVIM_SHIFT	5
+#define RT9455_REG_MASK3_BST32SIM_MASK		BIT(3)
+#define RT9455_REG_MASK3_BST32SIM_SHIFT		3
+
+/*
+ * Each array initialised below shows the possible real-world values for a
+ * group of bits belonging to RT9455 registers. The arrays are sorted in
+ * ascending order. The index of each real-world value represents the value
+ * that is encoded in the group of bits belonging to RT9455 registers.
+ */
+/* REG06[6:4] (ICHRG) in uAh */
+static const int rt9455_ichrg_values[] = {
+	 500000,  650000,  800000,  950000, 1100000, 1250000, 1400000, 1550000
+};
+
+/* REG02[7:2] (VOREG) in uV */
+static const int rt9455_voreg_values[] = {
+	3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
+	3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
+	3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
+	3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000,
+	4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000,
+	4300000, 4330000, 4350000, 4370000, 4390000, 4410000, 4430000, 4450000,
+	4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000,
+	4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000
+};
+
+/* REG07[3:0] (VMREG) in uV */
+static const int rt9455_vmreg_values[] = {
+	4200000, 4220000, 4240000, 4260000, 4280000, 4300000, 4320000, 4340000,
+	4360000, 4380000, 4400000, 4430000, 4450000, 4450000, 4450000, 4450000
+};
+
+/* REG05[5:4] (IEOC_PERCENTAGE) */
+static const int rt9455_ieoc_percentage_values[] = {
+	10, 30, 20, 30
+};
+
+/* REG05[1:0] (VMIVR) in uV */
+static const int rt9455_vmivr_values[] = {
+	4000000, 4250000, 4500000, 5000000
+};
+
+/* REG05[1:0] (IAICR) in uA */
+static const int rt9455_iaicr_values[] = {
+	100000, 500000, 1000000, 2000000
+};
+
+struct rt9455_info {
+	struct i2c_client		*client;
+	struct power_supply		*charger;
+#if IS_ENABLED(CONFIG_USB_PHY)
+	struct usb_phy			*usb_phy;
+	struct notifier_block		nb;
+#endif
+	struct gpio_desc		*gpiod_irq;
+	unsigned int			gpio_irq;
+	struct delayed_work		pwr_rdy_work;
+	struct delayed_work		max_charging_time_work;
+	struct delayed_work		batt_presence_work;
+};
+
+/* I2C read/write API */
+static int rt9455_read(struct rt9455_info *info, u8 reg, u8 *data)
+{
+	int ret;
+
+	ret = i2c_smbus_read_byte_data(info->client, reg);
+	if (ret < 0)
+		return ret;
+
+	*data = ret;
+	return 0;
+}
+
+static int rt9455_write(struct rt9455_info *info, u8 reg, u8 data)
+{
+	return i2c_smbus_write_byte_data(info->client, reg, data);
+}
+
+static int rt9455_read_mask(struct rt9455_info *info, u8 reg,
+			    u8 mask, u8 shift, u8 *data)
+{
+	u8 v;
+	int ret;
+
+	ret = rt9455_read(info, reg, &v);
+	if (ret < 0)
+		return ret;
+
+	v &= mask;
+	v >>= shift;
+	*data = v;
+
+	return 0;
+}
+
+static int rt9455_write_mask(struct rt9455_info *info, u8 reg,
+			     u8 mask, u8 shift, u8 data)
+{
+	u8 v;
+	int ret;
+
+	ret = rt9455_read(info, reg, &v);
+	if (ret < 0)
+		return ret;
+
+	v &= ~mask;
+	v |= ((data << shift) & mask);
+
+	return rt9455_write(info, reg, v);
+}
+
+/*
+ * Iterate through each element of the 'tbl' array until an element whose value
+ * is greater than v is found. Return the index of the respective element,
+ * or the index of the last element in the array, if no such element is found.
+ */
+static u8 rt9455_find_idx(const int tbl[], int tbl_size, int v)
+{
+	int i;
+
+	/* No need to iterate until the last index in the table because
+	 * if no element greater than v is found in the table,
+	 * or if only the last element is greater than v,
+	 * function returns the index of the last element.
+	 */
+	for (i = 0; i < tbl_size - 1; i++)
+		if (v <= tbl[i])
+			return i;
+
+	return (tbl_size - 1);
+}
+
+static int rt9455_get_field_val(struct rt9455_info *info,
+				u8 reg, u8 mask, u8 shift,
+				const int tbl[], int tbl_size,
+				int *val)
+{
+	u8 v;
+	int ret;
+
+	ret = rt9455_read_mask(info, reg, mask, shift, &v);
+	if (ret)
+		return ret;
+
+	v = (v >= tbl_size) ? (tbl_size - 1) : v;
+	*val = tbl[v];
+
+	return 0;
+}
+
+static int rt9455_set_field_val(struct rt9455_info *info,
+				u8 reg, u8 mask, u8 shift,
+				const int tbl[], int tbl_size,
+				int val)
+{
+	u8 idx;
+
+	idx = rt9455_find_idx(tbl, tbl_size, val);
+
+	return rt9455_write_mask(info, reg, mask, shift, idx);
+}
+
+static int rt9455_register_reset(struct rt9455_info *info)
+{
+	struct device *dev = &info->client->dev;
+	int ret, limit = 100;
+	u8 v;
+
+	ret = rt9455_write_mask(info, RT9455_REG_CTRL4,
+				RT9455_REG_CTRL4_RST_MASK,
+				RT9455_REG_CTRL4_RST_SHIFT,
+				0x1);
+	if (ret) {
+		dev_err(dev, "Failed to set RST bit\n");
+		return ret;
+	}
+
+	/* To make sure that reset operation has finished, loop until RST bit
+	 * is set to 0.
+	 */
+	do {
+		ret = rt9455_read_mask(info, RT9455_REG_CTRL4,
+				       RT9455_REG_CTRL4_RST_MASK,
+				       RT9455_REG_CTRL4_RST_SHIFT,
+				       &v);
+		if (ret) {
+			dev_err(dev, "Failed to read RST bit\n");
+			return ret;
+		}
+
+		if (!v)
+			break;
+
+		usleep_range(10, 100);
+	} while (--limit);
+
+	if (!limit)
+		return -EIO;
+
+	return 0;
+}
+
+/* Charger power supply property routines */
+static enum power_supply_property rt9455_charger_properties[] = {
+	POWER_SUPPLY_PROP_STATUS,
+	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_PRESENT,
+	POWER_SUPPLY_PROP_ONLINE,
+	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
+	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
+	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
+	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
+	POWER_SUPPLY_PROP_SCOPE,
+	POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
+	POWER_SUPPLY_PROP_MODEL_NAME,
+	POWER_SUPPLY_PROP_MANUFACTURER,
+};
+
+static char *rt9455_charger_supplied_to[] = {
+	"main-battery",
+};
+
+static int rt9455_charger_get_status(struct rt9455_info *info,
+				     union power_supply_propval *val)
+{
+	int ret;
+	u8 v;
+
+	ret = rt9455_read_mask(info, RT9455_REG_CTRL1,
+			       RT9455_REG_CTRL1_STAT_MASK,
+			       RT9455_REG_CTRL1_STAT_SHIFT,
+			       &v);
+	if (ret) {
+		dev_err(&info->client->dev, "Failed to read STAT bits\n");
+		return ret;
+	}
+
+	switch (v) {
+	case 0:
+		val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
+	break;
+	case 1:
+		val->intval = POWER_SUPPLY_STATUS_CHARGING;
+	break;
+	case 2:
+		val->intval = POWER_SUPPLY_STATUS_FULL;
+	break;
+	default:
+		val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
+	break;
+	}
+
+	return 0;
+}
+
+static int rt9455_charger_get_health(struct rt9455_info *info,
+				     union power_supply_propval *val)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+	u8 v;
+
+	val->intval = POWER_SUPPLY_HEALTH_GOOD;
+
+	ret = rt9455_read_mask(info, RT9455_REG_CTRL1,
+			       RT9455_REG_CTRL1_STAT_MASK,
+			       RT9455_REG_CTRL1_STAT_SHIFT,
+			       &v);
+	if (ret) {
+		dev_err(dev, "Failed to read STAT bits\n");
+		return ret;
+	}
+
+	if (v == RT9455_FAULT) {
+		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
+		return 0;
+	}
+
+	ret = rt9455_read(info, RT9455_REG_IRQ1, &v);
+	if (ret) {
+		dev_err(dev, "Failed to read IRQ1 register\n");
+		return ret;
+	}
+
+	if (v & RT9455_REG_IRQ1_TSDI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
+		return 0;
+	}
+	if (v & RT9455_REG_IRQ1_VINOVPI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
+		return 0;
+	}
+	if (v & RT9455_REG_IRQ1_BATAB_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
+		return 0;
+	}
+
+	ret = rt9455_read(info, RT9455_REG_IRQ2, &v);
+	if (ret) {
+		dev_err(dev, "Failed to read IRQ2 register\n");
+		return ret;
+	}
+
+	if (v & RT9455_REG_IRQ2_CHBATOVI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
+		return 0;
+	}
+	if (v & RT9455_REG_IRQ2_CH32MI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
+		return 0;
+	}
+
+	ret = rt9455_read(info, RT9455_REG_IRQ3, &v);
+	if (ret) {
+		dev_err(dev, "Failed to read IRQ3 register\n");
+		return ret;
+	}
+
+	if (v & RT9455_REG_IRQ3_BSTBUSOVI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
+		return 0;
+	}
+	if (v & RT9455_REG_IRQ3_BSTOLI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
+		return 0;
+	}
+	if (v & RT9455_REG_IRQ3_BSTLOWVI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
+		return 0;
+	}
+	if (v & RT9455_REG_IRQ3_BST32SI_MASK) {
+		val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
+		return 0;
+	}
+
+	return 0;
+}
+
+static int rt9455_charger_get_battery_presence(struct rt9455_info *info,
+					       union power_supply_propval *val)
+{
+	int ret;
+	u8 v;
+
+	ret = rt9455_read_mask(info, RT9455_REG_IRQ1,
+			       RT9455_REG_IRQ1_BATAB_MASK,
+			       RT9455_REG_IRQ1_BATAB_SHIFT,
+			       &v);
+	if (ret) {
+		dev_err(&info->client->dev, "Failed to read BATAB bit\n");
+		return ret;
+	}
+
+	/* Since BATAB is 1 when battery is NOT present and 0 otherwise,
+	 * we return !BATAB.
+	 */
+	val->intval = !v;
+
+	return 0;
+}
+
+static int rt9455_charger_get_online(struct rt9455_info *info,
+				     union power_supply_propval *val)
+{
+	int ret;
+	u8 v;
+
+	ret = rt9455_read_mask(info, RT9455_REG_CTRL1,
+			       RT9455_REG_CTRL1_PWR_RDY_MASK,
+			       RT9455_REG_CTRL1_PWR_RDY_SHIFT,
+			       &v);
+	if (ret) {
+		dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n");
+		return ret;
+	}
+
+	val->intval = v;
+
+	return 0;
+}
+
+static int rt9455_charger_get_current(struct rt9455_info *info,
+				      union power_supply_propval *val)
+{
+	int ret, curr;
+
+	ret = rt9455_get_field_val(info, RT9455_REG_CTRL6,
+				   RT9455_REG_CTRL6_ICHRG_MASK,
+				   RT9455_REG_CTRL6_ICHRG_SHIFT,
+				   rt9455_ichrg_values,
+				   ARRAY_SIZE(rt9455_ichrg_values),
+				   &curr);
+	if (ret) {
+		dev_err(&info->client->dev, "Failed to read ICHRG value\n");
+		return ret;
+	}
+
+	val->intval = curr;
+
+	return 0;
+}
+
+static int rt9455_charger_get_current_max(struct rt9455_info *info,
+					  union power_supply_propval *val)
+{
+	int idx = ARRAY_SIZE(rt9455_ichrg_values) - 1;
+
+	val->intval = rt9455_ichrg_values[idx];
+
+	return 0;
+}
+
+static int rt9455_charger_get_voltage(struct rt9455_info *info,
+				      union power_supply_propval *val)
+{
+	int voltage, ret;
+
+	ret = rt9455_get_field_val(info, RT9455_REG_CTRL3,
+				   RT9455_REG_CTRL3_VOREG_MASK,
+				   RT9455_REG_CTRL3_VOREG_SHIFT,
+				   rt9455_voreg_values,
+				   ARRAY_SIZE(rt9455_voreg_values),
+				   &voltage);
+	if (ret) {
+		dev_err(&info->client->dev, "Failed to read VOREG value\n");
+		return ret;
+	}
+
+	val->intval = voltage;
+
+	return 0;
+}
+
+static int rt9455_charger_get_voltage_max(struct rt9455_info *info,
+					  union power_supply_propval *val)
+{
+	int voltage_max, ret;
+
+	ret = rt9455_get_field_val(info, RT9455_REG_CTRL7,
+				   RT9455_REG_CTRL7_VMREG_MASK,
+				   RT9455_REG_CTRL7_VMREG_SHIFT,
+				   rt9455_vmreg_values,
+				   ARRAY_SIZE(rt9455_vmreg_values),
+				   &voltage_max);
+	if (ret) {
+		dev_err(&info->client->dev, "Failed to read VMREG value\n");
+		return ret;
+	}
+
+	val->intval = voltage_max;
+
+	return 0;
+}
+
+static int rt9455_charger_get_term_current(struct rt9455_info *info,
+					   union power_supply_propval *val)
+{
+	struct device *dev = &info->client->dev;
+	int ichrg, ieoc_percentage, ret;
+
+	ret = rt9455_get_field_val(info, RT9455_REG_CTRL6,
+				   RT9455_REG_CTRL6_ICHRG_MASK,
+				   RT9455_REG_CTRL6_ICHRG_SHIFT,
+				   rt9455_ichrg_values,
+				   ARRAY_SIZE(rt9455_ichrg_values),
+				   &ichrg);
+	if (ret) {
+		dev_err(dev, "Failed to read ICHRG value\n");
+		return ret;
+	}
+
+	ret = rt9455_get_field_val(info, RT9455_REG_CTRL5,
+				   RT9455_REG_CTRL5_IEOC_PERCENTAGE_MASK,
+				   RT9455_REG_CTRL5_IEOC_PERCENTAGE_SHIFT,
+				   rt9455_ieoc_percentage_values,
+				   ARRAY_SIZE(rt9455_ieoc_percentage_values),
+				   &ieoc_percentage);
+	if (ret) {
+		dev_err(dev, "Failed to read IEOC value\n");
+		return ret;
+	}
+
+	val->intval = ichrg * ieoc_percentage / 100;
+
+	return 0;
+}
+
+static int rt9455_charger_get_property(struct power_supply *psy,
+				       enum power_supply_property psp,
+				       union power_supply_propval *val)
+{
+	struct rt9455_info *info = power_supply_get_drvdata(psy);
+
+	switch (psp) {
+	case POWER_SUPPLY_PROP_STATUS:
+		return rt9455_charger_get_status(info, val);
+	case POWER_SUPPLY_PROP_HEALTH:
+		return rt9455_charger_get_health(info, val);
+	case POWER_SUPPLY_PROP_PRESENT:
+		return rt9455_charger_get_battery_presence(info, val);
+	case POWER_SUPPLY_PROP_ONLINE:
+		return rt9455_charger_get_online(info, val);
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
+		return rt9455_charger_get_current(info, val);
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
+		return rt9455_charger_get_current_max(info, val);
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
+		return rt9455_charger_get_voltage(info, val);
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
+		return rt9455_charger_get_voltage_max(info, val);
+	case POWER_SUPPLY_PROP_SCOPE:
+		val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
+		return 0;
+	case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
+		return rt9455_charger_get_term_current(info, val);
+	case POWER_SUPPLY_PROP_MODEL_NAME:
+		val->strval = RT9455_MODEL_NAME;
+		return 0;
+	case POWER_SUPPLY_PROP_MANUFACTURER:
+		val->strval = RT9455_MANUFACTURER;
+		return 0;
+	default:
+		return -ENODATA;
+	}
+}
+
+static int rt9455_charger_set_current(struct rt9455_info *info,
+				      const union power_supply_propval *val)
+{
+	return rt9455_set_field_val(info, RT9455_REG_CTRL6,
+				    RT9455_REG_CTRL6_ICHRG_MASK,
+				    RT9455_REG_CTRL6_ICHRG_SHIFT,
+				    rt9455_ichrg_values,
+				    ARRAY_SIZE(rt9455_ichrg_values),
+				    val->intval);
+}
+
+static int rt9455_charger_set_voltage(struct rt9455_info *info,
+				      const union power_supply_propval *val)
+{
+	return rt9455_set_field_val(info, RT9455_REG_CTRL3,
+				    RT9455_REG_CTRL3_VOREG_MASK,
+				    RT9455_REG_CTRL3_VOREG_SHIFT,
+				    rt9455_voreg_values,
+				    ARRAY_SIZE(rt9455_voreg_values),
+				    val->intval);
+}
+
+static int rt9455_charger_set_voltage_max(struct rt9455_info *info,
+					  const union power_supply_propval *val)
+{
+	return rt9455_set_field_val(info, RT9455_REG_CTRL7,
+				    RT9455_REG_CTRL7_VMREG_MASK,
+				    RT9455_REG_CTRL7_VMREG_SHIFT,
+				    rt9455_voreg_values,
+				    ARRAY_SIZE(rt9455_voreg_values),
+				    val->intval);
+}
+
+static int rt9455_charger_set_property(struct power_supply *psy,
+				       enum power_supply_property psp,
+				       const union power_supply_propval *val)
+{
+	struct rt9455_info *info = power_supply_get_drvdata(psy);
+
+	switch (psp) {
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
+		return rt9455_charger_set_current(info, val);
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
+		return rt9455_charger_set_voltage(info, val);
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
+		return rt9455_charger_set_voltage_max(info, val);
+	default:
+		return -EINVAL;
+	}
+}
+
+static int rt9455_charger_property_is_writeable(struct power_supply *psy,
+						enum power_supply_property psp)
+{
+	switch (psp) {
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
+	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+static int rt9455_hw_init(struct rt9455_info *info, u32 ichrg,
+			  u32 ieoc_percentage, u32 voreg,
+			  u32 vmivr, u32 iaicr)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	ret = rt9455_register_reset(info);
+	if (ret) {
+		dev_err(dev, "Power On Reset failed\n");
+		return ret;
+	}
+
+	/* Set TE bit in order to enable end of charge detection */
+	ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+				RT9455_REG_CTRL2_TE_MASK,
+				RT9455_REG_CTRL2_TE_SHIFT,
+				0x01);
+	if (ret) {
+		dev_err(dev, "Failed to set TE bit\n");
+		return ret;
+	}
+
+	/* Set TE_SHDN_EN bit in order to enable end of charge detection */
+	ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+				RT9455_REG_CTRL2_TE_SHDN_EN_MASK,
+				RT9455_REG_CTRL2_TE_SHDN_EN_SHIFT,
+				0x01);
+	if (ret) {
+		dev_err(dev, "Failed to set TE_SHDN_EN bit\n");
+		return ret;
+	}
+
+	/* Set BATD_EN bit in order to enable battery detection
+	 * when charging is done
+	 */
+	ret = rt9455_write_mask(info, RT9455_REG_CTRL7,
+				RT9455_REG_CTRL7_BATD_EN_MASK,
+				RT9455_REG_CTRL7_BATD_EN_SHIFT,
+				0x01);
+	if (ret) {
+		dev_err(dev, "Failed to set BATD_EN bit\n");
+		return ret;
+	}
+
+	/* Disable Safety Timer. In charge mode, this timer terminates charging
+	 * if no read or write via I2C is done within 32 minutes. This timer
+	 * avoids overcharging the baterry when the OS is not loaded and the
+	 * charger is connected to a power source.
+	 * In boost mode, this timer triggers BST32SI interrupt if no read or
+	 * write via I2C is done within 32 seconds.
+	 * When the OS is loaded and the charger driver is inserted, we use
+	 * delayed_work, named max_charging_time_work, to avoid overcharging
+	 * the battery.
+	 */
+	ret = rt9455_write_mask(info, RT9455_REG_CTRL5,
+				RT9455_REG_CTRL5_TMR_EN_MASK,
+				RT9455_REG_CTRL5_TMR_EN_SHIFT,
+				0x00);
+	if (ret) {
+		dev_err(dev, "Failed to disable Safety Timer\n");
+		return ret;
+	}
+
+	/* Set ICHRG to value retrieved from device-specific data */
+	ret = rt9455_set_field_val(info, RT9455_REG_CTRL6,
+				   RT9455_REG_CTRL6_ICHRG_MASK,
+				   RT9455_REG_CTRL6_ICHRG_SHIFT,
+				   rt9455_ichrg_values,
+				   ARRAY_SIZE(rt9455_ichrg_values), ichrg);
+	if (ret) {
+		dev_err(dev, "Failed to set ICHRG value\n");
+		return ret;
+	}
+
+	/* Set IEOC Percentage to value retrieved from device-specific data */
+	ret = rt9455_set_field_val(info, RT9455_REG_CTRL5,
+				   RT9455_REG_CTRL5_IEOC_PERCENTAGE_MASK,
+				   RT9455_REG_CTRL5_IEOC_PERCENTAGE_SHIFT,
+				   rt9455_ieoc_percentage_values,
+				   ARRAY_SIZE(rt9455_ieoc_percentage_values),
+				   ieoc_percentage);
+	if (ret) {
+		dev_err(dev, "Failed to set IEOC Percentage value\n");
+		return ret;
+	}
+
+	/* Set VOREG to value retrieved from device-specific data */
+	ret = rt9455_set_field_val(info, RT9455_REG_CTRL3,
+				   RT9455_REG_CTRL3_VOREG_MASK,
+				   RT9455_REG_CTRL3_VOREG_SHIFT,
+				   rt9455_voreg_values,
+				   ARRAY_SIZE(rt9455_voreg_values), voreg);
+	if (ret) {
+		dev_err(dev, "Failed to set VOREG value\n");
+		return ret;
+	}
+
+	/* Set VMIVR to value retrieved from device-specific data.
+	 * If no value is specified, default value for VMIVR is 4.5V.
+	 */
+	if (vmivr == -1)
+		vmivr = 4500000;
+
+	ret = rt9455_set_field_val(info, RT9455_REG_CTRL5,
+				   RT9455_REG_CTRL5_VMIVR_MASK,
+				   RT9455_REG_CTRL5_VMIVR_SHIFT,
+				   rt9455_vmivr_values,
+				   ARRAY_SIZE(rt9455_vmivr_values), vmivr);
+	if (ret) {
+		dev_err(dev, "Failed to set VMIVR value\n");
+		return ret;
+	}
+
+	/* Set IAICR to value retrieved from device-specific data.
+	 * If no value is specified, default value for IAICR is 500 mA.
+	 */
+	if (iaicr == -1)
+		iaicr = 500000;
+
+	ret = rt9455_set_field_val(info, RT9455_REG_CTRL2,
+				   RT9455_REG_CTRL2_IAICR_MASK,
+				   RT9455_REG_CTRL2_IAICR_SHIFT,
+				   rt9455_iaicr_values,
+				   ARRAY_SIZE(rt9455_iaicr_values), iaicr);
+	if (ret) {
+		dev_err(dev, "Failed to set IAICR value\n");
+		return ret;
+	}
+
+	ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+				RT9455_REG_CTRL2_IAICR_INT_MASK,
+				RT9455_REG_CTRL2_IAICR_INT_SHIFT,
+				0x01);
+	if (ret) {
+		dev_err(dev, "Failed to set IAICR_INT bit\n");
+		return ret;
+	}
+
+	ret = rt9455_write_mask(info, RT9455_REG_MASK2,
+				RT9455_REG_MASK2_CHMIVRIM_MASK,
+				RT9455_REG_MASK2_CHMIVRIM_SHIFT,
+				0x01);
+	if (ret) {
+		dev_err(dev, "Failed to mask CHMIVRI interrupt\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+static int rt9455_irq_handler_check_irq1_register(struct rt9455_info *info,
+						  bool *_is_battery_absent,
+						  bool *_alert_userspace)
+{
+	u8 irq1, mask1, mask2;
+	struct device *dev = &info->client->dev;
+	bool is_battery_absent = false;
+	bool alert_userspace = false;
+	int ret;
+
+	ret = rt9455_read(info, RT9455_REG_IRQ1, &irq1);
+	if (ret) {
+		dev_err(dev, "Failed to read IRQ1 register\n");
+		return ret;
+	}
+
+	ret = rt9455_read(info, RT9455_REG_MASK1, &mask1);
+	if (ret) {
+		dev_err(dev, "Failed to read MASK1 register\n");
+		return ret;
+	}
+
+	if (irq1 & RT9455_REG_IRQ1_TSDI_MASK) {
+		dev_err(dev, "Thermal shutdown fault occurred\n");
+		alert_userspace = true;
+	}
+
+	if (irq1 & RT9455_REG_IRQ1_VINOVPI_MASK) {
+		dev_err(dev, "Overvoltage input occurred\n");
+		alert_userspace = true;
+	}
+
+	if (irq1 & RT9455_REG_IRQ1_BATAB_MASK) {
+		dev_err(dev, "Battery absence occurred\n");
+		is_battery_absent = true;
+		alert_userspace = true;
+
+		if ((mask1 & RT9455_REG_MASK1_BATABM_MASK) == 0) {
+			ret = rt9455_write_mask(info, RT9455_REG_MASK1,
+						RT9455_REG_MASK1_BATABM_MASK,
+						RT9455_REG_MASK1_BATABM_SHIFT,
+						0x01);
+			if (ret) {
+				dev_err(dev, "Failed to mask BATAB interrupt\n");
+				return ret;
+			}
+		}
+
+		ret = rt9455_read(info, RT9455_REG_MASK2, &mask2);
+		if (ret) {
+			dev_err(dev, "Failed to read MASK2 register\n");
+			return ret;
+		}
+
+		if ((mask2 & RT9455_REG_MASK2_CHTERMIM_MASK)) {
+			ret = rt9455_write_mask(info, RT9455_REG_MASK2,
+						RT9455_REG_MASK2_CHTERMIM_MASK,
+						RT9455_REG_MASK2_CHTERMIM_SHIFT,
+						0x00);
+			if (ret) {
+				dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
+				return ret;
+			}
+		}
+
+		if ((mask2 & RT9455_REG_MASK2_CHRCHGIM_MASK)) {
+			ret = rt9455_write_mask(info, RT9455_REG_MASK2,
+						RT9455_REG_MASK2_CHRCHGIM_MASK,
+						RT9455_REG_MASK2_CHRCHGIM_SHIFT,
+						0x00);
+			if (ret) {
+				dev_err(dev, "Failed to unmask CHRCHGI interrupt\n");
+				return ret;
+			}
+		}
+
+		/* When the battery is absent, max_charging_time_work is
+		 * cancelled, since no charging is done.
+		 */
+		cancel_delayed_work_sync(&info->max_charging_time_work);
+		/* Since no interrupt is triggered when the battery is
+		 * reconnected, max_charging_time_work is not rescheduled.
+		 * Therefore, batt_presence_work is scheduled to check whether
+		 * the battery is still absent or not.
+		 */
+		schedule_delayed_work(&info->batt_presence_work,
+				      RT9455_BATT_PRESENCE_DELAY * HZ);
+	}
+
+	*_is_battery_absent = is_battery_absent;
+
+	if (alert_userspace)
+		*_alert_userspace = alert_userspace;
+
+	return 0;
+}
+
+static int rt9455_irq_handler_check_irq2_register(struct rt9455_info *info,
+						  bool is_battery_absent,
+						  bool *_alert_userspace)
+{
+	u8 irq2, mask2;
+	struct device *dev = &info->client->dev;
+	bool alert_userspace = false;
+	int ret;
+
+	ret = rt9455_read(info, RT9455_REG_IRQ2, &irq2);
+	if (ret) {
+		dev_err(dev, "Failed to read IRQ2 register\n");
+		return ret;
+	}
+
+	ret = rt9455_read(info, RT9455_REG_MASK2, &mask2);
+	if (ret) {
+		dev_err(dev, "Failed to read MASK2 register\n");
+		return ret;
+	}
+
+	if (irq2 & RT9455_REG_IRQ2_CHRVPI_MASK) {
+		dev_dbg(dev, "Charger fault occurred\n");
+		alert_userspace = true;
+		/* CHRVPI bit is set in 2 cases:
+		 * 1. when the power source is connected to the charger.
+		 * 2. when the power source is disconnected from the charger.
+		 * To identify the case, PWR_RDY bit is checked. Because
+		 * PWR_RDY bit is set / cleared after CHRVPI interrupt is
+		 * triggered, we use delayed_work to later read PWR_RDY bit.
+		 */
+		schedule_delayed_work(&info->pwr_rdy_work,
+				      RT9455_PWR_RDY_DELAY * HZ);
+	}
+	if (irq2 & RT9455_REG_IRQ2_CHBATOVI_MASK) {
+		dev_err(dev, "Battery OVP occurred\n");
+		alert_userspace = true;
+	}
+	if (irq2 & RT9455_REG_IRQ2_CHTERMI_MASK) {
+		dev_dbg(dev, "Charge terminated\n");
+		alert_userspace = true;
+
+		if (!is_battery_absent) {
+			if ((mask2 & RT9455_REG_MASK2_CHTERMIM_MASK) == 0) {
+				ret = rt9455_write_mask(info, RT9455_REG_MASK2,
+						RT9455_REG_MASK2_CHTERMIM_MASK,
+						RT9455_REG_MASK2_CHTERMIM_SHIFT,
+						0x01);
+				if (ret) {
+					dev_err(dev, "Failed to mask CHTERMI interrupt\n");
+					return ret;
+				}
+			}
+			cancel_delayed_work_sync(&info->max_charging_time_work);
+		}
+	}
+	if (irq2 & RT9455_REG_IRQ2_CHRCHGI_MASK) {
+		dev_dbg(dev, "Recharge request\n");
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL7,
+					RT9455_REG_CTRL7_CHG_EN_MASK,
+					RT9455_REG_CTRL7_CHG_EN_SHIFT,
+					0x01);
+		if (ret) {
+			dev_err(dev, "Failed to enable charging\n");
+			return ret;
+		}
+		if (mask2 & RT9455_REG_MASK2_CHTERMIM_MASK) {
+			ret = rt9455_write_mask(info, RT9455_REG_MASK2,
+						RT9455_REG_MASK2_CHTERMIM_MASK,
+						RT9455_REG_MASK2_CHTERMIM_SHIFT,
+						0x00);
+			if (ret) {
+				dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
+				return ret;
+			}
+		}
+		if (!is_battery_absent) {
+			schedule_delayed_work(&info->max_charging_time_work,
+					      RT9455_MAX_CHARGING_TIME * HZ);
+			alert_userspace = true;
+		}
+	}
+	if (irq2 & RT9455_REG_IRQ2_CH32MI_MASK) {
+		dev_err(dev, "Charger fault. 32 mins timeout occurred\n");
+		alert_userspace = true;
+	}
+	if (irq2 & RT9455_REG_IRQ2_CHTREGI_MASK) {
+		dev_warn(dev,
+			 "Charger warning. Thermal regulation loop active\n");
+		alert_userspace = true;
+	}
+	if (irq2 & RT9455_REG_IRQ2_CHMIVRI_MASK) {
+		dev_dbg(dev,
+			"Charger warning. Input voltage MIVR loop active\n");
+	}
+
+	if (alert_userspace)
+		*_alert_userspace = alert_userspace;
+
+	return 0;
+}
+
+static int rt9455_irq_handler_check_irq3_register(struct rt9455_info *info,
+						  bool *_alert_userspace)
+{
+	u8 irq3, mask3;
+	struct device *dev = &info->client->dev;
+	bool alert_userspace = false;
+	int ret;
+
+	ret = rt9455_read(info, RT9455_REG_IRQ3, &irq3);
+	if (ret) {
+		dev_err(dev, "Failed to read IRQ3 register\n");
+		return ret;
+	}
+
+	ret = rt9455_read(info, RT9455_REG_MASK3, &mask3);
+	if (ret) {
+		dev_err(dev, "Failed to read MASK3 register\n");
+		return ret;
+	}
+
+	if (irq3 & RT9455_REG_IRQ3_BSTBUSOVI_MASK) {
+		dev_err(dev, "Boost fault. Overvoltage input occurred\n");
+		alert_userspace = true;
+	}
+	if (irq3 & RT9455_REG_IRQ3_BSTOLI_MASK) {
+		dev_err(dev, "Boost fault. Overload\n");
+		alert_userspace = true;
+	}
+	if (irq3 & RT9455_REG_IRQ3_BSTLOWVI_MASK) {
+		dev_err(dev, "Boost fault. Battery voltage too low\n");
+		alert_userspace = true;
+	}
+	if (irq3 & RT9455_REG_IRQ3_BST32SI_MASK) {
+		dev_err(dev, "Boost fault. 32 seconds timeout occurred.\n");
+		alert_userspace = true;
+	}
+
+	if (alert_userspace) {
+		dev_dbg(dev, "Boost fault occurred, therefore the charger goes into charge mode\n");
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_OPA_MODE_MASK,
+					RT9455_REG_CTRL2_OPA_MODE_SHIFT,
+					RT9455_CHARGE_MODE);
+		if (ret) {
+			dev_err(dev, "Failed to set charger in charge mode\n");
+			return ret;
+		}
+		*_alert_userspace = alert_userspace;
+	}
+
+	return 0;
+}
+
+static irqreturn_t rt9455_irq_handler_thread(int irq, void *data)
+{
+	struct rt9455_info *info = data;
+	struct device *dev = &info->client->dev;
+	bool alert_userspace = false;
+	bool is_battery_absent = false;
+	u8 status;
+	int ret;
+
+	ret = rt9455_read_mask(info, RT9455_REG_CTRL1,
+			       RT9455_REG_CTRL1_STAT_MASK,
+			       RT9455_REG_CTRL1_STAT_SHIFT,
+			       &status);
+	if (ret) {
+		dev_err(dev, "Failed to read STAT bits\n");
+		return IRQ_HANDLED;
+	}
+	dev_dbg(dev, "Charger status is %d\n", status);
+
+	/* Each function that processes an IRQ register receives as output
+	 * parameter alert_userspace pointer. alert_userspace is set to true
+	 * in such a function only if an interrupt has occurred in the
+	 * respective interrupt register. This way, we avoid the following
+	 * case: interrupt occurs only in IRQ1 register,
+	 * rt9455_irq_handler_check_irq1_register() function sets to true
+	 * alert_userspace, but rt9455_irq_handler_check_irq2_register()
+	 * and rt9455_irq_handler_check_irq3_register() functions set to false
+	 * alert_userspace and power_supply_changed() is never called.
+	 */
+	ret = rt9455_irq_handler_check_irq1_register(info, &is_battery_absent,
+						     &alert_userspace);
+	if (ret) {
+		dev_err(dev, "Failed to handle IRQ1 register\n");
+		return IRQ_HANDLED;
+	}
+
+	ret = rt9455_irq_handler_check_irq2_register(info, is_battery_absent,
+						     &alert_userspace);
+	if (ret) {
+		dev_err(dev, "Failed to handle IRQ2 register\n");
+		return IRQ_HANDLED;
+	}
+
+	ret = rt9455_irq_handler_check_irq3_register(info, &alert_userspace);
+	if (ret) {
+		dev_err(dev, "Failed to handle IRQ3 register\n");
+		return IRQ_HANDLED;
+	}
+
+	if (alert_userspace) {
+		/* Sometimes, an interrupt occurs while probe() function is
+		 * executing and power_supply_register() is not yet called.
+		 * Do not call power_supply_charged() in this case.
+		 */
+		if (!IS_ERR_OR_NULL(info->charger))
+			power_supply_changed(info->charger);
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int rt9455_setup_irq(struct rt9455_info *info)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	/* Obtain IRQ GPIO */
+	info->gpiod_irq = devm_gpiod_get_index(dev, RT9455_IRQ_NAME, 0);
+	if (IS_ERR(info->gpiod_irq)) {
+		dev_err(dev, "Failed to get IRQ GPIO\n");
+		return PTR_ERR(info->gpiod_irq);
+	}
+
+	/* Configure IRQ GPIO */
+	ret = gpiod_direction_input(info->gpiod_irq);
+	if (ret) {
+		dev_err(dev, "Failed to set IRQ GPIO direction err = %d\n",
+			ret);
+		return ret;
+	}
+
+	/* Map the pin to an IRQ */
+	ret = gpiod_to_irq(info->gpiod_irq);
+	if (ret < 0) {
+		dev_err(dev, "Failed to associate GPIO with an IRQ err = %d\n",
+			ret);
+		return ret;
+	}
+
+	dev_dbg(dev, "GPIO resource, no:%d irq:%d\n",
+		desc_to_gpio(info->gpiod_irq), ret);
+	info->client->irq = ret;
+	info->gpio_irq = desc_to_gpio(info->gpiod_irq);
+
+	return 0;
+}
+
+static int rt9455_discover_charger(struct rt9455_info *info, u32 *ichrg,
+				   u32 *ieoc_percentage, u32 *voreg,
+				   u32 *vmivr, u32 *iaicr)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	if (!dev->of_node && !ACPI_HANDLE(dev)) {
+		dev_err(dev, "No support for either device tree or ACPI\n");
+		return -EINVAL;
+	}
+	/* ICHRG, IEOC_PERCENTAGE and VOREG are mandatory parameters. */
+	ret = device_property_read_u32(dev, "rt,ICHRG", ichrg);
+	if (ret) {
+		dev_err(dev, "Error: missing \"ICHRG\" property\n");
+		return ret;
+	}
+
+	ret = device_property_read_u32(dev, "rt,IEOC_PERCENTAGE",
+				       ieoc_percentage);
+	if (ret) {
+		dev_err(dev, "Error: missing \"IEOC_PERCENTAGE\" property\n");
+		return ret;
+	}
+
+	ret = device_property_read_u32(dev, "rt,VOREG", voreg);
+	if (ret) {
+		dev_err(dev, "Error: missing \"VOREG\" property\n");
+		return ret;
+	}
+
+	/* MIVR and IAICR are optional parameters. Do not return error if one
+	 * of them is not present in ACPI table or device tree specification,
+	 */
+	device_property_read_u32(dev, "rt,VMIVR", vmivr);
+	device_property_read_u32(dev, "rt,IAICR", iaicr);
+
+	ret = rt9455_setup_irq(info);
+	if (ret) {
+		dev_err(dev, "Failed to allocate IRQ resource\n");
+		return ret;
+	}
+
+	return 0;
+}
+
+static int rt9455_usb_event_none(struct rt9455_info *info,
+				 u8 opa_mode, u8 iaicr)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	if (opa_mode == RT9455_BOOST_MODE) {
+		/* If the charger is in boost mode, and it has received
+		 * USB_EVENT_NONE, this means the device powered by the
+		 * charger is not connected anymore.
+		 * In this case, the charger goes into charge mode.
+		 */
+		dev_dbg(dev, "USB_EVENT_NONE received, therefore the charger goes into charge mode\n");
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_OPA_MODE_MASK,
+					RT9455_REG_CTRL2_OPA_MODE_SHIFT,
+					RT9455_CHARGE_MODE);
+		if (ret) {
+			dev_err(dev, "Failed to set charger in charge mode\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	dev_dbg(dev, "USB_EVENT_NONE received, therefore IAICR is set to its minimum value\n");
+	if (iaicr != RT9455_IAICR_100MA) {
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_IAICR_MASK,
+					RT9455_REG_CTRL2_IAICR_SHIFT,
+					RT9455_IAICR_100MA);
+		if (ret) {
+			dev_err(dev, "Failed to set IAICR value\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	return NOTIFY_OK;
+}
+
+static int rt9455_usb_event_vbus(struct rt9455_info *info,
+				 u8 opa_mode, u8 iaicr)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	if (opa_mode == RT9455_BOOST_MODE) {
+		/* If the charger is in boost mode, and it has received
+		 * USB_EVENT_VBUS, this means the device powered by the
+		 * charger is not connected anymore.
+		 * In this case, the charger goes into charge mode.
+		 */
+		dev_dbg(dev, "USB_EVENT_VBUS received, therefore the charger goes into charge mode\n");
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_OPA_MODE_MASK,
+					RT9455_REG_CTRL2_OPA_MODE_SHIFT,
+					RT9455_CHARGE_MODE);
+		if (ret) {
+			dev_err(dev, "Failed to set charger in charge mode\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	dev_dbg(dev, "USB_EVENT_VBUS received, therefore IAICR is set to 500 mA\n");
+	if (iaicr != RT9455_IAICR_500MA) {
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_IAICR_MASK,
+					RT9455_REG_CTRL2_IAICR_SHIFT,
+					RT9455_IAICR_500MA);
+		if (ret) {
+			dev_err(dev, "Failed to set IAICR value\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	return NOTIFY_OK;
+}
+
+static int rt9455_usb_event_id(struct rt9455_info *info,
+			       u8 opa_mode, u8 iaicr)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	if (opa_mode == RT9455_CHARGE_MODE) {
+		/* If the charger is in charge mode, and it has received
+		 * USB_EVENT_ID, this means the device powered by the
+		 * charger is not connected anymore.
+		 * In this case, the charger goes into charge mode.
+		 */
+		dev_dbg(dev, "USB_EVENT_ID received, therefore the charger goes into boost mode\n");
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_OPA_MODE_MASK,
+					RT9455_REG_CTRL2_OPA_MODE_SHIFT,
+					RT9455_BOOST_MODE);
+		if (ret) {
+			dev_err(dev, "Failed to set charger in boost mode\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	dev_dbg(dev, "USB_EVENT_ID received, therefore IAICR is set to its minimum value\n");
+	if (iaicr != RT9455_IAICR_100MA) {
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_IAICR_MASK,
+					RT9455_REG_CTRL2_IAICR_SHIFT,
+					RT9455_IAICR_100MA);
+		if (ret) {
+			dev_err(dev, "Failed to set IAICR value\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	return NOTIFY_OK;
+}
+
+static int rt9455_usb_event_charger(struct rt9455_info *info,
+				    u8 opa_mode, u8 iaicr)
+{
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	if (opa_mode == RT9455_BOOST_MODE) {
+		/* If the charger is in boost mode, and it has received
+		 * USB_EVENT_CHARGER, this means the device powered by the
+		 * charger is not connected anymore.
+		 * In this case, the charger goes into charge mode.
+		 */
+		dev_dbg(dev, "USB_EVENT_CHARGER received, therefore the charger goes into charge mode\n");
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_OPA_MODE_MASK,
+					RT9455_REG_CTRL2_OPA_MODE_SHIFT,
+					RT9455_CHARGE_MODE);
+		if (ret) {
+			dev_err(dev, "Failed to set charger in charge mode\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	dev_dbg(dev, "USB_EVENT_CHARGER received, therefore IAICR is set to no current limit\n");
+	if (iaicr != RT9455_IAICR_NO_LIMIT) {
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL2,
+					RT9455_REG_CTRL2_IAICR_MASK,
+					RT9455_REG_CTRL2_IAICR_SHIFT,
+					RT9455_IAICR_NO_LIMIT);
+		if (ret) {
+			dev_err(dev, "Failed to set IAICR value\n");
+			return NOTIFY_DONE;
+		}
+	}
+
+	return NOTIFY_OK;
+}
+
+static int rt9455_usb_event(struct notifier_block *nb,
+			    unsigned long event, void *power)
+{
+	struct rt9455_info *info = container_of(nb, struct rt9455_info, nb);
+	struct device *dev = &info->client->dev;
+	u8 opa_mode, iaicr;
+	int ret;
+
+	if (!info)
+		return NOTIFY_DONE;
+
+	/* Determine whether the charger is in charge mode
+	 * or in boost mode.
+	 */
+	ret = rt9455_read_mask(info, RT9455_REG_CTRL2,
+			       RT9455_REG_CTRL2_OPA_MODE_MASK,
+			       RT9455_REG_CTRL2_OPA_MODE_SHIFT,
+			       &opa_mode);
+	if (ret) {
+		dev_err(dev, "Failed to read operation mode value\n");
+		return NOTIFY_DONE;
+	}
+
+	ret = rt9455_read_mask(info, RT9455_REG_CTRL2,
+			       RT9455_REG_CTRL2_IAICR_MASK,
+			       RT9455_REG_CTRL2_IAICR_SHIFT,
+			       &iaicr);
+	if (ret) {
+		dev_err(dev, "Failed to read IAICR value\n");
+		return NOTIFY_DONE;
+	}
+
+	dev_dbg(dev, "Received USB event %lu\n", event);
+	switch (event) {
+	case USB_EVENT_NONE:
+		return rt9455_usb_event_none(info, opa_mode, iaicr);
+	case USB_EVENT_VBUS:
+		return rt9455_usb_event_vbus(info, opa_mode, iaicr);
+	case USB_EVENT_ID:
+		return rt9455_usb_event_id(info, opa_mode, iaicr);
+	case USB_EVENT_CHARGER:
+		return rt9455_usb_event_charger(info, opa_mode, iaicr);
+	default:
+		dev_err(dev, "Unknown USB event\n");
+	}
+	return NOTIFY_DONE;
+}
+
+static void rt9455_pwr_rdy_work_callback(struct work_struct *work)
+{
+	struct rt9455_info *info = container_of(work, struct rt9455_info,
+						pwr_rdy_work.work);
+	struct device *dev = &info->client->dev;
+	u8 pwr_rdy;
+	int ret;
+
+	ret = rt9455_read_mask(info, RT9455_REG_CTRL1,
+			       RT9455_REG_CTRL1_PWR_RDY_MASK,
+			       RT9455_REG_CTRL1_PWR_RDY_SHIFT,
+			       &pwr_rdy);
+	if (ret) {
+		dev_err(dev, "Failed to read Power Ready bit\n");
+		return;
+	}
+	switch (pwr_rdy) {
+	case RT9455_PWR_FAULT:
+		dev_dbg(dev, "Charger disconnected from power source\n");
+		cancel_delayed_work_sync(&info->max_charging_time_work);
+		break;
+	case RT9455_PWR_GOOD:
+		dev_dbg(dev, "Charger connected to power source\n");
+		ret = rt9455_write_mask(info, RT9455_REG_CTRL7,
+					RT9455_REG_CTRL7_CHG_EN_MASK,
+					RT9455_REG_CTRL7_CHG_EN_SHIFT,
+					RT9455_CHARGE_ENABLE);
+		if (ret) {
+			dev_err(dev, "Failed to enable charging\n");
+			return;
+		}
+		schedule_delayed_work(&info->max_charging_time_work,
+				      RT9455_MAX_CHARGING_TIME * HZ);
+		break;
+	}
+}
+
+static void rt9455_max_charging_time_work_callback(struct work_struct *work)
+{
+	struct rt9455_info *info = container_of(work, struct rt9455_info,
+						max_charging_time_work.work);
+	struct device *dev = &info->client->dev;
+	int ret;
+
+	dev_err(dev, "Battery has been charging for at least 6 hours and is not yet fully charged. Battery is dead, therefore charging is disabled.\n");
+	ret = rt9455_write_mask(info, RT9455_REG_CTRL7,
+				RT9455_REG_CTRL7_CHG_EN_MASK,
+				RT9455_REG_CTRL7_CHG_EN_SHIFT,
+				RT9455_CHARGE_DISABLE);
+	if (ret)
+		dev_err(dev, "Failed to disable charging\n");
+}
+
+static void rt9455_batt_presence_work_callback(struct work_struct *work)
+{
+	struct rt9455_info *info = container_of(work, struct rt9455_info,
+						batt_presence_work.work);
+	struct device *dev = &info->client->dev;
+	u8 irq1;
+	int ret;
+
+	ret = rt9455_read(info, RT9455_REG_IRQ1, &irq1);
+	if (ret) {
+		dev_err(dev, "Failed to read IRQ1 register\n");
+		return;
+	}
+
+	/* If the battery is still absent, batt_presence_work is rescheduled.
+	   Otherwise, max_charging_time is scheduled.
+	 */
+	if (irq1 & RT9455_REG_IRQ1_BATAB_MASK) {
+		schedule_delayed_work(&info->batt_presence_work,
+				      RT9455_BATT_PRESENCE_DELAY * HZ);
+	} else {
+		schedule_delayed_work(&info->max_charging_time_work,
+				      RT9455_MAX_CHARGING_TIME * HZ);
+	}
+}
+
+struct power_supply_desc rt9455_charger_desc = {
+	.name			= RT9455_DRIVER_NAME,
+	.type			= POWER_SUPPLY_TYPE_USB,
+	.properties		= rt9455_charger_properties,
+	.num_properties		= ARRAY_SIZE(rt9455_charger_properties),
+	.get_property		= rt9455_charger_get_property,
+	.set_property		= rt9455_charger_set_property,
+	.property_is_writeable	= rt9455_charger_property_is_writeable,
+};
+
+static int rt9455_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+	struct device *dev = &client->dev;
+	struct rt9455_info *info;
+	struct power_supply_config rt9455_charger_config = {};
+	/* mandatory device-specific data values */
+	u32 ichrg, ieoc_percentage, voreg;
+	/* optional device-specific data values */
+	u32 vmivr = -1, iaicr = -1;
+	int ret;
+
+	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
+		dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
+		return -ENODEV;
+	}
+	info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
+	if (!info)
+		return -ENOMEM;
+
+	info->client = client;
+	i2c_set_clientdata(client, info);
+
+	ret = rt9455_discover_charger(info, &ichrg, &ieoc_percentage,
+				      &voreg, &vmivr, &iaicr);
+	if (ret) {
+		dev_err(dev, "Failed to discover charger\n");
+		return ret;
+	}
+
+#if IS_ENABLED(CONFIG_USB_PHY)
+	info->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
+	if (IS_ERR_OR_NULL(info->usb_phy)) {
+		dev_err(dev, "Failed to get USB transceiver\n");
+	} else {
+		info->nb.notifier_call = rt9455_usb_event;
+		ret = usb_register_notifier(info->usb_phy, &info->nb);
+		if (ret) {
+			dev_err(dev, "Failed to register USB notifier\n");
+			usb_put_phy(info->usb_phy);
+		}
+	}
+#endif
+
+	INIT_DELAYED_WORK(&info->pwr_rdy_work, rt9455_pwr_rdy_work_callback);
+	INIT_DELAYED_WORK(&info->max_charging_time_work,
+			  rt9455_max_charging_time_work_callback);
+	INIT_DELAYED_WORK(&info->batt_presence_work,
+			  rt9455_batt_presence_work_callback);
+
+	rt9455_charger_config.of_node		= dev->of_node;
+	rt9455_charger_config.drv_data		= info;
+	rt9455_charger_config.supplied_to	= rt9455_charger_supplied_to;
+	rt9455_charger_config.num_supplicants	=
+					ARRAY_SIZE(rt9455_charger_supplied_to);
+	ret = devm_request_threaded_irq(dev, client->irq, NULL,
+					rt9455_irq_handler_thread,
+					IRQF_TRIGGER_LOW | IRQF_ONESHOT,
+					RT9455_DRIVER_NAME, info);
+	if (ret < 0) {
+		dev_err(dev, "Failed to register IRQ handler\n");
+		return ret;
+	}
+
+	ret = rt9455_hw_init(info, ichrg, ieoc_percentage, voreg, vmivr, iaicr);
+	if (ret) {
+		dev_err(dev, "Failed to set charger to its default values\n");
+		return ret;
+	}
+
+	info->charger = power_supply_register(dev, &rt9455_charger_desc,
+					      &rt9455_charger_config);
+	if (IS_ERR_OR_NULL(info->charger)) {
+		dev_err(dev, "Failed to register charger\n");
+		ret = PTR_ERR(info->charger);
+		goto put_usb_phy;
+	}
+
+	return 0;
+
+put_usb_phy:
+#if IS_ENABLED(CONFIG_USB_PHY)
+	if (!IS_ERR_OR_NULL(info->usb_phy))  {
+		usb_unregister_notifier(info->usb_phy, &info->nb);
+		usb_put_phy(info->usb_phy);
+	}
+#endif
+	return ret;
+}
+
+static int rt9455_remove(struct i2c_client *client)
+{
+	int ret;
+	struct rt9455_info *info = i2c_get_clientdata(client);
+
+	ret = rt9455_register_reset(info);
+	if (ret)
+		dev_err(&info->client->dev, "Failed to set charger to its default values\n");
+
+#if IS_ENABLED(CONFIG_USB_PHY)
+	if (!IS_ERR_OR_NULL(info->usb_phy)) {
+		usb_unregister_notifier(info->usb_phy, &info->nb);
+		usb_put_phy(info->usb_phy);
+	}
+#endif
+
+	cancel_delayed_work_sync(&info->pwr_rdy_work);
+	cancel_delayed_work_sync(&info->max_charging_time_work);
+	cancel_delayed_work_sync(&info->batt_presence_work);
+
+	power_supply_unregister(info->charger);
+
+	return ret;
+}
+
+static const struct i2c_device_id rt9455_i2c_id_table[] = {
+	{ RT9455_DRIVER_NAME, 0 },
+	{ },
+};
+MODULE_DEVICE_TABLE(i2c, rt9455_i2c_id_table);
+
+static const struct of_device_id rt9455_of_match[] = {
+	{ .compatible = "rt,rt9455", },
+	{ },
+};
+MODULE_DEVICE_TABLE(of, rt9455_of_match);
+
+static const struct acpi_device_id rt9455_i2c_acpi_match[] = {
+	{"RTK9455", 0},
+	{}
+};
+MODULE_DEVICE_TABLE(acpi, rt9455_i2c_acpi_match);
+
+static struct i2c_driver rt9455_driver = {
+	.probe		= rt9455_probe,
+	.remove		= rt9455_remove,
+	.id_table	= rt9455_i2c_id_table,
+	.driver = {
+		.name		= RT9455_DRIVER_NAME,
+		.owner		= THIS_MODULE,
+		.of_match_table	= of_match_ptr(rt9455_of_match),
+		.acpi_match_table = ACPI_PTR(rt9455_i2c_acpi_match),
+	},
+};
+module_i2c_driver(rt9455_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Anda-Maria Nicolae <anda-maria.nicolae@xxxxxxxxx>");
+MODULE_ALIAS("i2c:rt9455-charger");
+MODULE_DESCRIPTION("Richtek RT9455 Charger Driver");
-- 
1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html




[Index of Archives]     [Device Tree Compilter]     [Device Tree Spec]     [Linux Driver Backports]     [Video for Linux]     [Linux USB Devel]     [Linux PCI Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [XFree86]     [Yosemite Backpacking]
  Powered by Linux