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