?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/rockchip: Don't change hdmi reference clock rate
[drm/drm-misc.git] / drivers / power / supply / bq256xx_charger.c
blob5514d1896bb847da6937e7c60fb540a51b46edd6
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 */
164 struct 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 */
187 struct 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
198 enum 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 */
230 struct 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 */
285 struct 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
319 static int bq256xx_watchdog_time[BQ256XX_NUM_WD_VAL] = {
320 0, 40000, 80000, 1600000
321 };
322
323 static const int bq25611d_vbatreg_values[] = {
324 3494000, 3590000, 3686000, 3790000, 3894000, 3990000, 4090000, 4140000,
325 4190000
326 };
327
328 static const int bq25618_619_vbatreg_values[] = {
329 3504000, 3600000, 3696000, 3800000, 3904000, 4000000, 4100000, 4150000,
330 4200000
331 };
332
333 static const int bq25618_619_ichg_values[] = {
334 1290000, 1360000, 1430000, 1500000
335 };
336
337 static 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
361 static 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(system_power_efficient_wq, &bq->usb_work);
369
370 return NOTIFY_OK;
371 }
372
373 static 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(bq->charger);
383 break;
384 default:
385 dev_err(bq->dev, "Error switching to charger mode.\n");
386 break;
387 }
388 }
389
390 static 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
401 static 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
414 static 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
427 static 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(bq->regmap, BQ256XX_CHARGER_STATUS_0,
435 &charger_status_0);
436 if (ret)
437 return ret;
438
439 ret = regmap_read(bq->regmap, BQ256XX_CHARGER_STATUS_1,
440 &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
456 static 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(bq->regmap, BQ256XX_CHARGER_CONTROL_0,
473 BQ256XX_CHG_CONFIG_MASK,
474 (chg_config ? 1 : 0) << BQ256XX_CHG_CONFIG_BIT_SHIFT);
475 }
476
477 static 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(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
484 &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
493 static 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(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
500 &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
512 static 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(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
521 BQ256XX_ICHG_MASK, ichg_reg_code);
522 }
523
524 static 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, ichg,
536 bq25618_619_ichg_values) + BQ25618_ICHG_THRESH;
537 }
538
539 return regmap_update_bits(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
540 BQ256XX_ICHG_MASK, ichg_reg_code);
541 }
542
543 static 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(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
550 &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
566 static 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(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
573 &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
588 static 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(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
595 &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
606 static 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(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
613 &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
624 static 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, vbatreg,
638 bq25618_619_vbatreg_values);
639 }
640
641 return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
642 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
643 BQ256XX_VBATREG_BIT_SHIFT);
644 }
645
646 static 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, vbatreg,
660 bq25611d_vbatreg_values);
661 }
662
663 return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
664 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
665 BQ256XX_VBATREG_BIT_SHIFT);
666 }
667
668 static 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(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
679 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
680 BQ256XX_VBATREG_BIT_SHIFT);
681 }
682
683 static 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(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
694 BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
695 BQ256XX_VBATREG_BIT_SHIFT);
696 }
697
698 static int bq256xx_set_ts_ignore(struct bq256xx_device *bq, bool ts_ignore)
699 {
700 return regmap_update_bits(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
701 BQ256XX_TS_IGNORE, (ts_ignore ? 1 : 0) << BQ256XX_TS_IGNORE_SHIFT);
702 }
703
704 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
711 &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
722 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
733 BQ256XX_IPRECHG_MASK, iprechg_reg_code);
734 }
735
736 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
743 &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
754 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
765 BQ256XX_IPRECHG_MASK, iprechg_reg_code);
766 }
767
768 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
775 &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
785 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
795 BQ256XX_ITERM_MASK, iterm_reg_code);
796 }
797
798 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
805 &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
815 static 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(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
825 BQ256XX_ITERM_MASK, iterm_reg_code);
826 }
827
828 static 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(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
835 &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
845 static 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(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
855 BQ256XX_VINDPM_MASK, vindpm_reg_code);
856 }
857
858 static 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(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
865 &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
875 static 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(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
885 BQ256XX_IINDPM_MASK, iindpm_reg_code);
886 }
887
888 static void bq256xx_charger_reset(void *data)
889 {
890 struct bq256xx_device *bq = data;
891
892 regmap_update_bits(bq->regmap, BQ256XX_PART_INFORMATION,
893 BQ256XX_REG_RST, BQ256XX_REG_RST);
894
895 if (!IS_ERR_OR_NULL(bq->usb2_phy))
896 usb_unregister_notifier(bq->usb2_phy, &bq->usb_nb);
897
898 if (!IS_ERR_OR_NULL(bq->usb3_phy))
899 usb_unregister_notifier(bq->usb3_phy, &bq->usb_nb);
900 }
901
902 static 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
963 static 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
985 static 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);
995 mutex_unlock(&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
1170 static 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(&bq->lock);
1178
1179 return memcmp(&old_state, new_state, sizeof(struct bq256xx_state)) != 0;
1180 }
1181
1182 static 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);
1189 if (ret < 0)
1190 goto irq_out;
1191
1192 if (!bq256xx_state_changed(bq, &state))
1193 goto irq_out;
1194
1195 mutex_lock(&bq->lock);
1196 bq->state = state;
1197 mutex_unlock(&bq->lock);
1198
1199 power_supply_changed(bq->charger);
1200
1201 irq_out:
1202 return IRQ_HANDLED;
1203 }
1204
1205 static 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
1221 static 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
1226 static 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
1244 static 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
1259 static 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
1269 static 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
1280 static 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
1291 static 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
1302 static 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
1313 static 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
1539 static 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(bq->dev,
1543 &bq256xx_power_supply_desc,
1544 psy_cfg);
1545 if (IS_ERR(bq->charger)) {
1546 dev_err(dev, "power supply register charger failed\n");
1547 return PTR_ERR(bq->charger);
1548 }
1549
1550 bq->battery = devm_power_supply_register(bq->dev,
1551 &bq256xx_battery_desc,
1552 psy_cfg);
1553 if (IS_ERR(bq->battery)) {
1554 dev_err(dev, "power supply register battery failed\n");
1555 return PTR_ERR(bq->battery);
1556 }
1557 return 0;
1558 }
1559
1560 static 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(bq->regmap, BQ256XX_CHARGER_CONTROL_1,
1578 BQ256XX_WATCHDOG_MASK, wd_reg_val <<
1579 BQ256XX_WDT_BIT_SHIFT);
1580 if (ret)
1581 return ret;
1582
1583 ret = power_supply_get_battery_info(bq->charger, &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(bq->charger, bat_info);
1650
1651 return 0;
1652 }
1653
1654 static 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->of_node = dev->of_node;
1661
1662 ret = device_property_read_u32(bq->dev, "ti,watchdog-timeout-ms",
1663 &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(bq->dev,
1672 "input-voltage-limit-microvolt",
1673 &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(bq->dev,
1678 "input-current-limit-microamp",
1679 &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(bq->dev, "ti,no-thermistor");
1684
1685 return 0;
1686 }
1687
1688 static 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, 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(bq->regmap)) {
1713 dev_err(dev, "Failed to allocate register map\n");
1714 return PTR_ERR(bq->regmap);
1715 }
1716
1717 i2c_set_clientdata(client, bq);
1718
1719 ret = bq256xx_parse_dt(bq, &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, USB_PHY_TYPE_USB2);
1731 if (!IS_ERR_OR_NULL(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(bq->usb2_phy, &bq->usb_nb);
1735 }
1736
1737 bq->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
1738 if (!IS_ERR_OR_NULL(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(bq->usb3_phy, &bq->usb_nb);
1742 }
1743
1744 if (client->irq) {
1745 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1746 bq256xx_irq_handler_thread,
1747 IRQF_TRIGGER_FALLING |
1748 IRQF_ONESHOT,
1749 dev_name(&client->dev), 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, 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
1771 static 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 };
1781 MODULE_DEVICE_TABLE(i2c, bq256xx_i2c_ids);
1782
1783 static 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 };
1793 MODULE_DEVICE_TABLE(of, bq256xx_of_match);
1794
1795 static 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 };
1805 MODULE_DEVICE_TABLE(acpi, bq256xx_acpi_match);
1806
1807 static 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 };
1816 module_i2c_driver(bq256xx_driver);
1817
1818 MODULE_AUTHOR("Ricardo Rivera-Matos <r-rivera-matos@ti.com>");
1819 MODULE_DESCRIPTION("bq256xx charger driver");
1820 MODULE_LICENSE("GPL v2");
Kernel DRM miscellaneous fixes and cross-tree changes