1// SPDX-License-Identifier: GPL-2.0
2// BQ256XX Battery Charger Driver
3// Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
4
5#include <linux/err.h>
6#include <linux/i2c.h>
7#include <linux/init.h>
8#include <linux/interrupt.h>
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/gpio/consumer.h>
12#include <linux/power_supply.h>
13#include <linux/regmap.h>
14#include <linux/types.h>
15#include <linux/usb/phy.h>
16#include <linux/device.h>
17#include <linux/moduleparam.h>
18#include <linux/slab.h>
19#include <linux/acpi.h>
20
21#define BQ256XX_MANUFACTURER "Texas Instruments"
22
23#define BQ256XX_INPUT_CURRENT_LIMIT 0x00
24#define BQ256XX_CHARGER_CONTROL_0 0x01
25#define BQ256XX_CHARGE_CURRENT_LIMIT 0x02
26#define BQ256XX_PRECHG_AND_TERM_CURR_LIM 0x03
27#define BQ256XX_BATTERY_VOLTAGE_LIMIT 0x04
28#define BQ256XX_CHARGER_CONTROL_1 0x05
29#define BQ256XX_CHARGER_CONTROL_2 0x06
30#define BQ256XX_CHARGER_CONTROL_3 0x07
31#define BQ256XX_CHARGER_STATUS_0 0x08
32#define BQ256XX_CHARGER_STATUS_1 0x09
33#define BQ256XX_CHARGER_STATUS_2 0x0a
34#define BQ256XX_PART_INFORMATION 0x0b
35#define BQ256XX_CHARGER_CONTROL_4 0x0c
36
37#define BQ256XX_IINDPM_MASK GENMASK(4, 0)
38#define BQ256XX_IINDPM_STEP_uA 100000
39#define BQ256XX_IINDPM_OFFSET_uA 100000
40#define BQ256XX_IINDPM_MIN_uA 100000
41#define BQ256XX_IINDPM_MAX_uA 3200000
42#define BQ256XX_IINDPM_DEF_uA 2400000
43
44#define BQ256XX_TS_IGNORE BIT(6)
45#define BQ256XX_TS_IGNORE_SHIFT 6
46
47#define BQ256XX_VINDPM_MASK GENMASK(3, 0)
48#define BQ256XX_VINDPM_STEP_uV 100000
49#define BQ256XX_VINDPM_OFFSET_uV 3900000
50#define BQ256XX_VINDPM_MIN_uV 3900000
51#define BQ256XX_VINDPM_MAX_uV 5400000
52#define BQ256XX_VINDPM_DEF_uV 4500000
53
54#define BQ256XX_VBATREG_MASK GENMASK(7, 3)
55#define BQ2560X_VBATREG_STEP_uV 32000
56#define BQ2560X_VBATREG_OFFSET_uV 3856000
57#define BQ2560X_VBATREG_MIN_uV 3856000
58#define BQ2560X_VBATREG_MAX_uV 4624000
59#define BQ2560X_VBATREG_DEF_uV 4208000
60#define BQ25601D_VBATREG_OFFSET_uV 3847000
61#define BQ25601D_VBATREG_MIN_uV 3847000
62#define BQ25601D_VBATREG_MAX_uV 4615000
63#define BQ25601D_VBATREG_DEF_uV 4199000
64#define BQ2561X_VBATREG_STEP_uV 10000
65#define BQ25611D_VBATREG_MIN_uV 3494000
66#define BQ25611D_VBATREG_MAX_uV 4510000
67#define BQ25611D_VBATREG_DEF_uV 4190000
68#define BQ25618_VBATREG_MIN_uV 3504000
69#define BQ25618_VBATREG_MAX_uV 4500000
70#define BQ25618_VBATREG_DEF_uV 4200000
71#define BQ256XX_VBATREG_BIT_SHIFT 3
72#define BQ2561X_VBATREG_THRESH 0x8
73#define BQ25611D_VBATREG_THRESH_uV 4290000
74#define BQ25618_VBATREG_THRESH_uV 4300000
75
76#define BQ256XX_CHG_CONFIG_MASK BIT(4)
77#define BQ256XX_CHG_CONFIG_BIT_SHIFT 4
78
79#define BQ256XX_ITERM_MASK GENMASK(3, 0)
80#define BQ256XX_ITERM_STEP_uA 60000
81#define BQ256XX_ITERM_OFFSET_uA 60000
82#define BQ256XX_ITERM_MIN_uA 60000
83#define BQ256XX_ITERM_MAX_uA 780000
84#define BQ256XX_ITERM_DEF_uA 180000
85#define BQ25618_ITERM_STEP_uA 20000
86#define BQ25618_ITERM_OFFSET_uA 20000
87#define BQ25618_ITERM_MIN_uA 20000
88#define BQ25618_ITERM_MAX_uA 260000
89#define BQ25618_ITERM_DEF_uA 60000
90
91#define BQ256XX_IPRECHG_MASK GENMASK(7, 4)
92#define BQ256XX_IPRECHG_STEP_uA 60000
93#define BQ256XX_IPRECHG_OFFSET_uA 60000
94#define BQ256XX_IPRECHG_MIN_uA 60000
95#define BQ256XX_IPRECHG_MAX_uA 780000
96#define BQ256XX_IPRECHG_DEF_uA 180000
97#define BQ25618_IPRECHG_STEP_uA 20000
98#define BQ25618_IPRECHG_OFFSET_uA 20000
99#define BQ25618_IPRECHG_MIN_uA 20000
100#define BQ25618_IPRECHG_MAX_uA 260000
101#define BQ25618_IPRECHG_DEF_uA 40000
102#define BQ256XX_IPRECHG_BIT_SHIFT 4
103
104#define BQ256XX_ICHG_MASK GENMASK(5, 0)
105#define BQ256XX_ICHG_STEP_uA 60000
106#define BQ256XX_ICHG_MIN_uA 0
107#define BQ256XX_ICHG_MAX_uA 3000000
108#define BQ2560X_ICHG_DEF_uA 2040000
109#define BQ25611D_ICHG_DEF_uA 1020000
110#define BQ25618_ICHG_STEP_uA 20000
111#define BQ25618_ICHG_MIN_uA 0
112#define BQ25618_ICHG_MAX_uA 1500000
113#define BQ25618_ICHG_DEF_uA 340000
114#define BQ25618_ICHG_THRESH 0x3c
115#define BQ25618_ICHG_THRESH_uA 1180000
116
117#define BQ256XX_VBUS_STAT_MASK GENMASK(7, 5)
118#define BQ256XX_VBUS_STAT_NO_INPUT 0
119#define BQ256XX_VBUS_STAT_USB_SDP BIT(5)
120#define BQ256XX_VBUS_STAT_USB_CDP BIT(6)
121#define BQ256XX_VBUS_STAT_USB_DCP (BIT(6) | BIT(5))
122#define BQ256XX_VBUS_STAT_USB_OTG (BIT(7) | BIT(6) | BIT(5))
123
124#define BQ256XX_CHRG_STAT_MASK GENMASK(4, 3)
125#define BQ256XX_CHRG_STAT_NOT_CHRGING 0
126#define BQ256XX_CHRG_STAT_PRECHRGING BIT(3)
127#define BQ256XX_CHRG_STAT_FAST_CHRGING BIT(4)
128#define BQ256XX_CHRG_STAT_CHRG_TERM (BIT(4) | BIT(3))
129
130#define BQ256XX_PG_STAT_MASK BIT(2)
131#define BQ256XX_WDT_FAULT_MASK BIT(7)
132#define BQ256XX_CHRG_FAULT_MASK GENMASK(5, 4)
133#define BQ256XX_CHRG_FAULT_NORMAL 0
134#define BQ256XX_CHRG_FAULT_INPUT BIT(4)
135#define BQ256XX_CHRG_FAULT_THERM BIT(5)
136#define BQ256XX_CHRG_FAULT_CST_EXPIRE (BIT(5) | BIT(4))
137#define BQ256XX_BAT_FAULT_MASK BIT(3)
138#define BQ256XX_NTC_FAULT_MASK GENMASK(2, 0)
139#define BQ256XX_NTC_FAULT_WARM BIT(1)
140#define BQ256XX_NTC_FAULT_COOL (BIT(1) | BIT(0))
141#define BQ256XX_NTC_FAULT_COLD (BIT(2) | BIT(0))
142#define BQ256XX_NTC_FAULT_HOT (BIT(2) | BIT(1))
143
144#define BQ256XX_NUM_WD_VAL 4
145#define BQ256XX_WATCHDOG_MASK GENMASK(5, 4)
146#define BQ256XX_WATCHDOG_MAX 1600000
147#define BQ256XX_WATCHDOG_DIS 0
148#define BQ256XX_WDT_BIT_SHIFT 4
149
150#define BQ256XX_REG_RST BIT(7)
151
152/**
153 * struct bq256xx_init_data -
154 * @ichg: fast charge current
155 * @iindpm: input current limit
156 * @vbatreg: charge voltage
157 * @iterm: termination current
158 * @iprechg: precharge current
159 * @vindpm: input voltage limit
160 * @ichg_max: maximum fast charge current
161 * @vbatreg_max: maximum charge voltage
162 * @ts_ignore: TS_IGNORE flag
163 */
164struct bq256xx_init_data {
165 u32 ichg;
166 u32 iindpm;
167 u32 vbatreg;
168 u32 iterm;
169 u32 iprechg;
170 u32 vindpm;
171 u32 ichg_max;
172 u32 vbatreg_max;
173 bool ts_ignore;
174};
175
176/**
177 * struct bq256xx_state -
178 * @vbus_stat: VBUS status according to BQ256XX_CHARGER_STATUS_0
179 * @chrg_stat: charging status according to BQ256XX_CHARGER_STATUS_0
180 * @online: PG status according to BQ256XX_CHARGER_STATUS_0
181 *
182 * @wdt_fault: watchdog fault according to BQ256XX_CHARGER_STATUS_1
183 * @bat_fault: battery fault according to BQ256XX_CHARGER_STATUS_1
184 * @chrg_fault: charging fault according to BQ256XX_CHARGER_STATUS_1
185 * @ntc_fault: TS fault according to BQ256XX_CHARGER_STATUS_1
186 */
187struct bq256xx_state {
188 u8 vbus_stat;
189 u8 chrg_stat;
190 bool online;
191
192 u8 wdt_fault;
193 u8 bat_fault;
194 u8 chrg_fault;
195 u8 ntc_fault;
196};
197
198enum bq256xx_id {
199 BQ25600,
200 BQ25600D,
201 BQ25601,
202 BQ25601D,
203 BQ25618,
204 BQ25619,
205 BQ25611D,
206};
207
208/**
209 * struct bq256xx_device -
210 * @client: i2c client structure
211 * @regmap: register map structure
212 * @dev: device structure
213 * @charger: power supply registered for the charger
214 * @battery: power supply registered for the battery
215 * @lock: mutex lock structure
216 *
217 * @usb2_phy: usb_phy identifier
218 * @usb3_phy: usb_phy identifier
219 * @usb_nb: notifier block
220 * @usb_work: usb work queue
221 * @usb_event: usb_event code
222 *
223 * @model_name: i2c name string
224 *
225 * @init_data: initialization data
226 * @chip_info: device variant information
227 * @state: device status and faults
228 * @watchdog_timer: watchdog timer value in milliseconds
229 */
230struct bq256xx_device {
231 struct i2c_client *client;
232 struct device *dev;
233 struct power_supply *charger;
234 struct power_supply *battery;
235 struct mutex lock;
236 struct regmap *regmap;
237
238 struct usb_phy *usb2_phy;
239 struct usb_phy *usb3_phy;
240 struct notifier_block usb_nb;
241 struct work_struct usb_work;
242 unsigned long usb_event;
243
244 char model_name[I2C_NAME_SIZE];
245
246 struct bq256xx_init_data init_data;
247 const struct bq256xx_chip_info *chip_info;
248 struct bq256xx_state state;
249 int watchdog_timer;
250};
251
252/**
253 * struct bq256xx_chip_info -
254 * @model_id: device instance
255 *
256 * @bq256xx_regmap_config: regmap configuration struct
257 * @bq256xx_get_ichg: pointer to instance specific get_ichg function
258 * @bq256xx_get_iindpm: pointer to instance specific get_iindpm function
259 * @bq256xx_get_vbatreg: pointer to instance specific get_vbatreg function
260 * @bq256xx_get_iterm: pointer to instance specific get_iterm function
261 * @bq256xx_get_iprechg: pointer to instance specific get_iprechg function
262 * @bq256xx_get_vindpm: pointer to instance specific get_vindpm function
263 *
264 * @bq256xx_set_ichg: pointer to instance specific set_ichg function
265 * @bq256xx_set_iindpm: pointer to instance specific set_iindpm function
266 * @bq256xx_set_vbatreg: pointer to instance specific set_vbatreg function
267 * @bq256xx_set_iterm: pointer to instance specific set_iterm function
268 * @bq256xx_set_iprechg: pointer to instance specific set_iprechg function
269 * @bq256xx_set_vindpm: pointer to instance specific set_vindpm function
270 * @bq256xx_set_charge_type: pointer to instance specific set_charge_type function
271 * @bq256xx_set_ts_ignore: pointer to instance specific set_ts_ignore function
272 *
273 * @bq256xx_def_ichg: default ichg value in microamps
274 * @bq256xx_def_iindpm: default iindpm value in microamps
275 * @bq256xx_def_vbatreg: default vbatreg value in microvolts
276 * @bq256xx_def_iterm: default iterm value in microamps
277 * @bq256xx_def_iprechg: default iprechg value in microamps
278 * @bq256xx_def_vindpm: default vindpm value in microvolts
279 *
280 * @bq256xx_max_ichg: maximum charge current in microamps
281 * @bq256xx_max_vbatreg: maximum battery regulation voltage in microvolts
282 *
283 * @has_usb_detect: indicates whether device has BC1.2 detection
284 */
285struct bq256xx_chip_info {
286 int model_id;
287
288 const struct regmap_config *bq256xx_regmap_config;
289
290 int (*bq256xx_get_ichg)(struct bq256xx_device *bq);
291 int (*bq256xx_get_iindpm)(struct bq256xx_device *bq);
292 int (*bq256xx_get_vbatreg)(struct bq256xx_device *bq);
293 int (*bq256xx_get_iterm)(struct bq256xx_device *bq);
294 int (*bq256xx_get_iprechg)(struct bq256xx_device *bq);
295 int (*bq256xx_get_vindpm)(struct bq256xx_device *bq);
296
297 int (*bq256xx_set_ichg)(struct bq256xx_device *bq, int ichg);
298 int (*bq256xx_set_iindpm)(struct bq256xx_device *bq, int iindpm);
299 int (*bq256xx_set_vbatreg)(struct bq256xx_device *bq, int vbatreg);
300 int (*bq256xx_set_iterm)(struct bq256xx_device *bq, int iterm);
301 int (*bq256xx_set_iprechg)(struct bq256xx_device *bq, int iprechg);
302 int (*bq256xx_set_vindpm)(struct bq256xx_device *bq, int vindpm);
303 int (*bq256xx_set_charge_type)(struct bq256xx_device *bq, int type);
304 int (*bq256xx_set_ts_ignore)(struct bq256xx_device *bq, bool ts_ignore);
305
306 int bq256xx_def_ichg;
307 int bq256xx_def_iindpm;
308 int bq256xx_def_vbatreg;
309 int bq256xx_def_iterm;
310 int bq256xx_def_iprechg;
311 int bq256xx_def_vindpm;
312
313 int bq256xx_max_ichg;
314 int bq256xx_max_vbatreg;
315
316 bool has_usb_detect;
317};
318
319static int bq256xx_watchdog_time[BQ256XX_NUM_WD_VAL] = {
320 0, 40000, 80000, 1600000
321};
322
323static const int bq25611d_vbatreg_values[] = {
324 3494000, 3590000, 3686000, 3790000, 3894000, 3990000, 4090000, 4140000,
325 4190000
326};
327
328static const int bq25618_619_vbatreg_values[] = {
329 3504000, 3600000, 3696000, 3800000, 3904000, 4000000, 4100000, 4150000,
330 4200000
331};
332
333static const int bq25618_619_ichg_values[] = {
334 1290000, 1360000, 1430000, 1500000
335};
336
337static int bq256xx_array_parse(int array_size, int val, const int array[])
338{
339 int i = 0;
340
341 if (val < array[i])
342 return i - 1;
343
344 if (val >= array[array_size - 1])
345 return array_size - 1;
346
347 for (i = 1; i < array_size; i++) {
348 if (val == array[i])
349 return i;
350
351 if (val > array[i - 1] && val < array[i]) {
352 if (val < array[i])
353 return i - 1;
354 else
355 return i;
356 }
357 }
358 return -EINVAL;
359}
360
361static int bq256xx_usb_notifier(struct notifier_block *nb, unsigned long val,
362 void *priv)
363{
364 struct bq256xx_device *bq =
365 container_of(nb, struct bq256xx_device, usb_nb);
366
367 bq->usb_event = val;
368 queue_work(wq: system_power_efficient_wq, work: &bq->usb_work);
369
370 return NOTIFY_OK;
371}
372
373static void bq256xx_usb_work(struct work_struct *data)
374{
375 struct bq256xx_device *bq =
376 container_of(data, struct bq256xx_device, usb_work);
377
378 switch (bq->usb_event) {
379 case USB_EVENT_ID:
380 break;
381 case USB_EVENT_NONE:
382 power_supply_changed(psy: bq->charger);
383 break;
384 default:
385 dev_err(bq->dev, "Error switching to charger mode.\n");
386 break;
387 }
388}
389
390static const struct reg_default bq2560x_reg_defs[] = {
391 {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
392 {BQ256XX_CHARGER_CONTROL_0, 0x1a},
393 {BQ256XX_CHARGE_CURRENT_LIMIT, 0xa2},
394 {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x22},
395 {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x58},
396 {BQ256XX_CHARGER_CONTROL_1, 0x9f},
397 {BQ256XX_CHARGER_CONTROL_2, 0x66},
398 {BQ256XX_CHARGER_CONTROL_3, 0x4c},
399};
400
401static const struct reg_default bq25611d_reg_defs[] = {
402 {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
403 {BQ256XX_CHARGER_CONTROL_0, 0x1a},
404 {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
405 {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
406 {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
407 {BQ256XX_CHARGER_CONTROL_1, 0x9e},
408 {BQ256XX_CHARGER_CONTROL_2, 0xe6},
409 {BQ256XX_CHARGER_CONTROL_3, 0x4c},
410 {BQ256XX_PART_INFORMATION, 0x54},
411 {BQ256XX_CHARGER_CONTROL_4, 0x75},
412};
413
414static const struct reg_default bq25618_619_reg_defs[] = {
415 {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
416 {BQ256XX_CHARGER_CONTROL_0, 0x1a},
417 {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
418 {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
419 {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
420 {BQ256XX_CHARGER_CONTROL_1, 0x9e},
421 {BQ256XX_CHARGER_CONTROL_2, 0xe6},
422 {BQ256XX_CHARGER_CONTROL_3, 0x4c},
423 {BQ256XX_PART_INFORMATION, 0x2c},
424 {BQ256XX_CHARGER_CONTROL_4, 0x75},
425};
426
427static int bq256xx_get_state(struct bq256xx_device *bq,
428 struct bq256xx_state *state)
429{
430 unsigned int charger_status_0;
431 unsigned int charger_status_1;
432 int ret;
433
434 ret = regmap_read(map: bq->regmap, BQ256XX_CHARGER_STATUS_0,
435 val: &charger_status_0);
436 if (ret)
437 return ret;
438
439 ret = regmap_read(map: bq->regmap, BQ256XX_CHARGER_STATUS_1,
440 val: &charger_status_1);
441 if (ret)
442 return ret;
443
444 state->vbus_stat = charger_status_0 & BQ256XX_VBUS_STAT_MASK;
445 state->chrg_stat = charger_status_0 & BQ256XX_CHRG_STAT_MASK;
446 state->online = charger_status_0 & BQ256XX_PG_STAT_MASK;
447
448 state->wdt_fault = charger_status_1 & BQ256XX_WDT_FAULT_MASK;
449 state->bat_fault = charger_status_1 & BQ256XX_BAT_FAULT_MASK;
450 state->chrg_fault = charger_status_1 & BQ256XX_CHRG_FAULT_MASK;
451 state->ntc_fault = charger_status_1 & BQ256XX_NTC_FAULT_MASK;
452
453 return 0;
454}
455
456static int bq256xx_set_charge_type(struct bq256xx_device *bq, int type)
457{
458 int chg_config = 0;
459
460 switch (type) {
461 case POWER_SUPPLY_CHARGE_TYPE_NONE:
462 chg_config = 0x0;
463 break;
464 case POWER_SUPPLY_CHARGE_TYPE_TRICKLE:
465 case POWER_SUPPLY_CHARGE_TYPE_FAST:
466 chg_config = 0x1;
467 break;
468 default:
469 return -EINVAL;
470 }
471
472 return regmap_update_bits(map: bq->regmap, BQ256XX_CHARGER_CONTROL_0,
473 BQ256XX_CHG_CONFIG_MASK,
474 val: (chg_config ? 1 : 0) << BQ256XX_CHG_CONFIG_BIT_SHIFT);
475}
476
477static int bq256xx_get_ichg_curr(struct bq256xx_device *bq)
478{
479 unsigned int charge_current_limit;
480 unsigned int ichg_reg_code;
481 int ret;
482
483 ret = regmap_read(map: bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
484 val: &charge_current_limit);
485 if (ret)
486 return ret;
487
488 ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
489
490 return ichg_reg_code * BQ256XX_ICHG_STEP_uA;
491}
492
493static int bq25618_619_get_ichg_curr(struct bq256xx_device *bq)
494{
495 unsigned int charge_current_limit;
496 unsigned int ichg_reg_code;
497 int ret;
498
499 ret = regmap_read(map: bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
500 val: &charge_current_limit);
501 if (ret)
502 return ret;
503
504 ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
505
506 if (ichg_reg_code < BQ25618_ICHG_THRESH)
507 return ichg_reg_code * BQ25618_ICHG_STEP_uA;
508
509 return bq25618_619_ichg_values[ichg_reg_code - BQ25618_ICHG_THRESH];
510}
511
512static int bq256xx_set_ichg_curr(struct bq256xx_device *bq, int ichg)
513{
514 unsigned int ichg_reg_code;
515 int ichg_max = bq->init_data.ichg_max;
516
517 ichg = clamp(ichg, BQ256XX_ICHG_MIN_uA, ichg_max);
518 ichg_reg_code = ichg / BQ256XX_ICHG_STEP_uA;
519
520 return regmap_update_bits(map: bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
521 BQ256XX_ICHG_MASK, val: ichg_reg_code);
522}
523
524static int bq25618_619_set_ichg_curr(struct bq256xx_device *bq, int ichg)
525{
526 int array_size = ARRAY_SIZE(bq25618_619_ichg_values);
527 unsigned int ichg_reg_code;
528 int ichg_max = bq->init_data.ichg_max;
529
530 ichg = clamp(ichg, BQ25618_ICHG_MIN_uA, ichg_max);
531
532 if (ichg <= BQ25618_ICHG_THRESH_uA) {
533 ichg_reg_code = ichg / BQ25618_ICHG_STEP_uA;
534 } else {
535 ichg_reg_code = bq256xx_array_parse(array_size, val: ichg,
536 array: bq25618_619_ichg_values) + BQ25618_ICHG_THRESH;
537 }
538
539 return regmap_update_bits(map: bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
540 BQ256XX_ICHG_MASK, val: ichg_reg_code);
541}
542
543static int bq25618_619_get_chrg_volt(struct bq256xx_device *bq)
544{
545 unsigned int battery_volt_lim;
546 unsigned int vbatreg_reg_code;
547 int ret;
548
549 ret = regmap_read(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
550 val: &battery_volt_lim);
551
552 if (ret)
553 return ret;
554
555 vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
556 BQ256XX_VBATREG_BIT_SHIFT;
557
558 if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
559 return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
560 BQ2561X_VBATREG_STEP_uV) +
561 BQ25618_VBATREG_THRESH_uV;
562
563 return bq25618_619_vbatreg_values[vbatreg_reg_code];
564}
565
566static int bq25611d_get_chrg_volt(struct bq256xx_device *bq)
567{
568 unsigned int battery_volt_lim;
569 unsigned int vbatreg_reg_code;
570 int ret;
571
572 ret = regmap_read(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
573 val: &battery_volt_lim);
574 if (ret)
575 return ret;
576
577 vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
578 BQ256XX_VBATREG_BIT_SHIFT;
579
580 if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
581 return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
582 BQ2561X_VBATREG_STEP_uV) +
583 BQ25611D_VBATREG_THRESH_uV;
584
585 return bq25611d_vbatreg_values[vbatreg_reg_code];
586}
587
588static int bq2560x_get_chrg_volt(struct bq256xx_device *bq)
589{
590 unsigned int battery_volt_lim;
591 unsigned int vbatreg_reg_code;
592 int ret;
593
594 ret = regmap_read(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
595 val: &battery_volt_lim);
596 if (ret)
597 return ret;
598
599 vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
600 BQ256XX_VBATREG_BIT_SHIFT;
601
602 return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
603 + BQ2560X_VBATREG_OFFSET_uV;
604}
605
606static int bq25601d_get_chrg_volt(struct bq256xx_device *bq)
607{
608 unsigned int battery_volt_lim;
609 unsigned int vbatreg_reg_code;
610 int ret;
611
612 ret = regmap_read(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
613 val: &battery_volt_lim);
614 if (ret)
615 return ret;
616
617 vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
618 BQ256XX_VBATREG_BIT_SHIFT;
619
620 return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
621 + BQ25601D_VBATREG_OFFSET_uV;
622}
623
624static int bq25618_619_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
625{
626 int array_size = ARRAY_SIZE(bq25618_619_vbatreg_values);
627 unsigned int vbatreg_reg_code;
628 int vbatreg_max = bq->init_data.vbatreg_max;
629
630 vbatreg = clamp(vbatreg, BQ25618_VBATREG_MIN_uV, vbatreg_max);
631
632 if (vbatreg > BQ25618_VBATREG_THRESH_uV)
633 vbatreg_reg_code = ((vbatreg -
634 BQ25618_VBATREG_THRESH_uV) /
635 (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
636 else {
637 vbatreg_reg_code = bq256xx_array_parse(array_size, val: vbatreg,
638 array: bq25618_619_vbatreg_values);
639 }
640
641 return regmap_update_bits(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
642 BQ256XX_VBATREG_MASK, val: vbatreg_reg_code <<
643 BQ256XX_VBATREG_BIT_SHIFT);
644}
645
646static int bq25611d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
647{
648 int array_size = ARRAY_SIZE(bq25611d_vbatreg_values);
649 unsigned int vbatreg_reg_code;
650 int vbatreg_max = bq->init_data.vbatreg_max;
651
652 vbatreg = clamp(vbatreg, BQ25611D_VBATREG_MIN_uV, vbatreg_max);
653
654 if (vbatreg > BQ25611D_VBATREG_THRESH_uV)
655 vbatreg_reg_code = ((vbatreg -
656 BQ25611D_VBATREG_THRESH_uV) /
657 (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
658 else {
659 vbatreg_reg_code = bq256xx_array_parse(array_size, val: vbatreg,
660 array: bq25611d_vbatreg_values);
661 }
662
663 return regmap_update_bits(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
664 BQ256XX_VBATREG_MASK, val: vbatreg_reg_code <<
665 BQ256XX_VBATREG_BIT_SHIFT);
666}
667
668static int bq2560x_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
669{
670 unsigned int vbatreg_reg_code;
671 int vbatreg_max = bq->init_data.vbatreg_max;
672
673 vbatreg = clamp(vbatreg, BQ2560X_VBATREG_MIN_uV, vbatreg_max);
674
675 vbatreg_reg_code = (vbatreg - BQ2560X_VBATREG_OFFSET_uV) /
676 BQ2560X_VBATREG_STEP_uV;
677
678 return regmap_update_bits(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
679 BQ256XX_VBATREG_MASK, val: vbatreg_reg_code <<
680 BQ256XX_VBATREG_BIT_SHIFT);
681}
682
683static int bq25601d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
684{
685 unsigned int vbatreg_reg_code;
686 int vbatreg_max = bq->init_data.vbatreg_max;
687
688 vbatreg = clamp(vbatreg, BQ25601D_VBATREG_MIN_uV, vbatreg_max);
689
690 vbatreg_reg_code = (vbatreg - BQ25601D_VBATREG_OFFSET_uV) /
691 BQ2560X_VBATREG_STEP_uV;
692
693 return regmap_update_bits(map: bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
694 BQ256XX_VBATREG_MASK, val: vbatreg_reg_code <<
695 BQ256XX_VBATREG_BIT_SHIFT);
696}
697
698static int bq256xx_set_ts_ignore(struct bq256xx_device *bq, bool ts_ignore)
699{
700 return regmap_update_bits(map: bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
701 BQ256XX_TS_IGNORE, val: (ts_ignore ? 1 : 0) << BQ256XX_TS_IGNORE_SHIFT);
702}
703
704static int bq256xx_get_prechrg_curr(struct bq256xx_device *bq)
705{
706 unsigned int prechg_and_term_curr_lim;
707 unsigned int iprechg_reg_code;
708 int ret;
709
710 ret = regmap_read(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
711 val: &prechg_and_term_curr_lim);
712 if (ret)
713 return ret;
714
715 iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
716 >> BQ256XX_IPRECHG_BIT_SHIFT;
717
718 return (iprechg_reg_code * BQ256XX_IPRECHG_STEP_uA) +
719 BQ256XX_IPRECHG_OFFSET_uA;
720}
721
722static int bq256xx_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
723{
724 unsigned int iprechg_reg_code;
725
726 iprechg = clamp(iprechg, BQ256XX_IPRECHG_MIN_uA,
727 BQ256XX_IPRECHG_MAX_uA);
728
729 iprechg_reg_code = ((iprechg - BQ256XX_IPRECHG_OFFSET_uA) /
730 BQ256XX_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
731
732 return regmap_update_bits(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
733 BQ256XX_IPRECHG_MASK, val: iprechg_reg_code);
734}
735
736static int bq25618_619_get_prechrg_curr(struct bq256xx_device *bq)
737{
738 unsigned int prechg_and_term_curr_lim;
739 unsigned int iprechg_reg_code;
740 int ret;
741
742 ret = regmap_read(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
743 val: &prechg_and_term_curr_lim);
744 if (ret)
745 return ret;
746
747 iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
748 >> BQ256XX_IPRECHG_BIT_SHIFT;
749
750 return (iprechg_reg_code * BQ25618_IPRECHG_STEP_uA) +
751 BQ25618_IPRECHG_OFFSET_uA;
752}
753
754static int bq25618_619_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
755{
756 unsigned int iprechg_reg_code;
757
758 iprechg = clamp(iprechg, BQ25618_IPRECHG_MIN_uA,
759 BQ25618_IPRECHG_MAX_uA);
760
761 iprechg_reg_code = ((iprechg - BQ25618_IPRECHG_OFFSET_uA) /
762 BQ25618_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
763
764 return regmap_update_bits(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
765 BQ256XX_IPRECHG_MASK, val: iprechg_reg_code);
766}
767
768static int bq256xx_get_term_curr(struct bq256xx_device *bq)
769{
770 unsigned int prechg_and_term_curr_lim;
771 unsigned int iterm_reg_code;
772 int ret;
773
774 ret = regmap_read(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
775 val: &prechg_and_term_curr_lim);
776 if (ret)
777 return ret;
778
779 iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
780
781 return (iterm_reg_code * BQ256XX_ITERM_STEP_uA) +
782 BQ256XX_ITERM_OFFSET_uA;
783}
784
785static int bq256xx_set_term_curr(struct bq256xx_device *bq, int iterm)
786{
787 unsigned int iterm_reg_code;
788
789 iterm = clamp(iterm, BQ256XX_ITERM_MIN_uA, BQ256XX_ITERM_MAX_uA);
790
791 iterm_reg_code = (iterm - BQ256XX_ITERM_OFFSET_uA) /
792 BQ256XX_ITERM_STEP_uA;
793
794 return regmap_update_bits(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
795 BQ256XX_ITERM_MASK, val: iterm_reg_code);
796}
797
798static int bq25618_619_get_term_curr(struct bq256xx_device *bq)
799{
800 unsigned int prechg_and_term_curr_lim;
801 unsigned int iterm_reg_code;
802 int ret;
803
804 ret = regmap_read(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
805 val: &prechg_and_term_curr_lim);
806 if (ret)
807 return ret;
808
809 iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
810
811 return (iterm_reg_code * BQ25618_ITERM_STEP_uA) +
812 BQ25618_ITERM_OFFSET_uA;
813}
814
815static int bq25618_619_set_term_curr(struct bq256xx_device *bq, int iterm)
816{
817 unsigned int iterm_reg_code;
818
819 iterm = clamp(iterm, BQ25618_ITERM_MIN_uA, BQ25618_ITERM_MAX_uA);
820
821 iterm_reg_code = (iterm - BQ25618_ITERM_OFFSET_uA) /
822 BQ25618_ITERM_STEP_uA;
823
824 return regmap_update_bits(map: bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
825 BQ256XX_ITERM_MASK, val: iterm_reg_code);
826}
827
828static int bq256xx_get_input_volt_lim(struct bq256xx_device *bq)
829{
830 unsigned int charger_control_2;
831 unsigned int vindpm_reg_code;
832 int ret;
833
834 ret = regmap_read(map: bq->regmap, BQ256XX_CHARGER_CONTROL_2,
835 val: &charger_control_2);
836 if (ret)
837 return ret;
838
839 vindpm_reg_code = charger_control_2 & BQ256XX_VINDPM_MASK;
840
841 return (vindpm_reg_code * BQ256XX_VINDPM_STEP_uV) +
842 BQ256XX_VINDPM_OFFSET_uV;
843}
844
845static int bq256xx_set_input_volt_lim(struct bq256xx_device *bq, int vindpm)
846{
847 unsigned int vindpm_reg_code;
848
849 vindpm = clamp(vindpm, BQ256XX_VINDPM_MIN_uV, BQ256XX_VINDPM_MAX_uV);
850
851 vindpm_reg_code = (vindpm - BQ256XX_VINDPM_OFFSET_uV) /
852 BQ256XX_VINDPM_STEP_uV;
853
854 return regmap_update_bits(map: bq->regmap, BQ256XX_CHARGER_CONTROL_2,
855 BQ256XX_VINDPM_MASK, val: vindpm_reg_code);
856}
857
858static int bq256xx_get_input_curr_lim(struct bq256xx_device *bq)
859{
860 unsigned int input_current_limit;
861 unsigned int iindpm_reg_code;
862 int ret;
863
864 ret = regmap_read(map: bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
865 val: &input_current_limit);
866 if (ret)
867 return ret;
868
869 iindpm_reg_code = input_current_limit & BQ256XX_IINDPM_MASK;
870
871 return (iindpm_reg_code * BQ256XX_IINDPM_STEP_uA) +
872 BQ256XX_IINDPM_OFFSET_uA;
873}
874
875static int bq256xx_set_input_curr_lim(struct bq256xx_device *bq, int iindpm)
876{
877 unsigned int iindpm_reg_code;
878
879 iindpm = clamp(iindpm, BQ256XX_IINDPM_MIN_uA, BQ256XX_IINDPM_MAX_uA);
880
881 iindpm_reg_code = (iindpm - BQ256XX_IINDPM_OFFSET_uA) /
882 BQ256XX_IINDPM_STEP_uA;
883
884 return regmap_update_bits(map: bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
885 BQ256XX_IINDPM_MASK, val: iindpm_reg_code);
886}
887
888static void bq256xx_charger_reset(void *data)
889{
890 struct bq256xx_device *bq = data;
891
892 regmap_update_bits(map: bq->regmap, BQ256XX_PART_INFORMATION,
893 BQ256XX_REG_RST, BQ256XX_REG_RST);
894
895 if (!IS_ERR_OR_NULL(ptr: bq->usb2_phy))
896 usb_unregister_notifier(x: bq->usb2_phy, nb: &bq->usb_nb);
897
898 if (!IS_ERR_OR_NULL(ptr: bq->usb3_phy))
899 usb_unregister_notifier(x: bq->usb3_phy, nb: &bq->usb_nb);
900}
901
902static int bq256xx_set_charger_property(struct power_supply *psy,
903 enum power_supply_property prop,
904 const union power_supply_propval *val)
905{
906 struct bq256xx_device *bq = power_supply_get_drvdata(psy);
907 int ret = -EINVAL;
908
909 switch (prop) {
910 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
911 ret = bq->chip_info->bq256xx_set_iindpm(bq, val->intval);
912 if (ret)
913 return ret;
914 break;
915
916 case POWER_SUPPLY_PROP_STATUS:
917 break;
918
919 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
920 ret = bq->chip_info->bq256xx_set_vbatreg(bq, val->intval);
921 if (ret)
922 return ret;
923 break;
924
925 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
926 ret = bq->chip_info->bq256xx_set_ichg(bq, val->intval);
927 if (ret)
928 return ret;
929 break;
930
931 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
932 ret = bq->chip_info->bq256xx_set_iprechg(bq, val->intval);
933 if (ret)
934 return ret;
935 break;
936
937 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
938 ret = bq->chip_info->bq256xx_set_iterm(bq, val->intval);
939 if (ret)
940 return ret;
941 break;
942
943 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
944 ret = bq->chip_info->bq256xx_set_vindpm(bq, val->intval);
945 if (ret)
946 return ret;
947 break;
948
949 case POWER_SUPPLY_PROP_CHARGE_TYPE:
950 ret = bq->chip_info->bq256xx_set_charge_type(bq, val->intval);
951 if (ret)
952 return ret;
953 break;
954
955 default:
956 break;
957 }
958
959 return ret;
960}
961
962
963static int bq256xx_get_battery_property(struct power_supply *psy,
964 enum power_supply_property psp,
965 union power_supply_propval *val)
966{
967 struct bq256xx_device *bq = power_supply_get_drvdata(psy);
968
969 switch (psp) {
970 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
971 val->intval = bq->init_data.ichg_max;
972 break;
973
974 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
975 val->intval = bq->init_data.vbatreg_max;
976 break;
977
978 default:
979 return -EINVAL;
980 }
981
982 return 0;
983}
984
985static int bq256xx_get_charger_property(struct power_supply *psy,
986 enum power_supply_property psp,
987 union power_supply_propval *val)
988{
989 struct bq256xx_device *bq = power_supply_get_drvdata(psy);
990 struct bq256xx_state state;
991 int ret = 0;
992
993 mutex_lock(&bq->lock);
994 ret = bq256xx_get_state(bq, state: &state);
995 mutex_unlock(lock: &bq->lock);
996 if (ret)
997 return ret;
998
999 switch (psp) {
1000 case POWER_SUPPLY_PROP_STATUS:
1001 if (state.vbus_stat == BQ256XX_VBUS_STAT_NO_INPUT ||
1002 state.vbus_stat == BQ256XX_VBUS_STAT_USB_OTG)
1003 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1004 else if (state.chrg_stat == BQ256XX_CHRG_STAT_NOT_CHRGING)
1005 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
1006 else if (state.chrg_stat == BQ256XX_CHRG_STAT_CHRG_TERM)
1007 val->intval = POWER_SUPPLY_STATUS_FULL;
1008 else
1009 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1010 break;
1011
1012 case POWER_SUPPLY_PROP_HEALTH:
1013 val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
1014 if (state.wdt_fault) {
1015 val->intval =
1016 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
1017 } else if (state.bat_fault) {
1018 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1019 } else {
1020 switch (state.chrg_stat) {
1021 case BQ256XX_CHRG_FAULT_INPUT:
1022 val->intval =
1023 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1024 break;
1025 case BQ256XX_CHRG_FAULT_THERM:
1026 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
1027 break;
1028 case BQ256XX_CHRG_FAULT_CST_EXPIRE:
1029 val->intval =
1030 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
1031 break;
1032 default:
1033 break;
1034 }
1035
1036 switch (state.ntc_fault) {
1037 case BQ256XX_NTC_FAULT_WARM:
1038 val->intval = POWER_SUPPLY_HEALTH_WARM;
1039 break;
1040 case BQ256XX_NTC_FAULT_COOL:
1041 val->intval = POWER_SUPPLY_HEALTH_COOL;
1042 break;
1043 case BQ256XX_NTC_FAULT_COLD:
1044 val->intval = POWER_SUPPLY_HEALTH_COLD;
1045 break;
1046 case BQ256XX_NTC_FAULT_HOT:
1047 val->intval = POWER_SUPPLY_HEALTH_HOT;
1048 break;
1049 default:
1050 val->intval = POWER_SUPPLY_HEALTH_GOOD;
1051 break;
1052 }
1053 }
1054 break;
1055
1056 case POWER_SUPPLY_PROP_USB_TYPE:
1057 if (bq->chip_info->has_usb_detect) {
1058 switch (state.vbus_stat) {
1059 case BQ256XX_VBUS_STAT_USB_SDP:
1060 val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1061 break;
1062 case BQ256XX_VBUS_STAT_USB_CDP:
1063 val->intval = POWER_SUPPLY_USB_TYPE_CDP;
1064 break;
1065 case BQ256XX_VBUS_STAT_USB_DCP:
1066 val->intval = POWER_SUPPLY_USB_TYPE_DCP;
1067 break;
1068 case BQ256XX_VBUS_STAT_USB_OTG:
1069 val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1070 break;
1071 default:
1072 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1073 break;
1074 }
1075 } else {
1076 switch (state.vbus_stat) {
1077 case BQ256XX_VBUS_STAT_USB_SDP:
1078 val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1079 break;
1080 case BQ256XX_VBUS_STAT_USB_OTG:
1081 val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1082 break;
1083 default:
1084 val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1085 break;
1086 }
1087 }
1088 break;
1089
1090 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1091 switch (state.chrg_stat) {
1092 case BQ256XX_CHRG_STAT_NOT_CHRGING:
1093 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1094 break;
1095 case BQ256XX_CHRG_STAT_PRECHRGING:
1096 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1097 break;
1098 case BQ256XX_CHRG_STAT_FAST_CHRGING:
1099 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1100 break;
1101 case BQ256XX_CHRG_STAT_CHRG_TERM:
1102 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1103 break;
1104 default:
1105 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
1106 }
1107 break;
1108
1109 case POWER_SUPPLY_PROP_MANUFACTURER:
1110 val->strval = BQ256XX_MANUFACTURER;
1111 break;
1112
1113 case POWER_SUPPLY_PROP_MODEL_NAME:
1114 val->strval = bq->model_name;
1115 break;
1116
1117 case POWER_SUPPLY_PROP_ONLINE:
1118 val->intval = state.online;
1119 break;
1120
1121 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1122 ret = bq->chip_info->bq256xx_get_vindpm(bq);
1123 if (ret < 0)
1124 return ret;
1125 val->intval = ret;
1126 break;
1127
1128 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1129 ret = bq->chip_info->bq256xx_get_iindpm(bq);
1130 if (ret < 0)
1131 return ret;
1132 val->intval = ret;
1133 break;
1134
1135 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1136 ret = bq->chip_info->bq256xx_get_vbatreg(bq);
1137 if (ret < 0)
1138 return ret;
1139 val->intval = ret;
1140 break;
1141
1142 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1143 ret = bq->chip_info->bq256xx_get_ichg(bq);
1144 if (ret < 0)
1145 return ret;
1146 val->intval = ret;
1147 break;
1148
1149 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1150 ret = bq->chip_info->bq256xx_get_iprechg(bq);
1151 if (ret < 0)
1152 return ret;
1153 val->intval = ret;
1154 break;
1155
1156 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1157 ret = bq->chip_info->bq256xx_get_iterm(bq);
1158 if (ret < 0)
1159 return ret;
1160 val->intval = ret;
1161 break;
1162
1163 default:
1164 return -EINVAL;
1165 }
1166
1167 return ret;
1168}
1169
1170static bool bq256xx_state_changed(struct bq256xx_device *bq,
1171 struct bq256xx_state *new_state)
1172{
1173 struct bq256xx_state old_state;
1174
1175 mutex_lock(&bq->lock);
1176 old_state = bq->state;
1177 mutex_unlock(lock: &bq->lock);
1178
1179 return memcmp(p: &old_state, q: new_state, size: sizeof(struct bq256xx_state)) != 0;
1180}
1181
1182static irqreturn_t bq256xx_irq_handler_thread(int irq, void *private)
1183{
1184 struct bq256xx_device *bq = private;
1185 struct bq256xx_state state;
1186 int ret;
1187
1188 ret = bq256xx_get_state(bq, state: &state);
1189 if (ret < 0)
1190 goto irq_out;
1191
1192 if (!bq256xx_state_changed(bq, new_state: &state))
1193 goto irq_out;
1194
1195 mutex_lock(&bq->lock);
1196 bq->state = state;
1197 mutex_unlock(lock: &bq->lock);
1198
1199 power_supply_changed(psy: bq->charger);
1200
1201irq_out:
1202 return IRQ_HANDLED;
1203}
1204
1205static enum power_supply_property bq256xx_power_supply_props[] = {
1206 POWER_SUPPLY_PROP_MANUFACTURER,
1207 POWER_SUPPLY_PROP_MODEL_NAME,
1208 POWER_SUPPLY_PROP_STATUS,
1209 POWER_SUPPLY_PROP_ONLINE,
1210 POWER_SUPPLY_PROP_HEALTH,
1211 POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
1212 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1213 POWER_SUPPLY_PROP_CHARGE_TYPE,
1214 POWER_SUPPLY_PROP_USB_TYPE,
1215 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1216 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1217 POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1218 POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1219};
1220
1221static enum power_supply_property bq256xx_battery_props[] = {
1222 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1223 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1224};
1225
1226static int bq256xx_property_is_writeable(struct power_supply *psy,
1227 enum power_supply_property prop)
1228{
1229 switch (prop) {
1230 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1231 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1232 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1233 case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1234 case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1235 case POWER_SUPPLY_PROP_STATUS:
1236 case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1237 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1238 return true;
1239 default:
1240 return false;
1241 }
1242}
1243
1244static const struct power_supply_desc bq256xx_power_supply_desc = {
1245 .name = "bq256xx-charger",
1246 .type = POWER_SUPPLY_TYPE_USB,
1247 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_SDP) |
1248 BIT(POWER_SUPPLY_USB_TYPE_CDP) |
1249 BIT(POWER_SUPPLY_USB_TYPE_DCP) |
1250 BIT(POWER_SUPPLY_USB_TYPE_ACA) |
1251 BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN),
1252 .properties = bq256xx_power_supply_props,
1253 .num_properties = ARRAY_SIZE(bq256xx_power_supply_props),
1254 .get_property = bq256xx_get_charger_property,
1255 .set_property = bq256xx_set_charger_property,
1256 .property_is_writeable = bq256xx_property_is_writeable,
1257};
1258
1259static struct power_supply_desc bq256xx_battery_desc = {
1260 .name = "bq256xx-battery",
1261 .type = POWER_SUPPLY_TYPE_BATTERY,
1262 .get_property = bq256xx_get_battery_property,
1263 .properties = bq256xx_battery_props,
1264 .num_properties = ARRAY_SIZE(bq256xx_battery_props),
1265 .property_is_writeable = bq256xx_property_is_writeable,
1266};
1267
1268
1269static bool bq256xx_is_volatile_reg(struct device *dev, unsigned int reg)
1270{
1271 switch (reg) {
1272 case BQ256XX_INPUT_CURRENT_LIMIT:
1273 case BQ256XX_CHARGER_STATUS_0...BQ256XX_CHARGER_STATUS_2:
1274 return true;
1275 default:
1276 return false;
1277 }
1278}
1279
1280static const struct regmap_config bq25600_regmap_config = {
1281 .reg_bits = 8,
1282 .val_bits = 8,
1283
1284 .max_register = BQ256XX_PART_INFORMATION,
1285 .reg_defaults = bq2560x_reg_defs,
1286 .num_reg_defaults = ARRAY_SIZE(bq2560x_reg_defs),
1287 .cache_type = REGCACHE_FLAT,
1288 .volatile_reg = bq256xx_is_volatile_reg,
1289};
1290
1291static const struct regmap_config bq25611d_regmap_config = {
1292 .reg_bits = 8,
1293 .val_bits = 8,
1294
1295 .max_register = BQ256XX_CHARGER_CONTROL_4,
1296 .reg_defaults = bq25611d_reg_defs,
1297 .num_reg_defaults = ARRAY_SIZE(bq25611d_reg_defs),
1298 .cache_type = REGCACHE_FLAT,
1299 .volatile_reg = bq256xx_is_volatile_reg,
1300};
1301
1302static const struct regmap_config bq25618_619_regmap_config = {
1303 .reg_bits = 8,
1304 .val_bits = 8,
1305
1306 .max_register = BQ256XX_CHARGER_CONTROL_4,
1307 .reg_defaults = bq25618_619_reg_defs,
1308 .num_reg_defaults = ARRAY_SIZE(bq25618_619_reg_defs),
1309 .cache_type = REGCACHE_FLAT,
1310 .volatile_reg = bq256xx_is_volatile_reg,
1311};
1312
1313static const struct bq256xx_chip_info bq256xx_chip_info_tbl[] = {
1314 [BQ25600] = {
1315 .model_id = BQ25600,
1316 .bq256xx_regmap_config = &bq25600_regmap_config,
1317 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1318 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1319 .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1320 .bq256xx_get_iterm = bq256xx_get_term_curr,
1321 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1322 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1323 .bq256xx_set_ts_ignore = NULL,
1324
1325 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1326 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1327 .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1328 .bq256xx_set_iterm = bq256xx_set_term_curr,
1329 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1330 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1331 .bq256xx_set_charge_type = bq256xx_set_charge_type,
1332
1333 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1334 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1335 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1336 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1337 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1338 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1339
1340 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1341 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1342
1343 .has_usb_detect = false,
1344 },
1345
1346 [BQ25600D] = {
1347 .model_id = BQ25600D,
1348 .bq256xx_regmap_config = &bq25600_regmap_config,
1349 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1350 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1351 .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1352 .bq256xx_get_iterm = bq256xx_get_term_curr,
1353 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1354 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1355
1356 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1357 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1358 .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1359 .bq256xx_set_iterm = bq256xx_set_term_curr,
1360 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1361 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1362 .bq256xx_set_charge_type = bq256xx_set_charge_type,
1363 .bq256xx_set_ts_ignore = NULL,
1364
1365 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1366 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1367 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1368 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1369 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1370 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1371
1372 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1373 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1374
1375 .has_usb_detect = true,
1376 },
1377
1378 [BQ25601] = {
1379 .model_id = BQ25601,
1380 .bq256xx_regmap_config = &bq25600_regmap_config,
1381 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1382 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1383 .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1384 .bq256xx_get_iterm = bq256xx_get_term_curr,
1385 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1386 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1387
1388 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1389 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1390 .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1391 .bq256xx_set_iterm = bq256xx_set_term_curr,
1392 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1393 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1394 .bq256xx_set_charge_type = bq256xx_set_charge_type,
1395 .bq256xx_set_ts_ignore = NULL,
1396
1397 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1398 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1399 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1400 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1401 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1402 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1403
1404 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1405 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1406
1407 .has_usb_detect = false,
1408 },
1409
1410 [BQ25601D] = {
1411 .model_id = BQ25601D,
1412 .bq256xx_regmap_config = &bq25600_regmap_config,
1413 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1414 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1415 .bq256xx_get_vbatreg = bq25601d_get_chrg_volt,
1416 .bq256xx_get_iterm = bq256xx_get_term_curr,
1417 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1418 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1419
1420 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1421 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1422 .bq256xx_set_vbatreg = bq25601d_set_chrg_volt,
1423 .bq256xx_set_iterm = bq256xx_set_term_curr,
1424 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1425 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1426 .bq256xx_set_charge_type = bq256xx_set_charge_type,
1427 .bq256xx_set_ts_ignore = NULL,
1428
1429 .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1430 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1431 .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1432 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1433 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1434 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1435
1436 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1437 .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1438
1439 .has_usb_detect = true,
1440 },
1441
1442 [BQ25611D] = {
1443 .model_id = BQ25611D,
1444 .bq256xx_regmap_config = &bq25611d_regmap_config,
1445 .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1446 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1447 .bq256xx_get_vbatreg = bq25611d_get_chrg_volt,
1448 .bq256xx_get_iterm = bq256xx_get_term_curr,
1449 .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1450 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1451
1452 .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1453 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1454 .bq256xx_set_vbatreg = bq25611d_set_chrg_volt,
1455 .bq256xx_set_iterm = bq256xx_set_term_curr,
1456 .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1457 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1458 .bq256xx_set_charge_type = bq256xx_set_charge_type,
1459 .bq256xx_set_ts_ignore = bq256xx_set_ts_ignore,
1460
1461 .bq256xx_def_ichg = BQ25611D_ICHG_DEF_uA,
1462 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1463 .bq256xx_def_vbatreg = BQ25611D_VBATREG_DEF_uV,
1464 .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1465 .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1466 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1467
1468 .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1469 .bq256xx_max_vbatreg = BQ25611D_VBATREG_MAX_uV,
1470
1471 .has_usb_detect = true,
1472 },
1473
1474 [BQ25618] = {
1475 .model_id = BQ25618,
1476 .bq256xx_regmap_config = &bq25618_619_regmap_config,
1477 .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1478 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1479 .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1480 .bq256xx_get_iterm = bq25618_619_get_term_curr,
1481 .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1482 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1483
1484 .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1485 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1486 .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1487 .bq256xx_set_iterm = bq25618_619_set_term_curr,
1488 .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1489 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1490 .bq256xx_set_charge_type = bq256xx_set_charge_type,
1491 .bq256xx_set_ts_ignore = bq256xx_set_ts_ignore,
1492
1493 .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1494 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1495 .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1496 .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1497 .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1498 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1499
1500 .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1501 .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1502
1503 .has_usb_detect = false,
1504 },
1505
1506 [BQ25619] = {
1507 .model_id = BQ25619,
1508 .bq256xx_regmap_config = &bq25618_619_regmap_config,
1509 .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1510 .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1511 .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1512 .bq256xx_get_iterm = bq25618_619_get_term_curr,
1513 .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1514 .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1515
1516 .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1517 .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1518 .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1519 .bq256xx_set_iterm = bq25618_619_set_term_curr,
1520 .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1521 .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1522 .bq256xx_set_charge_type = bq256xx_set_charge_type,
1523 .bq256xx_set_ts_ignore = bq256xx_set_ts_ignore,
1524
1525 .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1526 .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1527 .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1528 .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1529 .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1530 .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1531
1532 .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1533 .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1534
1535 .has_usb_detect = false,
1536 },
1537};
1538
1539static int bq256xx_power_supply_init(struct bq256xx_device *bq,
1540 struct power_supply_config *psy_cfg, struct device *dev)
1541{
1542 bq->charger = devm_power_supply_register(parent: bq->dev,
1543 desc: &bq256xx_power_supply_desc,
1544 cfg: psy_cfg);
1545 if (IS_ERR(ptr: bq->charger)) {
1546 dev_err(dev, "power supply register charger failed\n");
1547 return PTR_ERR(ptr: bq->charger);
1548 }
1549
1550 bq->battery = devm_power_supply_register(parent: bq->dev,
1551 desc: &bq256xx_battery_desc,
1552 cfg: psy_cfg);
1553 if (IS_ERR(ptr: bq->battery)) {
1554 dev_err(dev, "power supply register battery failed\n");
1555 return PTR_ERR(ptr: bq->battery);
1556 }
1557 return 0;
1558}
1559
1560static int bq256xx_hw_init(struct bq256xx_device *bq)
1561{
1562 struct power_supply_battery_info *bat_info;
1563 int wd_reg_val = BQ256XX_WATCHDOG_DIS;
1564 int ret = 0;
1565 int i;
1566
1567 for (i = 0; i < BQ256XX_NUM_WD_VAL; i++) {
1568 if (bq->watchdog_timer == bq256xx_watchdog_time[i]) {
1569 wd_reg_val = i;
1570 break;
1571 }
1572 if (i + 1 < BQ256XX_NUM_WD_VAL &&
1573 bq->watchdog_timer > bq256xx_watchdog_time[i] &&
1574 bq->watchdog_timer < bq256xx_watchdog_time[i + 1])
1575 wd_reg_val = i;
1576 }
1577 ret = regmap_update_bits(map: bq->regmap, BQ256XX_CHARGER_CONTROL_1,
1578 BQ256XX_WATCHDOG_MASK, val: wd_reg_val <<
1579 BQ256XX_WDT_BIT_SHIFT);
1580 if (ret)
1581 return ret;
1582
1583 ret = power_supply_get_battery_info(psy: bq->charger, info_out: &bat_info);
1584 if (ret == -ENOMEM)
1585 return ret;
1586
1587 if (ret) {
1588 dev_warn(bq->dev, "battery info missing, default values will be applied\n");
1589
1590 bat_info->constant_charge_current_max_ua =
1591 bq->chip_info->bq256xx_def_ichg;
1592
1593 bat_info->constant_charge_voltage_max_uv =
1594 bq->chip_info->bq256xx_def_vbatreg;
1595
1596 bat_info->precharge_current_ua =
1597 bq->chip_info->bq256xx_def_iprechg;
1598
1599 bat_info->charge_term_current_ua =
1600 bq->chip_info->bq256xx_def_iterm;
1601
1602 bq->init_data.ichg_max =
1603 bq->chip_info->bq256xx_max_ichg;
1604
1605 bq->init_data.vbatreg_max =
1606 bq->chip_info->bq256xx_max_vbatreg;
1607 } else {
1608 bq->init_data.ichg_max =
1609 bat_info->constant_charge_current_max_ua;
1610
1611 bq->init_data.vbatreg_max =
1612 bat_info->constant_charge_voltage_max_uv;
1613 }
1614
1615 ret = bq->chip_info->bq256xx_set_vindpm(bq, bq->init_data.vindpm);
1616 if (ret)
1617 return ret;
1618
1619 ret = bq->chip_info->bq256xx_set_iindpm(bq, bq->init_data.iindpm);
1620 if (ret)
1621 return ret;
1622
1623 ret = bq->chip_info->bq256xx_set_ichg(bq,
1624 bq->chip_info->bq256xx_def_ichg);
1625 if (ret)
1626 return ret;
1627
1628 ret = bq->chip_info->bq256xx_set_iprechg(bq,
1629 bat_info->precharge_current_ua);
1630 if (ret)
1631 return ret;
1632
1633 ret = bq->chip_info->bq256xx_set_vbatreg(bq,
1634 bq->chip_info->bq256xx_def_vbatreg);
1635 if (ret)
1636 return ret;
1637
1638 ret = bq->chip_info->bq256xx_set_iterm(bq,
1639 bat_info->charge_term_current_ua);
1640 if (ret)
1641 return ret;
1642
1643 if (bq->chip_info->bq256xx_set_ts_ignore) {
1644 ret = bq->chip_info->bq256xx_set_ts_ignore(bq, bq->init_data.ts_ignore);
1645 if (ret)
1646 return ret;
1647 }
1648
1649 power_supply_put_battery_info(psy: bq->charger, info: bat_info);
1650
1651 return 0;
1652}
1653
1654static int bq256xx_parse_dt(struct bq256xx_device *bq,
1655 struct power_supply_config *psy_cfg, struct device *dev)
1656{
1657 int ret = 0;
1658
1659 psy_cfg->drv_data = bq;
1660 psy_cfg->fwnode = dev_fwnode(dev);
1661
1662 ret = device_property_read_u32(dev: bq->dev, propname: "ti,watchdog-timeout-ms",
1663 val: &bq->watchdog_timer);
1664 if (ret)
1665 bq->watchdog_timer = BQ256XX_WATCHDOG_DIS;
1666
1667 if (bq->watchdog_timer > BQ256XX_WATCHDOG_MAX ||
1668 bq->watchdog_timer < BQ256XX_WATCHDOG_DIS)
1669 return -EINVAL;
1670
1671 ret = device_property_read_u32(dev: bq->dev,
1672 propname: "input-voltage-limit-microvolt",
1673 val: &bq->init_data.vindpm);
1674 if (ret)
1675 bq->init_data.vindpm = bq->chip_info->bq256xx_def_vindpm;
1676
1677 ret = device_property_read_u32(dev: bq->dev,
1678 propname: "input-current-limit-microamp",
1679 val: &bq->init_data.iindpm);
1680 if (ret)
1681 bq->init_data.iindpm = bq->chip_info->bq256xx_def_iindpm;
1682
1683 bq->init_data.ts_ignore = device_property_read_bool(dev: bq->dev, propname: "ti,no-thermistor");
1684
1685 return 0;
1686}
1687
1688static int bq256xx_probe(struct i2c_client *client)
1689{
1690 const struct i2c_device_id *id = i2c_client_get_device_id(client);
1691 struct device *dev = &client->dev;
1692 struct bq256xx_device *bq;
1693 struct power_supply_config psy_cfg = { };
1694
1695 int ret;
1696
1697 bq = devm_kzalloc(dev, size: sizeof(*bq), GFP_KERNEL);
1698 if (!bq)
1699 return -ENOMEM;
1700
1701 bq->client = client;
1702 bq->dev = dev;
1703 bq->chip_info = i2c_get_match_data(client);
1704
1705 mutex_init(&bq->lock);
1706
1707 strscpy(bq->model_name, id->name, sizeof(bq->model_name));
1708
1709 bq->regmap = devm_regmap_init_i2c(client,
1710 bq->chip_info->bq256xx_regmap_config);
1711
1712 if (IS_ERR(ptr: bq->regmap)) {
1713 dev_err(dev, "Failed to allocate register map\n");
1714 return PTR_ERR(ptr: bq->regmap);
1715 }
1716
1717 i2c_set_clientdata(client, data: bq);
1718
1719 ret = bq256xx_parse_dt(bq, psy_cfg: &psy_cfg, dev);
1720 if (ret) {
1721 dev_err(dev, "Failed to read device tree properties%d\n", ret);
1722 return ret;
1723 }
1724
1725 ret = devm_add_action_or_reset(dev, bq256xx_charger_reset, bq);
1726 if (ret)
1727 return ret;
1728
1729 /* OTG reporting */
1730 bq->usb2_phy = devm_usb_get_phy(dev, type: USB_PHY_TYPE_USB2);
1731 if (!IS_ERR_OR_NULL(ptr: bq->usb2_phy)) {
1732 INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1733 bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1734 usb_register_notifier(x: bq->usb2_phy, nb: &bq->usb_nb);
1735 }
1736
1737 bq->usb3_phy = devm_usb_get_phy(dev, type: USB_PHY_TYPE_USB3);
1738 if (!IS_ERR_OR_NULL(ptr: bq->usb3_phy)) {
1739 INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1740 bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1741 usb_register_notifier(x: bq->usb3_phy, nb: &bq->usb_nb);
1742 }
1743
1744 if (client->irq) {
1745 ret = devm_request_threaded_irq(dev, irq: client->irq, NULL,
1746 thread_fn: bq256xx_irq_handler_thread,
1747 IRQF_TRIGGER_FALLING |
1748 IRQF_ONESHOT,
1749 devname: dev_name(dev: &client->dev), dev_id: bq);
1750 if (ret < 0) {
1751 dev_err(dev, "get irq fail: %d\n", ret);
1752 return ret;
1753 }
1754 }
1755
1756 ret = bq256xx_power_supply_init(bq, psy_cfg: &psy_cfg, dev);
1757 if (ret) {
1758 dev_err(dev, "Failed to register power supply\n");
1759 return ret;
1760 }
1761
1762 ret = bq256xx_hw_init(bq);
1763 if (ret) {
1764 dev_err(dev, "Cannot initialize the chip.\n");
1765 return ret;
1766 }
1767
1768 return ret;
1769}
1770
1771static const struct i2c_device_id bq256xx_i2c_ids[] = {
1772 { "bq25600", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25600] },
1773 { "bq25600d", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25600D] },
1774 { "bq25601", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25601] },
1775 { "bq25601d", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25601D] },
1776 { "bq25611d", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25611D] },
1777 { "bq25618", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25618] },
1778 { "bq25619", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25619] },
1779 {}
1780};
1781MODULE_DEVICE_TABLE(i2c, bq256xx_i2c_ids);
1782
1783static const struct of_device_id bq256xx_of_match[] = {
1784 { .compatible = "ti,bq25600", .data = &bq256xx_chip_info_tbl[BQ25600] },
1785 { .compatible = "ti,bq25600d", .data = &bq256xx_chip_info_tbl[BQ25600D] },
1786 { .compatible = "ti,bq25601", .data = &bq256xx_chip_info_tbl[BQ25601] },
1787 { .compatible = "ti,bq25601d", .data = &bq256xx_chip_info_tbl[BQ25601D] },
1788 { .compatible = "ti,bq25611d", .data = &bq256xx_chip_info_tbl[BQ25611D] },
1789 { .compatible = "ti,bq25618", .data = &bq256xx_chip_info_tbl[BQ25618] },
1790 { .compatible = "ti,bq25619", .data = &bq256xx_chip_info_tbl[BQ25619] },
1791 {}
1792};
1793MODULE_DEVICE_TABLE(of, bq256xx_of_match);
1794
1795static const struct acpi_device_id bq256xx_acpi_match[] = {
1796 { "bq25600", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25600] },
1797 { "bq25600d", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25600D] },
1798 { "bq25601", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25601] },
1799 { "bq25601d", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25601D] },
1800 { "bq25611d", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25611D] },
1801 { "bq25618", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25618] },
1802 { "bq25619", (kernel_ulong_t)&bq256xx_chip_info_tbl[BQ25619] },
1803 {}
1804};
1805MODULE_DEVICE_TABLE(acpi, bq256xx_acpi_match);
1806
1807static struct i2c_driver bq256xx_driver = {
1808 .driver = {
1809 .name = "bq256xx-charger",
1810 .of_match_table = bq256xx_of_match,
1811 .acpi_match_table = bq256xx_acpi_match,
1812 },
1813 .probe = bq256xx_probe,
1814 .id_table = bq256xx_i2c_ids,
1815};
1816module_i2c_driver(bq256xx_driver);
1817
1818MODULE_AUTHOR("Ricardo Rivera-Matos <r-rivera-matos@ti.com>");
1819MODULE_DESCRIPTION("bq256xx charger driver");
1820MODULE_LICENSE("GPL v2");
1821

source code of linux/drivers/power/supply/bq256xx_charger.c