1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Summit Microelectronics SMB347 Battery Charger Driver |
4 | * |
5 | * Copyright (C) 2011, Intel Corporation |
6 | * |
7 | * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com> |
8 | * Mika Westerberg <mika.westerberg@linux.intel.com> |
9 | */ |
10 | |
11 | #include <linux/delay.h> |
12 | #include <linux/err.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/module.h> |
15 | #include <linux/init.h> |
16 | #include <linux/interrupt.h> |
17 | #include <linux/i2c.h> |
18 | #include <linux/power_supply.h> |
19 | #include <linux/property.h> |
20 | #include <linux/regmap.h> |
21 | #include <linux/regulator/driver.h> |
22 | |
23 | #include <dt-bindings/power/summit,smb347-charger.h> |
24 | |
25 | /* Use the default compensation method */ |
26 | #define SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT -1 |
27 | |
28 | /* Use default factory programmed value for hard/soft temperature limit */ |
29 | #define SMB3XX_TEMP_USE_DEFAULT -273 |
30 | |
31 | /* |
32 | * Configuration registers. These are mirrored to volatile RAM and can be |
33 | * written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be |
34 | * reloaded from non-volatile registers after POR. |
35 | */ |
36 | #define CFG_CHARGE_CURRENT 0x00 |
37 | #define CFG_CHARGE_CURRENT_FCC_MASK 0xe0 |
38 | #define CFG_CHARGE_CURRENT_FCC_SHIFT 5 |
39 | #define CFG_CHARGE_CURRENT_PCC_MASK 0x18 |
40 | #define CFG_CHARGE_CURRENT_PCC_SHIFT 3 |
41 | #define CFG_CHARGE_CURRENT_TC_MASK 0x07 |
42 | #define CFG_CURRENT_LIMIT 0x01 |
43 | #define CFG_CURRENT_LIMIT_DC_MASK 0xf0 |
44 | #define CFG_CURRENT_LIMIT_DC_SHIFT 4 |
45 | #define CFG_CURRENT_LIMIT_USB_MASK 0x0f |
46 | #define CFG_FLOAT_VOLTAGE 0x03 |
47 | #define CFG_FLOAT_VOLTAGE_FLOAT_MASK 0x3f |
48 | #define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK 0xc0 |
49 | #define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6 |
50 | #define CFG_STAT 0x05 |
51 | #define CFG_STAT_DISABLED BIT(5) |
52 | #define CFG_STAT_ACTIVE_HIGH BIT(7) |
53 | #define CFG_PIN 0x06 |
54 | #define CFG_PIN_EN_CTRL_MASK 0x60 |
55 | #define CFG_PIN_EN_CTRL_ACTIVE_HIGH 0x40 |
56 | #define CFG_PIN_EN_CTRL_ACTIVE_LOW 0x60 |
57 | #define CFG_PIN_EN_APSD_IRQ BIT(1) |
58 | #define CFG_PIN_EN_CHARGER_ERROR BIT(2) |
59 | #define CFG_PIN_EN_CTRL BIT(4) |
60 | #define CFG_THERM 0x07 |
61 | #define CFG_THERM_SOFT_HOT_COMPENSATION_MASK 0x03 |
62 | #define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0 |
63 | #define CFG_THERM_SOFT_COLD_COMPENSATION_MASK 0x0c |
64 | #define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2 |
65 | #define CFG_THERM_MONITOR_DISABLED BIT(4) |
66 | #define CFG_SYSOK 0x08 |
67 | #define CFG_SYSOK_INOK_ACTIVE_HIGH BIT(0) |
68 | #define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED BIT(2) |
69 | #define CFG_OTHER 0x09 |
70 | #define CFG_OTHER_RID_MASK 0xc0 |
71 | #define CFG_OTHER_RID_ENABLED_AUTO_OTG 0xc0 |
72 | #define CFG_OTG 0x0a |
73 | #define CFG_OTG_TEMP_THRESHOLD_MASK 0x30 |
74 | #define CFG_OTG_CURRENT_LIMIT_250mA BIT(2) |
75 | #define CFG_OTG_CURRENT_LIMIT_750mA BIT(3) |
76 | #define CFG_OTG_TEMP_THRESHOLD_SHIFT 4 |
77 | #define CFG_OTG_CC_COMPENSATION_MASK 0xc0 |
78 | #define CFG_OTG_CC_COMPENSATION_SHIFT 6 |
79 | #define CFG_TEMP_LIMIT 0x0b |
80 | #define CFG_TEMP_LIMIT_SOFT_HOT_MASK 0x03 |
81 | #define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0 |
82 | #define CFG_TEMP_LIMIT_SOFT_COLD_MASK 0x0c |
83 | #define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2 |
84 | #define CFG_TEMP_LIMIT_HARD_HOT_MASK 0x30 |
85 | #define CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4 |
86 | #define CFG_TEMP_LIMIT_HARD_COLD_MASK 0xc0 |
87 | #define CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6 |
88 | #define CFG_FAULT_IRQ 0x0c |
89 | #define CFG_FAULT_IRQ_DCIN_UV BIT(2) |
90 | #define CFG_STATUS_IRQ 0x0d |
91 | #define CFG_STATUS_IRQ_TERMINATION_OR_TAPER BIT(4) |
92 | #define CFG_STATUS_IRQ_CHARGE_TIMEOUT BIT(7) |
93 | #define CFG_ADDRESS 0x0e |
94 | |
95 | /* Command registers */ |
96 | #define CMD_A 0x30 |
97 | #define CMD_A_CHG_ENABLED BIT(1) |
98 | #define CMD_A_SUSPEND_ENABLED BIT(2) |
99 | #define CMD_A_OTG_ENABLED BIT(4) |
100 | #define CMD_A_ALLOW_WRITE BIT(7) |
101 | #define CMD_B 0x31 |
102 | #define CMD_C 0x33 |
103 | |
104 | /* Interrupt Status registers */ |
105 | #define IRQSTAT_A 0x35 |
106 | #define IRQSTAT_C 0x37 |
107 | #define IRQSTAT_C_TERMINATION_STAT BIT(0) |
108 | #define IRQSTAT_C_TERMINATION_IRQ BIT(1) |
109 | #define IRQSTAT_C_TAPER_IRQ BIT(3) |
110 | #define IRQSTAT_D 0x38 |
111 | #define IRQSTAT_D_CHARGE_TIMEOUT_STAT BIT(2) |
112 | #define IRQSTAT_D_CHARGE_TIMEOUT_IRQ BIT(3) |
113 | #define IRQSTAT_E 0x39 |
114 | #define IRQSTAT_E_USBIN_UV_STAT BIT(0) |
115 | #define IRQSTAT_E_USBIN_UV_IRQ BIT(1) |
116 | #define IRQSTAT_E_DCIN_UV_STAT BIT(4) |
117 | #define IRQSTAT_E_DCIN_UV_IRQ BIT(5) |
118 | #define IRQSTAT_F 0x3a |
119 | |
120 | /* Status registers */ |
121 | #define STAT_A 0x3b |
122 | #define STAT_A_FLOAT_VOLTAGE_MASK 0x3f |
123 | #define STAT_B 0x3c |
124 | #define STAT_C 0x3d |
125 | #define STAT_C_CHG_ENABLED BIT(0) |
126 | #define STAT_C_HOLDOFF_STAT BIT(3) |
127 | #define STAT_C_CHG_MASK 0x06 |
128 | #define STAT_C_CHG_SHIFT 1 |
129 | #define STAT_C_CHG_TERM BIT(5) |
130 | #define STAT_C_CHARGER_ERROR BIT(6) |
131 | #define STAT_E 0x3f |
132 | |
133 | #define SMB347_MAX_REGISTER 0x3f |
134 | |
135 | /** |
136 | * struct smb347_charger - smb347 charger instance |
137 | * @dev: pointer to device |
138 | * @regmap: pointer to driver regmap |
139 | * @mains: power_supply instance for AC/DC power |
140 | * @usb: power_supply instance for USB power |
141 | * @usb_rdev: USB VBUS regulator device |
142 | * @id: SMB charger ID |
143 | * @mains_online: is AC/DC input connected |
144 | * @usb_online: is USB input connected |
145 | * @irq_unsupported: is interrupt unsupported by SMB hardware |
146 | * @usb_vbus_enabled: is USB VBUS powered by SMB charger |
147 | * @max_charge_current: maximum current (in uA) the battery can be charged |
148 | * @max_charge_voltage: maximum voltage (in uV) the battery can be charged |
149 | * @pre_charge_current: current (in uA) to use in pre-charging phase |
150 | * @termination_current: current (in uA) used to determine when the |
151 | * charging cycle terminates |
152 | * @pre_to_fast_voltage: voltage (in uV) treshold used for transitioning to |
153 | * pre-charge to fast charge mode |
154 | * @mains_current_limit: maximum input current drawn from AC/DC input (in uA) |
155 | * @usb_hc_current_limit: maximum input high current (in uA) drawn from USB |
156 | * input |
157 | * @chip_temp_threshold: die temperature where device starts limiting charge |
158 | * current [%100 - %130] (in degree C) |
159 | * @soft_cold_temp_limit: soft cold temperature limit [%0 - %15] (in degree C), |
160 | * granularity is 5 deg C. |
161 | * @soft_hot_temp_limit: soft hot temperature limit [%40 - %55] (in degree C), |
162 | * granularity is 5 deg C. |
163 | * @hard_cold_temp_limit: hard cold temperature limit [%-5 - %10] (in degree C), |
164 | * granularity is 5 deg C. |
165 | * @hard_hot_temp_limit: hard hot temperature limit [%50 - %65] (in degree C), |
166 | * granularity is 5 deg C. |
167 | * @suspend_on_hard_temp_limit: suspend charging when hard limit is hit |
168 | * @soft_temp_limit_compensation: compensation method when soft temperature |
169 | * limit is hit |
170 | * @charge_current_compensation: current (in uA) for charging compensation |
171 | * current when temperature hits soft limits |
172 | * @use_mains: AC/DC input can be used |
173 | * @use_usb: USB input can be used |
174 | * @use_usb_otg: USB OTG output can be used (not implemented yet) |
175 | * @enable_control: how charging enable/disable is controlled |
176 | * (driver/pin controls) |
177 | * @inok_polarity: polarity of INOK signal which denotes presence of external |
178 | * power supply |
179 | * |
180 | * @use_main, @use_usb, and @use_usb_otg are means to enable/disable |
181 | * hardware support for these. This is useful when we want to have for |
182 | * example OTG charging controlled via OTG transceiver driver and not by |
183 | * the SMB347 hardware. |
184 | * |
185 | * Hard and soft temperature limit values are given as described in the |
186 | * device data sheet and assuming NTC beta value is %3750. Even if this is |
187 | * not the case, these values should be used. They can be mapped to the |
188 | * corresponding NTC beta values with the help of table %2 in the data |
189 | * sheet. So for example if NTC beta is %3375 and we want to program hard |
190 | * hot limit to be %53 deg C, @hard_hot_temp_limit should be set to %50. |
191 | * |
192 | * If zero value is given in any of the current and voltage values, the |
193 | * factory programmed default will be used. For soft/hard temperature |
194 | * values, pass in %SMB3XX_TEMP_USE_DEFAULT instead. |
195 | */ |
196 | struct smb347_charger { |
197 | struct device *dev; |
198 | struct regmap *regmap; |
199 | struct power_supply *mains; |
200 | struct power_supply *usb; |
201 | struct regulator_dev *usb_rdev; |
202 | unsigned int id; |
203 | bool mains_online; |
204 | bool usb_online; |
205 | bool irq_unsupported; |
206 | bool usb_vbus_enabled; |
207 | |
208 | unsigned int max_charge_current; |
209 | unsigned int max_charge_voltage; |
210 | unsigned int pre_charge_current; |
211 | unsigned int termination_current; |
212 | unsigned int pre_to_fast_voltage; |
213 | unsigned int mains_current_limit; |
214 | unsigned int usb_hc_current_limit; |
215 | unsigned int chip_temp_threshold; |
216 | int soft_cold_temp_limit; |
217 | int soft_hot_temp_limit; |
218 | int hard_cold_temp_limit; |
219 | int hard_hot_temp_limit; |
220 | bool suspend_on_hard_temp_limit; |
221 | unsigned int soft_temp_limit_compensation; |
222 | unsigned int charge_current_compensation; |
223 | bool use_mains; |
224 | bool use_usb; |
225 | bool use_usb_otg; |
226 | unsigned int enable_control; |
227 | unsigned int inok_polarity; |
228 | }; |
229 | |
230 | enum smb_charger_chipid { |
231 | SMB345, |
232 | SMB347, |
233 | SMB358, |
234 | NUM_CHIP_TYPES, |
235 | }; |
236 | |
237 | /* Fast charge current in uA */ |
238 | static const unsigned int fcc_tbl[NUM_CHIP_TYPES][8] = { |
239 | [SMB345] = { 200000, 450000, 600000, 900000, |
240 | 1300000, 1500000, 1800000, 2000000 }, |
241 | [SMB347] = { 700000, 900000, 1200000, 1500000, |
242 | 1800000, 2000000, 2200000, 2500000 }, |
243 | [SMB358] = { 200000, 450000, 600000, 900000, |
244 | 1300000, 1500000, 1800000, 2000000 }, |
245 | }; |
246 | /* Pre-charge current in uA */ |
247 | static const unsigned int pcc_tbl[NUM_CHIP_TYPES][4] = { |
248 | [SMB345] = { 150000, 250000, 350000, 450000 }, |
249 | [SMB347] = { 100000, 150000, 200000, 250000 }, |
250 | [SMB358] = { 150000, 250000, 350000, 450000 }, |
251 | }; |
252 | |
253 | /* Termination current in uA */ |
254 | static const unsigned int tc_tbl[NUM_CHIP_TYPES][8] = { |
255 | [SMB345] = { 30000, 40000, 60000, 80000, |
256 | 100000, 125000, 150000, 200000 }, |
257 | [SMB347] = { 37500, 50000, 100000, 150000, |
258 | 200000, 250000, 500000, 600000 }, |
259 | [SMB358] = { 30000, 40000, 60000, 80000, |
260 | 100000, 125000, 150000, 200000 }, |
261 | }; |
262 | |
263 | /* Input current limit in uA */ |
264 | static const unsigned int icl_tbl[NUM_CHIP_TYPES][10] = { |
265 | [SMB345] = { 300000, 500000, 700000, 1000000, 1500000, |
266 | 1800000, 2000000, 2000000, 2000000, 2000000 }, |
267 | [SMB347] = { 300000, 500000, 700000, 900000, 1200000, |
268 | 1500000, 1800000, 2000000, 2200000, 2500000 }, |
269 | [SMB358] = { 300000, 500000, 700000, 1000000, 1500000, |
270 | 1800000, 2000000, 2000000, 2000000, 2000000 }, |
271 | }; |
272 | |
273 | /* Charge current compensation in uA */ |
274 | static const unsigned int ccc_tbl[NUM_CHIP_TYPES][4] = { |
275 | [SMB345] = { 200000, 450000, 600000, 900000 }, |
276 | [SMB347] = { 250000, 700000, 900000, 1200000 }, |
277 | [SMB358] = { 200000, 450000, 600000, 900000 }, |
278 | }; |
279 | |
280 | /* Convert register value to current using lookup table */ |
281 | static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val) |
282 | { |
283 | if (val >= size) |
284 | return -EINVAL; |
285 | return tbl[val]; |
286 | } |
287 | |
288 | /* Convert current to register value using lookup table */ |
289 | static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val) |
290 | { |
291 | size_t i; |
292 | |
293 | for (i = 0; i < size; i++) |
294 | if (val < tbl[i]) |
295 | break; |
296 | return i > 0 ? i - 1 : -EINVAL; |
297 | } |
298 | |
299 | /** |
300 | * smb347_update_ps_status - refreshes the power source status |
301 | * @smb: pointer to smb347 charger instance |
302 | * |
303 | * Function checks whether any power source is connected to the charger and |
304 | * updates internal state accordingly. If there is a change to previous state |
305 | * function returns %1, otherwise %0 and negative errno in case of errror. |
306 | */ |
307 | static int smb347_update_ps_status(struct smb347_charger *smb) |
308 | { |
309 | bool usb = false; |
310 | bool dc = false; |
311 | unsigned int val; |
312 | int ret; |
313 | |
314 | ret = regmap_read(map: smb->regmap, IRQSTAT_E, val: &val); |
315 | if (ret < 0) |
316 | return ret; |
317 | |
318 | /* |
319 | * Dc and usb are set depending on whether they are enabled in |
320 | * platform data _and_ whether corresponding undervoltage is set. |
321 | */ |
322 | if (smb->use_mains) |
323 | dc = !(val & IRQSTAT_E_DCIN_UV_STAT); |
324 | if (smb->use_usb) |
325 | usb = !(val & IRQSTAT_E_USBIN_UV_STAT); |
326 | |
327 | ret = smb->mains_online != dc || smb->usb_online != usb; |
328 | smb->mains_online = dc; |
329 | smb->usb_online = usb; |
330 | |
331 | return ret; |
332 | } |
333 | |
334 | /* |
335 | * smb347_is_ps_online - returns whether input power source is connected |
336 | * @smb: pointer to smb347 charger instance |
337 | * |
338 | * Returns %true if input power source is connected. Note that this is |
339 | * dependent on what platform has configured for usable power sources. For |
340 | * example if USB is disabled, this will return %false even if the USB cable |
341 | * is connected. |
342 | */ |
343 | static bool smb347_is_ps_online(struct smb347_charger *smb) |
344 | { |
345 | return smb->usb_online || smb->mains_online; |
346 | } |
347 | |
348 | /** |
349 | * smb347_charging_status - returns status of charging |
350 | * @smb: pointer to smb347 charger instance |
351 | * |
352 | * Function returns charging status. %0 means no charging is in progress, |
353 | * %1 means pre-charging, %2 fast-charging and %3 taper-charging. |
354 | */ |
355 | static int smb347_charging_status(struct smb347_charger *smb) |
356 | { |
357 | unsigned int val; |
358 | int ret; |
359 | |
360 | if (!smb347_is_ps_online(smb)) |
361 | return 0; |
362 | |
363 | ret = regmap_read(map: smb->regmap, STAT_C, val: &val); |
364 | if (ret < 0) |
365 | return 0; |
366 | |
367 | return (val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT; |
368 | } |
369 | |
370 | static int smb347_charging_set(struct smb347_charger *smb, bool enable) |
371 | { |
372 | if (smb->enable_control != SMB3XX_CHG_ENABLE_SW) { |
373 | dev_dbg(smb->dev, "charging enable/disable in SW disabled\n" ); |
374 | return 0; |
375 | } |
376 | |
377 | if (enable && smb->usb_vbus_enabled) { |
378 | dev_dbg(smb->dev, "charging not enabled because USB is in host mode\n" ); |
379 | return 0; |
380 | } |
381 | |
382 | return regmap_update_bits(map: smb->regmap, CMD_A, CMD_A_CHG_ENABLED, |
383 | val: enable ? CMD_A_CHG_ENABLED : 0); |
384 | } |
385 | |
386 | static inline int smb347_charging_enable(struct smb347_charger *smb) |
387 | { |
388 | return smb347_charging_set(smb, enable: true); |
389 | } |
390 | |
391 | static inline int smb347_charging_disable(struct smb347_charger *smb) |
392 | { |
393 | return smb347_charging_set(smb, enable: false); |
394 | } |
395 | |
396 | static int smb347_start_stop_charging(struct smb347_charger *smb) |
397 | { |
398 | int ret; |
399 | |
400 | /* |
401 | * Depending on whether valid power source is connected or not, we |
402 | * disable or enable the charging. We do it manually because it |
403 | * depends on how the platform has configured the valid inputs. |
404 | */ |
405 | if (smb347_is_ps_online(smb)) { |
406 | ret = smb347_charging_enable(smb); |
407 | if (ret < 0) |
408 | dev_err(smb->dev, "failed to enable charging\n" ); |
409 | } else { |
410 | ret = smb347_charging_disable(smb); |
411 | if (ret < 0) |
412 | dev_err(smb->dev, "failed to disable charging\n" ); |
413 | } |
414 | |
415 | return ret; |
416 | } |
417 | |
418 | static int smb347_set_charge_current(struct smb347_charger *smb) |
419 | { |
420 | unsigned int id = smb->id; |
421 | int ret; |
422 | |
423 | if (smb->max_charge_current) { |
424 | ret = current_to_hw(tbl: fcc_tbl[id], ARRAY_SIZE(fcc_tbl[id]), |
425 | val: smb->max_charge_current); |
426 | if (ret < 0) |
427 | return ret; |
428 | |
429 | ret = regmap_update_bits(map: smb->regmap, CFG_CHARGE_CURRENT, |
430 | CFG_CHARGE_CURRENT_FCC_MASK, |
431 | val: ret << CFG_CHARGE_CURRENT_FCC_SHIFT); |
432 | if (ret < 0) |
433 | return ret; |
434 | } |
435 | |
436 | if (smb->pre_charge_current) { |
437 | ret = current_to_hw(tbl: pcc_tbl[id], ARRAY_SIZE(pcc_tbl[id]), |
438 | val: smb->pre_charge_current); |
439 | if (ret < 0) |
440 | return ret; |
441 | |
442 | ret = regmap_update_bits(map: smb->regmap, CFG_CHARGE_CURRENT, |
443 | CFG_CHARGE_CURRENT_PCC_MASK, |
444 | val: ret << CFG_CHARGE_CURRENT_PCC_SHIFT); |
445 | if (ret < 0) |
446 | return ret; |
447 | } |
448 | |
449 | if (smb->termination_current) { |
450 | ret = current_to_hw(tbl: tc_tbl[id], ARRAY_SIZE(tc_tbl[id]), |
451 | val: smb->termination_current); |
452 | if (ret < 0) |
453 | return ret; |
454 | |
455 | ret = regmap_update_bits(map: smb->regmap, CFG_CHARGE_CURRENT, |
456 | CFG_CHARGE_CURRENT_TC_MASK, val: ret); |
457 | if (ret < 0) |
458 | return ret; |
459 | } |
460 | |
461 | return 0; |
462 | } |
463 | |
464 | static int smb347_set_current_limits(struct smb347_charger *smb) |
465 | { |
466 | unsigned int id = smb->id; |
467 | int ret; |
468 | |
469 | if (smb->mains_current_limit) { |
470 | ret = current_to_hw(tbl: icl_tbl[id], ARRAY_SIZE(icl_tbl[id]), |
471 | val: smb->mains_current_limit); |
472 | if (ret < 0) |
473 | return ret; |
474 | |
475 | ret = regmap_update_bits(map: smb->regmap, CFG_CURRENT_LIMIT, |
476 | CFG_CURRENT_LIMIT_DC_MASK, |
477 | val: ret << CFG_CURRENT_LIMIT_DC_SHIFT); |
478 | if (ret < 0) |
479 | return ret; |
480 | } |
481 | |
482 | if (smb->usb_hc_current_limit) { |
483 | ret = current_to_hw(tbl: icl_tbl[id], ARRAY_SIZE(icl_tbl[id]), |
484 | val: smb->usb_hc_current_limit); |
485 | if (ret < 0) |
486 | return ret; |
487 | |
488 | ret = regmap_update_bits(map: smb->regmap, CFG_CURRENT_LIMIT, |
489 | CFG_CURRENT_LIMIT_USB_MASK, val: ret); |
490 | if (ret < 0) |
491 | return ret; |
492 | } |
493 | |
494 | return 0; |
495 | } |
496 | |
497 | static int smb347_set_voltage_limits(struct smb347_charger *smb) |
498 | { |
499 | int ret; |
500 | |
501 | if (smb->pre_to_fast_voltage) { |
502 | ret = smb->pre_to_fast_voltage; |
503 | |
504 | /* uV */ |
505 | ret = clamp_val(ret, 2400000, 3000000) - 2400000; |
506 | ret /= 200000; |
507 | |
508 | ret = regmap_update_bits(map: smb->regmap, CFG_FLOAT_VOLTAGE, |
509 | CFG_FLOAT_VOLTAGE_THRESHOLD_MASK, |
510 | val: ret << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT); |
511 | if (ret < 0) |
512 | return ret; |
513 | } |
514 | |
515 | if (smb->max_charge_voltage) { |
516 | ret = smb->max_charge_voltage; |
517 | |
518 | /* uV */ |
519 | ret = clamp_val(ret, 3500000, 4500000) - 3500000; |
520 | ret /= 20000; |
521 | |
522 | ret = regmap_update_bits(map: smb->regmap, CFG_FLOAT_VOLTAGE, |
523 | CFG_FLOAT_VOLTAGE_FLOAT_MASK, val: ret); |
524 | if (ret < 0) |
525 | return ret; |
526 | } |
527 | |
528 | return 0; |
529 | } |
530 | |
531 | static int smb347_set_temp_limits(struct smb347_charger *smb) |
532 | { |
533 | unsigned int id = smb->id; |
534 | bool enable_therm_monitor = false; |
535 | int ret = 0; |
536 | int val; |
537 | |
538 | if (smb->chip_temp_threshold) { |
539 | val = smb->chip_temp_threshold; |
540 | |
541 | /* degree C */ |
542 | val = clamp_val(val, 100, 130) - 100; |
543 | val /= 10; |
544 | |
545 | ret = regmap_update_bits(map: smb->regmap, CFG_OTG, |
546 | CFG_OTG_TEMP_THRESHOLD_MASK, |
547 | val: val << CFG_OTG_TEMP_THRESHOLD_SHIFT); |
548 | if (ret < 0) |
549 | return ret; |
550 | } |
551 | |
552 | if (smb->soft_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT) { |
553 | val = smb->soft_cold_temp_limit; |
554 | |
555 | val = clamp_val(val, 0, 15); |
556 | val /= 5; |
557 | /* this goes from higher to lower so invert the value */ |
558 | val = ~val & 0x3; |
559 | |
560 | ret = regmap_update_bits(map: smb->regmap, CFG_TEMP_LIMIT, |
561 | CFG_TEMP_LIMIT_SOFT_COLD_MASK, |
562 | val: val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT); |
563 | if (ret < 0) |
564 | return ret; |
565 | |
566 | enable_therm_monitor = true; |
567 | } |
568 | |
569 | if (smb->soft_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT) { |
570 | val = smb->soft_hot_temp_limit; |
571 | |
572 | val = clamp_val(val, 40, 55) - 40; |
573 | val /= 5; |
574 | |
575 | ret = regmap_update_bits(map: smb->regmap, CFG_TEMP_LIMIT, |
576 | CFG_TEMP_LIMIT_SOFT_HOT_MASK, |
577 | val: val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT); |
578 | if (ret < 0) |
579 | return ret; |
580 | |
581 | enable_therm_monitor = true; |
582 | } |
583 | |
584 | if (smb->hard_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT) { |
585 | val = smb->hard_cold_temp_limit; |
586 | |
587 | val = clamp_val(val, -5, 10) + 5; |
588 | val /= 5; |
589 | /* this goes from higher to lower so invert the value */ |
590 | val = ~val & 0x3; |
591 | |
592 | ret = regmap_update_bits(map: smb->regmap, CFG_TEMP_LIMIT, |
593 | CFG_TEMP_LIMIT_HARD_COLD_MASK, |
594 | val: val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT); |
595 | if (ret < 0) |
596 | return ret; |
597 | |
598 | enable_therm_monitor = true; |
599 | } |
600 | |
601 | if (smb->hard_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT) { |
602 | val = smb->hard_hot_temp_limit; |
603 | |
604 | val = clamp_val(val, 50, 65) - 50; |
605 | val /= 5; |
606 | |
607 | ret = regmap_update_bits(map: smb->regmap, CFG_TEMP_LIMIT, |
608 | CFG_TEMP_LIMIT_HARD_HOT_MASK, |
609 | val: val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT); |
610 | if (ret < 0) |
611 | return ret; |
612 | |
613 | enable_therm_monitor = true; |
614 | } |
615 | |
616 | /* |
617 | * If any of the temperature limits are set, we also enable the |
618 | * thermistor monitoring. |
619 | * |
620 | * When soft limits are hit, the device will start to compensate |
621 | * current and/or voltage depending on the configuration. |
622 | * |
623 | * When hard limit is hit, the device will suspend charging |
624 | * depending on the configuration. |
625 | */ |
626 | if (enable_therm_monitor) { |
627 | ret = regmap_update_bits(map: smb->regmap, CFG_THERM, |
628 | CFG_THERM_MONITOR_DISABLED, val: 0); |
629 | if (ret < 0) |
630 | return ret; |
631 | } |
632 | |
633 | if (smb->suspend_on_hard_temp_limit) { |
634 | ret = regmap_update_bits(map: smb->regmap, CFG_SYSOK, |
635 | CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED, val: 0); |
636 | if (ret < 0) |
637 | return ret; |
638 | } |
639 | |
640 | if (smb->soft_temp_limit_compensation != |
641 | SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT) { |
642 | val = smb->soft_temp_limit_compensation & 0x3; |
643 | |
644 | ret = regmap_update_bits(map: smb->regmap, CFG_THERM, |
645 | CFG_THERM_SOFT_HOT_COMPENSATION_MASK, |
646 | val: val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT); |
647 | if (ret < 0) |
648 | return ret; |
649 | |
650 | ret = regmap_update_bits(map: smb->regmap, CFG_THERM, |
651 | CFG_THERM_SOFT_COLD_COMPENSATION_MASK, |
652 | val: val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT); |
653 | if (ret < 0) |
654 | return ret; |
655 | } |
656 | |
657 | if (smb->charge_current_compensation) { |
658 | val = current_to_hw(tbl: ccc_tbl[id], ARRAY_SIZE(ccc_tbl[id]), |
659 | val: smb->charge_current_compensation); |
660 | if (val < 0) |
661 | return val; |
662 | |
663 | ret = regmap_update_bits(map: smb->regmap, CFG_OTG, |
664 | CFG_OTG_CC_COMPENSATION_MASK, |
665 | val: (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT); |
666 | if (ret < 0) |
667 | return ret; |
668 | } |
669 | |
670 | return ret; |
671 | } |
672 | |
673 | /* |
674 | * smb347_set_writable - enables/disables writing to non-volatile registers |
675 | * @smb: pointer to smb347 charger instance |
676 | * |
677 | * You can enable/disable writing to the non-volatile configuration |
678 | * registers by calling this function. |
679 | * |
680 | * Returns %0 on success and negative errno in case of failure. |
681 | */ |
682 | static int smb347_set_writable(struct smb347_charger *smb, bool writable, |
683 | bool irq_toggle) |
684 | { |
685 | struct i2c_client *client = to_i2c_client(smb->dev); |
686 | int ret; |
687 | |
688 | if (writable && irq_toggle && !smb->irq_unsupported) |
689 | disable_irq(irq: client->irq); |
690 | |
691 | ret = regmap_update_bits(map: smb->regmap, CMD_A, CMD_A_ALLOW_WRITE, |
692 | val: writable ? CMD_A_ALLOW_WRITE : 0); |
693 | |
694 | if ((!writable || ret) && irq_toggle && !smb->irq_unsupported) |
695 | enable_irq(irq: client->irq); |
696 | |
697 | return ret; |
698 | } |
699 | |
700 | static int smb347_hw_init(struct smb347_charger *smb) |
701 | { |
702 | unsigned int val; |
703 | int ret; |
704 | |
705 | ret = smb347_set_writable(smb, writable: true, irq_toggle: false); |
706 | if (ret < 0) |
707 | return ret; |
708 | |
709 | /* |
710 | * Program the platform specific configuration values to the device |
711 | * first. |
712 | */ |
713 | ret = smb347_set_charge_current(smb); |
714 | if (ret < 0) |
715 | goto fail; |
716 | |
717 | ret = smb347_set_current_limits(smb); |
718 | if (ret < 0) |
719 | goto fail; |
720 | |
721 | ret = smb347_set_voltage_limits(smb); |
722 | if (ret < 0) |
723 | goto fail; |
724 | |
725 | ret = smb347_set_temp_limits(smb); |
726 | if (ret < 0) |
727 | goto fail; |
728 | |
729 | /* If USB charging is disabled we put the USB in suspend mode */ |
730 | if (!smb->use_usb) { |
731 | ret = regmap_update_bits(map: smb->regmap, CMD_A, |
732 | CMD_A_SUSPEND_ENABLED, |
733 | CMD_A_SUSPEND_ENABLED); |
734 | if (ret < 0) |
735 | goto fail; |
736 | } |
737 | |
738 | /* |
739 | * If configured by platform data, we enable hardware Auto-OTG |
740 | * support for driving VBUS. Otherwise we disable it. |
741 | */ |
742 | ret = regmap_update_bits(map: smb->regmap, CFG_OTHER, CFG_OTHER_RID_MASK, |
743 | val: smb->use_usb_otg ? CFG_OTHER_RID_ENABLED_AUTO_OTG : 0); |
744 | if (ret < 0) |
745 | goto fail; |
746 | |
747 | /* Activate pin control, making it writable. */ |
748 | switch (smb->enable_control) { |
749 | case SMB3XX_CHG_ENABLE_PIN_ACTIVE_LOW: |
750 | case SMB3XX_CHG_ENABLE_PIN_ACTIVE_HIGH: |
751 | ret = regmap_set_bits(map: smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL); |
752 | if (ret < 0) |
753 | goto fail; |
754 | } |
755 | |
756 | /* |
757 | * Make the charging functionality controllable by a write to the |
758 | * command register unless pin control is specified in the platform |
759 | * data. |
760 | */ |
761 | switch (smb->enable_control) { |
762 | case SMB3XX_CHG_ENABLE_PIN_ACTIVE_LOW: |
763 | val = CFG_PIN_EN_CTRL_ACTIVE_LOW; |
764 | break; |
765 | case SMB3XX_CHG_ENABLE_PIN_ACTIVE_HIGH: |
766 | val = CFG_PIN_EN_CTRL_ACTIVE_HIGH; |
767 | break; |
768 | default: |
769 | val = 0; |
770 | break; |
771 | } |
772 | |
773 | ret = regmap_update_bits(map: smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL_MASK, |
774 | val); |
775 | if (ret < 0) |
776 | goto fail; |
777 | |
778 | /* Disable Automatic Power Source Detection (APSD) interrupt. */ |
779 | ret = regmap_update_bits(map: smb->regmap, CFG_PIN, CFG_PIN_EN_APSD_IRQ, val: 0); |
780 | if (ret < 0) |
781 | goto fail; |
782 | |
783 | ret = smb347_update_ps_status(smb); |
784 | if (ret < 0) |
785 | goto fail; |
786 | |
787 | ret = smb347_start_stop_charging(smb); |
788 | |
789 | fail: |
790 | smb347_set_writable(smb, writable: false, irq_toggle: false); |
791 | return ret; |
792 | } |
793 | |
794 | static irqreturn_t smb347_interrupt(int irq, void *data) |
795 | { |
796 | struct smb347_charger *smb = data; |
797 | unsigned int stat_c, irqstat_c, irqstat_d, irqstat_e; |
798 | bool handled = false; |
799 | int ret; |
800 | |
801 | /* SMB347 it needs at least 20ms for setting IRQSTAT_E_*IN_UV_IRQ */ |
802 | usleep_range(min: 25000, max: 35000); |
803 | |
804 | ret = regmap_read(map: smb->regmap, STAT_C, val: &stat_c); |
805 | if (ret < 0) { |
806 | dev_warn(smb->dev, "reading STAT_C failed\n" ); |
807 | return IRQ_NONE; |
808 | } |
809 | |
810 | ret = regmap_read(map: smb->regmap, IRQSTAT_C, val: &irqstat_c); |
811 | if (ret < 0) { |
812 | dev_warn(smb->dev, "reading IRQSTAT_C failed\n" ); |
813 | return IRQ_NONE; |
814 | } |
815 | |
816 | ret = regmap_read(map: smb->regmap, IRQSTAT_D, val: &irqstat_d); |
817 | if (ret < 0) { |
818 | dev_warn(smb->dev, "reading IRQSTAT_D failed\n" ); |
819 | return IRQ_NONE; |
820 | } |
821 | |
822 | ret = regmap_read(map: smb->regmap, IRQSTAT_E, val: &irqstat_e); |
823 | if (ret < 0) { |
824 | dev_warn(smb->dev, "reading IRQSTAT_E failed\n" ); |
825 | return IRQ_NONE; |
826 | } |
827 | |
828 | /* |
829 | * If we get charger error we report the error back to user. |
830 | * If the error is recovered charging will resume again. |
831 | */ |
832 | if (stat_c & STAT_C_CHARGER_ERROR) { |
833 | dev_err(smb->dev, "charging stopped due to charger error\n" ); |
834 | if (smb->use_mains) |
835 | power_supply_changed(psy: smb->mains); |
836 | if (smb->use_usb) |
837 | power_supply_changed(psy: smb->usb); |
838 | handled = true; |
839 | } |
840 | |
841 | /* |
842 | * If we reached the termination current the battery is charged and |
843 | * we can update the status now. Charging is automatically |
844 | * disabled by the hardware. |
845 | */ |
846 | if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) { |
847 | if (irqstat_c & IRQSTAT_C_TERMINATION_STAT) { |
848 | if (smb->use_mains) |
849 | power_supply_changed(psy: smb->mains); |
850 | if (smb->use_usb) |
851 | power_supply_changed(psy: smb->usb); |
852 | } |
853 | dev_dbg(smb->dev, "going to HW maintenance mode\n" ); |
854 | handled = true; |
855 | } |
856 | |
857 | /* |
858 | * If we got a charger timeout INT that means the charge |
859 | * full is not detected with in charge timeout value. |
860 | */ |
861 | if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_IRQ) { |
862 | dev_dbg(smb->dev, "total Charge Timeout INT received\n" ); |
863 | |
864 | if (irqstat_d & IRQSTAT_D_CHARGE_TIMEOUT_STAT) |
865 | dev_warn(smb->dev, "charging stopped due to timeout\n" ); |
866 | if (smb->use_mains) |
867 | power_supply_changed(psy: smb->mains); |
868 | if (smb->use_usb) |
869 | power_supply_changed(psy: smb->usb); |
870 | handled = true; |
871 | } |
872 | |
873 | /* |
874 | * If we got an under voltage interrupt it means that AC/USB input |
875 | * was connected or disconnected. |
876 | */ |
877 | if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) { |
878 | if (smb347_update_ps_status(smb) > 0) { |
879 | smb347_start_stop_charging(smb); |
880 | if (smb->use_mains) |
881 | power_supply_changed(psy: smb->mains); |
882 | if (smb->use_usb) |
883 | power_supply_changed(psy: smb->usb); |
884 | } |
885 | handled = true; |
886 | } |
887 | |
888 | return handled ? IRQ_HANDLED : IRQ_NONE; |
889 | } |
890 | |
891 | static int smb347_irq_set(struct smb347_charger *smb, bool enable) |
892 | { |
893 | int ret; |
894 | |
895 | if (smb->irq_unsupported) |
896 | return 0; |
897 | |
898 | ret = smb347_set_writable(smb, writable: true, irq_toggle: true); |
899 | if (ret < 0) |
900 | return ret; |
901 | |
902 | /* |
903 | * Enable/disable interrupts for: |
904 | * - under voltage |
905 | * - termination current reached |
906 | * - charger timeout |
907 | * - charger error |
908 | */ |
909 | ret = regmap_update_bits(map: smb->regmap, CFG_FAULT_IRQ, mask: 0xff, |
910 | val: enable ? CFG_FAULT_IRQ_DCIN_UV : 0); |
911 | if (ret < 0) |
912 | goto fail; |
913 | |
914 | ret = regmap_update_bits(map: smb->regmap, CFG_STATUS_IRQ, mask: 0xff, |
915 | val: enable ? (CFG_STATUS_IRQ_TERMINATION_OR_TAPER | |
916 | CFG_STATUS_IRQ_CHARGE_TIMEOUT) : 0); |
917 | if (ret < 0) |
918 | goto fail; |
919 | |
920 | ret = regmap_update_bits(map: smb->regmap, CFG_PIN, CFG_PIN_EN_CHARGER_ERROR, |
921 | val: enable ? CFG_PIN_EN_CHARGER_ERROR : 0); |
922 | fail: |
923 | smb347_set_writable(smb, writable: false, irq_toggle: true); |
924 | return ret; |
925 | } |
926 | |
927 | static inline int smb347_irq_enable(struct smb347_charger *smb) |
928 | { |
929 | return smb347_irq_set(smb, enable: true); |
930 | } |
931 | |
932 | static inline int smb347_irq_disable(struct smb347_charger *smb) |
933 | { |
934 | return smb347_irq_set(smb, enable: false); |
935 | } |
936 | |
937 | static int smb347_irq_init(struct smb347_charger *smb, |
938 | struct i2c_client *client) |
939 | { |
940 | int ret; |
941 | |
942 | smb->irq_unsupported = true; |
943 | |
944 | /* |
945 | * Interrupt pin is optional. If it is connected, we setup the |
946 | * interrupt support here. |
947 | */ |
948 | if (!client->irq) |
949 | return 0; |
950 | |
951 | ret = smb347_set_writable(smb, writable: true, irq_toggle: false); |
952 | if (ret < 0) |
953 | return ret; |
954 | |
955 | /* |
956 | * Configure the STAT output to be suitable for interrupts: disable |
957 | * all other output (except interrupts) and make it active low. |
958 | */ |
959 | ret = regmap_update_bits(map: smb->regmap, CFG_STAT, |
960 | CFG_STAT_ACTIVE_HIGH | CFG_STAT_DISABLED, |
961 | CFG_STAT_DISABLED); |
962 | |
963 | smb347_set_writable(smb, writable: false, irq_toggle: false); |
964 | |
965 | if (ret < 0) { |
966 | dev_warn(smb->dev, "failed to initialize IRQ: %d\n" , ret); |
967 | dev_warn(smb->dev, "disabling IRQ support\n" ); |
968 | return 0; |
969 | } |
970 | |
971 | ret = devm_request_threaded_irq(dev: smb->dev, irq: client->irq, NULL, |
972 | thread_fn: smb347_interrupt, IRQF_ONESHOT, |
973 | devname: client->name, dev_id: smb); |
974 | if (ret) |
975 | return ret; |
976 | |
977 | smb->irq_unsupported = false; |
978 | |
979 | ret = smb347_irq_enable(smb); |
980 | if (ret < 0) |
981 | return ret; |
982 | |
983 | return 0; |
984 | } |
985 | |
986 | /* |
987 | * Returns the constant charge current programmed |
988 | * into the charger in uA. |
989 | */ |
990 | static int get_const_charge_current(struct smb347_charger *smb) |
991 | { |
992 | unsigned int id = smb->id; |
993 | int ret, intval; |
994 | unsigned int v; |
995 | |
996 | if (!smb347_is_ps_online(smb)) |
997 | return -ENODATA; |
998 | |
999 | ret = regmap_read(map: smb->regmap, STAT_B, val: &v); |
1000 | if (ret < 0) |
1001 | return ret; |
1002 | |
1003 | /* |
1004 | * The current value is composition of FCC and PCC values |
1005 | * and we can detect which table to use from bit 5. |
1006 | */ |
1007 | if (v & 0x20) { |
1008 | intval = hw_to_current(tbl: fcc_tbl[id], |
1009 | ARRAY_SIZE(fcc_tbl[id]), val: v & 7); |
1010 | } else { |
1011 | v >>= 3; |
1012 | intval = hw_to_current(tbl: pcc_tbl[id], |
1013 | ARRAY_SIZE(pcc_tbl[id]), val: v & 7); |
1014 | } |
1015 | |
1016 | return intval; |
1017 | } |
1018 | |
1019 | /* |
1020 | * Returns the constant charge voltage programmed |
1021 | * into the charger in uV. |
1022 | */ |
1023 | static int get_const_charge_voltage(struct smb347_charger *smb) |
1024 | { |
1025 | int ret, intval; |
1026 | unsigned int v; |
1027 | |
1028 | if (!smb347_is_ps_online(smb)) |
1029 | return -ENODATA; |
1030 | |
1031 | ret = regmap_read(map: smb->regmap, STAT_A, val: &v); |
1032 | if (ret < 0) |
1033 | return ret; |
1034 | |
1035 | v &= STAT_A_FLOAT_VOLTAGE_MASK; |
1036 | if (v > 0x3d) |
1037 | v = 0x3d; |
1038 | |
1039 | intval = 3500000 + v * 20000; |
1040 | |
1041 | return intval; |
1042 | } |
1043 | |
1044 | static int smb347_get_charging_status(struct smb347_charger *smb, |
1045 | struct power_supply *psy) |
1046 | { |
1047 | int ret, status; |
1048 | unsigned int val; |
1049 | |
1050 | if (psy->desc->type == POWER_SUPPLY_TYPE_USB) { |
1051 | if (!smb->usb_online) |
1052 | return POWER_SUPPLY_STATUS_DISCHARGING; |
1053 | } else { |
1054 | if (!smb->mains_online) |
1055 | return POWER_SUPPLY_STATUS_DISCHARGING; |
1056 | } |
1057 | |
1058 | ret = regmap_read(map: smb->regmap, STAT_C, val: &val); |
1059 | if (ret < 0) |
1060 | return ret; |
1061 | |
1062 | if ((val & STAT_C_CHARGER_ERROR) || |
1063 | (val & STAT_C_HOLDOFF_STAT)) { |
1064 | /* |
1065 | * set to NOT CHARGING upon charger error |
1066 | * or charging has stopped. |
1067 | */ |
1068 | status = POWER_SUPPLY_STATUS_NOT_CHARGING; |
1069 | } else { |
1070 | if ((val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT) { |
1071 | /* |
1072 | * set to charging if battery is in pre-charge, |
1073 | * fast charge or taper charging mode. |
1074 | */ |
1075 | status = POWER_SUPPLY_STATUS_CHARGING; |
1076 | } else if (val & STAT_C_CHG_TERM) { |
1077 | /* |
1078 | * set the status to FULL if battery is not in pre |
1079 | * charge, fast charge or taper charging mode AND |
1080 | * charging is terminated at least once. |
1081 | */ |
1082 | status = POWER_SUPPLY_STATUS_FULL; |
1083 | } else { |
1084 | /* |
1085 | * in this case no charger error or termination |
1086 | * occured but charging is not in progress!!! |
1087 | */ |
1088 | status = POWER_SUPPLY_STATUS_NOT_CHARGING; |
1089 | } |
1090 | } |
1091 | |
1092 | return status; |
1093 | } |
1094 | |
1095 | static int smb347_get_property_locked(struct power_supply *psy, |
1096 | enum power_supply_property prop, |
1097 | union power_supply_propval *val) |
1098 | { |
1099 | struct smb347_charger *smb = power_supply_get_drvdata(psy); |
1100 | int ret; |
1101 | |
1102 | switch (prop) { |
1103 | case POWER_SUPPLY_PROP_STATUS: |
1104 | ret = smb347_get_charging_status(smb, psy); |
1105 | if (ret < 0) |
1106 | return ret; |
1107 | val->intval = ret; |
1108 | break; |
1109 | |
1110 | case POWER_SUPPLY_PROP_CHARGE_TYPE: |
1111 | if (psy->desc->type == POWER_SUPPLY_TYPE_USB) { |
1112 | if (!smb->usb_online) |
1113 | return -ENODATA; |
1114 | } else { |
1115 | if (!smb->mains_online) |
1116 | return -ENODATA; |
1117 | } |
1118 | |
1119 | /* |
1120 | * We handle trickle and pre-charging the same, and taper |
1121 | * and none the same. |
1122 | */ |
1123 | switch (smb347_charging_status(smb)) { |
1124 | case 1: |
1125 | val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; |
1126 | break; |
1127 | case 2: |
1128 | val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; |
1129 | break; |
1130 | default: |
1131 | val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; |
1132 | break; |
1133 | } |
1134 | break; |
1135 | |
1136 | case POWER_SUPPLY_PROP_ONLINE: |
1137 | if (psy->desc->type == POWER_SUPPLY_TYPE_USB) |
1138 | val->intval = smb->usb_online; |
1139 | else |
1140 | val->intval = smb->mains_online; |
1141 | break; |
1142 | |
1143 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: |
1144 | ret = get_const_charge_voltage(smb); |
1145 | if (ret < 0) |
1146 | return ret; |
1147 | val->intval = ret; |
1148 | break; |
1149 | |
1150 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: |
1151 | ret = get_const_charge_current(smb); |
1152 | if (ret < 0) |
1153 | return ret; |
1154 | val->intval = ret; |
1155 | break; |
1156 | |
1157 | default: |
1158 | return -EINVAL; |
1159 | } |
1160 | |
1161 | return 0; |
1162 | } |
1163 | |
1164 | static int smb347_get_property(struct power_supply *psy, |
1165 | enum power_supply_property prop, |
1166 | union power_supply_propval *val) |
1167 | { |
1168 | struct smb347_charger *smb = power_supply_get_drvdata(psy); |
1169 | struct i2c_client *client = to_i2c_client(smb->dev); |
1170 | int ret; |
1171 | |
1172 | if (!smb->irq_unsupported) |
1173 | disable_irq(irq: client->irq); |
1174 | |
1175 | ret = smb347_get_property_locked(psy, prop, val); |
1176 | |
1177 | if (!smb->irq_unsupported) |
1178 | enable_irq(irq: client->irq); |
1179 | |
1180 | return ret; |
1181 | } |
1182 | |
1183 | static enum power_supply_property smb347_properties[] = { |
1184 | POWER_SUPPLY_PROP_STATUS, |
1185 | POWER_SUPPLY_PROP_CHARGE_TYPE, |
1186 | POWER_SUPPLY_PROP_ONLINE, |
1187 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, |
1188 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, |
1189 | }; |
1190 | |
1191 | static bool smb347_volatile_reg(struct device *dev, unsigned int reg) |
1192 | { |
1193 | switch (reg) { |
1194 | case IRQSTAT_A: |
1195 | case IRQSTAT_C: |
1196 | case IRQSTAT_D: |
1197 | case IRQSTAT_E: |
1198 | case IRQSTAT_F: |
1199 | case STAT_A: |
1200 | case STAT_B: |
1201 | case STAT_C: |
1202 | case STAT_E: |
1203 | return true; |
1204 | } |
1205 | |
1206 | return false; |
1207 | } |
1208 | |
1209 | static bool smb347_readable_reg(struct device *dev, unsigned int reg) |
1210 | { |
1211 | switch (reg) { |
1212 | case CFG_CHARGE_CURRENT: |
1213 | case CFG_CURRENT_LIMIT: |
1214 | case CFG_FLOAT_VOLTAGE: |
1215 | case CFG_STAT: |
1216 | case CFG_PIN: |
1217 | case CFG_THERM: |
1218 | case CFG_SYSOK: |
1219 | case CFG_OTHER: |
1220 | case CFG_OTG: |
1221 | case CFG_TEMP_LIMIT: |
1222 | case CFG_FAULT_IRQ: |
1223 | case CFG_STATUS_IRQ: |
1224 | case CFG_ADDRESS: |
1225 | case CMD_A: |
1226 | case CMD_B: |
1227 | case CMD_C: |
1228 | return true; |
1229 | } |
1230 | |
1231 | return smb347_volatile_reg(dev, reg); |
1232 | } |
1233 | |
1234 | static void smb347_dt_parse_dev_info(struct smb347_charger *smb) |
1235 | { |
1236 | struct device *dev = smb->dev; |
1237 | |
1238 | smb->soft_temp_limit_compensation = |
1239 | SMB3XX_SOFT_TEMP_COMPENSATE_DEFAULT; |
1240 | /* |
1241 | * These properties come from the battery info, still we need to |
1242 | * pre-initialize the values. See smb347_get_battery_info() below. |
1243 | */ |
1244 | smb->soft_cold_temp_limit = SMB3XX_TEMP_USE_DEFAULT; |
1245 | smb->hard_cold_temp_limit = SMB3XX_TEMP_USE_DEFAULT; |
1246 | smb->soft_hot_temp_limit = SMB3XX_TEMP_USE_DEFAULT; |
1247 | smb->hard_hot_temp_limit = SMB3XX_TEMP_USE_DEFAULT; |
1248 | |
1249 | /* Charging constraints */ |
1250 | device_property_read_u32(dev, propname: "summit,fast-voltage-threshold-microvolt" , |
1251 | val: &smb->pre_to_fast_voltage); |
1252 | device_property_read_u32(dev, propname: "summit,mains-current-limit-microamp" , |
1253 | val: &smb->mains_current_limit); |
1254 | device_property_read_u32(dev, propname: "summit,usb-current-limit-microamp" , |
1255 | val: &smb->usb_hc_current_limit); |
1256 | |
1257 | /* For thermometer monitoring */ |
1258 | device_property_read_u32(dev, propname: "summit,chip-temperature-threshold-celsius" , |
1259 | val: &smb->chip_temp_threshold); |
1260 | device_property_read_u32(dev, propname: "summit,soft-compensation-method" , |
1261 | val: &smb->soft_temp_limit_compensation); |
1262 | device_property_read_u32(dev, propname: "summit,charge-current-compensation-microamp" , |
1263 | val: &smb->charge_current_compensation); |
1264 | |
1265 | /* Supported charging mode */ |
1266 | smb->use_mains = device_property_read_bool(dev, propname: "summit,enable-mains-charging" ); |
1267 | smb->use_usb = device_property_read_bool(dev, propname: "summit,enable-usb-charging" ); |
1268 | smb->use_usb_otg = device_property_read_bool(dev, propname: "summit,enable-otg-charging" ); |
1269 | |
1270 | /* Select charging control */ |
1271 | device_property_read_u32(dev, propname: "summit,enable-charge-control" , |
1272 | val: &smb->enable_control); |
1273 | |
1274 | /* |
1275 | * Polarity of INOK signal indicating presence of external power |
1276 | * supply connected to the charger. |
1277 | */ |
1278 | device_property_read_u32(dev, propname: "summit,inok-polarity" , |
1279 | val: &smb->inok_polarity); |
1280 | } |
1281 | |
1282 | static int smb347_get_battery_info(struct smb347_charger *smb) |
1283 | { |
1284 | struct power_supply_battery_info *info; |
1285 | struct power_supply *supply; |
1286 | int err; |
1287 | |
1288 | if (smb->mains) |
1289 | supply = smb->mains; |
1290 | else |
1291 | supply = smb->usb; |
1292 | |
1293 | err = power_supply_get_battery_info(psy: supply, info_out: &info); |
1294 | if (err == -ENXIO || err == -ENODEV) |
1295 | return 0; |
1296 | if (err) |
1297 | return err; |
1298 | |
1299 | if (info->constant_charge_current_max_ua != -EINVAL) |
1300 | smb->max_charge_current = info->constant_charge_current_max_ua; |
1301 | |
1302 | if (info->constant_charge_voltage_max_uv != -EINVAL) |
1303 | smb->max_charge_voltage = info->constant_charge_voltage_max_uv; |
1304 | |
1305 | if (info->precharge_current_ua != -EINVAL) |
1306 | smb->pre_charge_current = info->precharge_current_ua; |
1307 | |
1308 | if (info->charge_term_current_ua != -EINVAL) |
1309 | smb->termination_current = info->charge_term_current_ua; |
1310 | |
1311 | if (info->temp_alert_min != INT_MIN) |
1312 | smb->soft_cold_temp_limit = info->temp_alert_min; |
1313 | |
1314 | if (info->temp_alert_max != INT_MAX) |
1315 | smb->soft_hot_temp_limit = info->temp_alert_max; |
1316 | |
1317 | if (info->temp_min != INT_MIN) |
1318 | smb->hard_cold_temp_limit = info->temp_min; |
1319 | |
1320 | if (info->temp_max != INT_MAX) |
1321 | smb->hard_hot_temp_limit = info->temp_max; |
1322 | |
1323 | /* Suspend when battery temperature is outside hard limits */ |
1324 | if (smb->hard_cold_temp_limit != SMB3XX_TEMP_USE_DEFAULT || |
1325 | smb->hard_hot_temp_limit != SMB3XX_TEMP_USE_DEFAULT) |
1326 | smb->suspend_on_hard_temp_limit = true; |
1327 | |
1328 | return 0; |
1329 | } |
1330 | |
1331 | static int smb347_usb_vbus_get_current_limit(struct regulator_dev *rdev) |
1332 | { |
1333 | struct smb347_charger *smb = rdev_get_drvdata(rdev); |
1334 | unsigned int val; |
1335 | int ret; |
1336 | |
1337 | ret = regmap_read(map: smb->regmap, CFG_OTG, val: &val); |
1338 | if (ret < 0) |
1339 | return ret; |
1340 | |
1341 | /* |
1342 | * It's unknown what happens if this bit is unset due to lack of |
1343 | * access to the datasheet, assume it's limit-enable. |
1344 | */ |
1345 | if (!(val & CFG_OTG_CURRENT_LIMIT_250mA)) |
1346 | return 0; |
1347 | |
1348 | return val & CFG_OTG_CURRENT_LIMIT_750mA ? 750000 : 250000; |
1349 | } |
1350 | |
1351 | static int smb347_usb_vbus_set_new_current_limit(struct smb347_charger *smb, |
1352 | int max_uA) |
1353 | { |
1354 | const unsigned int mask = CFG_OTG_CURRENT_LIMIT_750mA | |
1355 | CFG_OTG_CURRENT_LIMIT_250mA; |
1356 | unsigned int val = CFG_OTG_CURRENT_LIMIT_250mA; |
1357 | int ret; |
1358 | |
1359 | if (max_uA >= 750000) |
1360 | val |= CFG_OTG_CURRENT_LIMIT_750mA; |
1361 | |
1362 | ret = regmap_update_bits(map: smb->regmap, CFG_OTG, mask, val); |
1363 | if (ret < 0) |
1364 | dev_err(smb->dev, "failed to change USB current limit\n" ); |
1365 | |
1366 | return ret; |
1367 | } |
1368 | |
1369 | static int smb347_usb_vbus_set_current_limit(struct regulator_dev *rdev, |
1370 | int min_uA, int max_uA) |
1371 | { |
1372 | struct smb347_charger *smb = rdev_get_drvdata(rdev); |
1373 | int ret; |
1374 | |
1375 | ret = smb347_set_writable(smb, writable: true, irq_toggle: true); |
1376 | if (ret < 0) |
1377 | return ret; |
1378 | |
1379 | ret = smb347_usb_vbus_set_new_current_limit(smb, max_uA); |
1380 | smb347_set_writable(smb, writable: false, irq_toggle: true); |
1381 | |
1382 | return ret; |
1383 | } |
1384 | |
1385 | static int smb347_usb_vbus_regulator_enable(struct regulator_dev *rdev) |
1386 | { |
1387 | struct smb347_charger *smb = rdev_get_drvdata(rdev); |
1388 | int ret, max_uA; |
1389 | |
1390 | ret = smb347_set_writable(smb, writable: true, irq_toggle: true); |
1391 | if (ret < 0) |
1392 | return ret; |
1393 | |
1394 | smb347_charging_disable(smb); |
1395 | |
1396 | if (device_property_read_bool(dev: &rdev->dev, propname: "summit,needs-inok-toggle" )) { |
1397 | unsigned int sysok = 0; |
1398 | |
1399 | if (smb->inok_polarity == SMB3XX_SYSOK_INOK_ACTIVE_LOW) |
1400 | sysok = CFG_SYSOK_INOK_ACTIVE_HIGH; |
1401 | |
1402 | /* |
1403 | * VBUS won't be powered if INOK is active, so we need to |
1404 | * manually disable INOK on some platforms. |
1405 | */ |
1406 | ret = regmap_update_bits(map: smb->regmap, CFG_SYSOK, |
1407 | CFG_SYSOK_INOK_ACTIVE_HIGH, val: sysok); |
1408 | if (ret < 0) { |
1409 | dev_err(smb->dev, "failed to disable INOK\n" ); |
1410 | goto done; |
1411 | } |
1412 | } |
1413 | |
1414 | ret = smb347_usb_vbus_get_current_limit(rdev); |
1415 | if (ret < 0) { |
1416 | dev_err(smb->dev, "failed to get USB VBUS current limit\n" ); |
1417 | goto done; |
1418 | } |
1419 | |
1420 | max_uA = ret; |
1421 | |
1422 | ret = smb347_usb_vbus_set_new_current_limit(smb, max_uA: 250000); |
1423 | if (ret < 0) { |
1424 | dev_err(smb->dev, "failed to preset USB VBUS current limit\n" ); |
1425 | goto done; |
1426 | } |
1427 | |
1428 | ret = regmap_set_bits(map: smb->regmap, CMD_A, CMD_A_OTG_ENABLED); |
1429 | if (ret < 0) { |
1430 | dev_err(smb->dev, "failed to enable USB VBUS\n" ); |
1431 | goto done; |
1432 | } |
1433 | |
1434 | smb->usb_vbus_enabled = true; |
1435 | |
1436 | ret = smb347_usb_vbus_set_new_current_limit(smb, max_uA); |
1437 | if (ret < 0) { |
1438 | dev_err(smb->dev, "failed to restore USB VBUS current limit\n" ); |
1439 | goto done; |
1440 | } |
1441 | done: |
1442 | smb347_set_writable(smb, writable: false, irq_toggle: true); |
1443 | |
1444 | return ret; |
1445 | } |
1446 | |
1447 | static int smb347_usb_vbus_regulator_disable(struct regulator_dev *rdev) |
1448 | { |
1449 | struct smb347_charger *smb = rdev_get_drvdata(rdev); |
1450 | int ret; |
1451 | |
1452 | ret = smb347_set_writable(smb, writable: true, irq_toggle: true); |
1453 | if (ret < 0) |
1454 | return ret; |
1455 | |
1456 | ret = regmap_clear_bits(map: smb->regmap, CMD_A, CMD_A_OTG_ENABLED); |
1457 | if (ret < 0) { |
1458 | dev_err(smb->dev, "failed to disable USB VBUS\n" ); |
1459 | goto done; |
1460 | } |
1461 | |
1462 | smb->usb_vbus_enabled = false; |
1463 | |
1464 | if (device_property_read_bool(dev: &rdev->dev, propname: "summit,needs-inok-toggle" )) { |
1465 | unsigned int sysok = 0; |
1466 | |
1467 | if (smb->inok_polarity == SMB3XX_SYSOK_INOK_ACTIVE_HIGH) |
1468 | sysok = CFG_SYSOK_INOK_ACTIVE_HIGH; |
1469 | |
1470 | ret = regmap_update_bits(map: smb->regmap, CFG_SYSOK, |
1471 | CFG_SYSOK_INOK_ACTIVE_HIGH, val: sysok); |
1472 | if (ret < 0) { |
1473 | dev_err(smb->dev, "failed to enable INOK\n" ); |
1474 | goto done; |
1475 | } |
1476 | } |
1477 | |
1478 | smb347_start_stop_charging(smb); |
1479 | done: |
1480 | smb347_set_writable(smb, writable: false, irq_toggle: true); |
1481 | |
1482 | return ret; |
1483 | } |
1484 | |
1485 | static const struct regmap_config smb347_regmap = { |
1486 | .reg_bits = 8, |
1487 | .val_bits = 8, |
1488 | .max_register = SMB347_MAX_REGISTER, |
1489 | .volatile_reg = smb347_volatile_reg, |
1490 | .readable_reg = smb347_readable_reg, |
1491 | .cache_type = REGCACHE_RBTREE, |
1492 | }; |
1493 | |
1494 | static const struct regulator_ops smb347_usb_vbus_regulator_ops = { |
1495 | .is_enabled = regulator_is_enabled_regmap, |
1496 | .enable = smb347_usb_vbus_regulator_enable, |
1497 | .disable = smb347_usb_vbus_regulator_disable, |
1498 | .get_current_limit = smb347_usb_vbus_get_current_limit, |
1499 | .set_current_limit = smb347_usb_vbus_set_current_limit, |
1500 | }; |
1501 | |
1502 | static const struct power_supply_desc smb347_mains_desc = { |
1503 | .name = "smb347-mains" , |
1504 | .type = POWER_SUPPLY_TYPE_MAINS, |
1505 | .get_property = smb347_get_property, |
1506 | .properties = smb347_properties, |
1507 | .num_properties = ARRAY_SIZE(smb347_properties), |
1508 | }; |
1509 | |
1510 | static const struct power_supply_desc smb347_usb_desc = { |
1511 | .name = "smb347-usb" , |
1512 | .type = POWER_SUPPLY_TYPE_USB, |
1513 | .get_property = smb347_get_property, |
1514 | .properties = smb347_properties, |
1515 | .num_properties = ARRAY_SIZE(smb347_properties), |
1516 | }; |
1517 | |
1518 | static const struct regulator_desc smb347_usb_vbus_regulator_desc = { |
1519 | .name = "smb347-usb-vbus" , |
1520 | .of_match = of_match_ptr("usb-vbus" ), |
1521 | .ops = &smb347_usb_vbus_regulator_ops, |
1522 | .type = REGULATOR_VOLTAGE, |
1523 | .owner = THIS_MODULE, |
1524 | .enable_reg = CMD_A, |
1525 | .enable_mask = CMD_A_OTG_ENABLED, |
1526 | .enable_val = CMD_A_OTG_ENABLED, |
1527 | .fixed_uV = 5000000, |
1528 | .n_voltages = 1, |
1529 | }; |
1530 | |
1531 | static int smb347_probe(struct i2c_client *client) |
1532 | { |
1533 | const struct i2c_device_id *id = i2c_client_get_device_id(client); |
1534 | struct power_supply_config mains_usb_cfg = {}; |
1535 | struct regulator_config usb_rdev_cfg = {}; |
1536 | struct device *dev = &client->dev; |
1537 | struct smb347_charger *smb; |
1538 | int ret; |
1539 | |
1540 | smb = devm_kzalloc(dev, size: sizeof(*smb), GFP_KERNEL); |
1541 | if (!smb) |
1542 | return -ENOMEM; |
1543 | smb->dev = &client->dev; |
1544 | smb->id = id->driver_data; |
1545 | i2c_set_clientdata(client, data: smb); |
1546 | |
1547 | smb347_dt_parse_dev_info(smb); |
1548 | if (!smb->use_mains && !smb->use_usb) |
1549 | return -EINVAL; |
1550 | |
1551 | smb->regmap = devm_regmap_init_i2c(client, &smb347_regmap); |
1552 | if (IS_ERR(ptr: smb->regmap)) |
1553 | return PTR_ERR(ptr: smb->regmap); |
1554 | |
1555 | mains_usb_cfg.drv_data = smb; |
1556 | mains_usb_cfg.of_node = dev->of_node; |
1557 | if (smb->use_mains) { |
1558 | smb->mains = devm_power_supply_register(parent: dev, desc: &smb347_mains_desc, |
1559 | cfg: &mains_usb_cfg); |
1560 | if (IS_ERR(ptr: smb->mains)) |
1561 | return PTR_ERR(ptr: smb->mains); |
1562 | } |
1563 | |
1564 | if (smb->use_usb) { |
1565 | smb->usb = devm_power_supply_register(parent: dev, desc: &smb347_usb_desc, |
1566 | cfg: &mains_usb_cfg); |
1567 | if (IS_ERR(ptr: smb->usb)) |
1568 | return PTR_ERR(ptr: smb->usb); |
1569 | } |
1570 | |
1571 | ret = smb347_get_battery_info(smb); |
1572 | if (ret) |
1573 | return ret; |
1574 | |
1575 | ret = smb347_hw_init(smb); |
1576 | if (ret < 0) |
1577 | return ret; |
1578 | |
1579 | ret = smb347_irq_init(smb, client); |
1580 | if (ret) |
1581 | return ret; |
1582 | |
1583 | usb_rdev_cfg.dev = dev; |
1584 | usb_rdev_cfg.driver_data = smb; |
1585 | usb_rdev_cfg.regmap = smb->regmap; |
1586 | |
1587 | smb->usb_rdev = devm_regulator_register(dev, |
1588 | regulator_desc: &smb347_usb_vbus_regulator_desc, |
1589 | config: &usb_rdev_cfg); |
1590 | if (IS_ERR(ptr: smb->usb_rdev)) { |
1591 | smb347_irq_disable(smb); |
1592 | return PTR_ERR(ptr: smb->usb_rdev); |
1593 | } |
1594 | |
1595 | return 0; |
1596 | } |
1597 | |
1598 | static void smb347_remove(struct i2c_client *client) |
1599 | { |
1600 | struct smb347_charger *smb = i2c_get_clientdata(client); |
1601 | |
1602 | smb347_usb_vbus_regulator_disable(rdev: smb->usb_rdev); |
1603 | smb347_irq_disable(smb); |
1604 | } |
1605 | |
1606 | static void smb347_shutdown(struct i2c_client *client) |
1607 | { |
1608 | smb347_remove(client); |
1609 | } |
1610 | |
1611 | static const struct i2c_device_id smb347_id[] = { |
1612 | { "smb345" , SMB345 }, |
1613 | { "smb347" , SMB347 }, |
1614 | { "smb358" , SMB358 }, |
1615 | { }, |
1616 | }; |
1617 | MODULE_DEVICE_TABLE(i2c, smb347_id); |
1618 | |
1619 | static const struct of_device_id smb3xx_of_match[] = { |
1620 | { .compatible = "summit,smb345" }, |
1621 | { .compatible = "summit,smb347" }, |
1622 | { .compatible = "summit,smb358" }, |
1623 | { }, |
1624 | }; |
1625 | MODULE_DEVICE_TABLE(of, smb3xx_of_match); |
1626 | |
1627 | static struct i2c_driver smb347_driver = { |
1628 | .driver = { |
1629 | .name = "smb347" , |
1630 | .of_match_table = smb3xx_of_match, |
1631 | }, |
1632 | .probe = smb347_probe, |
1633 | .remove = smb347_remove, |
1634 | .shutdown = smb347_shutdown, |
1635 | .id_table = smb347_id, |
1636 | }; |
1637 | module_i2c_driver(smb347_driver); |
1638 | |
1639 | MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>" ); |
1640 | MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>" ); |
1641 | MODULE_DESCRIPTION("SMB347 battery charger driver" ); |
1642 | MODULE_LICENSE("GPL" ); |
1643 | |