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 */
rt9455_find_idx(const int tbl[],int tbl_size,int v)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
rt9455_get_field_val(struct rt9455_info * info,enum rt9455_fields field,const int tbl[],int tbl_size,int * val)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
rt9455_set_field_val(struct rt9455_info * info,enum rt9455_fields field,const int tbl[],int tbl_size,int val)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
rt9455_register_reset(struct rt9455_info * info)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
rt9455_charger_get_status(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_health(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_battery_presence(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_online(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_current(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_current_max(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_voltage(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_voltage_max(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_term_current(struct rt9455_info * info,union power_supply_propval * val)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
rt9455_charger_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)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
rt9455_hw_init(struct rt9455_info * info,u32 ichrg,u32 ieoc_percentage,u32 mivr,u32 iaicr)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 */
rt9455_set_boost_voltage_before_boost_mode(struct rt9455_info * info)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 */
rt9455_set_voreg_before_charge_mode(struct rt9455_info * info)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
rt9455_irq_handler_check_irq1_register(struct rt9455_info * info,bool * _is_battery_absent,bool * _alert_userspace)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
rt9455_irq_handler_check_irq2_register(struct rt9455_info * info,bool is_battery_absent,bool * _alert_userspace)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
rt9455_irq_handler_check_irq3_register(struct rt9455_info * info,bool * _alert_userspace)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
rt9455_irq_handler_thread(int irq,void * data)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
rt9455_discover_charger(struct rt9455_info * info,u32 * ichrg,u32 * ieoc_percentage,u32 * mivr,u32 * iaicr)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)
rt9455_usb_event_none(struct rt9455_info * info,u8 opa_mode,u8 iaicr)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
rt9455_usb_event_vbus(struct rt9455_info * info,u8 opa_mode,u8 iaicr)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
rt9455_usb_event_id(struct rt9455_info * info,u8 opa_mode,u8 iaicr)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
rt9455_usb_event_charger(struct rt9455_info * info,u8 opa_mode,u8 iaicr)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
rt9455_usb_event(struct notifier_block * nb,unsigned long event,void * power)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
rt9455_pwr_rdy_work_callback(struct work_struct * work)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
rt9455_max_charging_time_work_callback(struct work_struct * work)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
rt9455_batt_presence_work_callback(struct work_struct * work)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
rt9455_is_writeable_reg(struct device * dev,unsigned int reg)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
rt9455_is_volatile_reg(struct device * dev,unsigned int reg)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
rt9455_probe(struct i2c_client * client)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
rt9455_remove(struct i2c_client * client)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