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