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