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