]>
Commit | Line | Data |
---|---|---|
e86d69dd AMN |
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 | ||
69 | enum 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 | ||
104 | static 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 */ | |
185 | static 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 */ | |
194 | static 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 */ | |
210 | static 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 */ | |
222 | static 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) */ | |
228 | static const int rt9455_ieoc_percentage_values[] = { | |
229 | 10, 30, 20, 30 | |
230 | }; | |
231 | ||
232 | /* REG05[1:0] (MIVR) in uV */ | |
233 | static const int rt9455_mivr_values[] = { | |
234 | 4000000, 4250000, 4500000, 5000000 | |
235 | }; | |
236 | ||
237 | /* REG05[1:0] (IAICR) in uA */ | |
238 | static const int rt9455_iaicr_values[] = { | |
239 | 100000, 500000, 1000000, 2000000 | |
240 | }; | |
241 | ||
242 | struct 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 | */ | |
263 | static 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 | ||
280 | static 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 | ||
297 | static 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 | ||
306 | static 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 */ | |
342 | static 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 | ||
357 | static char *rt9455_charger_supplied_to[] = { | |
358 | "main-battery", | |
359 | }; | |
360 | ||
361 | static 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 | ||
413 | static 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 | ||
493 | static 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 | ||
514 | static 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 | ||
531 | static 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 | ||
551 | static 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 | ||
561 | static 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 | ||
581 | static 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 | ||
591 | static 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 | ||
620 | static 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 | ||
659 | static 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 | ||
fb323ecc | 807 | #if IS_ENABLED(CONFIG_USB_PHY) |
e86d69dd AMN |
808 | /* |
809 | * Before setting the charger into boost mode, boost output voltage is | |
810 | * set. This is needed because boost output voltage may differ from battery | |
811 | * regulation voltage. F_VOREG bits represent either battery regulation voltage | |
812 | * or boost output voltage, depending on the mode the charger is. Both battery | |
813 | * regulation voltage and boost output voltage are read from DT/ACPI during | |
814 | * probe. | |
815 | */ | |
816 | static int rt9455_set_boost_voltage_before_boost_mode(struct rt9455_info *info) | |
817 | { | |
818 | struct device *dev = &info->client->dev; | |
819 | int ret; | |
820 | ||
821 | ret = rt9455_set_field_val(info, F_VOREG, | |
822 | rt9455_boost_voltage_values, | |
823 | ARRAY_SIZE(rt9455_boost_voltage_values), | |
824 | info->boost_voltage); | |
825 | if (ret) { | |
826 | dev_err(dev, "Failed to set boost output voltage value\n"); | |
827 | return ret; | |
828 | } | |
829 | ||
830 | return 0; | |
831 | } | |
fb323ecc | 832 | #endif |
e86d69dd AMN |
833 | |
834 | /* | |
835 | * Before setting the charger into charge mode, battery regulation voltage is | |
836 | * set. This is needed because boost output voltage may differ from battery | |
837 | * regulation voltage. F_VOREG bits represent either battery regulation voltage | |
838 | * or boost output voltage, depending on the mode the charger is. Both battery | |
839 | * regulation voltage and boost output voltage are read from DT/ACPI during | |
840 | * probe. | |
841 | */ | |
842 | static int rt9455_set_voreg_before_charge_mode(struct rt9455_info *info) | |
843 | { | |
844 | struct device *dev = &info->client->dev; | |
845 | int ret; | |
846 | ||
847 | ret = rt9455_set_field_val(info, F_VOREG, | |
848 | rt9455_voreg_values, | |
849 | ARRAY_SIZE(rt9455_voreg_values), | |
850 | info->voreg); | |
851 | if (ret) { | |
852 | dev_err(dev, "Failed to set VOREG value\n"); | |
853 | return ret; | |
854 | } | |
855 | ||
856 | return 0; | |
857 | } | |
858 | ||
859 | static int rt9455_irq_handler_check_irq1_register(struct rt9455_info *info, | |
860 | bool *_is_battery_absent, | |
861 | bool *_alert_userspace) | |
862 | { | |
863 | unsigned int irq1, mask1, mask2; | |
864 | struct device *dev = &info->client->dev; | |
865 | bool is_battery_absent = false; | |
866 | bool alert_userspace = false; | |
867 | int ret; | |
868 | ||
869 | ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1); | |
870 | if (ret) { | |
871 | dev_err(dev, "Failed to read IRQ1 register\n"); | |
872 | return ret; | |
873 | } | |
874 | ||
875 | ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1); | |
876 | if (ret) { | |
877 | dev_err(dev, "Failed to read MASK1 register\n"); | |
878 | return ret; | |
879 | } | |
880 | ||
881 | if (irq1 & GET_MASK(F_TSDI)) { | |
882 | dev_err(dev, "Thermal shutdown fault occurred\n"); | |
883 | alert_userspace = true; | |
884 | } | |
885 | ||
886 | if (irq1 & GET_MASK(F_VINOVPI)) { | |
887 | dev_err(dev, "Overvoltage input occurred\n"); | |
888 | alert_userspace = true; | |
889 | } | |
890 | ||
891 | if (irq1 & GET_MASK(F_BATAB)) { | |
892 | dev_err(dev, "Battery absence occurred\n"); | |
893 | is_battery_absent = true; | |
894 | alert_userspace = true; | |
895 | ||
896 | if ((mask1 & GET_MASK(F_BATABM)) == 0) { | |
897 | ret = regmap_field_write(info->regmap_fields[F_BATABM], | |
898 | 0x01); | |
899 | if (ret) { | |
900 | dev_err(dev, "Failed to mask BATAB interrupt\n"); | |
901 | return ret; | |
902 | } | |
903 | } | |
904 | ||
905 | ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2); | |
906 | if (ret) { | |
907 | dev_err(dev, "Failed to read MASK2 register\n"); | |
908 | return ret; | |
909 | } | |
910 | ||
911 | if (mask2 & GET_MASK(F_CHTERMIM)) { | |
912 | ret = regmap_field_write( | |
913 | info->regmap_fields[F_CHTERMIM], 0x00); | |
914 | if (ret) { | |
915 | dev_err(dev, "Failed to unmask CHTERMI interrupt\n"); | |
916 | return ret; | |
917 | } | |
918 | } | |
919 | ||
920 | if (mask2 & GET_MASK(F_CHRCHGIM)) { | |
921 | ret = regmap_field_write( | |
922 | info->regmap_fields[F_CHRCHGIM], 0x00); | |
923 | if (ret) { | |
924 | dev_err(dev, "Failed to unmask CHRCHGI interrupt\n"); | |
925 | return ret; | |
926 | } | |
927 | } | |
928 | ||
929 | /* | |
930 | * When the battery is absent, max_charging_time_work is | |
931 | * cancelled, since no charging is done. | |
932 | */ | |
933 | cancel_delayed_work_sync(&info->max_charging_time_work); | |
934 | /* | |
935 | * Since no interrupt is triggered when the battery is | |
936 | * reconnected, max_charging_time_work is not rescheduled. | |
937 | * Therefore, batt_presence_work is scheduled to check whether | |
938 | * the battery is still absent or not. | |
939 | */ | |
940 | queue_delayed_work(system_power_efficient_wq, | |
941 | &info->batt_presence_work, | |
942 | RT9455_BATT_PRESENCE_DELAY * HZ); | |
943 | } | |
944 | ||
945 | *_is_battery_absent = is_battery_absent; | |
946 | ||
947 | if (alert_userspace) | |
948 | *_alert_userspace = alert_userspace; | |
949 | ||
950 | return 0; | |
951 | } | |
952 | ||
953 | static int rt9455_irq_handler_check_irq2_register(struct rt9455_info *info, | |
954 | bool is_battery_absent, | |
955 | bool *_alert_userspace) | |
956 | { | |
957 | unsigned int irq2, mask2; | |
958 | struct device *dev = &info->client->dev; | |
959 | bool alert_userspace = false; | |
960 | int ret; | |
961 | ||
962 | ret = regmap_read(info->regmap, RT9455_REG_IRQ2, &irq2); | |
963 | if (ret) { | |
964 | dev_err(dev, "Failed to read IRQ2 register\n"); | |
965 | return ret; | |
966 | } | |
967 | ||
968 | ret = regmap_read(info->regmap, RT9455_REG_MASK2, &mask2); | |
969 | if (ret) { | |
970 | dev_err(dev, "Failed to read MASK2 register\n"); | |
971 | return ret; | |
972 | } | |
973 | ||
974 | if (irq2 & GET_MASK(F_CHRVPI)) { | |
975 | dev_dbg(dev, "Charger fault occurred\n"); | |
e86d69dd AMN |
976 | /* |
977 | * CHRVPI bit is set in 2 cases: | |
978 | * 1. when the power source is connected to the charger. | |
979 | * 2. when the power source is disconnected from the charger. | |
980 | * To identify the case, PWR_RDY bit is checked. Because | |
981 | * PWR_RDY bit is set / cleared after CHRVPI interrupt is | |
982 | * triggered, it is used delayed_work to later read PWR_RDY bit. | |
f5bbc91c AMN |
983 | * Also, do not set to true alert_userspace, because there is no |
984 | * need to notify userspace when CHRVPI interrupt has occurred. | |
985 | * Userspace will be notified after PWR_RDY bit is read. | |
e86d69dd AMN |
986 | */ |
987 | queue_delayed_work(system_power_efficient_wq, | |
988 | &info->pwr_rdy_work, | |
989 | RT9455_PWR_RDY_DELAY * HZ); | |
990 | } | |
991 | if (irq2 & GET_MASK(F_CHBATOVI)) { | |
992 | dev_err(dev, "Battery OVP occurred\n"); | |
993 | alert_userspace = true; | |
994 | } | |
995 | if (irq2 & GET_MASK(F_CHTERMI)) { | |
996 | dev_dbg(dev, "Charge terminated\n"); | |
997 | if (!is_battery_absent) { | |
998 | if ((mask2 & GET_MASK(F_CHTERMIM)) == 0) { | |
999 | ret = regmap_field_write( | |
1000 | info->regmap_fields[F_CHTERMIM], 0x01); | |
1001 | if (ret) { | |
1002 | dev_err(dev, "Failed to mask CHTERMI interrupt\n"); | |
1003 | return ret; | |
1004 | } | |
1005 | /* | |
1006 | * Update MASK2 value, since CHTERMIM bit is | |
1007 | * set. | |
1008 | */ | |
1009 | mask2 = mask2 | GET_MASK(F_CHTERMIM); | |
1010 | } | |
1011 | cancel_delayed_work_sync(&info->max_charging_time_work); | |
1012 | alert_userspace = true; | |
1013 | } | |
1014 | } | |
1015 | if (irq2 & GET_MASK(F_CHRCHGI)) { | |
1016 | dev_dbg(dev, "Recharge request\n"); | |
1017 | ret = regmap_field_write(info->regmap_fields[F_CHG_EN], | |
1018 | RT9455_CHARGE_ENABLE); | |
1019 | if (ret) { | |
1020 | dev_err(dev, "Failed to enable charging\n"); | |
1021 | return ret; | |
1022 | } | |
1023 | if (mask2 & GET_MASK(F_CHTERMIM)) { | |
1024 | ret = regmap_field_write( | |
1025 | info->regmap_fields[F_CHTERMIM], 0x00); | |
1026 | if (ret) { | |
1027 | dev_err(dev, "Failed to unmask CHTERMI interrupt\n"); | |
1028 | return ret; | |
1029 | } | |
1030 | /* Update MASK2 value, since CHTERMIM bit is cleared. */ | |
1031 | mask2 = mask2 & ~GET_MASK(F_CHTERMIM); | |
1032 | } | |
1033 | if (!is_battery_absent) { | |
1034 | /* | |
1035 | * No need to check whether the charger is connected to | |
1036 | * power source when CHRCHGI is received, since CHRCHGI | |
1037 | * is not triggered if the charger is not connected to | |
1038 | * the power source. | |
1039 | */ | |
1040 | queue_delayed_work(system_power_efficient_wq, | |
1041 | &info->max_charging_time_work, | |
1042 | RT9455_MAX_CHARGING_TIME * HZ); | |
1043 | alert_userspace = true; | |
1044 | } | |
1045 | } | |
1046 | if (irq2 & GET_MASK(F_CH32MI)) { | |
1047 | dev_err(dev, "Charger fault. 32 mins timeout occurred\n"); | |
1048 | alert_userspace = true; | |
1049 | } | |
1050 | if (irq2 & GET_MASK(F_CHTREGI)) { | |
1051 | dev_warn(dev, | |
1052 | "Charger warning. Thermal regulation loop active\n"); | |
1053 | alert_userspace = true; | |
1054 | } | |
1055 | if (irq2 & GET_MASK(F_CHMIVRI)) { | |
1056 | dev_dbg(dev, | |
1057 | "Charger warning. Input voltage MIVR loop active\n"); | |
1058 | } | |
1059 | ||
1060 | if (alert_userspace) | |
1061 | *_alert_userspace = alert_userspace; | |
1062 | ||
1063 | return 0; | |
1064 | } | |
1065 | ||
1066 | static int rt9455_irq_handler_check_irq3_register(struct rt9455_info *info, | |
1067 | bool *_alert_userspace) | |
1068 | { | |
1069 | unsigned int irq3, mask3; | |
1070 | struct device *dev = &info->client->dev; | |
1071 | bool alert_userspace = false; | |
1072 | int ret; | |
1073 | ||
1074 | ret = regmap_read(info->regmap, RT9455_REG_IRQ3, &irq3); | |
1075 | if (ret) { | |
1076 | dev_err(dev, "Failed to read IRQ3 register\n"); | |
1077 | return ret; | |
1078 | } | |
1079 | ||
1080 | ret = regmap_read(info->regmap, RT9455_REG_MASK3, &mask3); | |
1081 | if (ret) { | |
1082 | dev_err(dev, "Failed to read MASK3 register\n"); | |
1083 | return ret; | |
1084 | } | |
1085 | ||
1086 | if (irq3 & GET_MASK(F_BSTBUSOVI)) { | |
1087 | dev_err(dev, "Boost fault. Overvoltage input occurred\n"); | |
1088 | alert_userspace = true; | |
1089 | } | |
1090 | if (irq3 & GET_MASK(F_BSTOLI)) { | |
1091 | dev_err(dev, "Boost fault. Overload\n"); | |
1092 | alert_userspace = true; | |
1093 | } | |
1094 | if (irq3 & GET_MASK(F_BSTLOWVI)) { | |
1095 | dev_err(dev, "Boost fault. Battery voltage too low\n"); | |
1096 | alert_userspace = true; | |
1097 | } | |
1098 | if (irq3 & GET_MASK(F_BST32SI)) { | |
1099 | dev_err(dev, "Boost fault. 32 seconds timeout occurred.\n"); | |
1100 | alert_userspace = true; | |
1101 | } | |
1102 | ||
1103 | if (alert_userspace) { | |
1104 | dev_info(dev, "Boost fault occurred, therefore the charger goes into charge mode\n"); | |
1105 | ret = rt9455_set_voreg_before_charge_mode(info); | |
1106 | if (ret) { | |
1107 | dev_err(dev, "Failed to set VOREG before entering charge mode\n"); | |
1108 | return ret; | |
1109 | } | |
1110 | ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], | |
1111 | RT9455_CHARGE_MODE); | |
1112 | if (ret) { | |
1113 | dev_err(dev, "Failed to set charger in charge mode\n"); | |
1114 | return ret; | |
1115 | } | |
1116 | *_alert_userspace = alert_userspace; | |
1117 | } | |
1118 | ||
1119 | return 0; | |
1120 | } | |
1121 | ||
1122 | static irqreturn_t rt9455_irq_handler_thread(int irq, void *data) | |
1123 | { | |
1124 | struct rt9455_info *info = data; | |
1125 | struct device *dev; | |
1126 | bool alert_userspace = false; | |
1127 | bool is_battery_absent = false; | |
1128 | unsigned int status; | |
1129 | int ret; | |
1130 | ||
1131 | if (!info) | |
1132 | return IRQ_NONE; | |
1133 | ||
1134 | dev = &info->client->dev; | |
1135 | ||
1136 | if (irq != info->client->irq) { | |
1137 | dev_err(dev, "Interrupt is not for RT9455 charger\n"); | |
1138 | return IRQ_NONE; | |
1139 | } | |
1140 | ||
1141 | ret = regmap_field_read(info->regmap_fields[F_STAT], &status); | |
1142 | if (ret) { | |
1143 | dev_err(dev, "Failed to read STAT bits\n"); | |
1144 | return IRQ_HANDLED; | |
1145 | } | |
1146 | dev_dbg(dev, "Charger status is %d\n", status); | |
1147 | ||
1148 | /* | |
1149 | * Each function that processes an IRQ register receives as output | |
1150 | * parameter alert_userspace pointer. alert_userspace is set to true | |
1151 | * in such a function only if an interrupt has occurred in the | |
1152 | * respective interrupt register. This way, it is avoided the following | |
1153 | * case: interrupt occurs only in IRQ1 register, | |
1154 | * rt9455_irq_handler_check_irq1_register() function sets to true | |
1155 | * alert_userspace, but rt9455_irq_handler_check_irq2_register() | |
1156 | * and rt9455_irq_handler_check_irq3_register() functions set to false | |
1157 | * alert_userspace and power_supply_changed() is never called. | |
1158 | */ | |
1159 | ret = rt9455_irq_handler_check_irq1_register(info, &is_battery_absent, | |
1160 | &alert_userspace); | |
1161 | if (ret) { | |
1162 | dev_err(dev, "Failed to handle IRQ1 register\n"); | |
1163 | return IRQ_HANDLED; | |
1164 | } | |
1165 | ||
1166 | ret = rt9455_irq_handler_check_irq2_register(info, is_battery_absent, | |
1167 | &alert_userspace); | |
1168 | if (ret) { | |
1169 | dev_err(dev, "Failed to handle IRQ2 register\n"); | |
1170 | return IRQ_HANDLED; | |
1171 | } | |
1172 | ||
1173 | ret = rt9455_irq_handler_check_irq3_register(info, &alert_userspace); | |
1174 | if (ret) { | |
1175 | dev_err(dev, "Failed to handle IRQ3 register\n"); | |
1176 | return IRQ_HANDLED; | |
1177 | } | |
1178 | ||
1179 | if (alert_userspace) { | |
1180 | /* | |
1181 | * Sometimes, an interrupt occurs while rt9455_probe() function | |
1182 | * is executing and power_supply_register() is not yet called. | |
f5bbc91c | 1183 | * Do not call power_supply_changed() in this case. |
e86d69dd AMN |
1184 | */ |
1185 | if (info->charger) | |
1186 | power_supply_changed(info->charger); | |
1187 | } | |
1188 | ||
1189 | return IRQ_HANDLED; | |
1190 | } | |
1191 | ||
1192 | static int rt9455_discover_charger(struct rt9455_info *info, u32 *ichrg, | |
1193 | u32 *ieoc_percentage, | |
1194 | u32 *mivr, u32 *iaicr) | |
1195 | { | |
1196 | struct device *dev = &info->client->dev; | |
1197 | int ret; | |
1198 | ||
1199 | if (!dev->of_node && !ACPI_HANDLE(dev)) { | |
1200 | dev_err(dev, "No support for either device tree or ACPI\n"); | |
1201 | return -EINVAL; | |
1202 | } | |
1203 | /* | |
1204 | * ICHRG, IEOC_PERCENTAGE, VOREG and boost output voltage are mandatory | |
1205 | * parameters. | |
1206 | */ | |
1207 | ret = device_property_read_u32(dev, "richtek,output-charge-current", | |
1208 | ichrg); | |
1209 | if (ret) { | |
1210 | dev_err(dev, "Error: missing \"output-charge-current\" property\n"); | |
1211 | return ret; | |
1212 | } | |
1213 | ||
1214 | ret = device_property_read_u32(dev, "richtek,end-of-charge-percentage", | |
1215 | ieoc_percentage); | |
1216 | if (ret) { | |
1217 | dev_err(dev, "Error: missing \"end-of-charge-percentage\" property\n"); | |
1218 | return ret; | |
1219 | } | |
1220 | ||
1221 | ret = device_property_read_u32(dev, | |
1222 | "richtek,battery-regulation-voltage", | |
1223 | &info->voreg); | |
1224 | if (ret) { | |
1225 | dev_err(dev, "Error: missing \"battery-regulation-voltage\" property\n"); | |
1226 | return ret; | |
1227 | } | |
1228 | ||
1229 | ret = device_property_read_u32(dev, "richtek,boost-output-voltage", | |
1230 | &info->boost_voltage); | |
1231 | if (ret) { | |
1232 | dev_err(dev, "Error: missing \"boost-output-voltage\" property\n"); | |
1233 | return ret; | |
1234 | } | |
1235 | ||
1236 | /* | |
1237 | * MIVR and IAICR are optional parameters. Do not return error if one of | |
1238 | * them is not present in ACPI table or device tree specification. | |
1239 | */ | |
1240 | device_property_read_u32(dev, "richtek,min-input-voltage-regulation", | |
1241 | mivr); | |
1242 | device_property_read_u32(dev, "richtek,avg-input-current-regulation", | |
1243 | iaicr); | |
1244 | ||
1245 | return 0; | |
1246 | } | |
1247 | ||
fb323ecc | 1248 | #if IS_ENABLED(CONFIG_USB_PHY) |
e86d69dd AMN |
1249 | static int rt9455_usb_event_none(struct rt9455_info *info, |
1250 | u8 opa_mode, u8 iaicr) | |
1251 | { | |
1252 | struct device *dev = &info->client->dev; | |
1253 | int ret; | |
1254 | ||
1255 | if (opa_mode == RT9455_BOOST_MODE) { | |
1256 | ret = rt9455_set_voreg_before_charge_mode(info); | |
1257 | if (ret) { | |
1258 | dev_err(dev, "Failed to set VOREG before entering charge mode\n"); | |
1259 | return ret; | |
1260 | } | |
1261 | /* | |
1262 | * If the charger is in boost mode, and it has received | |
1263 | * USB_EVENT_NONE, this means the consumer device powered by the | |
1264 | * charger is not connected anymore. | |
1265 | * In this case, the charger goes into charge mode. | |
1266 | */ | |
1267 | dev_dbg(dev, "USB_EVENT_NONE received, therefore the charger goes into charge mode\n"); | |
1268 | ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], | |
1269 | RT9455_CHARGE_MODE); | |
1270 | if (ret) { | |
1271 | dev_err(dev, "Failed to set charger in charge mode\n"); | |
1272 | return NOTIFY_DONE; | |
1273 | } | |
1274 | } | |
1275 | ||
1276 | dev_dbg(dev, "USB_EVENT_NONE received, therefore IAICR is set to its minimum value\n"); | |
1277 | if (iaicr != RT9455_IAICR_100MA) { | |
1278 | ret = regmap_field_write(info->regmap_fields[F_IAICR], | |
1279 | RT9455_IAICR_100MA); | |
1280 | if (ret) { | |
1281 | dev_err(dev, "Failed to set IAICR value\n"); | |
1282 | return NOTIFY_DONE; | |
1283 | } | |
1284 | } | |
1285 | ||
1286 | return NOTIFY_OK; | |
1287 | } | |
1288 | ||
1289 | static int rt9455_usb_event_vbus(struct rt9455_info *info, | |
1290 | u8 opa_mode, u8 iaicr) | |
1291 | { | |
1292 | struct device *dev = &info->client->dev; | |
1293 | int ret; | |
1294 | ||
1295 | if (opa_mode == RT9455_BOOST_MODE) { | |
1296 | ret = rt9455_set_voreg_before_charge_mode(info); | |
1297 | if (ret) { | |
1298 | dev_err(dev, "Failed to set VOREG before entering charge mode\n"); | |
1299 | return ret; | |
1300 | } | |
1301 | /* | |
1302 | * If the charger is in boost mode, and it has received | |
1303 | * USB_EVENT_VBUS, this means the consumer device powered by the | |
1304 | * charger is not connected anymore. | |
1305 | * In this case, the charger goes into charge mode. | |
1306 | */ | |
1307 | dev_dbg(dev, "USB_EVENT_VBUS received, therefore the charger goes into charge mode\n"); | |
1308 | ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], | |
1309 | RT9455_CHARGE_MODE); | |
1310 | if (ret) { | |
1311 | dev_err(dev, "Failed to set charger in charge mode\n"); | |
1312 | return NOTIFY_DONE; | |
1313 | } | |
1314 | } | |
1315 | ||
1316 | dev_dbg(dev, "USB_EVENT_VBUS received, therefore IAICR is set to 500 mA\n"); | |
1317 | if (iaicr != RT9455_IAICR_500MA) { | |
1318 | ret = regmap_field_write(info->regmap_fields[F_IAICR], | |
1319 | RT9455_IAICR_500MA); | |
1320 | if (ret) { | |
1321 | dev_err(dev, "Failed to set IAICR value\n"); | |
1322 | return NOTIFY_DONE; | |
1323 | } | |
1324 | } | |
1325 | ||
1326 | return NOTIFY_OK; | |
1327 | } | |
1328 | ||
1329 | static int rt9455_usb_event_id(struct rt9455_info *info, | |
1330 | u8 opa_mode, u8 iaicr) | |
1331 | { | |
1332 | struct device *dev = &info->client->dev; | |
1333 | int ret; | |
1334 | ||
1335 | if (opa_mode == RT9455_CHARGE_MODE) { | |
1336 | ret = rt9455_set_boost_voltage_before_boost_mode(info); | |
1337 | if (ret) { | |
1338 | dev_err(dev, "Failed to set boost output voltage before entering boost mode\n"); | |
1339 | return ret; | |
1340 | } | |
1341 | /* | |
1342 | * If the charger is in charge mode, and it has received | |
1343 | * USB_EVENT_ID, this means a consumer device is connected and | |
1344 | * it should be powered by the charger. | |
1345 | * In this case, the charger goes into boost mode. | |
1346 | */ | |
1347 | dev_dbg(dev, "USB_EVENT_ID received, therefore the charger goes into boost mode\n"); | |
1348 | ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], | |
1349 | RT9455_BOOST_MODE); | |
1350 | if (ret) { | |
1351 | dev_err(dev, "Failed to set charger in boost mode\n"); | |
1352 | return NOTIFY_DONE; | |
1353 | } | |
1354 | } | |
1355 | ||
1356 | dev_dbg(dev, "USB_EVENT_ID received, therefore IAICR is set to its minimum value\n"); | |
1357 | if (iaicr != RT9455_IAICR_100MA) { | |
1358 | ret = regmap_field_write(info->regmap_fields[F_IAICR], | |
1359 | RT9455_IAICR_100MA); | |
1360 | if (ret) { | |
1361 | dev_err(dev, "Failed to set IAICR value\n"); | |
1362 | return NOTIFY_DONE; | |
1363 | } | |
1364 | } | |
1365 | ||
1366 | return NOTIFY_OK; | |
1367 | } | |
1368 | ||
1369 | static int rt9455_usb_event_charger(struct rt9455_info *info, | |
1370 | u8 opa_mode, u8 iaicr) | |
1371 | { | |
1372 | struct device *dev = &info->client->dev; | |
1373 | int ret; | |
1374 | ||
1375 | if (opa_mode == RT9455_BOOST_MODE) { | |
1376 | ret = rt9455_set_voreg_before_charge_mode(info); | |
1377 | if (ret) { | |
1378 | dev_err(dev, "Failed to set VOREG before entering charge mode\n"); | |
1379 | return ret; | |
1380 | } | |
1381 | /* | |
1382 | * If the charger is in boost mode, and it has received | |
1383 | * USB_EVENT_CHARGER, this means the consumer device powered by | |
1384 | * the charger is not connected anymore. | |
1385 | * In this case, the charger goes into charge mode. | |
1386 | */ | |
1387 | dev_dbg(dev, "USB_EVENT_CHARGER received, therefore the charger goes into charge mode\n"); | |
1388 | ret = regmap_field_write(info->regmap_fields[F_OPA_MODE], | |
1389 | RT9455_CHARGE_MODE); | |
1390 | if (ret) { | |
1391 | dev_err(dev, "Failed to set charger in charge mode\n"); | |
1392 | return NOTIFY_DONE; | |
1393 | } | |
1394 | } | |
1395 | ||
1396 | dev_dbg(dev, "USB_EVENT_CHARGER received, therefore IAICR is set to no current limit\n"); | |
1397 | if (iaicr != RT9455_IAICR_NO_LIMIT) { | |
1398 | ret = regmap_field_write(info->regmap_fields[F_IAICR], | |
1399 | RT9455_IAICR_NO_LIMIT); | |
1400 | if (ret) { | |
1401 | dev_err(dev, "Failed to set IAICR value\n"); | |
1402 | return NOTIFY_DONE; | |
1403 | } | |
1404 | } | |
1405 | ||
1406 | return NOTIFY_OK; | |
1407 | } | |
1408 | ||
1409 | static int rt9455_usb_event(struct notifier_block *nb, | |
1410 | unsigned long event, void *power) | |
1411 | { | |
1412 | struct rt9455_info *info = container_of(nb, struct rt9455_info, nb); | |
1413 | struct device *dev = &info->client->dev; | |
1414 | unsigned int opa_mode, iaicr; | |
1415 | int ret; | |
1416 | ||
e86d69dd AMN |
1417 | /* |
1418 | * Determine whether the charger is in charge mode | |
1419 | * or in boost mode. | |
1420 | */ | |
1421 | ret = regmap_field_read(info->regmap_fields[F_OPA_MODE], | |
1422 | &opa_mode); | |
1423 | if (ret) { | |
1424 | dev_err(dev, "Failed to read OPA_MODE value\n"); | |
1425 | return NOTIFY_DONE; | |
1426 | } | |
1427 | ||
1428 | ret = regmap_field_read(info->regmap_fields[F_IAICR], | |
1429 | &iaicr); | |
1430 | if (ret) { | |
1431 | dev_err(dev, "Failed to read IAICR value\n"); | |
1432 | return NOTIFY_DONE; | |
1433 | } | |
1434 | ||
1435 | dev_dbg(dev, "Received USB event %lu\n", event); | |
1436 | switch (event) { | |
1437 | case USB_EVENT_NONE: | |
1438 | return rt9455_usb_event_none(info, opa_mode, iaicr); | |
1439 | case USB_EVENT_VBUS: | |
1440 | return rt9455_usb_event_vbus(info, opa_mode, iaicr); | |
1441 | case USB_EVENT_ID: | |
1442 | return rt9455_usb_event_id(info, opa_mode, iaicr); | |
1443 | case USB_EVENT_CHARGER: | |
1444 | return rt9455_usb_event_charger(info, opa_mode, iaicr); | |
1445 | default: | |
1446 | dev_err(dev, "Unknown USB event\n"); | |
1447 | } | |
1448 | return NOTIFY_DONE; | |
1449 | } | |
fb323ecc | 1450 | #endif |
e86d69dd AMN |
1451 | |
1452 | static void rt9455_pwr_rdy_work_callback(struct work_struct *work) | |
1453 | { | |
1454 | struct rt9455_info *info = container_of(work, struct rt9455_info, | |
1455 | pwr_rdy_work.work); | |
1456 | struct device *dev = &info->client->dev; | |
1457 | unsigned int pwr_rdy; | |
1458 | int ret; | |
1459 | ||
1460 | ret = regmap_field_read(info->regmap_fields[F_PWR_RDY], &pwr_rdy); | |
1461 | if (ret) { | |
1462 | dev_err(dev, "Failed to read PWR_RDY bit\n"); | |
1463 | return; | |
1464 | } | |
1465 | switch (pwr_rdy) { | |
1466 | case RT9455_PWR_FAULT: | |
1467 | dev_dbg(dev, "Charger disconnected from power source\n"); | |
1468 | cancel_delayed_work_sync(&info->max_charging_time_work); | |
1469 | break; | |
1470 | case RT9455_PWR_GOOD: | |
1471 | dev_dbg(dev, "Charger connected to power source\n"); | |
1472 | ret = regmap_field_write(info->regmap_fields[F_CHG_EN], | |
1473 | RT9455_CHARGE_ENABLE); | |
1474 | if (ret) { | |
1475 | dev_err(dev, "Failed to enable charging\n"); | |
1476 | return; | |
1477 | } | |
1478 | queue_delayed_work(system_power_efficient_wq, | |
1479 | &info->max_charging_time_work, | |
1480 | RT9455_MAX_CHARGING_TIME * HZ); | |
1481 | break; | |
1482 | } | |
f5bbc91c AMN |
1483 | /* |
1484 | * Notify userspace that the charger has been either connected to or | |
1485 | * disconnected from the power source. | |
1486 | */ | |
1487 | power_supply_changed(info->charger); | |
e86d69dd AMN |
1488 | } |
1489 | ||
1490 | static void rt9455_max_charging_time_work_callback(struct work_struct *work) | |
1491 | { | |
1492 | struct rt9455_info *info = container_of(work, struct rt9455_info, | |
1493 | max_charging_time_work.work); | |
1494 | struct device *dev = &info->client->dev; | |
1495 | int ret; | |
1496 | ||
1497 | 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"); | |
1498 | ret = regmap_field_write(info->regmap_fields[F_CHG_EN], | |
1499 | RT9455_CHARGE_DISABLE); | |
1500 | if (ret) | |
1501 | dev_err(dev, "Failed to disable charging\n"); | |
1502 | } | |
1503 | ||
1504 | static void rt9455_batt_presence_work_callback(struct work_struct *work) | |
1505 | { | |
1506 | struct rt9455_info *info = container_of(work, struct rt9455_info, | |
1507 | batt_presence_work.work); | |
1508 | struct device *dev = &info->client->dev; | |
1509 | unsigned int irq1, mask1; | |
1510 | int ret; | |
1511 | ||
1512 | ret = regmap_read(info->regmap, RT9455_REG_IRQ1, &irq1); | |
1513 | if (ret) { | |
1514 | dev_err(dev, "Failed to read IRQ1 register\n"); | |
1515 | return; | |
1516 | } | |
1517 | ||
1518 | /* | |
1519 | * If the battery is still absent, batt_presence_work is rescheduled. | |
1520 | * Otherwise, max_charging_time is scheduled. | |
1521 | */ | |
1522 | if (irq1 & GET_MASK(F_BATAB)) { | |
1523 | queue_delayed_work(system_power_efficient_wq, | |
1524 | &info->batt_presence_work, | |
1525 | RT9455_BATT_PRESENCE_DELAY * HZ); | |
1526 | } else { | |
1527 | queue_delayed_work(system_power_efficient_wq, | |
1528 | &info->max_charging_time_work, | |
1529 | RT9455_MAX_CHARGING_TIME * HZ); | |
1530 | ||
1531 | ret = regmap_read(info->regmap, RT9455_REG_MASK1, &mask1); | |
1532 | if (ret) { | |
1533 | dev_err(dev, "Failed to read MASK1 register\n"); | |
1534 | return; | |
1535 | } | |
1536 | ||
1537 | if (mask1 & GET_MASK(F_BATABM)) { | |
1538 | ret = regmap_field_write(info->regmap_fields[F_BATABM], | |
1539 | 0x00); | |
1540 | if (ret) | |
1541 | dev_err(dev, "Failed to unmask BATAB interrupt\n"); | |
1542 | } | |
f5bbc91c AMN |
1543 | /* |
1544 | * Notify userspace that the battery is now connected to the | |
1545 | * charger. | |
1546 | */ | |
1547 | power_supply_changed(info->charger); | |
e86d69dd AMN |
1548 | } |
1549 | } | |
1550 | ||
1551 | static const struct power_supply_desc rt9455_charger_desc = { | |
1552 | .name = RT9455_DRIVER_NAME, | |
1553 | .type = POWER_SUPPLY_TYPE_USB, | |
1554 | .properties = rt9455_charger_properties, | |
1555 | .num_properties = ARRAY_SIZE(rt9455_charger_properties), | |
1556 | .get_property = rt9455_charger_get_property, | |
1557 | }; | |
1558 | ||
1559 | static bool rt9455_is_writeable_reg(struct device *dev, unsigned int reg) | |
1560 | { | |
1561 | switch (reg) { | |
1562 | case RT9455_REG_DEV_ID: | |
1563 | case RT9455_REG_IRQ1: | |
1564 | case RT9455_REG_IRQ2: | |
1565 | case RT9455_REG_IRQ3: | |
1566 | return false; | |
1567 | default: | |
1568 | return true; | |
1569 | } | |
1570 | } | |
1571 | ||
1572 | static bool rt9455_is_volatile_reg(struct device *dev, unsigned int reg) | |
1573 | { | |
1574 | switch (reg) { | |
1575 | case RT9455_REG_DEV_ID: | |
1576 | case RT9455_REG_CTRL5: | |
1577 | case RT9455_REG_CTRL6: | |
1578 | return false; | |
1579 | default: | |
1580 | return true; | |
1581 | } | |
1582 | } | |
1583 | ||
1584 | static const struct regmap_config rt9455_regmap_config = { | |
1585 | .reg_bits = 8, | |
1586 | .val_bits = 8, | |
1587 | .writeable_reg = rt9455_is_writeable_reg, | |
1588 | .volatile_reg = rt9455_is_volatile_reg, | |
1589 | .max_register = RT9455_REG_MASK3, | |
1590 | .cache_type = REGCACHE_RBTREE, | |
1591 | }; | |
1592 | ||
1593 | static int rt9455_probe(struct i2c_client *client, | |
1594 | const struct i2c_device_id *id) | |
1595 | { | |
1596 | struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); | |
1597 | struct device *dev = &client->dev; | |
1598 | struct rt9455_info *info; | |
1599 | struct power_supply_config rt9455_charger_config = {}; | |
1600 | /* | |
1601 | * Mandatory device-specific data values. Also, VOREG and boost output | |
1602 | * voltage are mandatory values, but they are stored in rt9455_info | |
1603 | * structure. | |
1604 | */ | |
1605 | u32 ichrg, ieoc_percentage; | |
1606 | /* Optional device-specific data values. */ | |
1607 | u32 mivr = -1, iaicr = -1; | |
1608 | int i, ret; | |
1609 | ||
1610 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { | |
1611 | dev_err(dev, "No support for SMBUS_BYTE_DATA\n"); | |
1612 | return -ENODEV; | |
1613 | } | |
1614 | info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL); | |
1615 | if (!info) | |
1616 | return -ENOMEM; | |
1617 | ||
1618 | info->client = client; | |
1619 | i2c_set_clientdata(client, info); | |
1620 | ||
1621 | info->regmap = devm_regmap_init_i2c(client, | |
1622 | &rt9455_regmap_config); | |
1623 | if (IS_ERR(info->regmap)) { | |
1624 | dev_err(dev, "Failed to initialize register map\n"); | |
1625 | return -EINVAL; | |
1626 | } | |
1627 | ||
1628 | for (i = 0; i < F_MAX_FIELDS; i++) { | |
1629 | info->regmap_fields[i] = | |
1630 | devm_regmap_field_alloc(dev, info->regmap, | |
1631 | rt9455_reg_fields[i]); | |
1632 | if (IS_ERR(info->regmap_fields[i])) { | |
1633 | dev_err(dev, | |
1634 | "Failed to allocate regmap field = %d\n", i); | |
1635 | return PTR_ERR(info->regmap_fields[i]); | |
1636 | } | |
1637 | } | |
1638 | ||
1639 | ret = rt9455_discover_charger(info, &ichrg, &ieoc_percentage, | |
1640 | &mivr, &iaicr); | |
1641 | if (ret) { | |
1642 | dev_err(dev, "Failed to discover charger\n"); | |
1643 | return ret; | |
1644 | } | |
1645 | ||
1646 | #if IS_ENABLED(CONFIG_USB_PHY) | |
1647 | info->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2); | |
1648 | if (IS_ERR(info->usb_phy)) { | |
1649 | dev_err(dev, "Failed to get USB transceiver\n"); | |
1650 | } else { | |
1651 | info->nb.notifier_call = rt9455_usb_event; | |
1652 | ret = usb_register_notifier(info->usb_phy, &info->nb); | |
1653 | if (ret) { | |
1654 | dev_err(dev, "Failed to register USB notifier\n"); | |
1655 | /* | |
1656 | * If usb_register_notifier() fails, set notifier_call | |
1657 | * to NULL, to avoid calling usb_unregister_notifier(). | |
1658 | */ | |
1659 | info->nb.notifier_call = NULL; | |
1660 | } | |
1661 | } | |
1662 | #endif | |
1663 | ||
1664 | INIT_DEFERRABLE_WORK(&info->pwr_rdy_work, rt9455_pwr_rdy_work_callback); | |
1665 | INIT_DEFERRABLE_WORK(&info->max_charging_time_work, | |
1666 | rt9455_max_charging_time_work_callback); | |
1667 | INIT_DEFERRABLE_WORK(&info->batt_presence_work, | |
1668 | rt9455_batt_presence_work_callback); | |
1669 | ||
1670 | rt9455_charger_config.of_node = dev->of_node; | |
1671 | rt9455_charger_config.drv_data = info; | |
1672 | rt9455_charger_config.supplied_to = rt9455_charger_supplied_to; | |
1673 | rt9455_charger_config.num_supplicants = | |
1674 | ARRAY_SIZE(rt9455_charger_supplied_to); | |
1675 | ret = devm_request_threaded_irq(dev, client->irq, NULL, | |
1676 | rt9455_irq_handler_thread, | |
1677 | IRQF_TRIGGER_LOW | IRQF_ONESHOT, | |
1678 | RT9455_DRIVER_NAME, info); | |
1679 | if (ret) { | |
1680 | dev_err(dev, "Failed to register IRQ handler\n"); | |
1681 | goto put_usb_notifier; | |
1682 | } | |
1683 | ||
1684 | ret = rt9455_hw_init(info, ichrg, ieoc_percentage, mivr, iaicr); | |
1685 | if (ret) { | |
1686 | dev_err(dev, "Failed to set charger to its default values\n"); | |
1687 | goto put_usb_notifier; | |
1688 | } | |
1689 | ||
1690 | info->charger = devm_power_supply_register(dev, &rt9455_charger_desc, | |
1691 | &rt9455_charger_config); | |
1692 | if (IS_ERR(info->charger)) { | |
1693 | dev_err(dev, "Failed to register charger\n"); | |
1694 | ret = PTR_ERR(info->charger); | |
1695 | goto put_usb_notifier; | |
1696 | } | |
1697 | ||
1698 | return 0; | |
1699 | ||
1700 | put_usb_notifier: | |
1701 | #if IS_ENABLED(CONFIG_USB_PHY) | |
1702 | if (info->nb.notifier_call) { | |
1703 | usb_unregister_notifier(info->usb_phy, &info->nb); | |
1704 | info->nb.notifier_call = NULL; | |
1705 | } | |
1706 | #endif | |
1707 | return ret; | |
1708 | } | |
1709 | ||
1710 | static int rt9455_remove(struct i2c_client *client) | |
1711 | { | |
1712 | int ret; | |
1713 | struct rt9455_info *info = i2c_get_clientdata(client); | |
1714 | ||
1715 | ret = rt9455_register_reset(info); | |
1716 | if (ret) | |
1717 | dev_err(&info->client->dev, "Failed to set charger to its default values\n"); | |
1718 | ||
1719 | #if IS_ENABLED(CONFIG_USB_PHY) | |
1720 | if (info->nb.notifier_call) | |
1721 | usb_unregister_notifier(info->usb_phy, &info->nb); | |
1722 | #endif | |
1723 | ||
1724 | cancel_delayed_work_sync(&info->pwr_rdy_work); | |
1725 | cancel_delayed_work_sync(&info->max_charging_time_work); | |
1726 | cancel_delayed_work_sync(&info->batt_presence_work); | |
1727 | ||
1728 | return ret; | |
1729 | } | |
1730 | ||
1731 | static const struct i2c_device_id rt9455_i2c_id_table[] = { | |
1732 | { RT9455_DRIVER_NAME, 0 }, | |
1733 | { }, | |
1734 | }; | |
1735 | MODULE_DEVICE_TABLE(i2c, rt9455_i2c_id_table); | |
1736 | ||
1737 | static const struct of_device_id rt9455_of_match[] = { | |
1738 | { .compatible = "richtek,rt9455", }, | |
1739 | { }, | |
1740 | }; | |
1741 | MODULE_DEVICE_TABLE(of, rt9455_of_match); | |
1742 | ||
1743 | static const struct acpi_device_id rt9455_i2c_acpi_match[] = { | |
1744 | { "RT945500", 0 }, | |
1745 | { } | |
1746 | }; | |
1747 | MODULE_DEVICE_TABLE(acpi, rt9455_i2c_acpi_match); | |
1748 | ||
1749 | static struct i2c_driver rt9455_driver = { | |
1750 | .probe = rt9455_probe, | |
1751 | .remove = rt9455_remove, | |
1752 | .id_table = rt9455_i2c_id_table, | |
1753 | .driver = { | |
1754 | .name = RT9455_DRIVER_NAME, | |
1755 | .of_match_table = of_match_ptr(rt9455_of_match), | |
1756 | .acpi_match_table = ACPI_PTR(rt9455_i2c_acpi_match), | |
1757 | }, | |
1758 | }; | |
1759 | module_i2c_driver(rt9455_driver); | |
1760 | ||
1761 | MODULE_LICENSE("GPL"); | |
1762 | MODULE_AUTHOR("Anda-Maria Nicolae <anda-maria.nicolae@intel.com>"); | |
1763 | MODULE_ALIAS("i2c:rt9455-charger"); | |
1764 | MODULE_DESCRIPTION("Richtek RT9455 Charger Driver"); |