rt9455_charger.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Driver for Richtek RT9455WSC battery charger.
   4 *
   5 * Copyright (C) 2015 Intel Corporation
   6 */
   7
   8#include <linux/module.h>
   9#include <linux/interrupt.h>
  10#include <linux/delay.h>
  11#include <linux/of.h>
  12#include <linux/pm_runtime.h>
  13#include <linux/power_supply.h>
  14#include <linux/i2c.h>
  15#include <linux/acpi.h>
  16#include <linux/usb/phy.h>
  17#include <linux/regmap.h>
  18
  19#define RT9455_MANUFACTURER			"Richtek"
  20#define RT9455_MODEL_NAME			"RT9455"
  21#define RT9455_DRIVER_NAME			"rt9455-charger"
  22
  23#define RT9455_IRQ_NAME				"interrupt"
  24
  25#define RT9455_PWR_RDY_DELAY			1 /* 1 second */
  26#define RT9455_MAX_CHARGING_TIME		21600 /* 6 hrs */
  27#define RT9455_BATT_PRESENCE_DELAY		60 /* 60 seconds */
  28
  29#define RT9455_CHARGE_MODE			0x00
  30#define RT9455_BOOST_MODE			0x01
  31
  32#define RT9455_FAULT				0x03
  33
  34#define RT9455_IAICR_100MA			0x00
  35#define RT9455_IAICR_500MA			0x01
  36#define RT9455_IAICR_NO_LIMIT			0x03
  37
  38#define RT9455_CHARGE_DISABLE			0x00
  39#define RT9455_CHARGE_ENABLE			0x01
  40
  41#define RT9455_PWR_FAULT			0x00
  42#define RT9455_PWR_GOOD				0x01
  43
  44#define RT9455_REG_CTRL1			0x00 /* CTRL1 reg address */
  45#define RT9455_REG_CTRL2			0x01 /* CTRL2 reg address */
  46#define RT9455_REG_CTRL3			0x02 /* CTRL3 reg address */
  47#define RT9455_REG_DEV_ID			0x03 /* DEV_ID reg address */
  48#define RT9455_REG_CTRL4			0x04 /* CTRL4 reg address */
  49#define RT9455_REG_CTRL5			0x05 /* CTRL5 reg address */
  50#define RT9455_REG_CTRL6			0x06 /* CTRL6 reg address */
  51#define RT9455_REG_CTRL7			0x07 /* CTRL7 reg address */
  52#define RT9455_REG_IRQ1				0x08 /* IRQ1 reg address */
  53#define RT9455_REG_IRQ2				0x09 /* IRQ2 reg address */
  54#define RT9455_REG_IRQ3				0x0A /* IRQ3 reg address */
  55#define RT9455_REG_MASK1			0x0B /* MASK1 reg address */
  56#define RT9455_REG_MASK2			0x0C /* MASK2 reg address */
  57#define RT9455_REG_MASK3			0x0D /* MASK3 reg address */
  58
  59enum rt9455_fields {
  60	F_STAT, F_BOOST, F_PWR_RDY, F_OTG_PIN_POLARITY, /* CTRL1 reg fields */
  61
  62	F_IAICR, F_TE_SHDN_EN, F_HIGHER_OCP, F_TE, F_IAICR_INT, F_HIZ,
  63	F_OPA_MODE, /* CTRL2 reg fields */
  64
  65	F_VOREG, F_OTG_PL, F_OTG_EN, /* CTRL3 reg fields */
  66
  67	F_VENDOR_ID, F_CHIP_REV, /* DEV_ID reg fields */
  68
  69	F_RST, /* CTRL4 reg fields */
  70
  71	F_TMR_EN, F_MIVR, F_IPREC, F_IEOC_PERCENTAGE, /* CTRL5 reg fields*/
  72
  73	F_IAICR_SEL, F_ICHRG, F_VPREC, /* CTRL6 reg fields */
  74
  75	F_BATD_EN, F_CHG_EN, F_VMREG, /* CTRL7 reg fields */
  76
  77	F_TSDI, F_VINOVPI, F_BATAB, /* IRQ1 reg fields */
  78
  79	F_CHRVPI, F_CHBATOVI, F_CHTERMI, F_CHRCHGI, F_CH32MI, F_CHTREGI,
  80	F_CHMIVRI, /* IRQ2 reg fields */
  81
  82	F_BSTBUSOVI, F_BSTOLI, F_BSTLOWVI, F_BST32SI, /* IRQ3 reg fields */
  83
  84	F_TSDM, F_VINOVPIM, F_BATABM, /* MASK1 reg fields */
  85
  86	F_CHRVPIM, F_CHBATOVIM, F_CHTERMIM, F_CHRCHGIM, F_CH32MIM, F_CHTREGIM,
  87	F_CHMIVRIM, /* MASK2 reg fields */
  88
  89	F_BSTVINOVIM, F_BSTOLIM, F_BSTLOWVIM, F_BST32SIM, /* MASK3 reg fields */
  90
  91	F_MAX_FIELDS
  92};
  93
  94static const struct reg_field rt9455_reg_fields[] = {
  95	[F_STAT]		= REG_FIELD(RT9455_REG_CTRL1, 4, 5),
  96	[F_BOOST]		= REG_FIELD(RT9455_REG_CTRL1, 3, 3),
  97	[F_PWR_RDY]		= REG_FIELD(RT9455_REG_CTRL1, 2, 2),
  98	[F_OTG_PIN_POLARITY]	= REG_FIELD(RT9455_REG_CTRL1, 1, 1),
  99
 100	[F_IAICR]		= REG_FIELD(RT9455_REG_CTRL2, 6, 7),
 101	[F_TE_SHDN_EN]		= REG_FIELD(RT9455_REG_CTRL2, 5, 5),
 102	[F_HIGHER_OCP]		= REG_FIELD(RT9455_REG_CTRL2, 4, 4),
 103	[F_TE]			= REG_FIELD(RT9455_REG_CTRL2, 3, 3),
 104	[F_IAICR_INT]		= REG_FIELD(RT9455_REG_CTRL2, 2, 2),
 105	[F_HIZ]			= REG_FIELD(RT9455_REG_CTRL2, 1, 1),
 106	[F_OPA_MODE]		= REG_FIELD(RT9455_REG_CTRL2, 0, 0),
 107
 108	[F_VOREG]		= REG_FIELD(RT9455_REG_CTRL3, 2, 7),
 109	[F_OTG_PL]		= REG_FIELD(RT9455_REG_CTRL3, 1, 1),
 110	[F_OTG_EN]		= REG_FIELD(RT9455_REG_CTRL3, 0, 0),
 111
 112	[F_VENDOR_ID]		= REG_FIELD(RT9455_REG_DEV_ID, 4, 7),
 113	[F_CHIP_REV]		= REG_FIELD(RT9455_REG_DEV_ID, 0, 3),
 114
 115	[F_RST]			= REG_FIELD(RT9455_REG_CTRL4, 7, 7),
 116
 117	[F_TMR_EN]		= REG_FIELD(RT9455_REG_CTRL5, 7, 7),
 118	[F_MIVR]		= REG_FIELD(RT9455_REG_CTRL5, 4, 5),
 119	[F_IPREC]		= REG_FIELD(RT9455_REG_CTRL5, 2, 3),
 120	[F_IEOC_PERCENTAGE]	= REG_FIELD(RT9455_REG_CTRL5, 0, 1),
 121
 122	[F_IAICR_SEL]		= REG_FIELD(RT9455_REG_CTRL6, 7, 7),
 123	[F_ICHRG]		= REG_FIELD(RT9455_REG_CTRL6, 4, 6),
 124	[F_VPREC]		= REG_FIELD(RT9455_REG_CTRL6, 0, 2),
 125
 126	[F_BATD_EN]		= REG_FIELD(RT9455_REG_CTRL7, 6, 6),
 127	[F_CHG_EN]		= REG_FIELD(RT9455_REG_CTRL7, 4, 4),
 128	[F_VMREG]		= REG_FIELD(RT9455_REG_CTRL7, 0, 3),
 129
 130	[F_TSDI]		= REG_FIELD(RT9455_REG_IRQ1, 7, 7),
 131	[F_VINOVPI]		= REG_FIELD(RT9455_REG_IRQ1, 6, 6),
 132	[F_BATAB]		= REG_FIELD(RT9455_REG_IRQ1, 0, 0),
 133
 134	[F_CHRVPI]		= REG_FIELD(RT9455_REG_IRQ2, 7, 7),
 135	[F_CHBATOVI]		= REG_FIELD(RT9455_REG_IRQ2, 5, 5),
 136	[F_CHTERMI]		= REG_FIELD(RT9455_REG_IRQ2, 4, 4),
 137	[F_CHRCHGI]		= REG_FIELD(RT9455_REG_IRQ2, 3, 3),
 138	[F_CH32MI]		= REG_FIELD(RT9455_REG_IRQ2, 2, 2),
 139	[F_CHTREGI]		= REG_FIELD(RT9455_REG_IRQ2, 1, 1),
 140	[F_CHMIVRI]		= REG_FIELD(RT9455_REG_IRQ2, 0, 0),
 141
 142	[F_BSTBUSOVI]		= REG_FIELD(RT9455_REG_IRQ3, 7, 7),
 143	[F_BSTOLI]		= REG_FIELD(RT9455_REG_IRQ3, 6, 6),
 144	[F_BSTLOWVI]		= REG_FIELD(RT9455_REG_IRQ3, 5, 5),
 145	[F_BST32SI]		= REG_FIELD(RT9455_REG_IRQ3, 3, 3),
 146
 147	[F_TSDM]		= REG_FIELD(RT9455_REG_MASK1, 7, 7),
 148	[F_VINOVPIM]		= REG_FIELD(RT9455_REG_MASK1, 6, 6),
 149	[F_BATABM]		= REG_FIELD(RT9455_REG_MASK1, 0, 0),
 150
 151	[F_CHRVPIM]		= REG_FIELD(RT9455_REG_MASK2, 7, 7),
 152	[F_CHBATOVIM]		= REG_FIELD(RT9455_REG_MASK2, 5, 5),
 153	[F_CHTERMIM]		= REG_FIELD(RT9455_REG_MASK2, 4, 4),
 154	[F_CHRCHGIM]		= REG_FIELD(RT9455_REG_MASK2, 3, 3),
 155	[F_CH32MIM]		= REG_FIELD(RT9455_REG_MASK2, 2, 2),
 156	[F_CHTREGIM]		= REG_FIELD(RT9455_REG_MASK2, 1, 1),
 157	[F_CHMIVRIM]		= REG_FIELD(RT9455_REG_MASK2, 0, 0),
 158
 159	[F_BSTVINOVIM]		= REG_FIELD(RT9455_REG_MASK3, 7, 7),
 160	[F_BSTOLIM]		= REG_FIELD(RT9455_REG_MASK3, 6, 6),
 161	[F_BSTLOWVIM]		= REG_FIELD(RT9455_REG_MASK3, 5, 5),
 162	[F_BST32SIM]		= REG_FIELD(RT9455_REG_MASK3, 3, 3),
 163};
 164
 165#define GET_MASK(fid)	(BIT(rt9455_reg_fields[fid].msb + 1) - \
 166			 BIT(rt9455_reg_fields[fid].lsb))
 167
 168/*
 169 * Each array initialised below shows the possible real-world values for a
 170 * group of bits belonging to RT9455 registers. The arrays are sorted in
 171 * ascending order. The index of each real-world value represents the value
 172 * that is encoded in the group of bits belonging to RT9455 registers.
 173 */
 174/* REG06[6:4] (ICHRG) in uAh */
 175static const int rt9455_ichrg_values[] = {
 176	 500000,  650000,  800000,  950000, 1100000, 1250000, 1400000, 1550000
 177};
 178
 179/*
 180 * When the charger is in charge mode, REG02[7:2] represent battery regulation
 181 * voltage.
 182 */
 183/* REG02[7:2] (VOREG) in uV */
 184static const int rt9455_voreg_values[] = {
 185	3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
 186	3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
 187	3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
 188	3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000,
 189	4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000,
 190	4300000, 4330000, 4350000, 4370000, 4390000, 4410000, 4430000, 4450000,
 191	4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000,
 192	4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000, 4450000
 193};
 194
 195#if IS_ENABLED(CONFIG_USB_PHY)
 196/*
 197 * When the charger is in boost mode, REG02[7:2] represent boost output
 198 * voltage.
 199 */
 200/* REG02[7:2] (Boost output voltage) in uV */
 201static const int rt9455_boost_voltage_values[] = {
 202	4425000, 4450000, 4475000, 4500000, 4525000, 4550000, 4575000, 4600000,
 203	4625000, 4650000, 4675000, 4700000, 4725000, 4750000, 4775000, 4800000,
 204	4825000, 4850000, 4875000, 4900000, 4925000, 4950000, 4975000, 5000000,
 205	5025000, 5050000, 5075000, 5100000, 5125000, 5150000, 5175000, 5200000,
 206	5225000, 5250000, 5275000, 5300000, 5325000, 5350000, 5375000, 5400000,
 207	5425000, 5450000, 5475000, 5500000, 5525000, 5550000, 5575000, 5600000,
 208	5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000,
 209	5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000, 5600000,
 210};
 211#endif
 212
 213/* REG07[3:0] (VMREG) in uV */
 214static const int rt9455_vmreg_values[] = {
 215	4200000, 4220000, 4240000, 4260000, 4280000, 4300000, 4320000, 4340000,
 216	4360000, 4380000, 4400000, 4430000, 4450000, 4450000, 4450000, 4450000
 217};
 218
 219/* REG05[5:4] (IEOC_PERCENTAGE) */
 220static const int rt9455_ieoc_percentage_values[] = {
 221	10, 30, 20, 30
 222};
 223
 224/* REG05[1:0] (MIVR) in uV */
 225static const int rt9455_mivr_values[] = {
 226	4000000, 4250000, 4500000, 5000000
 227};
 228
 229/* REG05[1:0] (IAICR) in uA */
 230static const int rt9455_iaicr_values[] = {
 231	100000, 500000, 1000000, 2000000
 232};
 233
 234struct rt9455_info {
 235	struct i2c_client		*client;
 236	struct regmap			*regmap;
 237	struct regmap_field		*regmap_fields[F_MAX_FIELDS];
 238	struct power_supply		*charger;
 239#if IS_ENABLED(CONFIG_USB_PHY)
 240	struct usb_phy			*usb_phy;
 241	struct notifier_block		nb;
 242#endif
 243	struct delayed_work		pwr_rdy_work;
 244	struct delayed_work		max_charging_time_work;
 245	struct delayed_work		batt_presence_work;
 246	u32				voreg;
 247	u32				boost_voltage;
 248};
 249
 250/*
 251 * Iterate through each element of the 'tbl' array until an element whose value
 252 * is greater than v is found. Return the index of the respective element,
 253 * or the index of the last element in the array, if no such element is found.
 254 */
 255static unsigned int rt9455_find_idx(const int tbl[], int tbl_size, int v)
 256{
 257	int i;
 258
 259	/*
 260	 * No need to iterate until the last index in the table because
 261	 * if no element greater than v is found in the table,
 262	 * or if only the last element is greater than v,
 263	 * function returns the index of the last element.
 264	 */
 265	for (i = 0; i < tbl_size - 1; i++)
 266		if (v <= tbl[i])
 267			return i;
 268
 269	return (tbl_size - 1);
 270}
 271
 272static int rt9455_get_field_val(struct rt9455_info *info,
 273				enum rt9455_fields field,
 274				const int tbl[], int tbl_size, int *val)
 275{
 276	unsigned int v;
 277	int ret;
 278
 279	ret = regmap_field_read(info->regmap_fields[field], &v);
 280	if (ret)
 281		return ret;
 282
 283	v = (v >= tbl_size) ? (tbl_size - 1) : v;
 284	*val = tbl[v];
 285
 286	return 0;
 287}
 288
 289static int rt9455_set_field_val(struct rt9455_info *info,
 290				enum rt9455_fields field,
 291				const int tbl[], int tbl_size, int val)
 292{
 293	unsigned int idx = rt9455_find_idx(tbl, tbl_size, val);
 294
 295	return regmap_field_write(info->regmap_fields[field], idx);
 296}
 297
 298static int rt9455_register_reset(struct rt9455_info *info)
 299{
 300	struct device *dev = &info->client->dev;
 301	unsigned int v;
 302	int ret, limit = 100;
 303
 304	ret = regmap_field_write(info->regmap_fields[F_RST], 0x01);
 305	if (ret) {
 306		dev_err(dev, "Failed to set RST bit\n");
 307		return ret;
 308	}
 309
 310	/*
 311	 * To make sure that reset operation has finished, loop until RST bit
 312	 * is set to 0.
 313	 */
 314	do {
 315		ret = regmap_field_read(info->regmap_fields[F_RST], &v);
 316		if (ret) {
 317			dev_err(dev, "Failed to read RST bit\n");
 318			return ret;
 319		}
 320
 321		if (!v)
 322			break;
 323
 324		usleep_range(10, 100);
 325	} while (--limit);
 326
 327	if (!limit)
 328		return -EIO;
 329
 330	return 0;
 331}
 332
 333/* Charger power supply property routines */
 334static enum power_supply_property rt9455_charger_properties[] = {
 335	POWER_SUPPLY_PROP_STATUS,
 336	POWER_SUPPLY_PROP_HEALTH,
 337	POWER_SUPPLY_PROP_PRESENT,
 338	POWER_SUPPLY_PROP_ONLINE,
 339	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 340	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 341	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 342	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 343	POWER_SUPPLY_PROP_SCOPE,
 344	POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
 345	POWER_SUPPLY_PROP_MODEL_NAME,
 346	POWER_SUPPLY_PROP_MANUFACTURER,
 347};
 348
 349static char *rt9455_charger_supplied_to[] = {
 350	"main-battery",
 351};
 352
 353static int rt9455_charger_get_status(struct rt9455_info *info,
 354				     union power_supply_propval *val)
 355{
 356	unsigned int v, pwr_rdy;
 357	int ret;
 358
 359	ret = regmap_field_read(info->regmap_fields[F_PWR_RDY],
 360				&pwr_rdy);
 361	if (ret) {
 362		dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n");
 363		return ret;
 364	}
 365
 366	/*
 367	 * If PWR_RDY bit is unset, the battery is discharging. Otherwise,
 368	 * STAT bits value must be checked.
 369	 */
 370	if (!pwr_rdy) {
 371		val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 372		return 0;
 373	}
 374
 375	ret = regmap_field_read(info->regmap_fields[F_STAT], &v);
 376	if (ret) {
 377		dev_err(&info->client->dev, "Failed to read STAT bits\n");
 378		return ret;
 379	}
 380
 381	switch (v) {
 382	case 0:
 383		/*
 384		 * If PWR_RDY bit is set, but STAT bits value is 0, the charger
 385		 * may be in one of the following cases:
 386		 * 1. CHG_EN bit is 0.
 387		 * 2. CHG_EN bit is 1 but the battery is not connected.
 388		 * In any of these cases, POWER_SUPPLY_STATUS_NOT_CHARGING is
 389		 * returned.
 390		 */
 391		val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 392		return 0;
 393	case 1:
 394		val->intval = POWER_SUPPLY_STATUS_CHARGING;
 395		return 0;
 396	case 2:
 397		val->intval = POWER_SUPPLY_STATUS_FULL;
 398		return 0;
 399	default:
 400		val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 401		return 0;
 402	}
 403}
 404
 405static int rt9455_charger_get_health(struct rt9455_info *info,
 406				     union power_supply_propval *val)
 407{
 408	struct device *dev = &info->client->dev;
 409	unsigned int v;
 410	int ret;
 411
 412	val->intval = POWER_SUPPLY_HEALTH_GOOD;
 413
 414	ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &v);
 415	if (ret) {
 416		dev_err(dev, "Failed to read IRQ1 register\n");
 417		return ret;
 418	}
 419
 420	if (v & GET_MASK(F_TSDI)) {
 421		val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 422		return 0;
 423	}
 424	if (v & GET_MASK(F_VINOVPI)) {
 425		val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 426		return 0;
 427	}
 428	if (v & GET_MASK(F_BATAB)) {
 429		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 430		return 0;
 431	}
 432
 433	ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &v);
 434	if (ret) {
 435		dev_err(dev, "Failed to read IRQ2 register\n");
 436		return ret;
 437	}
 438
 439	if (v & GET_MASK(F_CHBATOVI)) {
 440		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 441		return 0;
 442	}
 443	if (v & GET_MASK(F_CH32MI)) {
 444		val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 445		return 0;
 446	}
 447
 448	ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &v);
 449	if (ret) {
 450		dev_err(dev, "Failed to read IRQ3 register\n");
 451		return ret;
 452	}
 453
 454	if (v & GET_MASK(F_BSTBUSOVI)) {
 455		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 456		return 0;
 457	}
 458	if (v & GET_MASK(F_BSTOLI)) {
 459		val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 460		return 0;
 461	}
 462	if (v & GET_MASK(F_BSTLOWVI)) {
 463		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 464		return 0;
 465	}
 466	if (v & GET_MASK(F_BST32SI)) {
 467		val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 468		return 0;
 469	}
 470
 471	ret = regmap_field_read(info->regmap_fields[F_STAT], &v);
 472	if (ret) {
 473		dev_err(dev, "Failed to read STAT bits\n");
 474		return ret;
 475	}
 476
 477	if (v == RT9455_FAULT) {
 478		val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 479		return 0;
 480	}
 481
 482	return 0;
 483}
 484
 485static int rt9455_charger_get_battery_presence(struct rt9455_info *info,
 486					       union power_supply_propval *val)
 487{
 488	unsigned int v;
 489	int ret;
 490
 491	ret = regmap_field_read(info->regmap_fields[F_BATAB], &v);
 492	if (ret) {
 493		dev_err(&info->client->dev, "Failed to read BATAB bit\n");
 494		return ret;
 495	}
 496
 497	/*
 498	 * Since BATAB is 1 when battery is NOT present and 0 otherwise,
 499	 * !BATAB is returned.
 500	 */
 501	val->intval = !v;
 502
 503	return 0;
 504}
 505
 506static int rt9455_charger_get_online(struct rt9455_info *info,
 507				     union power_supply_propval *val)
 508{
 509	unsigned int v;
 510	int ret;
 511
 512	ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &v);
 513	if (ret) {
 514		dev_err(&info->client->dev, "Failed to read PWR_RDY bit\n");
 515		return ret;
 516	}
 517
 518	val->intval = (int)v;
 519
 520	return 0;
 521}
 522
 523static int rt9455_charger_get_current(struct rt9455_info *info,
 524				      union power_supply_propval *val)
 525{
 526	int curr;
 527	int ret;
 528
 529	ret = rt9455_get_field_val(info, F_ICHRG,
 530				   rt9455_ichrg_values,
 531				   ARRAY_SIZE(rt9455_ichrg_values),
 532				   &curr);
 533	if (ret) {
 534		dev_err(&info->client->dev, "Failed to read ICHRG value\n");
 535		return ret;
 536	}
 537
 538	val->intval = curr;
 539
 540	return 0;
 541}
 542
 543static int rt9455_charger_get_current_max(struct rt9455_info *info,
 544					  union power_supply_propval *val)
 545{
 546	int idx = ARRAY_SIZE(rt9455_ichrg_values) - 1;
 547
 548	val->intval = rt9455_ichrg_values[idx];
 549
 550	return 0;
 551}
 552
 553static int rt9455_charger_get_voltage(struct rt9455_info *info,
 554				      union power_supply_propval *val)
 555{
 556	int voltage;
 557	int ret;
 558
 559	ret = rt9455_get_field_val(info, F_VOREG,
 560				   rt9455_voreg_values,
 561				   ARRAY_SIZE(rt9455_voreg_values),
 562				   &voltage);
 563	if (ret) {
 564		dev_err(&info->client->dev, "Failed to read VOREG value\n");
 565		return ret;
 566	}
 567
 568	val->intval = voltage;
 569
 570	return 0;
 571}
 572
 573static int rt9455_charger_get_voltage_max(struct rt9455_info *info,
 574					  union power_supply_propval *val)
 575{
 576	int idx = ARRAY_SIZE(rt9455_vmreg_values) - 1;
 577
 578	val->intval = rt9455_vmreg_values[idx];
 579
 580	return 0;
 581}
 582
 583static int rt9455_charger_get_term_current(struct rt9455_info *info,
 584					   union power_supply_propval *val)
 585{
 586	struct device *dev = &info->client->dev;
 587	int ichrg, ieoc_percentage, ret;
 588
 589	ret = rt9455_get_field_val(info, F_ICHRG,
 590				   rt9455_ichrg_values,
 591				   ARRAY_SIZE(rt9455_ichrg_values),
 592				   &ichrg);
 593	if (ret) {
 594		dev_err(dev, "Failed to read ICHRG value\n");
 595		return ret;
 596	}
 597
 598	ret = rt9455_get_field_val(info, F_IEOC_PERCENTAGE,
 599				   rt9455_ieoc_percentage_values,
 600				   ARRAY_SIZE(rt9455_ieoc_percentage_values),
 601				   &ieoc_percentage);
 602	if (ret) {
 603		dev_err(dev, "Failed to read IEOC value\n");
 604		return ret;
 605	}
 606
 607	val->intval = ichrg * ieoc_percentage / 100;
 608
 609	return 0;
 610}
 611
 612static int rt9455_charger_get_property(struct power_supply *psy,
 613				       enum power_supply_property psp,
 614				       union power_supply_propval *val)
 615{
 616	struct rt9455_info *info = power_supply_get_drvdata(psy);
 617
 618	switch (psp) {
 619	case POWER_SUPPLY_PROP_STATUS:
 620		return rt9455_charger_get_status(info, val);
 621	case POWER_SUPPLY_PROP_HEALTH:
 622		return rt9455_charger_get_health(info, val);
 623	case POWER_SUPPLY_PROP_PRESENT:
 624		return rt9455_charger_get_battery_presence(info, val);
 625	case POWER_SUPPLY_PROP_ONLINE:
 626		return rt9455_charger_get_online(info, val);
 627	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 628		return rt9455_charger_get_current(info, val);
 629	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 630		return rt9455_charger_get_current_max(info, val);
 631	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 632		return rt9455_charger_get_voltage(info, val);
 633	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 634		return rt9455_charger_get_voltage_max(info, val);
 635	case POWER_SUPPLY_PROP_SCOPE:
 636		val->intval = POWER_SUPPLY_SCOPE_SYSTEM;
 637		return 0;
 638	case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 639		return rt9455_charger_get_term_current(info, val);
 640	case POWER_SUPPLY_PROP_MODEL_NAME:
 641		val->strval = RT9455_MODEL_NAME;
 642		return 0;
 643	case POWER_SUPPLY_PROP_MANUFACTURER:
 644		val->strval = RT9455_MANUFACTURER;
 645		return 0;
 646	default:
 647		return -ENODATA;
 648	}
 649}
 650
 651static int rt9455_hw_init(struct rt9455_info *info, u32 ichrg,
 652			  u32 ieoc_percentage,
 653			  u32 mivr, u32 iaicr)
 654{
 655	struct device *dev = &info->client->dev;
 656	int idx, ret;
 657
 658	ret = rt9455_register_reset(info);
 659	if (ret) {
 660		dev_err(dev, "Power On Reset failed\n");
 661		return ret;
 662	}
 663
 664	/* Set TE bit in order to enable end of charge detection */
 665	ret = regmap_field_write(info->regmap_fields[F_TE], 1);
 666	if (ret) {
 667		dev_err(dev, "Failed to set TE bit\n");
 668		return ret;
 669	}
 670
 671	/* Set TE_SHDN_EN bit in order to enable end of charge detection */
 672	ret = regmap_field_write(info->regmap_fields[F_TE_SHDN_EN], 1);
 673	if (ret) {
 674		dev_err(dev, "Failed to set TE_SHDN_EN bit\n");
 675		return ret;
 676	}
 677
 678	/*
 679	 * Set BATD_EN bit in order to enable battery detection
 680	 * when charging is done
 681	 */
 682	ret = regmap_field_write(info->regmap_fields[F_BATD_EN], 1);
 683	if (ret) {
 684		dev_err(dev, "Failed to set BATD_EN bit\n");
 685		return ret;
 686	}
 687
 688	/*
 689	 * Disable Safety Timer. In charge mode, this timer terminates charging
 690	 * if no read or write via I2C is done within 32 minutes. This timer
 691	 * avoids overcharging the baterry when the OS is not loaded and the
 692	 * charger is connected to a power source.
 693	 * In boost mode, this timer triggers BST32SI interrupt if no read or
 694	 * write via I2C is done within 32 seconds.
 695	 * When the OS is loaded and the charger driver is inserted, it is used
 696	 * delayed_work, named max_charging_time_work, to avoid overcharging
 697	 * the battery.
 698	 */
 699	ret = regmap_field_write(info->regmap_fields[F_TMR_EN], 0x00);
 700	if (ret) {
 701		dev_err(dev, "Failed to disable Safety Timer\n");
 702		return ret;
 703	}
 704
 705	/* Set ICHRG to value retrieved from device-specific data */
 706	ret = rt9455_set_field_val(info, F_ICHRG,
 707				   rt9455_ichrg_values,
 708				   ARRAY_SIZE(rt9455_ichrg_values), ichrg);
 709	if (ret) {
 710		dev_err(dev, "Failed to set ICHRG value\n");
 711		return ret;
 712	}
 713
 714	/* Set IEOC Percentage to value retrieved from device-specific data */
 715	ret = rt9455_set_field_val(info, F_IEOC_PERCENTAGE,
 716				   rt9455_ieoc_percentage_values,
 717				   ARRAY_SIZE(rt9455_ieoc_percentage_values),
 718				   ieoc_percentage);
 719	if (ret) {
 720		dev_err(dev, "Failed to set IEOC Percentage value\n");
 721		return ret;
 722	}
 723
 724	/* Set VOREG to value retrieved from device-specific data */
 725	ret = rt9455_set_field_val(info, F_VOREG,
 726				   rt9455_voreg_values,
 727				   ARRAY_SIZE(rt9455_voreg_values),
 728				   info->voreg);
 729	if (ret) {
 730		dev_err(dev, "Failed to set VOREG value\n");
 731		return ret;
 732	}
 733
 734	/* Set VMREG value to maximum (4.45V). */
 735	idx = ARRAY_SIZE(rt9455_vmreg_values) - 1;
 736	ret = rt9455_set_field_val(info, F_VMREG,
 737				   rt9455_vmreg_values,
 738				   ARRAY_SIZE(rt9455_vmreg_values),
 739				   rt9455_vmreg_values[idx]);
 740	if (ret) {
 741		dev_err(dev, "Failed to set VMREG value\n");
 742		return ret;
 743	}
 744
 745	/*
 746	 * Set MIVR to value retrieved from device-specific data.
 747	 * If no value is specified, default value for MIVR is 4.5V.
 748	 */
 749	if (mivr == -1)
 750		mivr = 4500000;
 751
 752	ret = rt9455_set_field_val(info, F_MIVR,
 753				   rt9455_mivr_values,
 754				   ARRAY_SIZE(rt9455_mivr_values), mivr);
 755	if (ret) {
 756		dev_err(dev, "Failed to set MIVR value\n");
 757		return ret;
 758	}
 759
 760	/*
 761	 * Set IAICR to value retrieved from device-specific data.
 762	 * If no value is specified, default value for IAICR is 500 mA.
 763	 */
 764	if (iaicr == -1)
 765		iaicr = 500000;
 766
 767	ret = rt9455_set_field_val(info, F_IAICR,
 768				   rt9455_iaicr_values,
 769				   ARRAY_SIZE(rt9455_iaicr_values), iaicr);
 770	if (ret) {
 771		dev_err(dev, "Failed to set IAICR value\n");
 772		return ret;
 773	}
 774
 775	/*
 776	 * Set IAICR_INT bit so that IAICR value is determined by IAICR bits
 777	 * and not by OTG pin.
 778	 */
 779	ret = regmap_field_write(info->regmap_fields[F_IAICR_INT], 0x01);
 780	if (ret) {
 781		dev_err(dev, "Failed to set IAICR_INT bit\n");
 782		return ret;
 783	}
 784
 785	/*
 786	 * Disable CHMIVRI interrupt. Because the driver sets MIVR value,
 787	 * CHMIVRI is triggered, but there is no action to be taken by the
 788	 * driver when CHMIVRI is triggered.
 789	 */
 790	ret = regmap_field_write(info->regmap_fields[F_CHMIVRIM], 0x01);
 791	if (ret) {
 792		dev_err(dev, "Failed to mask CHMIVRI interrupt\n");
 793		return ret;
 794	}
 795
 796	return 0;
 797}
 798
 799#if IS_ENABLED(CONFIG_USB_PHY)
 800/*
 801 * Before setting the charger into boost mode, boost output voltage is
 802 * set. This is needed because boost output voltage may differ from battery
 803 * regulation voltage. F_VOREG bits represent either battery regulation voltage
 804 * or boost output voltage, depending on the mode the charger is. Both battery
 805 * regulation voltage and boost output voltage are read from DT/ACPI during
 806 * probe.
 807 */
 808static int rt9455_set_boost_voltage_before_boost_mode(struct rt9455_info *info)
 809{
 810	struct device *dev = &info->client->dev;
 811	int ret;
 812
 813	ret = rt9455_set_field_val(info, F_VOREG,
 814				   rt9455_boost_voltage_values,
 815				   ARRAY_SIZE(rt9455_boost_voltage_values),
 816				   info->boost_voltage);
 817	if (ret) {
 818		dev_err(dev, "Failed to set boost output voltage value\n");
 819		return ret;
 820	}
 821
 822	return 0;
 823}
 824#endif
 825
 826/*
 827 * Before setting the charger into charge mode, battery regulation voltage is
 828 * set. This is needed because boost output voltage may differ from battery
 829 * regulation voltage. F_VOREG bits represent either battery regulation voltage
 830 * or boost output voltage, depending on the mode the charger is. Both battery
 831 * regulation voltage and boost output voltage are read from DT/ACPI during
 832 * probe.
 833 */
 834static int rt9455_set_voreg_before_charge_mode(struct rt9455_info *info)
 835{
 836	struct device *dev = &info->client->dev;
 837	int ret;
 838
 839	ret = rt9455_set_field_val(info, F_VOREG,
 840				   rt9455_voreg_values,
 841				   ARRAY_SIZE(rt9455_voreg_values),
 842				   info->voreg);
 843	if (ret) {
 844		dev_err(dev, "Failed to set VOREG value\n");
 845		return ret;
 846	}
 847
 848	return 0;
 849}
 850
 851static int rt9455_irq_handler_check_irq1_register(struct rt9455_info *info,
 852						  bool *_is_battery_absent,
 853						  bool *_alert_userspace)
 854{
 855	unsigned int irq1, mask1, mask2;
 856	struct device *dev = &info->client->dev;
 857	bool is_battery_absent = false;
 858	bool alert_userspace = false;
 859	int ret;
 860
 861	ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1);
 862	if (ret) {
 863		dev_err(dev, "Failed to read IRQ1 register\n");
 864		return ret;
 865	}
 866
 867	ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1);
 868	if (ret) {
 869		dev_err(dev, "Failed to read MASK1 register\n");
 870		return ret;
 871	}
 872
 873	if (irq1 & GET_MASK(F_TSDI)) {
 874		dev_err(dev, "Thermal shutdown fault occurred\n");
 875		alert_userspace = true;
 876	}
 877
 878	if (irq1 & GET_MASK(F_VINOVPI)) {
 879		dev_err(dev, "Overvoltage input occurred\n");
 880		alert_userspace = true;
 881	}
 882
 883	if (irq1 & GET_MASK(F_BATAB)) {
 884		dev_err(dev, "Battery absence occurred\n");
 885		is_battery_absent = true;
 886		alert_userspace = true;
 887
 888		if ((mask1 & GET_MASK(F_BATABM)) == 0) {
 889			ret = regmap_field_write(info->regmap_fields[F_BATABM],
 890						 0x01);
 891			if (ret) {
 892				dev_err(dev, "Failed to mask BATAB interrupt\n");
 893				return ret;
 894			}
 895		}
 896
 897		ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2);
 898		if (ret) {
 899			dev_err(dev, "Failed to read MASK2 register\n");
 900			return ret;
 901		}
 902
 903		if (mask2 & GET_MASK(F_CHTERMIM)) {
 904			ret = regmap_field_write(
 905				info->regmap_fields[F_CHTERMIM], 0x00);
 906			if (ret) {
 907				dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
 908				return ret;
 909			}
 910		}
 911
 912		if (mask2 & GET_MASK(F_CHRCHGIM)) {
 913			ret = regmap_field_write(
 914				info->regmap_fields[F_CHRCHGIM], 0x00);
 915			if (ret) {
 916				dev_err(dev, "Failed to unmask CHRCHGI interrupt\n");
 917				return ret;
 918			}
 919		}
 920
 921		/*
 922		 * When the battery is absent, max_charging_time_work is
 923		 * cancelled, since no charging is done.
 924		 */
 925		cancel_delayed_work_sync(&info->max_charging_time_work);
 926		/*
 927		 * Since no interrupt is triggered when the battery is
 928		 * reconnected, max_charging_time_work is not rescheduled.
 929		 * Therefore, batt_presence_work is scheduled to check whether
 930		 * the battery is still absent or not.
 931		 */
 932		queue_delayed_work(system_power_efficient_wq,
 933				   &info->batt_presence_work,
 934				   RT9455_BATT_PRESENCE_DELAY * HZ);
 935	}
 936
 937	*_is_battery_absent = is_battery_absent;
 938
 939	if (alert_userspace)
 940		*_alert_userspace = alert_userspace;
 941
 942	return 0;
 943}
 944
 945static int rt9455_irq_handler_check_irq2_register(struct rt9455_info *info,
 946						  bool is_battery_absent,
 947						  bool *_alert_userspace)
 948{
 949	unsigned int irq2, mask2;
 950	struct device *dev = &info->client->dev;
 951	bool alert_userspace = false;
 952	int ret;
 953
 954	ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &irq2);
 955	if (ret) {
 956		dev_err(dev, "Failed to read IRQ2 register\n");
 957		return ret;
 958	}
 959
 960	ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2);
 961	if (ret) {
 962		dev_err(dev, "Failed to read MASK2 register\n");
 963		return ret;
 964	}
 965
 966	if (irq2 & GET_MASK(F_CHRVPI)) {
 967		dev_dbg(dev, "Charger fault occurred\n");
 968		/*
 969		 * CHRVPI bit is set in 2 cases:
 970		 * 1. when the power source is connected to the charger.
 971		 * 2. when the power source is disconnected from the charger.
 972		 * To identify the case, PWR_RDY bit is checked. Because
 973		 * PWR_RDY bit is set / cleared after CHRVPI interrupt is
 974		 * triggered, it is used delayed_work to later read PWR_RDY bit.
 975		 * Also, do not set to true alert_userspace, because there is no
 976		 * need to notify userspace when CHRVPI interrupt has occurred.
 977		 * Userspace will be notified after PWR_RDY bit is read.
 978		 */
 979		queue_delayed_work(system_power_efficient_wq,
 980				   &info->pwr_rdy_work,
 981				   RT9455_PWR_RDY_DELAY * HZ);
 982	}
 983	if (irq2 & GET_MASK(F_CHBATOVI)) {
 984		dev_err(dev, "Battery OVP occurred\n");
 985		alert_userspace = true;
 986	}
 987	if (irq2 & GET_MASK(F_CHTERMI)) {
 988		dev_dbg(dev, "Charge terminated\n");
 989		if (!is_battery_absent) {
 990			if ((mask2 & GET_MASK(F_CHTERMIM)) == 0) {
 991				ret = regmap_field_write(
 992					info->regmap_fields[F_CHTERMIM], 0x01);
 993				if (ret) {
 994					dev_err(dev, "Failed to mask CHTERMI interrupt\n");
 995					return ret;
 996				}
 997				/*
 998				 * Update MASK2 value, since CHTERMIM bit is
 999				 * set.
1000				 */
1001				mask2 = mask2 | GET_MASK(F_CHTERMIM);
1002			}
1003			cancel_delayed_work_sync(&info->max_charging_time_work);
1004			alert_userspace = true;
1005		}
1006	}
1007	if (irq2 & GET_MASK(F_CHRCHGI)) {
1008		dev_dbg(dev, "Recharge request\n");
1009		ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1010					 RT9455_CHARGE_ENABLE);
1011		if (ret) {
1012			dev_err(dev, "Failed to enable charging\n");
1013			return ret;
1014		}
1015		if (mask2 & GET_MASK(F_CHTERMIM)) {
1016			ret = regmap_field_write(
1017				info->regmap_fields[F_CHTERMIM], 0x00);
1018			if (ret) {
1019				dev_err(dev, "Failed to unmask CHTERMI interrupt\n");
1020				return ret;
1021			}
1022			/* Update MASK2 value, since CHTERMIM bit is cleared. */
1023			mask2 = mask2 & ~GET_MASK(F_CHTERMIM);
1024		}
1025		if (!is_battery_absent) {
1026			/*
1027			 * No need to check whether the charger is connected to
1028			 * power source when CHRCHGI is received, since CHRCHGI
1029			 * is not triggered if the charger is not connected to
1030			 * the power source.
1031			 */
1032			queue_delayed_work(system_power_efficient_wq,
1033					   &info->max_charging_time_work,
1034					   RT9455_MAX_CHARGING_TIME * HZ);
1035			alert_userspace = true;
1036		}
1037	}
1038	if (irq2 & GET_MASK(F_CH32MI)) {
1039		dev_err(dev, "Charger fault. 32 mins timeout occurred\n");
1040		alert_userspace = true;
1041	}
1042	if (irq2 & GET_MASK(F_CHTREGI)) {
1043		dev_warn(dev,
1044			 "Charger warning. Thermal regulation loop active\n");
1045		alert_userspace = true;
1046	}
1047	if (irq2 & GET_MASK(F_CHMIVRI)) {
1048		dev_dbg(dev,
1049			"Charger warning. Input voltage MIVR loop active\n");
1050	}
1051
1052	if (alert_userspace)
1053		*_alert_userspace = alert_userspace;
1054
1055	return 0;
1056}
1057
1058static int rt9455_irq_handler_check_irq3_register(struct rt9455_info *info,
1059						  bool *_alert_userspace)
1060{
1061	unsigned int irq3, mask3;
1062	struct device *dev = &info->client->dev;
1063	bool alert_userspace = false;
1064	int ret;
1065
1066	ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &irq3);
1067	if (ret) {
1068		dev_err(dev, "Failed to read IRQ3 register\n");
1069		return ret;
1070	}
1071
1072	ret = regmap_read(info->regmap, RT9455_REG_MASK3, &mask3);
1073	if (ret) {
1074		dev_err(dev, "Failed to read MASK3 register\n");
1075		return ret;
1076	}
1077
1078	if (irq3 & GET_MASK(F_BSTBUSOVI)) {
1079		dev_err(dev, "Boost fault. Overvoltage input occurred\n");
1080		alert_userspace = true;
1081	}
1082	if (irq3 & GET_MASK(F_BSTOLI)) {
1083		dev_err(dev, "Boost fault. Overload\n");
1084		alert_userspace = true;
1085	}
1086	if (irq3 & GET_MASK(F_BSTLOWVI)) {
1087		dev_err(dev, "Boost fault. Battery voltage too low\n");
1088		alert_userspace = true;
1089	}
1090	if (irq3 & GET_MASK(F_BST32SI)) {
1091		dev_err(dev, "Boost fault. 32 seconds timeout occurred.\n");
1092		alert_userspace = true;
1093	}
1094
1095	if (alert_userspace) {
1096		dev_info(dev, "Boost fault occurred, therefore the charger goes into charge mode\n");
1097		ret = rt9455_set_voreg_before_charge_mode(info);
1098		if (ret) {
1099			dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1100			return ret;
1101		}
1102		ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1103					 RT9455_CHARGE_MODE);
1104		if (ret) {
1105			dev_err(dev, "Failed to set charger in charge mode\n");
1106			return ret;
1107		}
1108		*_alert_userspace = alert_userspace;
1109	}
1110
1111	return 0;
1112}
1113
1114static irqreturn_t rt9455_irq_handler_thread(int irq, void *data)
1115{
1116	struct rt9455_info *info = data;
1117	struct device *dev;
1118	bool alert_userspace = false;
1119	bool is_battery_absent = false;
1120	unsigned int status;
1121	int ret;
1122
1123	if (!info)
1124		return IRQ_NONE;
1125
1126	dev = &info->client->dev;
1127
1128	if (irq != info->client->irq) {
1129		dev_err(dev, "Interrupt is not for RT9455 charger\n");
1130		return IRQ_NONE;
1131	}
1132
1133	ret = regmap_field_read(info->regmap_fields[F_STAT], &status);
1134	if (ret) {
1135		dev_err(dev, "Failed to read STAT bits\n");
1136		return IRQ_HANDLED;
1137	}
1138	dev_dbg(dev, "Charger status is %d\n", status);
1139
1140	/*
1141	 * Each function that processes an IRQ register receives as output
1142	 * parameter alert_userspace pointer. alert_userspace is set to true
1143	 * in such a function only if an interrupt has occurred in the
1144	 * respective interrupt register. This way, it is avoided the following
1145	 * case: interrupt occurs only in IRQ1 register,
1146	 * rt9455_irq_handler_check_irq1_register() function sets to true
1147	 * alert_userspace, but rt9455_irq_handler_check_irq2_register()
1148	 * and rt9455_irq_handler_check_irq3_register() functions set to false
1149	 * alert_userspace and power_supply_changed() is never called.
1150	 */
1151	ret = rt9455_irq_handler_check_irq1_register(info, &is_battery_absent,
1152						     &alert_userspace);
1153	if (ret) {
1154		dev_err(dev, "Failed to handle IRQ1 register\n");
1155		return IRQ_HANDLED;
1156	}
1157
1158	ret = rt9455_irq_handler_check_irq2_register(info, is_battery_absent,
1159						     &alert_userspace);
1160	if (ret) {
1161		dev_err(dev, "Failed to handle IRQ2 register\n");
1162		return IRQ_HANDLED;
1163	}
1164
1165	ret = rt9455_irq_handler_check_irq3_register(info, &alert_userspace);
1166	if (ret) {
1167		dev_err(dev, "Failed to handle IRQ3 register\n");
1168		return IRQ_HANDLED;
1169	}
1170
1171	if (alert_userspace) {
1172		/*
1173		 * Sometimes, an interrupt occurs while rt9455_probe() function
1174		 * is executing and power_supply_register() is not yet called.
1175		 * Do not call power_supply_changed() in this case.
1176		 */
1177		if (info->charger)
1178			power_supply_changed(info->charger);
1179	}
1180
1181	return IRQ_HANDLED;
1182}
1183
1184static int rt9455_discover_charger(struct rt9455_info *info, u32 *ichrg,
1185				   u32 *ieoc_percentage,
1186				   u32 *mivr, u32 *iaicr)
1187{
1188	struct device *dev = &info->client->dev;
1189	int ret;
1190
1191	if (!dev->of_node && !ACPI_HANDLE(dev)) {
1192		dev_err(dev, "No support for either device tree or ACPI\n");
1193		return -EINVAL;
1194	}
1195	/*
1196	 * ICHRG, IEOC_PERCENTAGE, VOREG and boost output voltage are mandatory
1197	 * parameters.
1198	 */
1199	ret = device_property_read_u32(dev, "richtek,output-charge-current",
1200				       ichrg);
1201	if (ret) {
1202		dev_err(dev, "Error: missing \"output-charge-current\" property\n");
1203		return ret;
1204	}
1205
1206	ret = device_property_read_u32(dev, "richtek,end-of-charge-percentage",
1207				       ieoc_percentage);
1208	if (ret) {
1209		dev_err(dev, "Error: missing \"end-of-charge-percentage\" property\n");
1210		return ret;
1211	}
1212
1213	ret = device_property_read_u32(dev,
1214				       "richtek,battery-regulation-voltage",
1215				       &info->voreg);
1216	if (ret) {
1217		dev_err(dev, "Error: missing \"battery-regulation-voltage\" property\n");
1218		return ret;
1219	}
1220
1221	ret = device_property_read_u32(dev, "richtek,boost-output-voltage",
1222				       &info->boost_voltage);
1223	if (ret) {
1224		dev_err(dev, "Error: missing \"boost-output-voltage\" property\n");
1225		return ret;
1226	}
1227
1228	/*
1229	 * MIVR and IAICR are optional parameters. Do not return error if one of
1230	 * them is not present in ACPI table or device tree specification.
1231	 */
1232	device_property_read_u32(dev, "richtek,min-input-voltage-regulation",
1233				 mivr);
1234	device_property_read_u32(dev, "richtek,avg-input-current-regulation",
1235				 iaicr);
1236
1237	return 0;
1238}
1239
1240#if IS_ENABLED(CONFIG_USB_PHY)
1241static int rt9455_usb_event_none(struct rt9455_info *info,
1242				 u8 opa_mode, u8 iaicr)
1243{
1244	struct device *dev = &info->client->dev;
1245	int ret;
1246
1247	if (opa_mode == RT9455_BOOST_MODE) {
1248		ret = rt9455_set_voreg_before_charge_mode(info);
1249		if (ret) {
1250			dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1251			return ret;
1252		}
1253		/*
1254		 * If the charger is in boost mode, and it has received
1255		 * USB_EVENT_NONE, this means the consumer device powered by the
1256		 * charger is not connected anymore.
1257		 * In this case, the charger goes into charge mode.
1258		 */
1259		dev_dbg(dev, "USB_EVENT_NONE received, therefore the charger goes into charge mode\n");
1260		ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1261					 RT9455_CHARGE_MODE);
1262		if (ret) {
1263			dev_err(dev, "Failed to set charger in charge mode\n");
1264			return NOTIFY_DONE;
1265		}
1266	}
1267
1268	dev_dbg(dev, "USB_EVENT_NONE received, therefore IAICR is set to its minimum value\n");
1269	if (iaicr != RT9455_IAICR_100MA) {
1270		ret = regmap_field_write(info->regmap_fields[F_IAICR],
1271					 RT9455_IAICR_100MA);
1272		if (ret) {
1273			dev_err(dev, "Failed to set IAICR value\n");
1274			return NOTIFY_DONE;
1275		}
1276	}
1277
1278	return NOTIFY_OK;
1279}
1280
1281static int rt9455_usb_event_vbus(struct rt9455_info *info,
1282				 u8 opa_mode, u8 iaicr)
1283{
1284	struct device *dev = &info->client->dev;
1285	int ret;
1286
1287	if (opa_mode == RT9455_BOOST_MODE) {
1288		ret = rt9455_set_voreg_before_charge_mode(info);
1289		if (ret) {
1290			dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1291			return ret;
1292		}
1293		/*
1294		 * If the charger is in boost mode, and it has received
1295		 * USB_EVENT_VBUS, this means the consumer device powered by the
1296		 * charger is not connected anymore.
1297		 * In this case, the charger goes into charge mode.
1298		 */
1299		dev_dbg(dev, "USB_EVENT_VBUS received, therefore the charger goes into charge mode\n");
1300		ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1301					 RT9455_CHARGE_MODE);
1302		if (ret) {
1303			dev_err(dev, "Failed to set charger in charge mode\n");
1304			return NOTIFY_DONE;
1305		}
1306	}
1307
1308	dev_dbg(dev, "USB_EVENT_VBUS received, therefore IAICR is set to 500 mA\n");
1309	if (iaicr != RT9455_IAICR_500MA) {
1310		ret = regmap_field_write(info->regmap_fields[F_IAICR],
1311					 RT9455_IAICR_500MA);
1312		if (ret) {
1313			dev_err(dev, "Failed to set IAICR value\n");
1314			return NOTIFY_DONE;
1315		}
1316	}
1317
1318	return NOTIFY_OK;
1319}
1320
1321static int rt9455_usb_event_id(struct rt9455_info *info,
1322			       u8 opa_mode, u8 iaicr)
1323{
1324	struct device *dev = &info->client->dev;
1325	int ret;
1326
1327	if (opa_mode == RT9455_CHARGE_MODE) {
1328		ret = rt9455_set_boost_voltage_before_boost_mode(info);
1329		if (ret) {
1330			dev_err(dev, "Failed to set boost output voltage before entering boost mode\n");
1331			return ret;
1332		}
1333		/*
1334		 * If the charger is in charge mode, and it has received
1335		 * USB_EVENT_ID, this means a consumer device is connected and
1336		 * it should be powered by the charger.
1337		 * In this case, the charger goes into boost mode.
1338		 */
1339		dev_dbg(dev, "USB_EVENT_ID received, therefore the charger goes into boost mode\n");
1340		ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1341					 RT9455_BOOST_MODE);
1342		if (ret) {
1343			dev_err(dev, "Failed to set charger in boost mode\n");
1344			return NOTIFY_DONE;
1345		}
1346	}
1347
1348	dev_dbg(dev, "USB_EVENT_ID received, therefore IAICR is set to its minimum value\n");
1349	if (iaicr != RT9455_IAICR_100MA) {
1350		ret = regmap_field_write(info->regmap_fields[F_IAICR],
1351					 RT9455_IAICR_100MA);
1352		if (ret) {
1353			dev_err(dev, "Failed to set IAICR value\n");
1354			return NOTIFY_DONE;
1355		}
1356	}
1357
1358	return NOTIFY_OK;
1359}
1360
1361static int rt9455_usb_event_charger(struct rt9455_info *info,
1362				    u8 opa_mode, u8 iaicr)
1363{
1364	struct device *dev = &info->client->dev;
1365	int ret;
1366
1367	if (opa_mode == RT9455_BOOST_MODE) {
1368		ret = rt9455_set_voreg_before_charge_mode(info);
1369		if (ret) {
1370			dev_err(dev, "Failed to set VOREG before entering charge mode\n");
1371			return ret;
1372		}
1373		/*
1374		 * If the charger is in boost mode, and it has received
1375		 * USB_EVENT_CHARGER, this means the consumer device powered by
1376		 * the charger is not connected anymore.
1377		 * In this case, the charger goes into charge mode.
1378		 */
1379		dev_dbg(dev, "USB_EVENT_CHARGER received, therefore the charger goes into charge mode\n");
1380		ret = regmap_field_write(info->regmap_fields[F_OPA_MODE],
1381					 RT9455_CHARGE_MODE);
1382		if (ret) {
1383			dev_err(dev, "Failed to set charger in charge mode\n");
1384			return NOTIFY_DONE;
1385		}
1386	}
1387
1388	dev_dbg(dev, "USB_EVENT_CHARGER received, therefore IAICR is set to no current limit\n");
1389	if (iaicr != RT9455_IAICR_NO_LIMIT) {
1390		ret = regmap_field_write(info->regmap_fields[F_IAICR],
1391					 RT9455_IAICR_NO_LIMIT);
1392		if (ret) {
1393			dev_err(dev, "Failed to set IAICR value\n");
1394			return NOTIFY_DONE;
1395		}
1396	}
1397
1398	return NOTIFY_OK;
1399}
1400
1401static int rt9455_usb_event(struct notifier_block *nb,
1402			    unsigned long event, void *power)
1403{
1404	struct rt9455_info *info = container_of(nb, struct rt9455_info, nb);
1405	struct device *dev = &info->client->dev;
1406	unsigned int opa_mode, iaicr;
1407	int ret;
1408
1409	/*
1410	 * Determine whether the charger is in charge mode
1411	 * or in boost mode.
1412	 */
1413	ret = regmap_field_read(info->regmap_fields[F_OPA_MODE],
1414				&opa_mode);
1415	if (ret) {
1416		dev_err(dev, "Failed to read OPA_MODE value\n");
1417		return NOTIFY_DONE;
1418	}
1419
1420	ret = regmap_field_read(info->regmap_fields[F_IAICR],
1421				&iaicr);
1422	if (ret) {
1423		dev_err(dev, "Failed to read IAICR value\n");
1424		return NOTIFY_DONE;
1425	}
1426
1427	dev_dbg(dev, "Received USB event %lu\n", event);
1428	switch (event) {
1429	case USB_EVENT_NONE:
1430		return rt9455_usb_event_none(info, opa_mode, iaicr);
1431	case USB_EVENT_VBUS:
1432		return rt9455_usb_event_vbus(info, opa_mode, iaicr);
1433	case USB_EVENT_ID:
1434		return rt9455_usb_event_id(info, opa_mode, iaicr);
1435	case USB_EVENT_CHARGER:
1436		return rt9455_usb_event_charger(info, opa_mode, iaicr);
1437	default:
1438		dev_err(dev, "Unknown USB event\n");
1439	}
1440	return NOTIFY_DONE;
1441}
1442#endif
1443
1444static void rt9455_pwr_rdy_work_callback(struct work_struct *work)
1445{
1446	struct rt9455_info *info = container_of(work, struct rt9455_info,
1447						pwr_rdy_work.work);
1448	struct device *dev = &info->client->dev;
1449	unsigned int pwr_rdy;
1450	int ret;
1451
1452	ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &pwr_rdy);
1453	if (ret) {
1454		dev_err(dev, "Failed to read PWR_RDY bit\n");
1455		return;
1456	}
1457	switch (pwr_rdy) {
1458	case RT9455_PWR_FAULT:
1459		dev_dbg(dev, "Charger disconnected from power source\n");
1460		cancel_delayed_work_sync(&info->max_charging_time_work);
1461		break;
1462	case RT9455_PWR_GOOD:
1463		dev_dbg(dev, "Charger connected to power source\n");
1464		ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1465					 RT9455_CHARGE_ENABLE);
1466		if (ret) {
1467			dev_err(dev, "Failed to enable charging\n");
1468			return;
1469		}
1470		queue_delayed_work(system_power_efficient_wq,
1471				   &info->max_charging_time_work,
1472				   RT9455_MAX_CHARGING_TIME * HZ);
1473		break;
1474	}
1475	/*
1476	 * Notify userspace that the charger has been either connected to or
1477	 * disconnected from the power source.
1478	 */
1479	power_supply_changed(info->charger);
1480}
1481
1482static void rt9455_max_charging_time_work_callback(struct work_struct *work)
1483{
1484	struct rt9455_info *info = container_of(work, struct rt9455_info,
1485						max_charging_time_work.work);
1486	struct device *dev = &info->client->dev;
1487	int ret;
1488
1489	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");
1490	ret = regmap_field_write(info->regmap_fields[F_CHG_EN],
1491				 RT9455_CHARGE_DISABLE);
1492	if (ret)
1493		dev_err(dev, "Failed to disable charging\n");
1494}
1495
1496static void rt9455_batt_presence_work_callback(struct work_struct *work)
1497{
1498	struct rt9455_info *info = container_of(work, struct rt9455_info,
1499						batt_presence_work.work);
1500	struct device *dev = &info->client->dev;
1501	unsigned int irq1, mask1;
1502	int ret;
1503
1504	ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1);
1505	if (ret) {
1506		dev_err(dev, "Failed to read IRQ1 register\n");
1507		return;
1508	}
1509
1510	/*
1511	 * If the battery is still absent, batt_presence_work is rescheduled.
1512	 * Otherwise, max_charging_time is scheduled.
1513	 */
1514	if (irq1 & GET_MASK(F_BATAB)) {
1515		queue_delayed_work(system_power_efficient_wq,
1516				   &info->batt_presence_work,
1517				   RT9455_BATT_PRESENCE_DELAY * HZ);
1518	} else {
1519		queue_delayed_work(system_power_efficient_wq,
1520				   &info->max_charging_time_work,
1521				   RT9455_MAX_CHARGING_TIME * HZ);
1522
1523		ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1);
1524		if (ret) {
1525			dev_err(dev, "Failed to read MASK1 register\n");
1526			return;
1527		}
1528
1529		if (mask1 & GET_MASK(F_BATABM)) {
1530			ret = regmap_field_write(info->regmap_fields[F_BATABM],
1531						 0x00);
1532			if (ret)
1533				dev_err(dev, "Failed to unmask BATAB interrupt\n");
1534		}
1535		/*
1536		 * Notify userspace that the battery is now connected to the
1537		 * charger.
1538		 */
1539		power_supply_changed(info->charger);
1540	}
1541}
1542
1543static const struct power_supply_desc rt9455_charger_desc = {
1544	.name			= RT9455_DRIVER_NAME,
1545	.type			= POWER_SUPPLY_TYPE_USB,
1546	.properties		= rt9455_charger_properties,
1547	.num_properties		= ARRAY_SIZE(rt9455_charger_properties),
1548	.get_property		= rt9455_charger_get_property,
1549};
1550
1551static bool rt9455_is_writeable_reg(struct device *dev, unsigned int reg)
1552{
1553	switch (reg) {
1554	case RT9455_REG_DEV_ID:
1555	case RT9455_REG_IRQ1:
1556	case RT9455_REG_IRQ2:
1557	case RT9455_REG_IRQ3:
1558		return false;
1559	default:
1560		return true;
1561	}
1562}
1563
1564static bool rt9455_is_volatile_reg(struct device *dev, unsigned int reg)
1565{
1566	switch (reg) {
1567	case RT9455_REG_DEV_ID:
1568	case RT9455_REG_CTRL5:
1569	case RT9455_REG_CTRL6:
1570		return false;
1571	default:
1572		return true;
1573	}
1574}
1575
1576static const struct regmap_config rt9455_regmap_config = {
1577	.reg_bits	= 8,
1578	.val_bits	= 8,
1579	.writeable_reg	= rt9455_is_writeable_reg,
1580	.volatile_reg	= rt9455_is_volatile_reg,
1581	.max_register	= RT9455_REG_MASK3,
1582	.cache_type	= REGCACHE_MAPLE,
1583};
1584
1585static int rt9455_probe(struct i2c_client *client)
1586{
1587	struct i2c_adapter *adapter = client->adapter;
1588	struct device *dev = &client->dev;
1589	struct rt9455_info *info;
1590	struct power_supply_config rt9455_charger_config = {};
1591	/*
1592	 * Mandatory device-specific data values. Also, VOREG and boost output
1593	 * voltage are mandatory values, but they are stored in rt9455_info
1594	 * structure.
1595	 */
1596	u32 ichrg, ieoc_percentage;
1597	/* Optional device-specific data values. */
1598	u32 mivr = -1, iaicr = -1;
1599	int i, ret;
1600
1601	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
1602		dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
1603		return -ENODEV;
1604	}
1605	info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
1606	if (!info)
1607		return -ENOMEM;
1608
1609	info->client = client;
1610	i2c_set_clientdata(client, info);
1611
1612	info->regmap = devm_regmap_init_i2c(client,
1613					    &rt9455_regmap_config);
1614	if (IS_ERR(info->regmap)) {
1615		dev_err(dev, "Failed to initialize register map\n");
1616		return -EINVAL;
1617	}
1618
1619	for (i = 0; i < F_MAX_FIELDS; i++) {
1620		info->regmap_fields[i] =
1621			devm_regmap_field_alloc(dev, info->regmap,
1622						rt9455_reg_fields[i]);
1623		if (IS_ERR(info->regmap_fields[i])) {
1624			dev_err(dev,
1625				"Failed to allocate regmap field = %d\n", i);
1626			return PTR_ERR(info->regmap_fields[i]);
1627		}
1628	}
1629
1630	ret = rt9455_discover_charger(info, &ichrg, &ieoc_percentage,
1631				      &mivr, &iaicr);
1632	if (ret) {
1633		dev_err(dev, "Failed to discover charger\n");
1634		return ret;
1635	}
1636
1637#if IS_ENABLED(CONFIG_USB_PHY)
1638	info->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1639	if (IS_ERR(info->usb_phy)) {
1640		dev_err(dev, "Failed to get USB transceiver\n");
1641	} else {
1642		info->nb.notifier_call = rt9455_usb_event;
1643		ret = usb_register_notifier(info->usb_phy, &info->nb);
1644		if (ret) {
1645			dev_err(dev, "Failed to register USB notifier\n");
1646			/*
1647			 * If usb_register_notifier() fails, set notifier_call
1648			 * to NULL, to avoid calling usb_unregister_notifier().
1649			 */
1650			info->nb.notifier_call = NULL;
1651		}
1652	}
1653#endif
1654
1655	INIT_DEFERRABLE_WORK(&info->pwr_rdy_work, rt9455_pwr_rdy_work_callback);
1656	INIT_DEFERRABLE_WORK(&info->max_charging_time_work,
1657			     rt9455_max_charging_time_work_callback);
1658	INIT_DEFERRABLE_WORK(&info->batt_presence_work,
1659			     rt9455_batt_presence_work_callback);
1660
1661	rt9455_charger_config.fwnode		= dev_fwnode(dev);
1662	rt9455_charger_config.drv_data		= info;
1663	rt9455_charger_config.supplied_to	= rt9455_charger_supplied_to;
1664	rt9455_charger_config.num_supplicants	=
1665					ARRAY_SIZE(rt9455_charger_supplied_to);
1666
1667	info->charger = devm_power_supply_register(dev, &rt9455_charger_desc,
1668						   &rt9455_charger_config);
1669	if (IS_ERR(info->charger)) {
1670		dev_err(dev, "Failed to register charger\n");
1671		ret = PTR_ERR(info->charger);
1672		goto put_usb_notifier;
1673	}
1674
1675	ret = devm_request_threaded_irq(dev, client->irq, NULL,
1676					rt9455_irq_handler_thread,
1677					IRQF_TRIGGER_LOW | IRQF_ONESHOT,
1678					RT9455_DRIVER_NAME, info);
1679	if (ret) {
1680		dev_err(dev, "Failed to register IRQ handler\n");
1681		goto put_usb_notifier;
1682	}
1683
1684	ret = rt9455_hw_init(info, ichrg, ieoc_percentage, mivr, iaicr);
1685	if (ret) {
1686		dev_err(dev, "Failed to set charger to its default values\n");
1687		goto put_usb_notifier;
1688	}
1689
1690	return 0;
1691
1692put_usb_notifier:
1693#if IS_ENABLED(CONFIG_USB_PHY)
1694	if (info->nb.notifier_call)  {
1695		usb_unregister_notifier(info->usb_phy, &info->nb);
1696		info->nb.notifier_call = NULL;
1697	}
1698#endif
1699	return ret;
1700}
1701
1702static void rt9455_remove(struct i2c_client *client)
1703{
1704	int ret;
1705	struct rt9455_info *info = i2c_get_clientdata(client);
1706
1707	ret = rt9455_register_reset(info);
1708	if (ret)
1709		dev_err(&info->client->dev, "Failed to set charger to its default values\n");
1710
1711#if IS_ENABLED(CONFIG_USB_PHY)
1712	if (info->nb.notifier_call)
1713		usb_unregister_notifier(info->usb_phy, &info->nb);
1714#endif
1715
1716	cancel_delayed_work_sync(&info->pwr_rdy_work);
1717	cancel_delayed_work_sync(&info->max_charging_time_work);
1718	cancel_delayed_work_sync(&info->batt_presence_work);
1719}
1720
1721static const struct i2c_device_id rt9455_i2c_id_table[] = {
1722	{ RT9455_DRIVER_NAME },
1723	{ }
1724};
1725MODULE_DEVICE_TABLE(i2c, rt9455_i2c_id_table);
1726
1727static const struct of_device_id rt9455_of_match[] __maybe_unused = {
1728	{ .compatible = "richtek,rt9455", },
1729	{ },
1730};
1731MODULE_DEVICE_TABLE(of, rt9455_of_match);
1732
1733#ifdef CONFIG_ACPI
1734static const struct acpi_device_id rt9455_i2c_acpi_match[] = {
1735	{ "RT945500", 0 },
1736	{ }
1737};
1738MODULE_DEVICE_TABLE(acpi, rt9455_i2c_acpi_match);
1739#endif
1740
1741static struct i2c_driver rt9455_driver = {
1742	.probe		= rt9455_probe,
1743	.remove		= rt9455_remove,
1744	.id_table	= rt9455_i2c_id_table,
1745	.driver = {
1746		.name		= RT9455_DRIVER_NAME,
1747		.of_match_table	= of_match_ptr(rt9455_of_match),
1748		.acpi_match_table = ACPI_PTR(rt9455_i2c_acpi_match),
1749	},
1750};
1751module_i2c_driver(rt9455_driver);
1752
1753MODULE_LICENSE("GPL");
1754MODULE_AUTHOR("Anda-Maria Nicolae <anda-maria.nicolae@intel.com>");
1755MODULE_DESCRIPTION("Richtek RT9455 Charger Driver");