]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - drivers/power/supply/rt9455_charger.c
projects / mirror_ubuntu-eoan-kernel.git / blob
? search:


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