aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorFalong Li2018-06-08 03:21:14 -0500
committerFalong Li2018-06-08 03:21:14 -0500
commit0af3e297ed5a85e2894d7965ea9f85d4e12d6986 (patch)
tree4dd95a91e7f21c891ef64add99921596f5692ef4
parent76eb04689b470b5d996fb6de3e6e40cc47168c7b (diff)
downloadbms-kernel-4-4-0af3e297ed5a85e2894d7965ea9f85d4e12d6986.tar.gz
bms-kernel-4-4-0af3e297ed5a85e2894d7965ea9f85d4e12d6986.tar.xz
bms-kernel-4-4-0af3e297ed5a85e2894d7965ea9f85d4e12d6986.zip
add bq25700 support
Diffstat
-rw-r--r--drivers/power/bq25700/Kconfig6
-rw-r--r--drivers/power/bq25700/Makefile1
-rw-r--r--drivers/power/bq25700/bq25700.h31
-rw-r--r--drivers/power/bq25700/bq25700_charger.c2034
-rw-r--r--drivers/power/bq25700/bq25700_reg.h508
5 files changed, 2580 insertions, 0 deletions
diff --git a/drivers/power/bq25700/Kconfig b/drivers/power/bq25700/Kconfig
new file mode 100644
index 000000000000..e039cc2c1250
--- /dev/null
+++ b/drivers/power/bq25700/Kconfig
@@ -0,0 +1,6 @@
1config CHARGER_BQ25700
2 tristate "TI BQ25700 buck-boost battery charger driver"
3 depends on I2C
4 default y
5 help
6 Say Y to enable support for TI bq25700 charger
diff --git a/drivers/power/bq25700/Makefile b/drivers/power/bq25700/Makefile
new file mode 100644
index 000000000000..00e461fa3a7f
--- /dev/null
+++ b/drivers/power/bq25700/Makefile
@@ -0,0 +1 @@
obj-$(CONFIG_CHARGER_BQ25700) += bq25700_charger.o
diff --git a/drivers/power/bq25700/bq25700.h b/drivers/power/bq25700/bq25700.h
new file mode 100644
index 000000000000..be19ada2e92a
--- /dev/null
+++ b/drivers/power/bq25700/bq25700.h
@@ -0,0 +1,31 @@
1/*
2 * BQ2570x battery charging driver
3 *
4 * Copyright (C) 2017 Texas Instruments
5 *
6 * This package is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9
10 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
11 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
12 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
13 */
14
15#ifndef _LINUX_BQ25700_H
16#define _LINUX_BQ25700_H
17
18#include <linux/power_supply.h>
19
20struct bq25700_platform_data {
21
22 int chg_mv;
23 int chg_ma;
24 int ivl_mv;
25 int icl_ma;
26
27 int boostv;
28 int boosti;
29};
30
31#endif
diff --git a/drivers/power/bq25700/bq25700_charger.c b/drivers/power/bq25700/bq25700_charger.c
new file mode 100644
index 000000000000..7878302ecf2d
--- /dev/null
+++ b/drivers/power/bq25700/bq25700_charger.c
@@ -0,0 +1,2034 @@
1/*
2 * BQ25700 battery charging driver
3 *
4 * Copyright (C) 2017 Texas Instruments *
5 * This package is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8
9 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
10 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
11 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
12 */
13
14
15#define pr_fmt(fmt) "[bq25700] %s: " fmt, __func__
16
17#include <linux/gpio.h>
18#include <linux/i2c.h>
19#include <linux/init.h>
20#include <linux/interrupt.h>
21#include <linux/module.h>
22#include <linux/power_supply.h>
23#include <linux/slab.h>
24#include <linux/kernel.h>
25#include <linux/sched.h>
26#include <linux/kthread.h>
27#include <linux/delay.h>
28#include <linux/of.h>
29#include <linux/of_device.h>
30#include <linux/of_gpio.h>
31#include <linux/err.h>
32#include <linux/regulator/driver.h>
33#include <linux/regulator/of_regulator.h>
34#include <linux/regulator/machine.h>
35#include <linux/debugfs.h>
36#include <linux/bitops.h>
37#include <linux/math64.h>
38
39#include "bq25700_reg.h"
40#include "bq25700.h"
41
42#define bq_info pr_info
43#define bq_dbg pr_debug
44#define bq_err pr_err
45#define bq_log pr_err
46
47enum {
48 USER = BIT(0),
49 BATT = BIT(1), /* Batt FULL */
50};
51
52enum {
53 BQ25700 = 0x00,
54};
55
56enum {
57 CHARGE_STATE_NOT_CHARGING,
58 CHARGE_STATE_PRECHARGE,
59 CHARGE_STATE_FASTCHARGE,
60 CHARGE_STATE_OTG,
61};
62
63
64struct bq25700_otg_regulator {
65 struct regulator_desc rdesc;
66 struct regulator_dev *rdev;
67};
68
69
70struct bq25700 {
71 struct device *dev;
72 struct i2c_client *client;
73
74 int part_no;
75 int revision;
76
77 struct mutex data_lock;
78 struct mutex i2c_rw_lock;
79 struct mutex profile_change_lock;
80 struct mutex charging_disable_lock;
81 struct mutex usb_online_lock;
82 struct mutex adc_lock;
83 struct mutex irq_complete;
84
85 bool irq_waiting;
86 bool irq_disabled;
87 bool resume_completed;
88
89 bool batt_present;
90 bool usb_present;
91 bool usb_online;
92
93 bool vbus_present;
94
95 bool batt_full;
96
97 int vbus_volt;
98 int vbat_volt;
99 int vsys_volt;
100 int psys_volt;
101 int cmpin_volt;
102 int ibus_curr;
103 int chg_curr;
104 int dsg_curr;
105
106 int batt_temp;
107
108 bool charge_enabled; /* Register bit status */
109 bool otg_enabled;
110 bool vindpm_triggered;
111 bool iindpm_triggered;
112
113 int usb_psy_ma;
114
115 int icl_ma;
116 int ivl_mv;
117
118 int chg_ma;
119 int chg_mv;
120
121 int charge_state;
122 int charging_disabled_status;
123 int fault_status;
124
125 int dev_id;
126
127 enum power_supply_type supply_type;
128
129 struct delayed_work monitor_work;
130
131 struct bq25700_platform_data *platform_data;
132 struct bq25700_otg_regulator otg_vreg;
133
134 int skip_writes;
135 int skip_reads;
136
137 struct dentry *debug_root;
138
139 struct power_supply *usb_psy;
140 struct power_supply *bms_psy;
141 struct power_supply *batt_psy;
142 struct power_supply_desc batt_psy_d;
143};
144
145
146static int __bq25700_read_word(struct bq25700 *bq, u8 reg, u16 *data)
147{
148 s32 ret;
149
150 ret = i2c_smbus_read_word_data(bq->client, reg);
151 if (ret < 0) {
152 bq_err("i2c read fail: can't read from reg 0x%02X\n", reg);
153 return ret;
154 }
155
156 *data = (u16) ret;
157
158 return 0;
159}
160
161
162static int __bq25700_write_word(struct bq25700 *bq, u8 reg, u16 data)
163{
164 s32 ret;
165
166 ret = i2c_smbus_write_word_data(bq->client, reg, data);
167 if (ret < 0) {
168 bq_err("i2c read fail: can't read from reg 0x%02X\n", reg);
169 return ret;
170 }
171
172 return 0;
173}
174
175
176static int bq25700_read_reg(struct bq25700 *bq, u8 reg, u16 *data)
177{
178 int ret;
179
180 if (bq->skip_reads) {
181 *data = 0;
182 return 0;
183 }
184
185 mutex_lock(&bq->i2c_rw_lock);
186 ret = __bq25700_read_word(bq, reg, data);
187 mutex_unlock(&bq->i2c_rw_lock);
188
189 return ret;
190}
191
192static int bq25700_write_reg(struct bq25700 *bq, u8 reg, u16 data)
193{
194 int ret;
195
196 if (bq->skip_writes) {
197 return 0;
198 }
199
200 mutex_lock(&bq->i2c_rw_lock);
201 ret = __bq25700_write_word(bq, reg, data);
202 mutex_unlock(&bq->i2c_rw_lock);
203
204 return ret;
205}
206
207static int bq25700_update_bits(struct bq25700 *bq, u8 reg,
208 u16 mask, u16 data)
209{
210 int ret;
211 u16 tmp;
212
213 if (bq->skip_reads || bq->skip_writes)
214 return 0;
215
216 mutex_lock(&bq->i2c_rw_lock);
217 ret = __bq25700_read_word(bq, reg, &tmp);
218 if (ret) {
219 bq_err("Failed: reg=%02X, ret=%d\n", reg, ret);
220 goto out;
221 }
222
223 tmp &= ~mask;
224 tmp |= data & mask;
225
226 ret = __bq25700_write_word(bq, reg, tmp);
227 if (ret)
228 bq_err("Failed: reg=%02X, ret=%d\n", reg, ret);
229
230out:
231 mutex_unlock(&bq->i2c_rw_lock);
232 return ret;
233}
234
235
236static int bq25700_set_lwpwr_mode(struct bq25700 *bq, bool enable)
237{
238 int ret;
239 u16 reg_val;
240
241 if (enable == true)
242 reg_val = BQ25700_LWPWR_MODE_ENABLE;
243 else
244 reg_val = BQ25700_LWPWR_MODE_DISABLE;
245
246 reg_val <<= BQ25700_LWPWR_MODE_CTRL_SHIFT;
247
248 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
249 BQ25700_LWPWR_MODE_CTRL_MASK, reg_val);
250
251 return ret;
252}
253
254static int bq25700_set_watchdog_timer(struct bq25700 *bq, int time)
255{
256 int ret;
257 u16 reg_val;
258
259 if (time == 0)
260 reg_val = BQ25700_WDTMR_DISABLE;
261 else if (time == 5)
262 reg_val = BQ25700_WDTMR_5S;
263 else if (time == 88)
264 reg_val = BQ25700_WDTMR_88S;
265 else
266 reg_val = BQ25700_WDTMR_175S;
267
268 reg_val <<= BQ25700_WDTMR_ADJ_SHIFT;
269
270 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
271 BQ25700_WDTMR_ADJ_MASK, reg_val);
272
273 return ret;
274}
275
276static int bq25700_set_idpm_auto_enable(struct bq25700 *bq, bool enable)
277{
278 int ret;
279 u16 reg_val;
280
281 if (enable == true)
282 reg_val = BQ25700_IDPM_AUTO_ENABLE;
283 else
284 reg_val = BQ25700_IDPM_AUTO_DISABLE;
285
286 reg_val <<= BQ25700_IDPM_AUTO_CTRL_SHIFT;
287
288 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
289 BQ25700_IDPM_AUTO_CTRL_MASK, reg_val);
290
291 return ret;
292}
293
294static int bq25700_set_otg_on_chrgok(struct bq25700 *bq, bool enable)
295{
296 int ret;
297 u16 reg_val;
298
299 if (enable == false)
300 reg_val = BQ25700_OTG_ON_CHRGOK_DISABLE;
301 else
302 reg_val = BQ25700_OTG_ON_CHRGOK_ENABLE;
303
304 reg_val <<= BQ25700_OTG_ON_CHRGOK_CTRL_SHIFT;
305
306 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
307 BQ25700_OTG_ON_CHRGOK_CTRL_MASK, reg_val);
308
309 return ret;
310}
311
312static int bq25700_set_pwm_freq(struct bq25700 *bq, int freq)
313{
314 int ret;
315 u16 reg_val;
316
317 if (freq == 1200)
318 reg_val = BQ25700_PWM_FREQ_1200KHZ;
319 else
320 reg_val = BQ25700_PWM_FREQ_800KHZ;
321
322 reg_val <<= BQ25700_PWM_FREQ_SHIFT;
323
324 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
325 BQ25700_PWM_FREQ_MASK, reg_val);
326
327 return ret;
328}
329
330static int bq25700_set_learn_mode(struct bq25700 *bq, bool enable)
331{
332 int ret;
333 u16 reg_val;
334
335 if (enable == false)
336 reg_val = BQ25700_LEARN_MODE_DISABLE;
337 else
338 reg_val = BQ25700_LEARN_MODE_ENABLE;
339
340 reg_val <<= BQ25700_LEARN_MODE_CTRL_SHIFT;
341
342 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
343 BQ25700_LEARN_MODE_CTRL_MASK, reg_val);
344
345 return ret;
346}
347
348static int bq25700_set_iadpt_gain(struct bq25700 *bq, int gain)
349{
350 int ret;
351 u16 reg_val;
352
353 if (gain == 20)
354 reg_val = BQ25700_IADPT_GAIN_20X;
355 else
356 reg_val = BQ25700_IADPT_GAIN_40X;
357
358 reg_val <<= BQ25700_IADPT_GAIN_SHIFT;
359
360 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
361 BQ25700_IADPT_GAIN_MASK, reg_val);
362
363 return ret;
364}
365
366static int bq25700_set_ibat_gain(struct bq25700 *bq, int gain)
367{
368 int ret;
369 u16 reg_val;
370
371 if (gain == 8)
372 reg_val = BQ25700_IBAT_GAIN_8X;
373 else
374 reg_val = BQ25700_IBAT_GAIN_16X;
375
376 reg_val <<= BQ25700_IBAT_GAIN_SHIFT;
377
378 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
379 BQ25700_IBAT_GAIN_MASK, reg_val);
380
381 return ret;
382}
383
384static int bq25700_set_ldo_mode(struct bq25700 *bq, bool enable)
385{
386 int ret;
387 u16 reg_val;
388
389 if (enable == false)
390 reg_val = BQ25700_LDO_MODE_DISABLE;
391 else
392 reg_val = BQ25700_LDO_MODE_ENABLE;
393
394 reg_val <<= BQ25700_LDO_MODE_CTRL_SHIFT;
395
396 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
397 BQ25700_LDO_MODE_CTRL_MASK, reg_val);
398
399 return ret;
400}
401
402static int bq25700_set_idpm_enable(struct bq25700 *bq, bool enable)
403{
404 int ret;
405 u16 reg_val;
406
407 if (enable == false)
408 reg_val = BQ25700_IDPM_DISABLE;
409 else
410 reg_val = BQ25700_IDPM_ENABLE;
411
412 reg_val <<= BQ25700_IDPM_CTRL_SHIFT;
413
414 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
415 BQ25700_IDPM_CTRL_MASK, reg_val);
416
417 return ret;
418}
419
420static int bq25700_charge_enable(struct bq25700 *bq, bool enable)
421{
422 int ret;
423 u16 reg_val;
424
425 if (enable == true)
426 reg_val = BQ25700_CHRG_ENABLE;
427 else
428 reg_val = BQ25700_CHRG_DISABLE;
429
430 reg_val <<= BQ25700_CHRG_CTRL_SHIFT;
431
432 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION0,
433 BQ25700_CHRG_CTRL_MASK, reg_val);
434
435 return ret;
436}
437
438
439static int bq25700_set_rsns_rac(struct bq25700 *bq, int mohm)
440{
441 int ret;
442 u16 reg_val;
443
444 if (mohm == 10)
445 reg_val = BQ25700_RSNS_RAC_10MOHM;
446 else
447 reg_val = BQ25700_RSNS_RAC_20MOHM;
448
449 reg_val <<= BQ25700_RSNS_RAC_SHIFT;
450
451 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION1,
452 BQ25700_RSNS_RAC_MASK, reg_val);
453
454 return ret;
455}
456
457static int bq25700_set_rsns_rsr(struct bq25700 *bq, int mohm)
458{
459 int ret;
460 u16 reg_val;
461
462 if (mohm == 10)
463 reg_val = BQ25700_RSNS_RSR_10MOHM;
464 else
465 reg_val = BQ25700_RSNS_RSR_20MOHM;
466
467 reg_val <<= BQ25700_RSNS_RSR_SHIFT;
468
469 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION1,
470 BQ25700_RSNS_RSR_MASK, reg_val);
471
472 return ret;
473}
474
475static int bq25700_set_acoc_enable(struct bq25700 *bq, bool enable)
476{
477 int ret;
478 u16 reg_val;
479
480 if (enable == false)
481 reg_val = BQ25700_ACOC_DISABLE;
482 else
483 reg_val = BQ25700_ACOC_ENABLE;
484
485 reg_val <<= BQ25700_ACOC_CTRL_SHIFT;
486
487 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION2,
488 BQ25700_ACOC_CTRL_MASK, reg_val);
489
490 return ret;
491}
492
493static int bq25700_set_acoc_volt_pct(struct bq25700 *bq, int volt_pct)
494{
495 int ret;
496 u16 reg_val;
497
498 if (volt_pct == 125)
499 reg_val = BQ25700_ACOC_VTH_125PCT;
500 else
501 reg_val = BQ25700_ACOC_VTH_200PCT;
502
503 reg_val <<= BQ25700_ACOC_VTH_SHIFT;
504
505 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION2,
506 BQ25700_ACOC_VTH_MASK, reg_val);
507
508 return ret;
509}
510
511
512static int bq25700_set_batoc_enable(struct bq25700 *bq, bool enable)
513{
514 int ret;
515 u16 reg_val;
516
517 if (enable == false)
518 reg_val = BQ25700_BATOC_DISABLE;
519 else
520 reg_val = BQ25700_BATOC_ENABLE;
521
522 reg_val <<= BQ25700_BATOC_CTRL_SHIFT;
523
524 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION2,
525 BQ25700_BATOC_CTRL_MASK, reg_val);
526
527 return ret;
528}
529
530static int bq25700_set_batoc_volt_pct(struct bq25700 *bq, int volt_pct)
531{
532 int ret;
533 u16 reg_val;
534
535 if (volt_pct == 125)
536 reg_val = BQ25700_BATOC_VTH_125PCT;
537 else
538 reg_val = BQ25700_BATOC_VTH_200PCT;
539
540 reg_val <<= BQ25700_BATOC_VTH_SHIFT;
541
542 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION2,
543 BQ25700_BATOC_VTH_MASK, reg_val);
544
545 return ret;
546}
547
548
549static int bq25700_set_hiz_mode(struct bq25700 *bq, bool enable)
550{
551 int ret;
552 u16 reg_val;
553
554 if (enable == false)
555 reg_val = BQ25700_HIZ_MODE_DISABLE;
556 else
557 reg_val = BQ25700_HIZ_MODE_ENABLE;
558
559 reg_val <<= BQ25700_HIZ_MODE_CTRL_SHIFT;
560
561 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION3,
562 BQ25700_HIZ_MODE_CTRL_MASK, reg_val);
563
564 return ret;
565}
566
567static int bq25700_reset_reg(struct bq25700 *bq, bool enable)
568{
569 int ret;
570 u16 reg_val;
571
572 if (enable == false)
573 reg_val = BQ25700_REG_RESET_IDLE;
574 else
575 reg_val = BQ25700_REG_RESET;
576
577 reg_val <<= BQ25700_REG_RESET_CTRL_SHIFT;
578
579 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION3,
580 BQ25700_REG_RESET_CTRL_MASK, reg_val);
581
582 return ret;
583}
584
585static int bq25700_reset_vindpm(struct bq25700 *bq, bool enable)
586{
587 int ret;
588 u16 reg_val;
589
590 if (enable == false)
591 reg_val = BQ25700_VINDPM_RESET_IDLE;
592 else
593 reg_val = BQ25700_VINDPM_RESET;
594
595 reg_val <<= BQ25700_VINDPM_RESET_CTRL_SHIFT;
596
597 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION3,
598 BQ25700_VINDPM_RESET_CTRL_MASK, reg_val);
599
600 return ret;
601}
602
603static int bq25700_set_otg_enable(struct bq25700 *bq, bool enable)
604{
605 int ret;
606 u16 reg_val;
607
608 if (enable == false)
609 reg_val = BQ25700_OTG_DISABLE;
610 else
611 reg_val = BQ25700_OTG_ENABLE;
612
613 reg_val <<= BQ25700_OTG_CTRL_SHIFT;
614
615 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION3,
616 BQ25700_OTG_CTRL_MASK, reg_val);
617
618 return ret;
619}
620
621static int bq25700_set_ico_enable(struct bq25700 *bq, bool enable)
622{
623 int ret;
624 u16 reg_val;
625
626 if (enable == false)
627 reg_val = BQ25700_ICO_DISABLE;
628 else
629 reg_val = BQ25700_ICO_ENABLE;
630
631 reg_val <<= BQ25700_ICO_MODE_CTRL_SHIFT;
632
633 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION3,
634 BQ25700_ICO_MODE_CTRL_MASK, reg_val);
635
636 return ret;
637}
638
639static int bq25700_set_batfet_in_hiz(struct bq25700 *bq, bool enable)
640{
641 int ret;
642 u16 reg_val;
643
644 if (enable == true)
645 reg_val = BQ25700_HIZ_BATFET_ON;
646 else
647 reg_val = BQ25700_HIZ_BATFET_OFF;
648
649 reg_val <<= BQ25700_HIZ_BATFET_CTRL_SHIFT;
650
651 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_OPTION3,
652 BQ25700_HIZ_BATFET_CTRL_MASK, reg_val);
653
654 return ret;
655}
656
657static int bq25700_get_ilim2_vth(struct bq25700 *bq, int *vth)
658{
659 int ret;
660 u16 reg_val;
661
662 ret = bq25700_read_reg(bq, BQ25700_REG_PROHOT_OPTION0, &reg_val);
663 if (ret)
664 return ret;
665
666 *vth = reg_val & BQ25700_ILIM2_VTH_MASK;
667 *vth >>= BQ25700_ILIM2_VTH_SHIFT;
668 *vth *= BQ25700_ILIM2_VTH_LSB;
669 *vth += BQ25700_ILIM2_VTH_BASE;
670
671 return 0;
672}
673
674static int bq25700_set_icrit_deglitch(struct bq25700 *bq, int deg)
675{
676 int ret;
677 u16 reg_val;
678
679 if (deg == 15)
680 reg_val = BQ25700_ICRIT_DEG_15US;
681 else if (deg == 100)
682 reg_val = BQ25700_ICRIT_DEG_100US;
683 else if (deg == 400)
684 reg_val = BQ25700_ICRIT_DEG_400US;
685 else
686 reg_val = BQ25700_ICRIT_DEG_800US;
687
688 reg_val <<= BQ25700_ICRIT_DEG_SHIFT;
689
690 ret = bq25700_update_bits(bq, BQ25700_REG_PROHOT_OPTION0,
691 BQ25700_ICRIT_DEG_MASK, reg_val);
692
693 return ret;
694}
695
696static int bq25700_set_vsys_threshold(struct bq25700 *bq, int th)
697{
698 int ret;
699 u16 reg_val;
700
701 if (th == 5750)
702 reg_val = BQ25700_VSYS_VTH_5P75V_2P85V;
703 else if (th == 6000)
704 reg_val = BQ25700_VSYS_VTH_6P0V_3P1V;
705 else if (th == 6250)
706 reg_val = BQ25700_VSYS_VTH_6P25V_3P35V;
707 else
708 reg_val = BQ25700_VSYS_VTH_6P5V_3P6V;
709
710 reg_val <<= BQ25700_VSYS_VTH_SHIFT;
711
712 ret = bq25700_update_bits(bq, BQ25700_REG_PROHOT_OPTION0,
713 BQ25700_VSYS_VTH_MASK, reg_val);
714
715 return ret;
716}
717
718static int bq25700_set_dsg_th(struct bq25700 *bq, int vth)
719{
720 int ret;
721 u16 reg_val;
722
723 if (vth < BQ25700_DSG_VTH_BASE)
724 vth = BQ25700_DSG_VTH_BASE;
725
726 vth -= BQ25700_DSG_VTH_BASE;
727 reg_val = vth / BQ25700_DSG_VTH_LSB;
728 reg_val <<= BQ25700_DSG_VTH_SHIFT;
729
730 ret = bq25700_update_bits(bq, BQ25700_REG_PROHOT_OPTION1,
731 BQ25700_DSG_VTH_MASK, reg_val);
732
733 return ret;
734}
735
736static int bq25700_set_adc_scan_mode(struct bq25700 *bq, bool oneshot)
737{
738 int ret;
739 u16 reg_val;
740
741 if (oneshot == true)
742 reg_val = BQ25700_ADC_CONV_ONESHOT;
743 else
744 reg_val = BQ25700_ADC_CONV_CONT;
745
746 reg_val <<= BQ25700_ADC_CONV_SHIFT;
747
748 ret = bq25700_update_bits(bq, BQ25700_REG_ADC_OPTION,
749 BQ25700_ADC_CONV_MASK, reg_val);
750
751 return ret;
752}
753
754static int bq25700_adc_start(struct bq25700 *bq, bool start)
755{
756 int ret;
757 u16 reg_val;
758
759 if (start == false)
760 reg_val = BQ25700_ADC_START_IDLE;
761 else
762 reg_val = BQ25700_ADC_START;
763
764 reg_val <<= BQ25700_ADC_START_CTRL_SHIFT;
765
766 ret = bq25700_update_bits(bq, BQ25700_REG_ADC_OPTION,
767 BQ25700_ADC_START_CTRL_MASK, reg_val);
768
769 return ret;
770}
771
772static int bq25700_set_adc_full_scale(struct bq25700 *bq, int scale)
773{
774 int ret;
775 u16 reg_val;
776
777 if (scale == 2040)
778 reg_val = BQ25700_ADC_FULLSCALE_2P04V;
779 else
780 reg_val = BQ25700_ADC_FULLSCALE_3P06V;
781
782 reg_val <<= BQ25700_ADC_FULLSCALE_SHIFT;
783
784 ret = bq25700_update_bits(bq, BQ25700_REG_ADC_OPTION,
785 BQ25700_ADC_FULLSCALE_MASK, reg_val);
786
787 return ret;
788}
789
790static int bq25700_set_adc_scan_channel(struct bq25700 *bq, int mask)
791{
792
793 int ret;
794 u16 reg_val;
795
796 reg_val = mask & 0xFF;
797
798 ret = bq25700_update_bits(bq, BQ25700_REG_ADC_OPTION,
799 0xFF, reg_val);
800 return ret;
801}
802static int bq25700_set_charge_current(struct bq25700 *bq, int curr)
803{
804 int ret;
805 u16 reg_val;
806
807 if (curr < BQ25700_CHARGE_CURRENT_BASE)
808 curr = BQ25700_CHARGE_CURRENT_BASE;
809
810 curr -= BQ25700_CHARGE_CURRENT_BASE;
811 reg_val = curr / BQ25700_CHARGE_CURRENT_LSB;
812 reg_val <<= BQ25700_CHARGE_CURRENT_SHIFT;
813
814 ret = bq25700_update_bits(bq, BQ25700_REG_CHARGE_CURRENT,
815 BQ25700_CHARGE_CURRENT_MASK, reg_val);
816
817 return ret;
818}
819
820static int bq25700_set_charge_volt(struct bq25700 *bq, int volt)
821{
822 int ret;
823 u16 reg_val;
824
825 if (volt < BQ25700_MAX_CHG_VOLT_BASE)
826 volt = BQ25700_MAX_CHG_VOLT_BASE;
827
828 volt -= BQ25700_MAX_CHG_VOLT_BASE;
829 reg_val = volt / BQ25700_MAX_CHG_VOLT_LSB;
830 reg_val <<= BQ25700_MAX_CHG_VOLT_SHIFT;
831
832 ret = bq25700_update_bits(bq, BQ25700_REG_MAX_CHG_VOLT,
833 BQ25700_MAX_CHG_VOLT_MASK, reg_val);
834
835 return ret;
836}
837
838static int bq25700_set_min_sys_volt(struct bq25700 *bq, int volt)
839{
840 int ret;
841 u16 reg_val;
842
843 if (volt < BQ25700_MIN_SYS_VOLT_BASE)
844 volt = BQ25700_MIN_SYS_VOLT_BASE;
845
846 volt -= BQ25700_MIN_SYS_VOLT_BASE;
847 reg_val = volt / BQ25700_MIN_SYS_VOLT_LSB;
848 reg_val <<= BQ25700_MIN_SYS_VOLT_SHIFT;
849
850 ret = bq25700_update_bits(bq, BQ25700_REG_MIN_SYS_VOLT,
851 BQ25700_MIN_SYS_VOLT_MASK, reg_val);
852
853 return ret;
854}
855
856static int bq25700_set_input_current_limit(struct bq25700 *bq, int curr)
857{
858 int ret;
859 u16 reg_val;
860
861 if (curr < BQ25700_INLIM_HOST_BASE)
862 curr = BQ25700_INLIM_HOST_BASE;
863
864 curr -= BQ25700_INLIM_HOST_BASE;
865 reg_val = curr / BQ25700_INLIM_HOST_LSB;
866 reg_val <<= BQ25700_INLIM_HOST_SHIFT;
867
868 ret = bq25700_update_bits(bq, BQ25700_REG_IIN_HOST,
869 BQ25700_INLIM_HOST_MASK, reg_val);
870
871 return ret;
872}
873
874static int bq25700_get_real_input_current_limit(struct bq25700 *bq, int curr)
875{
876 int ret;
877 u16 reg_val;
878
879 ret = bq25700_read_reg(bq, BQ25700_REG_IIN_DPM, &reg_val);
880 if (ret)
881 return ret;
882
883 curr = reg_val & BQ25700_IIN_DPM_MASK;
884 curr >>= BQ25700_IIN_DPM_SHIFT;
885 curr *= BQ25700_IIN_DPM_LSB;
886 curr += BQ25700_IIN_DPM_BASE;
887
888 return 0;
889}
890
891static int bq25700_set_input_volt_limit(struct bq25700 *bq, int volt)
892{
893 int ret;
894 u16 reg_val;
895
896 if (volt < BQ25700_VIN_DPM_BASE)
897 volt = BQ25700_VIN_DPM_BASE;
898
899 volt -= BQ25700_VIN_DPM_BASE;
900 reg_val = volt / BQ25700_VIN_DPM_LSB;
901 reg_val <<= BQ25700_VIN_DPM_SHIFT;
902
903 ret = bq25700_update_bits(bq, BQ25700_REG_VIN_DPM,
904 BQ25700_VIN_DPM_MASK, reg_val);
905
906 return ret;
907}
908
909static int bq25700_set_otg_voltage(struct bq25700 *bq, int volt)
910{
911 int ret;
912 u16 reg_val;
913
914 if (volt < BQ25700_OTG_VOLT_BASE)
915 volt = BQ25700_OTG_VOLT_BASE;
916
917 volt -= BQ25700_OTG_VOLT_BASE;
918 reg_val = volt / BQ25700_OTG_VOLT_LSB;
919 reg_val <<= BQ25700_OTG_VOLT_SHIFT;
920
921 ret = bq25700_update_bits(bq, BQ25700_REG_OTG_VOLT,
922 BQ25700_OTG_VOLT_MASK, reg_val);
923
924 return ret;
925}
926
927static int bq25700_set_otg_current(struct bq25700 *bq, int curr)
928{
929 int ret;
930 u16 reg_val;
931
932 if (curr < BQ25700_OTG_CURRENT_BASE)
933 curr = BQ25700_OTG_CURRENT_BASE;
934
935 curr -= BQ25700_OTG_CURRENT_BASE;
936 reg_val = curr / BQ25700_OTG_CURRENT_LSB;
937 reg_val <<= BQ25700_OTG_CURRENT_SHIFT;
938
939 ret = bq25700_update_bits(bq, BQ25700_REG_OTG_CURRENT,
940 BQ25700_OTG_CURRENT_MASK, reg_val);
941
942 return ret;
943}
944
945static int bq25700_read_vbus_volt(struct bq25700 *bq, int *volt)
946{
947 int ret;
948 u16 reg_val;
949
950 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_VBUS_PSYS, &reg_val);
951 if (ret)
952 return ret;
953
954 *volt = reg_val & BQ25700_ADC_VBUS_VOLT_MASK;
955 *volt >>= BQ25700_ADC_VBUS_VOLT_SHIFT;
956 *volt *= BQ25700_ADC_VBUS_VOLT_LSB;
957 *volt += BQ25700_ADC_VBUS_VOLT_BASE;
958
959 return 0;
960}
961
962static int bq25700_read_psys_volt(struct bq25700 *bq, int *volt)
963{
964 int ret;
965 u16 reg_val;
966
967 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_VBUS_PSYS, &reg_val);
968 if (ret)
969 return ret;
970
971 *volt = reg_val & BQ25700_ADC_PSYS_VOLT_MASK;
972 *volt >>= BQ25700_ADC_PSYS_VOLT_SHIFT;
973 *volt *= BQ25700_ADC_PSYS_VOLT_LSB;
974 *volt += BQ25700_ADC_PSYS_VOLT_BASE;
975
976 return 0;
977}
978
979static int bq25700_read_ibat_chg_current(struct bq25700 *bq, int *curr)
980{
981 int ret;
982 u16 reg_val;
983
984 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_IBAT, &reg_val);
985 if (ret)
986 return ret;
987
988 *curr = reg_val & BQ25700_ADC_CHG_CURRENT_MASK;
989 *curr >>= BQ25700_ADC_CHG_CURRENT_SHIFT;
990 *curr *= BQ25700_ADC_CHG_CURRENT_LSB;
991 *curr += BQ25700_ADC_CHG_CURRENT_BASE;
992
993 return 0;
994}
995
996static int bq25700_read_ibat_dsg_current(struct bq25700 *bq, int *curr)
997{
998 int ret;
999 u16 reg_val;
1000
1001 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_IBAT, &reg_val);
1002 if (ret)
1003 return ret;
1004
1005 *curr = reg_val & BQ25700_ADC_DSG_CURRENT_MASK;
1006 *curr >>= BQ25700_ADC_DSG_CURRENT_SHIFT;
1007 *curr *= BQ25700_ADC_DSG_CURRENT_LSB;
1008 *curr += BQ25700_ADC_DSG_CURRENT_BASE;
1009
1010 return 0;
1011}
1012
1013static int bq25700_read_ibus_current(struct bq25700 *bq, int *curr)
1014{
1015 int ret;
1016 u16 reg_val;
1017
1018 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_IIN_CMPIN, &reg_val);
1019 if (ret)
1020 return ret;
1021
1022 *curr = reg_val & BQ25700_ADC_INPUT_CURRENT_MASK;
1023 *curr >>= BQ25700_ADC_INPUT_CURRENT_SHIFT;
1024 *curr *= BQ25700_ADC_INPUT_CURRENT_LSB;
1025 *curr += BQ25700_ADC_INPUT_CURRENT_BASE;
1026
1027 return 0;
1028}
1029
1030static int bq25700_read_cmpin_volt(struct bq25700 *bq, int *volt)
1031{
1032 int ret;
1033 u16 reg_val;
1034
1035 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_IIN_CMPIN, &reg_val);
1036 if (ret)
1037 return ret;
1038
1039 *volt = reg_val & BQ25700_ADC_CMPIN_VOLT_MASK;
1040 *volt >>= BQ25700_ADC_CMPIN_VOLT_SHIFT;
1041 *volt *= BQ25700_ADC_CMPIN_VOLT_LSB;
1042 *volt += BQ25700_ADC_CMPIN_VOLT_BASE;
1043
1044 return 0;
1045}
1046
1047static int bq25700_read_vsys_volt(struct bq25700 *bq, int *volt)
1048{
1049 int ret;
1050 u16 reg_val;
1051
1052 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_VSYS_VBAT, &reg_val);
1053 if (ret)
1054 return ret;
1055
1056 *volt = reg_val & BQ25700_ADC_SYS_VOLT_MASK;
1057 *volt >>= BQ25700_ADC_SYS_VOLT_SHIFT;
1058 *volt *= BQ25700_ADC_SYS_VOLT_LSB;
1059 *volt += BQ25700_ADC_SYS_VOLT_BASE;
1060
1061 return 0;
1062}
1063
1064static int bq25700_read_vbat_volt(struct bq25700 *bq, int *volt)
1065{
1066 int ret;
1067 u16 reg_val;
1068
1069 ret = bq25700_read_reg(bq, BQ25700_REG_ADC_VSYS_VBAT, &reg_val);
1070 if (ret)
1071 return ret;
1072
1073 *volt = reg_val & BQ25700_ADC_BAT_VOLT_MASK;
1074 *volt >>= BQ25700_ADC_BAT_VOLT_SHIFT;
1075 *volt *= BQ25700_ADC_BAT_VOLT_LSB;
1076 *volt += BQ25700_ADC_BAT_VOLT_BASE;
1077
1078 return 0;
1079}
1080
1081static int bq25700_get_vbus_present(struct bq25700 *bq)
1082{
1083 int ret;
1084 u16 status;
1085
1086 ret = bq25700_read_reg(bq, BQ25700_REG_CHARGER_STATUS, &status);
1087 if (!ret)
1088 bq->vbus_present = status & BQ25700_AC_STAT_MASK;
1089
1090 return ret;
1091}
1092
1093static int bq25700_get_charge_state(struct bq25700 *bq)
1094{
1095 int ret;
1096 u16 mode;
1097
1098 ret = bq25700_read_reg(bq, BQ25700_REG_CHARGER_STATUS, &mode);
1099 if (!ret) {
1100 if (mode & BQ25700_FAST_CHG_STAT_MASK)
1101 bq->charge_state = CHARGE_STATE_FASTCHARGE;
1102 else if (mode & BQ25700_PRE_CHG_STAT_MASK)
1103 bq->charge_state = CHARGE_STATE_PRECHARGE;
1104 else if (mode & BQ25700_OTG_STAT_MASK)
1105 bq->charge_state = CHARGE_STATE_OTG;
1106 else
1107 bq->charge_state = CHARGE_STATE_NOT_CHARGING;
1108 }
1109 return ret;
1110}
1111
1112
1113static int bq25700_get_batt_property(struct bq25700 *bq,
1114 enum power_supply_property psp,
1115 union power_supply_propval *val)
1116{
1117 int ret;
1118
1119 if (bq->bms_psy == NULL) {
1120 pr_err("%s: bms power supply is NULL\n", __func__);
1121 return -ENODEV;
1122 }
1123
1124 ret = power_supply_get_property(bq->bms_psy, psp, val);
1125
1126 return ret;
1127}
1128
1129
1130static void set_usb_present(struct bq25700 *bq)
1131{
1132
1133 bq25700_get_vbus_present(bq);
1134
1135 if (!bq->vbus_present && bq->usb_present) {
1136 bq->usb_present = false;
1137 power_supply_set_present(bq->usb_psy, bq->usb_present);
1138
1139 pr_info("usb removed, set usb present = %d\n", bq->usb_present);
1140 } else if (bq->vbus_present && !bq->usb_present) {
1141 bq->usb_present = true;
1142 power_supply_set_present(bq->usb_psy, bq->usb_present);
1143
1144 pr_info("usb plugged in, set usb present = %d\n",
1145 bq->usb_present);
1146 }
1147}
1148
1149static void set_usb_online(struct bq25700 *bq)
1150{
1151 int ret;
1152
1153 mutex_lock(&bq->usb_online_lock);
1154
1155 if (!bq->usb_online && bq->usb_present
1156 && bq->charge_enabled && bq->chg_ma) {
1157 ret = power_supply_set_online(bq->usb_psy, true);
1158 if (!ret) {
1159 bq->usb_online = true;
1160 pr_info("set usb online %d successfully\n",
1161 bq->usb_online);
1162 } else {
1163 pr_err("set usb online 1 failed\n");
1164 }
1165 } else if (bq->usb_online && (!bq->usb_present || !bq->charge_enabled
1166 || !bq->chg_ma)) {
1167 ret = power_supply_set_online(bq->usb_psy, false);
1168 if (!ret) {
1169 bq->usb_online = false;
1170 pr_info("set usb online %d successfully\n",
1171 bq->usb_online);
1172 } else {
1173 pr_err("set usb online 0 failed\n");
1174 }
1175 }
1176
1177 mutex_unlock(&bq->usb_online_lock);
1178}
1179
1180
1181static int bq25700_charging_disable(struct bq25700 *bq, int reason, int disable)
1182{
1183
1184 int ret = 0;
1185 int disabled;
1186
1187 mutex_lock(&bq->charging_disable_lock);
1188
1189 disabled = bq->charging_disabled_status;
1190
1191 pr_info("reason=%d requested_disable=%d disabled_status=%d\n",
1192 reason, disable, disabled);
1193
1194 if (disable == true)
1195 disabled |= reason;
1196 else
1197 disabled &= ~reason;
1198
1199 if (disabled && bq->charge_enabled)
1200 ret = bq25700_charge_enable(bq, false);
1201 else if (!disabled && !bq->charge_enabled)
1202 ret = bq25700_charge_enable(bq, true);
1203
1204 if (ret) {
1205 pr_err
1206 ("Couldn't disable/enable charging for reason=%d ret=%d\n",
1207 ret, reason);
1208 } else {
1209 bq->charging_disabled_status = disabled;
1210 mutex_lock(&bq->data_lock);
1211 bq->charge_enabled = !disabled;
1212 mutex_unlock(&bq->data_lock);
1213 }
1214 mutex_unlock(&bq->charging_disable_lock);
1215
1216 set_usb_online(bq);
1217
1218 return ret;
1219}
1220
1221static int bq25700_update_charging_profile(struct bq25700 *bq)
1222{
1223 int ret;
1224
1225 mutex_lock(&bq->profile_change_lock);
1226
1227 ret = bq25700_set_charge_volt(bq, bq->chg_mv);
1228 if (ret)
1229 pr_err("Failed to set chargevolt, ret=%d\n", ret);
1230
1231 ret = bq25700_set_charge_current(bq, bq->chg_ma);
1232 if (ret)
1233 pr_err("Failed to set chargecurrent, ret=%d\n", ret);
1234
1235 ret = bq25700_set_input_current_limit(bq, bq->icl_ma);
1236 if (ret < 0)
1237 pr_err("couldn't set input current limit, ret=%d\n", ret);
1238
1239 ret = bq25700_set_input_volt_limit(bq, bq->ivl_mv);
1240 if (ret < 0)
1241 pr_err("couldn't set input voltage limit, ret=%d\n", ret);
1242
1243 mutex_unlock(&bq->profile_change_lock);
1244
1245 return 0;
1246}
1247
1248
1249static int bq25700_get_prop_charge_type(struct bq25700 *bq)
1250{
1251
1252 switch (bq->charge_state) {
1253 case CHARGE_STATE_FASTCHARGE:
1254 return POWER_SUPPLY_CHARGE_TYPE_FAST;
1255 case CHARGE_STATE_PRECHARGE:
1256 return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1257 case CHARGE_STATE_NOT_CHARGING:
1258 return POWER_SUPPLY_CHARGE_TYPE_NONE;
1259 default:
1260 return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
1261 }
1262}
1263
1264#if 0
1265static int bq25700_get_prop_batt_present(struct bq25700 *bq)
1266{
1267 union power_supply_propval batt_prop = { 0, };
1268 int ret;
1269
1270 ret = bq25700_get_batt_property(bq,
1271 POWER_SUPPLY_PROP_PRESENT, &batt_prop);
1272 if (!ret)
1273 bq->batt_present = batt_prop.intval;
1274
1275 return ret;
1276
1277}
1278
1279static int bq25700_get_prop_batt_full(struct bq25700 *bq)
1280{
1281 union power_supply_propval batt_prop = { 0, };
1282 int ret;
1283
1284 ret = bq25700_get_batt_property(bq,
1285 POWER_SUPPLY_PROP_STATUS, &batt_prop);
1286 if (!ret)
1287 bq->batt_full = (batt_prop.intval == POWER_SUPPLY_STATUS_FULL);
1288
1289 return ret;
1290}
1291#endif
1292
1293static int bq25700_get_prop_charge_status(struct bq25700 *bq)
1294{
1295 union power_supply_propval batt_prop = { 0, };
1296 int ret;
1297
1298 ret = bq25700_get_batt_property(bq,
1299 POWER_SUPPLY_PROP_STATUS, &batt_prop);
1300 if (!ret && batt_prop.intval == POWER_SUPPLY_STATUS_FULL)
1301 return POWER_SUPPLY_STATUS_FULL;
1302
1303 if (bq->charge_state == CHARGE_STATE_FASTCHARGE ||
1304 bq->charge_state == CHARGE_STATE_PRECHARGE)
1305 return POWER_SUPPLY_STATUS_CHARGING;
1306 else if (bq->charge_state == CHARGE_STATE_NOT_CHARGING)
1307 return POWER_SUPPLY_STATUS_NOT_CHARGING;
1308 else if (!bq->vbus_present)
1309 return POWER_SUPPLY_STATUS_DISCHARGING;
1310 else
1311 return POWER_SUPPLY_STATUS_UNKNOWN;
1312
1313}
1314
1315static enum power_supply_property bq25700_charger_props[] = {
1316 POWER_SUPPLY_PROP_CHARGE_TYPE,
1317 POWER_SUPPLY_PROP_PRESENT,
1318 POWER_SUPPLY_PROP_CHARGING_ENABLED,
1319 POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED,
1320 POWER_SUPPLY_PROP_HEALTH,
1321 POWER_SUPPLY_PROP_CAPACITY,
1322 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1323 POWER_SUPPLY_PROP_CURRENT_NOW,
1324 POWER_SUPPLY_PROP_STATUS,
1325 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1326 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
1327 POWER_SUPPLY_PROP_TEMP,
1328/* POWER_SUPPLY_PROP_TIME_TO_EMPTY,*/
1329 POWER_SUPPLY_PROP_CHARGE_FULL,
1330 POWER_SUPPLY_PROP_CYCLE_COUNT,
1331 POWER_SUPPLY_PROP_TECHNOLOGY,
1332 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1333 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1334 POWER_SUPPLY_PROP_CURRENT_CAPABILITY,
1335 POWER_SUPPLY_PROP_TYPE,
1336
1337};
1338
1339static int bq25700_charger_get_property(struct power_supply *psy,
1340 enum power_supply_property psp,
1341 union power_supply_propval *val)
1342{
1343
1344 struct bq25700 *bq = power_supply_get_drvdata(psy);
1345
1346 switch (psp) {
1347 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1348 val->intval = bq25700_get_prop_charge_type(bq);
1349 break;
1350 case POWER_SUPPLY_PROP_CHARGING_ENABLED:
1351 val->intval = bq->charge_enabled;
1352 break;
1353 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1354 val->intval = 4800000; /* 4800 mAh */
1355 break;
1356
1357 case POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED:
1358 val->intval = !bq->charging_disabled_status;
1359 break;
1360 case POWER_SUPPLY_PROP_STATUS:
1361 val->intval = bq25700_get_prop_charge_status(bq);
1362 break;
1363 case POWER_SUPPLY_PROP_HEALTH:
1364 case POWER_SUPPLY_PROP_PRESENT:
1365 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1366 case POWER_SUPPLY_PROP_CURRENT_NOW:
1367 case POWER_SUPPLY_PROP_CAPACITY:
1368 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
1369 case POWER_SUPPLY_PROP_TEMP:
1370 case POWER_SUPPLY_PROP_CHARGE_FULL:
1371 case POWER_SUPPLY_PROP_TECHNOLOGY:
1372 return bq25700_get_batt_property(bq, psp, val);
1373 default:
1374 return -EINVAL;
1375
1376 }
1377
1378 return 0;
1379}
1380
1381static int bq25700_charger_set_property(struct power_supply *psy,
1382 enum power_supply_property prop,
1383 const union power_supply_propval *val)
1384{
1385 struct bq25700 *bq = power_supply_get_drvdata(psy);
1386
1387 int ret;
1388
1389 switch (prop) {
1390 case POWER_SUPPLY_PROP_CHARGING_ENABLED:
1391 bq25700_charging_disable(bq, USER, !val->intval);
1392
1393 power_supply_changed(bq->batt_psy);
1394 power_supply_changed(bq->usb_psy);
1395 pr_info("POWER_SUPPLY_PROP_CHARGING_ENABLED: %s\n",
1396 val->intval ? "enable" : "disable");
1397 break;
1398 case POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED:
1399 bq25700_charging_disable(bq, BATT, !val->intval);
1400 break;
1401 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1402 bq->chg_mv = val->intval / 1000;
1403 ret = bq25700_set_charge_volt(bq, bq->chg_mv);
1404 if (ret)
1405 pr_err("Failed to set chargevolt, ret=%d\n", ret);
1406 break;
1407 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1408 bq->chg_ma = val->intval / 1000;
1409 ret = bq25700_set_charge_current(bq, bq->chg_ma);
1410 if (ret)
1411 pr_err("Failed to set chargecurrent, ret=%d\n", ret);
1412
1413 set_usb_online(bq);
1414 break;
1415 case POWER_SUPPLY_PROP_TYPE:
1416 bq->supply_type = val->intval;
1417 /* notify USB of supply type */
1418 ret =
1419 power_supply_set_supply_type(bq->usb_psy, bq->supply_type);
1420 pr_err("set power supply type :%d %s\n", bq->supply_type,
1421 !ret ? "successfully" : "failed");
1422 set_usb_present(bq);
1423 set_usb_online(bq);
1424 break;
1425
1426 case POWER_SUPPLY_PROP_CURRENT_CAPABILITY:
1427 bq->icl_ma = val->intval / 1000; /* uA to mA */
1428 bq25700_update_charging_profile(bq);
1429 break;
1430
1431 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1432 bq->ivl_mv = val->intval / 1000;
1433 bq25700_update_charging_profile(bq);
1434 break;
1435
1436 default:
1437 return -EINVAL;
1438 }
1439
1440 return 0;
1441}
1442
1443static int bq25700_charger_is_writeable(struct power_supply *psy,
1444 enum power_supply_property prop)
1445{
1446 int ret;
1447
1448 switch (prop) {
1449 case POWER_SUPPLY_PROP_CHARGING_ENABLED:
1450 case POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED:
1451 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1452 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1453 case POWER_SUPPLY_PROP_TYPE:
1454 case POWER_SUPPLY_PROP_CURRENT_CAPABILITY:
1455 case POWER_SUPPLY_PROP_TYPEC_MODE:
1456 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1457 ret = 1;
1458 break;
1459 default:
1460 ret = 0;
1461 break;
1462 }
1463 return ret;
1464}
1465
1466static void bq25700_external_power_changed(struct power_supply *psy)
1467{
1468#if 0
1469 struct bq25700 *bq = container_of(psy, struct bq25700, batt_psy);
1470
1471 union power_supply_propval prop = { 0, };
1472 int ret, current_limit = 0;
1473
1474 ret = bq->usb_psy->get_property(bq->usb_psy,
1475 POWER_SUPPLY_PROP_CURRENT_MAX, &prop);
1476 if (ret < 0)
1477 pr_err("could not read USB current_max property, ret=%d\n",
1478 ret);
1479 else
1480 current_limit = prop.intval / 1000;
1481
1482 pr_info("current_limit = %d\n", current_limit);
1483
1484 if (bq->usb_psy_ma != current_limit) {
1485 bq->usb_psy_ma = current_limit;
1486 bq25700_update_charging_profile(bq);
1487 }
1488
1489 ret = bq->usb_psy->get_property(bq->usb_psy,
1490 POWER_SUPPLY_PROP_ONLINE, &prop);
1491 if (ret < 0)
1492 pr_err("could not read USB ONLINE property, ret=%d\n", ret);
1493 else
1494 pr_info("usb online status =%d\n", prop.intval);
1495
1496 ret = 0;
1497 if (bq->usb_present
1498 /* && bq->charge_enabled *//*!bq->charging_disabled_status */
1499 /*&& bq->usb_psy_ma != 0 */) {
1500 if (prop.intval == 0) {
1501 pr_err("set usb online\n");
1502 ret = power_supply_set_online(bq->usb_psy, true);
1503 }
1504 } else {
1505 if (prop.intval == 1) {
1506 pr_err("set usb offline\n");
1507 ret = power_supply_set_online(bq->usb_psy, false);
1508 }
1509 }
1510
1511 if (ret < 0)
1512 pr_info("could not set usb online state, ret=%d\n", ret);
1513#endif
1514
1515}
1516
1517static int bq25700_psy_register(struct bq25700 *bq)
1518{
1519 int ret;
1520 struct power_supply_config batt_psy_cfg = {};
1521
1522 bq->batt_psy_d.name = "battery";
1523 bq->batt_psy_d.type = POWER_SUPPLY_TYPE_BATTERY;
1524 bq->batt_psy_d.properties = bq25700_charger_props;
1525 bq->batt_psy_d.num_properties = ARRAY_SIZE(bq25700_charger_props);
1526 bq->batt_psy_d.get_property = bq25700_charger_get_property;
1527 bq->batt_psy_d.set_property = bq25700_charger_set_property;
1528 bq->batt_psy_d.external_power_changed = bq25700_external_power_changed;
1529 bq->batt_psy_d.property_is_writeable = bq25700_charger_is_writeable;
1530
1531 batt_psy_cfg.drv_data = bq;
1532 batt_psy_cfg.num_supplicants = 0;
1533
1534 bq->batt_psy = power_supply_register(bq->dev,
1535 &bq->batt_psy_d,
1536 &batt_psy_cfg);
1537 if (IS_ERR(bq->batt_psy)) {
1538 bq_err("couldn't register battery psy, ret = %ld\n",
1539 PTR_ERR(bq->batt_psy));
1540 return ret;
1541 }
1542
1543 return 0;
1544}
1545
1546static void bq25700_psy_unregister(struct bq25700 *bq)
1547{
1548 power_supply_unregister(bq->batt_psy);
1549}
1550
1551static int bq25700_otg_regulator_enable(struct regulator_dev *rdev)
1552{
1553 int ret;
1554 struct bq25700 *bq = rdev_get_drvdata(rdev);
1555
1556 ret = bq25700_set_otg_enable(bq, true);
1557 if (ret) {
1558 pr_err("Couldn't enable OTG mode ret=%d\n", ret);
1559 } else {
1560 bq->otg_enabled = true;
1561 pr_info("bq25700 OTG mode Enabled!\n");
1562 }
1563
1564 return ret;
1565}
1566
1567static int bq25700_otg_regulator_disable(struct regulator_dev *rdev)
1568{
1569 int ret;
1570 struct bq25700 *bq = rdev_get_drvdata(rdev);
1571
1572 ret = bq25700_set_otg_enable(bq, false);
1573 if (ret) {
1574 pr_err("Couldn't disable OTG mode, ret=%d\n", ret);
1575 } else {
1576 bq->otg_enabled = false;
1577 pr_info("bq25700 OTG mode Disabled\n");
1578 }
1579
1580 return ret;
1581}
1582
1583static int bq25700_otg_regulator_is_enable(struct regulator_dev *rdev)
1584{
1585 struct bq25700 *bq = rdev_get_drvdata(rdev);
1586
1587 bq25700_get_charge_state(bq);
1588
1589 return (bq->charge_state == CHARGE_STATE_OTG) ? 1 : 0;
1590
1591}
1592
1593struct regulator_ops bq25700_otg_reg_ops = {
1594 .enable = bq25700_otg_regulator_enable,
1595 .disable = bq25700_otg_regulator_disable,
1596 .is_enabled = bq25700_otg_regulator_is_enable,
1597};
1598
1599static int bq25700_regulator_init(struct bq25700 *bq)
1600{
1601 int ret = 0;
1602 struct regulator_init_data *init_data;
1603 struct regulator_config cfg = { };
1604
1605 init_data = of_get_regulator_init_data(bq->dev, bq->dev->of_node);
1606 if (!init_data) {
1607 dev_err(bq->dev, "Unable to allocate memory\n");
1608 return -ENOMEM;
1609 }
1610
1611 if (init_data->constraints.name) {
1612 bq->otg_vreg.rdesc.owner = THIS_MODULE;
1613 bq->otg_vreg.rdesc.type = REGULATOR_VOLTAGE;
1614 bq->otg_vreg.rdesc.ops = &bq25700_otg_reg_ops;
1615 bq->otg_vreg.rdesc.name = init_data->constraints.name;
1616 pr_info("regualtor name = %s\n", bq->otg_vreg.rdesc.name);
1617
1618 cfg.dev = bq->dev;
1619 cfg.init_data = init_data;
1620 cfg.driver_data = bq;
1621 cfg.of_node = bq->dev->of_node;
1622
1623 init_data->constraints.valid_ops_mask
1624 |= REGULATOR_CHANGE_STATUS;
1625
1626 bq->otg_vreg.rdev =
1627 regulator_register(&bq->otg_vreg.rdesc, &cfg);
1628 if (IS_ERR(bq->otg_vreg.rdev)) {
1629 ret = PTR_ERR(bq->otg_vreg.rdev);
1630 bq->otg_vreg.rdev = NULL;
1631 if (ret != -EPROBE_DEFER)
1632 dev_err(bq->dev,
1633 "OTG reg failed, rc=%d\n", ret);
1634 }
1635 }
1636
1637 return ret;
1638}
1639
1640static struct bq25700_platform_data *bq25700_parse_dt(struct device *dev,
1641 struct bq25700 *bq)
1642{
1643 int ret;
1644 struct device_node *np = dev->of_node;
1645 struct bq25700_platform_data *pdata;
1646
1647 pdata = devm_kzalloc(dev, sizeof(struct bq25700_platform_data),
1648 GFP_KERNEL);
1649 if (!pdata) {
1650 pr_err("Out of memory\n");
1651 return NULL;
1652 }
1653
1654 ret =
1655 of_property_read_u32(np, "ti,bq25700,input-volt-limit",
1656 &pdata->ivl_mv);
1657 if (ret)
1658 pr_err("Failed to read node of ti,bq25700,input-volt-limit\n");
1659
1660 ret =
1661 of_property_read_u32(np, "ti,bq25700,input-curr-limit",
1662 &pdata->icl_ma);
1663 if (ret)
1664 pr_err("Failed to read node of ti,bq25700,input-curr-limit\n");
1665
1666 ret =
1667 of_property_read_u32(np, "ti,bq25700,charge-volt", &pdata->chg_mv);
1668 if (ret)
1669 pr_err("Failed to read node of ti,bq25700,charge-volt\n");
1670
1671 ret =
1672 of_property_read_u32(np, "ti,bq25700,charge-current",
1673 &pdata->chg_ma);
1674 if (ret)
1675 pr_err("Failed to read node of ti,bq25700,charge-current\n");
1676
1677 ret =
1678 of_property_read_u32(np, "ti,bq25700,boost-voltage",
1679 &pdata->boostv);
1680 if (ret)
1681 pr_err("Failed to read node of ti,bq25700,boost-voltage\n");
1682
1683 ret =
1684 of_property_read_u32(np, "ti,bq25700,boost-current",
1685 &pdata->boosti);
1686 if (ret)
1687 pr_err("Failed to read node of ti,bq25700,boost-current\n");
1688
1689 return pdata;
1690}
1691
1692static int bq25700_init_device(struct bq25700 *bq)
1693{
1694 int ret;
1695
1696 bq25700_set_watchdog_timer(bq, BQ25700_WDTMR_175S);
1697
1698 bq->ivl_mv = bq->platform_data->ivl_mv;
1699 bq->icl_ma = bq->platform_data->icl_ma;
1700 bq->chg_mv = bq->platform_data->chg_mv;
1701 bq->chg_ma = bq->platform_data->chg_ma;
1702
1703 /* set initial charging profile */
1704 bq25700_update_charging_profile(bq);
1705
1706 bq25700_set_rsns_rac(bq, 10);
1707 bq25700_set_rsns_rsr(bq, 10);
1708
1709 ret = bq25700_set_otg_voltage(bq, bq->platform_data->boostv);
1710 if (ret)
1711 pr_err("Failed to set boost voltage, ret = %d\n", ret);
1712
1713 ret = bq25700_set_otg_current(bq, bq->platform_data->boosti);
1714 if (ret)
1715 pr_err("Failed to set boost current, ret = %d\n", ret);
1716
1717 bq25700_set_acoc_volt_pct(bq, 125);
1718 bq25700_set_acoc_enable(bq, true);
1719 bq25700_set_batoc_volt_pct(bq, 125);
1720 bq25700_set_batoc_enable(bq, true);
1721
1722 ret = bq25700_charge_enable(bq, true);
1723 if (ret) {
1724 pr_err("Failed to enable charger, ret = %d\n", ret);
1725 } else {
1726 bq->charge_enabled = true;
1727 pr_info("Charger Enabled Successfully!\n");
1728 }
1729
1730 bq25700_set_adc_scan_channel(bq, 0xFF);
1731
1732 ret = bq25700_adc_start(bq, false);
1733 pr_info("ADC start %s\n", !ret ? "successfully" : "failed");
1734
1735 return 0;
1736}
1737
1738static int bq25700_detect_device(struct bq25700 *bq)
1739{
1740 int ret;
1741 u16 data;
1742
1743 ret = bq25700_read_reg(bq, BQ25700_REG_DEVICE_ID, &data);
1744 if (ret == 0)
1745 bq->dev_id = data & BQ25700_DEVICE_ID_MASK;
1746
1747 return ret;
1748}
1749
1750static const unsigned char *charge_stat_str[] = {
1751 "Not Charging",
1752 "Precharging",
1753 "Fast Charging",
1754 "Charge Done",
1755};
1756
1757static void bq25700_dump_status(struct bq25700 *bq)
1758{
1759 pr_info("battery %s, temperature: %d\n",
1760 bq->batt_present ? "present" : "not present", bq->batt_temp);
1761
1762 if (bq->vindpm_triggered)
1763 pr_info("VINDPM triggered\n");
1764 if (bq->iindpm_triggered)
1765 pr_info("IINDPM triggered\n");
1766
1767 pr_info("vbus:%d, ibus:%d, vbat:%d,ichg:%d, idsg:%d\n",
1768 bq->vbus_volt, bq->ibus_curr, bq->vbat_volt, bq->chg_curr,
1769 bq->dsg_curr);
1770
1771 pr_info("%s\n", charge_stat_str[bq->charge_state]);
1772}
1773
1774static void bq25700_update_status(struct bq25700 *bq)
1775{
1776 u16 status;
1777 int ret;
1778 int last_charge_state;
1779 int last_fault_status;
1780
1781 last_charge_state = bq->charge_state;
1782 bq25700_get_charge_state(bq);
1783
1784 ret = bq25700_read_reg(bq, BQ25700_REG_CHARGER_STATUS, &status);
1785 if (ret)
1786 return;
1787
1788 mutex_lock(&bq->data_lock);
1789 bq->vindpm_triggered = !!(status & BQ25700_VINDPM_STAT_MASK);
1790 bq->iindpm_triggered = !!(status & BQ25700_IINDPM_STAT_MASK);
1791 mutex_unlock(&bq->data_lock);
1792
1793 last_fault_status = bq->fault_status;
1794 bq->fault_status = status & 0xFF;
1795 if (bq->charge_state != last_charge_state ||
1796 bq->fault_status != last_fault_status)
1797 power_supply_changed(bq->batt_psy);
1798
1799 bq25700_read_vbus_volt(bq, &bq->vbus_volt);
1800 bq25700_read_ibat_chg_current(bq, &bq->chg_curr);
1801 bq25700_read_ibat_dsg_current(bq, &bq->dsg_curr);
1802 bq25700_read_vbat_volt(bq, &bq->vbat_volt);
1803 bq25700_read_vsys_volt(bq, &bq->vsys_volt);
1804 bq25700_read_ibus_current(bq, &bq->ibus_curr);
1805}
1806
1807static void bq25700_monitor_workfunc(struct work_struct *work)
1808{
1809 struct bq25700 *bq =
1810 container_of(work, struct bq25700, monitor_work.work);
1811
1812 bq25700_update_status(bq);
1813 bq25700_dump_status(bq);
1814
1815 schedule_delayed_work(&bq->monitor_work, 5 * HZ);
1816}
1817
1818const u8 reg_list[] = {
1819 0x12, 0x14, 0x15, 0x30,
1820 0x31, 0x32, 0x33, 0x34,
1821 0x35, 0x20, 0x31, 0x22,
1822 0x23, 0x24, 0x25, 0x26,
1823 0x3B, 0x3C, 0x3D, 0x3E,
1824 0x3F, 0xFE, 0xFF
1825 };
1826
1827static int show_registers(struct seq_file *m, void *data)
1828{
1829 struct bq25700 *bq = m->private;
1830 u8 i;
1831 int ret;
1832 u16 val;
1833
1834 for (i = 0x0; i <= ARRAY_SIZE(reg_list); i++) {
1835 ret = bq25700_read_reg(bq, reg_list[i], &val);
1836 if (!ret)
1837 seq_printf(m, "Reg[%02X] = 0x%04X\n", reg_list[i], val);
1838 }
1839 return 0;
1840}
1841
1842static int reg_debugfs_open(struct inode *inode, struct file *file)
1843{
1844 struct bq25700 *bq = inode->i_private;
1845
1846 return single_open(file, show_registers, bq);
1847}
1848
1849static const struct file_operations reg_debugfs_ops = {
1850 .owner = THIS_MODULE,
1851 .open = reg_debugfs_open,
1852 .read = seq_read,
1853 .llseek = seq_lseek,
1854 .release = single_release,
1855};
1856
1857static void create_debugfs_entry(struct bq25700 *bq)
1858{
1859 bq->debug_root = debugfs_create_dir("bq25700", NULL);
1860 if (!bq->debug_root)
1861 pr_err("Failed to create debug dir\n");
1862
1863 if (bq->debug_root) {
1864
1865 debugfs_create_file("registers", S_IFREG | S_IRUGO,
1866 bq->debug_root, bq, &reg_debugfs_ops);
1867
1868 debugfs_create_x32("charging_disable_status", S_IFREG | S_IRUGO,
1869 bq->debug_root,
1870 &(bq->charging_disabled_status));
1871
1872 debugfs_create_x32("fault_status", S_IFREG | S_IRUGO,
1873 bq->debug_root, &(bq->fault_status));
1874
1875 debugfs_create_x32("charge_state", S_IFREG | S_IRUGO,
1876 bq->debug_root, &(bq->charge_state));
1877
1878 debugfs_create_x32("skip_reads",
1879 S_IFREG | S_IWUSR | S_IRUGO,
1880 bq->debug_root, &(bq->skip_reads));
1881 debugfs_create_x32("skip_writes",
1882 S_IFREG | S_IWUSR | S_IRUGO,
1883 bq->debug_root, &(bq->skip_writes));
1884 }
1885}
1886
1887static int bq25700_charger_probe(struct i2c_client *client,
1888 const struct i2c_device_id *id)
1889{
1890 struct bq25700 *bq;
1891 struct power_supply *usb_psy = NULL;
1892 struct power_supply *bms_psy = NULL;
1893
1894 int ret;
1895
1896 usb_psy = power_supply_get_by_name("usb");
1897 if (!usb_psy) {
1898 dev_dbg(&client->dev, "USB supply not found, defer probe\n");
1899 return -EPROBE_DEFER;
1900 }
1901
1902 bms_psy = power_supply_get_by_name("bms");
1903 if (!bms_psy) {
1904 dev_dbg(&client->dev, "bms supply not found, defer probe\n");
1905 return -EPROBE_DEFER;
1906 }
1907
1908 bq = devm_kzalloc(&client->dev, sizeof(struct bq25700), GFP_KERNEL);
1909 if (!bq) {
1910 pr_err("Out of memory\n");
1911 return -ENOMEM;
1912 }
1913
1914 bq->dev = &client->dev;
1915 bq->usb_psy = usb_psy;
1916 bq->bms_psy = bms_psy;
1917
1918 bq->client = client;
1919 i2c_set_clientdata(client, bq);
1920
1921 mutex_init(&bq->i2c_rw_lock);
1922 mutex_init(&bq->data_lock);
1923 mutex_init(&bq->profile_change_lock);
1924 mutex_init(&bq->charging_disable_lock);
1925 mutex_init(&bq->usb_online_lock);
1926 mutex_init(&bq->adc_lock);
1927
1928 create_debugfs_entry(bq);
1929 ret = bq25700_detect_device(bq);
1930 if (ret) {
1931 pr_err("No bq25700 device found!\n");
1932 return -ENODEV;
1933 }
1934
1935 if (client->dev.of_node)
1936 bq->platform_data = bq25700_parse_dt(&client->dev, bq);
1937 else
1938 bq->platform_data = client->dev.platform_data;
1939
1940 if (!bq->platform_data) {
1941 pr_err("No platform data provided.\n");
1942 return -EINVAL;
1943 }
1944
1945 ret = bq25700_init_device(bq);
1946 if (ret) {
1947 pr_err("Failed to init device\n");
1948 return ret;
1949 }
1950
1951 ret = bq25700_psy_register(bq);
1952 if (ret)
1953 return ret;
1954
1955 ret = bq25700_regulator_init(bq);
1956 if (ret) {
1957 pr_err("Couldn't initialize bq25700 regulator ret=%d\n", ret);
1958 return ret;
1959 }
1960
1961 INIT_DELAYED_WORK(&bq->monitor_work, bq25700_monitor_workfunc);
1962
1963 bq25700_update_charging_profile(bq);
1964 set_usb_present(bq);
1965 set_usb_online(bq);
1966 schedule_delayed_work(&bq->monitor_work, 0);
1967
1968 pr_info("bq25700 probe successfully, ManufactureID:%d\n!",
1969 bq->dev_id);
1970
1971 return 0;
1972
1973}
1974
1975static int bq25700_charger_remove(struct i2c_client *client)
1976{
1977 struct bq25700 *bq = i2c_get_clientdata(client);
1978
1979 cancel_delayed_work_sync(&bq->monitor_work);
1980
1981 regulator_unregister(bq->otg_vreg.rdev);
1982
1983 bq25700_psy_unregister(bq);
1984
1985 mutex_destroy(&bq->charging_disable_lock);
1986 mutex_destroy(&bq->profile_change_lock);
1987 mutex_destroy(&bq->data_lock);
1988 mutex_destroy(&bq->i2c_rw_lock);
1989 mutex_destroy(&bq->usb_online_lock);
1990 mutex_destroy(&bq->adc_lock);
1991
1992 debugfs_remove_recursive(bq->debug_root);
1993
1994 return 0;
1995}
1996
1997static void bq25700_charger_shutdown(struct i2c_client *client)
1998{
1999 pr_info("shutdown\n");
2000}
2001
2002static struct of_device_id bq25700_charger_match_table[] = {
2003 {.compatible = "ti,bq25703",},
2004 {},
2005};
2006
2007MODULE_DEVICE_TABLE(of, bq25700_charger_match_table);
2008
2009static const struct i2c_device_id bq25700_charger_id[] = {
2010 {"bq25700-charger", BQ25700},
2011 {},
2012};
2013
2014MODULE_DEVICE_TABLE(i2c, bq25700_charger_id);
2015
2016static struct i2c_driver bq25700_charger_driver = {
2017 .driver = {
2018 .name = "bq25700-charger",
2019 .owner = THIS_MODULE,
2020 .of_match_table = bq25700_charger_match_table,
2021 },
2022 .id_table = bq25700_charger_id,
2023
2024 .probe = bq25700_charger_probe,
2025 .remove = bq25700_charger_remove,
2026 .shutdown = bq25700_charger_shutdown,
2027
2028};
2029
2030module_i2c_driver(bq25700_charger_driver);
2031
2032MODULE_DESCRIPTION("TI BQ2570x Charger Driver");
2033MODULE_LICENSE("GPL v2");
2034MODULE_AUTHOR("Texas Instruments");
diff --git a/drivers/power/bq25700/bq25700_reg.h b/drivers/power/bq25700/bq25700_reg.h
new file mode 100644
index 000000000000..90821b25112a
--- /dev/null
+++ b/drivers/power/bq25700/bq25700_reg.h
@@ -0,0 +1,508 @@
1#ifndef __BQ25700_HEADER__
2#define __BQ25700_HEADER__
3
4#define BQ25700_REG_CHARGE_OPTION0 0x12
5#define BQ25700_LWPWR_MODE_CTRL_MASK 0x8000
6#define BQ25700_LWPWR_MODE_CTRL_SHIFT 15
7#define BQ25700_LWPWR_MODE_ENABLE 0
8#define BQ25700_LWPWR_MODE_DISABLE 1
9#define BQ25700_WDTMR_ADJ_MASK 0x6000
10#define BQ25700_WDTMR_ADJ_SHIFT 13
11#define BQ25700_WDTMR_DISABLE 0
12#define BQ25700_WDTMR_5S 1
13#define BQ25700_WDTMR_88S 2
14#define BQ25700_WDTMR_175S 3
15#define BQ25700_IDPM_AUTO_CTRL_MASK 0x1000
16#define BQ25700_IDPM_AUTO_CTRL_SHIFT 12
17#define BQ25700_IDPM_AUTO_ENABLE 0
18#define BQ25700_IDPM_AUTO_DISABLE 1
19#define BQ25700_OTG_ON_CHRGOK_CTRL_MASK 0x800
20#define BQ25700_OTG_ON_CHRGOK_CTRL_SHIFT 11
21#define BQ25700_OTG_ON_CHRGOK_DISABLE 0
22#define BQ25700_OTG_ON_CHRGOK_ENABLE 1
23#define BQ25700_OUT_OF_AUDIO_CTRL_MASK 0x400
24#define BQ25700_OUT_OF_AUDIO_CTRL_SHIFT 10
25#define BQ25700_OOA_DISABLE 0
26#define BQ25700_OOA_ENABLE 1
27#define BQ25700_PWM_FREQ_MASK 0x200
28#define BQ25700_PWM_FREQ_SHIFT 9
29#define BQ25700_PWM_FREQ_1200KHZ 0
30#define BQ25700_PWM_FREQ_800KHZ 1
31#define BQ25700_LEARN_MODE_CTRL_MASK 0x20
32#define BQ25700_LEARN_MODE_CTRL_SHIFT 5
33#define BQ25700_LEARN_MODE_DISABLE 0
34#define BQ25700_LEARN_MODE_ENABLE 1
35#define BQ25700_IADPT_GAIN_MASK 0x10
36#define BQ25700_IADPT_GAIN_SHIFT 4
37#define BQ25700_IADPT_GAIN_20X 0
38#define BQ25700_IADPT_GAIN_40X 1
39#define BQ25700_IBAT_GAIN_MASK 0x08
40#define BQ25700_IBAT_GAIN_SHIFT 3
41#define BQ25700_IBAT_GAIN_8X 0
42#define BQ25700_IBAT_GAIN_16X 1
43#define BQ25700_LDO_MODE_CTRL_MASK 0x04
44#define BQ25700_LDO_MODE_CTRL_SHIFT 2
45#define BQ25700_LDO_MODE_DISABLE 0
46#define BQ25700_LDO_MODE_ENABLE 1
47#define BQ25700_IDPM_CTRL_MASK 0x02
48#define BQ25700_IDPM_CTRL_SHIFT 1
49#define BQ25700_IDPM_DISABLE 0
50#define BQ25700_IDPM_ENABLE 1
51#define BQ25700_CHRG_CTRL_MASK 0x01
52#define BQ25700_CHRG_CTRL_SHIFT 0
53#define BQ25700_CHRG_ENABLE 0
54#define BQ25700_CHRG_DISABLE 1
55
56#define BQ25700_REG_CHARGE_OPTION1 0x30
57#define BQ25700_IBAT_OUTPUT_BUF_CTRL_MASK 0x8000
58#define BQ25700_IBAT_OUTPUT_BUF_CTRL_SHIFT 15
59#define BQ25700_IBAT_OUTPUT_BUF_DISABLE 0
60#define BQ25700_IBAT_OUTPUT_BUF_ENABLE 1
61#define BQ25700_LWPWR_PROCHOT_CTRL_MASK 0x6000
62#define BQ25700_LWPWR_PROCHOT_CTRL_SHIFT 13
63#define BQ25700_LWPWR_PROCHOT_DISABLE 0
64#define BQ25700_LWPWR_PROCHOT_IDCHG_ENABLE 1
65#define BQ25700_LWPWR_PROCHOT_VSYS_ENABLE 2
66#define BQ25700_LWPWR_PROCHOT_CTRL_RSVED 3
67#define BQ25700_PSYS_CTRL_MASK 0x1000
68#define BQ25700_PSYS_CTRL_SHIFT 12
69#define BQ25700_PSYS_DISABLE 0
70#define BQ25700_PSYS_ENABLE 1
71#define BQ25700_RSNS_RAC_MASK 0x800
72#define BQ25700_RSNS_RAC_SHIFT 11
73#define BQ25700_RSNS_RAC_10MOHM 0
74#define BQ25700_RSNS_RAC_20MOHM 1
75#define BQ25700_RSNS_RSR_MASK 0x400
76#define BQ25700_RSNS_RSR_SHIFT 10
77#define BQ25700_RSNS_RSR_10MOHM 0
78#define BQ25700_RSNS_RSR_20MOHM 1
79#define BQ25700_PSYS_RATIO_MASK 0x200
80#define BQ25700_PSYS_RATIO_SHIFT 9
81#define BQ25700_PSYS_RATIO_0P25UAW 0
82#define BQ25700_PSYS_RATIO_1UAW 1
83#define BQ25700_CMP_REF_MASK 0x80
84#define BQ25700_CMP_REF_SHIFT 7
85#define BQ25700_CMP_REF_2P3V 0
86#define BQ25700_CMP_REF_1P2V 1
87#define BQ25700_CMP_POL_MASK 0x40
88#define BQ25700_CMP_POL_SHIFT 6
89#define BQ25700_CMP_POL_ABOVE 0
90#define BQ25700_CMP_POL_BELOW 1
91#define BQ25700_CMP_DEG_TIME_MASK 0x30
92#define BQ25700_CMP_DEG_TIME_SHIFT 4
93#define BQ25700_CMP_DEG_DISABLE 0
94#define BQ25700_CMP_DEG_1US 1
95#define BQ25700_CMP_DEG_2MS 2
96#define BQ25700_CMP_DEG_5S 3
97#define BQ25700_POWER_PATH_CTRL_MASK 0x08
98#define BQ25700_POWER_PATH_CTRL_SHIFT 3
99#define BQ25700_POWER_PATH_ON 0
100#define BQ25700_POWER_PATH_OFF 1
101#define BQ25700_SHIP_DSG_CTRL_MASK 0x02
102#define BQ25700_SHIP_DSG_CTRL_SHIFT 1
103#define BQ25700_SHIP_DSG_DISABLE 0
104#define BQ25700_SHIP_DSG_ENABLE 1
105#define BQ25700_AUTO_WAKEUP_CTRL_MASK 0x01
106#define BQ25700_AUTO_WAKEUP_CTRL_SHIFT 0
107#define BQ25700_AUTO_WAKEUP_ENABLE 0
108#define BQ25700_AUTO_WAKEUP_DISABLE 1
109
110#define BQ25700_REG_CHARGE_OPTION2 0x31
111#define BQ25700_PPM_OVERLOAD_TIME_MASK 0xC000
112#define BQ25700_PPM_OVERLOAD_TIME_SHIFT 14
113#define BQ25700_PPM_OVERLOAD_1MS 0
114#define BQ25700_PPM_OVERLOAD_2MS 1
115#define BQ25700_PPM_OVERLOAD_10MS 2
116#define BQ25700_PPM_OVERLOAD_20MS 3
117#define BQ25700_PPM_IDPM_CTRL_MASK 0x2000
118#define BQ25700_PPM_IDPM_CTRL_SHIFT 13
119#define BQ25700_PPM_IDPM_DISABLE 0
120#define BQ25700_PPM_IDPM_ENABLE 1
121#define BQ25700_PPM_VSYS_CTRL_MASK 0x1000
122#define BQ25700_PPM_VSYS_CTRL_SHIFT 12
123#define BQ25700_PPM_VSYS_DISABLE 0
124#define BQ25700_PPM_VSYS_ENABLE 1
125#define BQ25700_PPM_OVERLOAD_STAT_MASK 0x800
126#define BQ25700_PPM_OVERLOAD_STAT_SHIFT 11
127#define BQ25700_PPM_OVERLOAD_INACTIVE 0
128#define BQ25700_PPM_OVERLOAD_ACTIVE 1
129#define BQ25700_PPM_RELAX_STAT_MASK 0x400
130#define BQ25700_PPM_RELAX_STAT_SHIFT 10
131#define BQ25700_PPM_RELAX_INACTIVE 0
132#define BQ25700_PPM_RELAX_ACTIVE 1
133#define BQ25700_PPM_CYCLE_TIME_MASK 0x300
134#define BQ25700_PPM_CYCLE_TIME_SHIFT 8
135#define BQ25700_PPM_CYCLE_TIME_5MS 0
136#define BQ25700_PPM_CYCLE_TIME_10MS 1
137#define BQ25700_PPM_CYCLE_TIME_20MS 2
138#define BQ25700_PPM_CYCLE_TIME_40MS 3
139#define BQ25700_ILIM_PIN_CTRL_MASK 0x80
140#define BQ25700_ILIM_PIN_CTRL_SHIFT 7
141#define BQ25700_ILIM_PIN_DISABLE 0
142#define BQ25700_ILIM_PIN_ENABLE 1
143#define BQ25700_IBAT_PIN_CTRL_MASK 0x40
144#define BQ25700_IBAT_PIN_CTRL_SHIFT 6
145#define BQ25700_IBAT_PIN_DSG 0
146#define BQ25700_IBAT_PIN_CHG 1
147#define BQ25700_Q2_OCP_TH_MASK 0x20
148#define BQ25700_Q2_OCP_TH_SHIFT 5
149#define BQ25700_Q2_OCP_TH_210MV 0
150#define BQ25700_Q2_OCP_TH_150MV 1
151#define BQ25700_ACX_OCP_TH_MASK 0x10
152#define BQ25700_ACX_OCP_TH_SHIFT 4
153#define BQ25700_ACX_OCP_TH_280MV 0
154#define BQ25700_ACX_OCP_TH_150MV 1
155#define BQ25700_ACOC_CTRL_MASK 0x08
156#define BQ25700_ACOC_CTRL_SHIFT 3
157#define BQ25700_ACOC_DISABLE 0
158#define BQ25700_ACOC_ENABLE 1
159#define BQ25700_ACOC_VTH_MASK 0x04
160#define BQ25700_ACOC_VTH_SHIFT 2
161#define BQ25700_ACOC_VTH_125PCT 0
162#define BQ25700_ACOC_VTH_200PCT 1
163#define BQ25700_BATOC_CTRL_MASK 0x02
164#define BQ25700_BATOC_CTRL_SHIFT 1
165#define BQ25700_BATOC_DISABLE 0
166#define BQ25700_BATOC_ENABLE 1
167#define BQ25700_BATOC_VTH_MASK 0x01
168#define BQ25700_BATOC_VTH_SHIFT 0
169#define BQ25700_BATOC_VTH_125PCT 0
170#define BQ25700_BATOC_VTH_200PCT 1
171
172#define BQ25700_REG_CHARGE_OPTION3 0x32
173#define BQ25700_HIZ_MODE_CTRL_MASK 0x8000
174#define BQ25700_HIZ_MODE_CTRL_SHIFT 15
175#define BQ25700_HIZ_MODE_DISABLE 0
176#define BQ25700_HIZ_MODE_ENABLE 1
177#define BQ25700_REG_RESET_CTRL_MASK 0x4000
178#define BQ25700_REG_RESET_CTRL_SHIFT 14
179#define BQ25700_REG_RESET_IDLE 0
180#define BQ25700_REG_RESET 1
181#define BQ25700_VINDPM_RESET_CTRL_MASK 0x2000
182#define BQ25700_VINDPM_RESET_CTRL_SHIFT 13
183#define BQ25700_VINDPM_RESET_IDLE 0
184#define BQ25700_VINDPM_RESET 1
185#define BQ25700_OTG_CTRL_MASK 0x1000
186#define BQ25700_OTG_CTRL_SHIFT 12
187#define BQ25700_OTG_DISABLE 0
188#define BQ25700_OTG_ENABLE 1
189#define BQ25700_ICO_MODE_CTRL_MASK 0x1000
190#define BQ25700_ICO_MODE_CTRL_SHIFT 12
191#define BQ25700_ICO_DISABLE 0
192#define BQ25700_ICO_ENABLE 1
193#define BQ25700_HIZ_BATFET_CTRL_MASK 0x02
194#define BQ25700_HIZ_BATFET_CTRL_SHIFT 1
195#define BQ25700_HIZ_BATFET_ON 0
196#define BQ25700_HIZ_BATFET_OFF 1
197#define BQ25700_OTG_PSYS_CTRL_MASK 0x01
198#define BQ25700_OTG_PSYS_CTRL_SHIFT 0
199#define BQ25700_OTG_PSYS_DSG_MINUS_OTG_PWR 0
200#define BQ25700_OTG_PSYS_DSG_ONLY 1
201
202#define BQ25700_REG_PROHOT_OPTION0 0x33
203#define BQ25700_ILIM2_VTH_MASK 0xF800
204#define BQ25700_ILIM2_VTH_SHIFT 11
205#define BQ25700_ILIM2_VTH_BASE 0
206#define BQ25700_ILIM2_VTH_LSB 10
207#define BQ25700_ICRIT_DEG_MASK 0x600
208#define BQ25700_ICRIT_DEG_SHIFT 9
209#define BQ25700_ICRIT_DEG_15US 0
210#define BQ25700_ICRIT_DEG_100US 1
211#define BQ25700_ICRIT_DEG_400US 2
212#define BQ25700_ICRIT_DEG_800US 3
213#define BQ25700_VSYS_VTH_MASK 0xC0
214#define BQ25700_VSYS_VTH_SHIFT 6
215#define BQ25700_VSYS_VTH_5P75V_2P85V 0
216#define BQ25700_VSYS_VTH_6P0V_3P1V 1
217#define BQ25700_VSYS_VTH_6P25V_3P35V 2
218#define BQ25700_VSYS_VTH_6P5V_3P6V 3
219#define BQ25700_PROCHOT_EXT_CTRL_MASK 0x20
220#define BQ25700_PROCHOT_EXT_CTRL_SHIFT 5
221#define BQ25700_PROCHOT_EXT_DISABLE 0
222#define BQ25700_PROCHOT_EXT_ENABLE 1
223#define BQ25700_PROCHOT_WIDTH_MASK 0x0C
224#define BQ25700_PROCHOT_WIDTH_SHIFT 2
225#define BQ25700_PROCHOT_WIDTH_100US 0
226#define BQ25700_PROCHOT_WIDTH_1MS 1
227#define BQ25700_PROCHOT_WIDTH_10MS 2
228#define BQ25700_PROCHOT_WIDTH_5MS 3
229#define BQ25700_PROCHOT_CLEAR_MASK 0x04
230#define BQ25700_PROCHOT_CLEAR_SHIFT 2
231#define BQ25700_PROCHOT_CLEAR_DO 0
232#define BQ25700_PROCHOT_CLEAR_IDLE 1
233#define BQ25700_INOM_DEG_MASK 0x02
234#define BQ25700_INOM_DEG_SHIFT 1
235#define BQ25700_INOM_DEG_1MS 0
236#define BQ25700_INOM_DEG_50MS 1
237
238#define BQ25700_REG_PROHOT_OPTION1 0x34
239#define BQ25700_DSG_VTH_MASK 0xFC00
240#define BQ25700_DSG_VTH_SHIFT 10
241#define BQ25700_DSG_VTH_BASE 0
242#define BQ25700_DSG_VTH_LSB 512
243#define BQ25700_DSG_DEG_MASK 0x300
244#define BQ25700_DSG_DEG_SHIFT 8
245#define BQ25700_DSG_DEG_1P6MS 0
246#define BQ25700_DSG_DEG_100US 1
247#define BQ25700_DSG_DEG_6MS 2
248#define BQ25700_DSG_DEG_12MS 3
249#define BQ25700_PROCHOT_COMP_CTRL_MASK 0x40
250#define BQ25700_PROCHOT_COMP_CTRL_SHIFT 6
251#define BQ25700_PROCHOT_COMP_DISABLE 0
252#define BQ25700_PROCHOT_COMP_ENABLE 1
253#define BQ25700_PROCHOT_ICRIT_CTRL_MASK 0x40
254#define BQ25700_PROCHOT_ICRIT_CTRL_SHIFT 6
255#define BQ25700_PROCHOT_ICRIT_DISABLE 0
256#define BQ25700_PROCHOT_ICRIT_ENABLE 1
257#define BQ25700_PROCHOT_INOM_CTRL_MASK 0x40
258#define BQ25700_PROCHOT_INOM_CTRL_SHIFT 6
259#define BQ25700_PROCHOT_INOM_DISABLE 0
260#define BQ25700_PROCHOT_INOM_ENABLE 1
261#define BQ25700_PROCHOT_DSG_CTRL_MASK 0x40
262#define BQ25700_PROCHOT_DSG_CTRL_SHIFT 6
263#define BQ25700_PROCHOT_DSG_DISABLE 0
264#define BQ25700_PROCHOT_DSG_ENABLE 1
265#define BQ25700_PROCHOT_VSYS_CTRL_MASK 0x40
266#define BQ25700_PROCHOT_VSYS_CTRL_SHIFT 6
267#define BQ25700_PROCHOT_VSYS_DISABLE 0
268#define BQ25700_PROCHOT_VSYS_ENABLE 1
269#define BQ25700_PROCHOT_BATPRES_CTRL_MASK 0x40
270#define BQ25700_PROCHOT_BATPRES_CTRL_SHIFT 6
271#define BQ25700_PROCHOT_BATPRES_DISABLE 0
272#define BQ25700_PROCHOT_BATPRES_ENABLE 1
273#define BQ25700_PROCHOT_ACOK_CTRL_MASK 0x40
274#define BQ25700_PROCHOT_ACOK_CTRL_SHIFT 6
275#define BQ25700_PROCHOT_ACOK_DISABLE 0
276#define BQ25700_PROCHOT_ACOK_ENABLE 1
277
278#define BQ25700_REG_ADC_OPTION 0x35
279#define BQ25700_ADC_CONV_MASK 0x8000
280#define BQ25700_ADC_CONV_SHIFT 15
281#define BQ25700_ADC_CONV_ONESHOT 0
282#define BQ25700_ADC_CONV_CONT 1
283#define BQ25700_ADC_START_CTRL_MASK 0x4000
284#define BQ25700_ADC_START_CTRL_SHIFT 14
285#define BQ25700_ADC_START_IDLE 0
286#define BQ25700_ADC_START 1
287#define BQ25700_ADC_FULLSCALE_MASK 0x2000
288#define BQ25700_ADC_FULLSCALE_SHIFT 13
289#define BQ25700_ADC_FULLSCALE_2P04V 0
290#define BQ25700_ADC_FULLSCALE_3P06V 1
291#define BQ25700_ADC_CMPIN_CTRL_MASK 0x80
292#define BQ25700_ADC_CMPIN_CTRL_SHIFT 7
293#define BQ25700_ADC_CMPIN_DISABLE 0
294#define BQ25700_ADC_CMPIN_ENABLE 1
295#define BQ25700_ADC_VBUS_CTRL_MASK 0x40
296#define BQ25700_ADC_VBUS_CTRL_SHIFT 6
297#define BQ25700_ADC_VBUS_DISABLE 0
298#define BQ25700_ADC_VBUS_ENABLE 1
299#define BQ25700_ADC_PSYS_CTRL_MASK 0x20
300#define BQ25700_ADC_PSYS_CTRL_SHIFT 5
301#define BQ25700_ADC_PSYS_DISABLE 0
302#define BQ25700_ADC_PSYS_ENABLE 1
303#define BQ25700_ADC_IIN_CTRL_MASK 0x10
304#define BQ25700_ADC_IIN_CTRL_SHIFT 4
305#define BQ25700_ADC_IIN_DISABLE 0
306#define BQ25700_ADC_IIN_ENABLE 1
307#define BQ25700_ADC_DSG_CTRL_MASK 0x08
308#define BQ25700_ADC_DSG_CTRL_SHIFT 3
309#define BQ25700_ADC_DSG_DISABLE 0
310#define BQ25700_ADC_DSG_ENABLE 1
311#define BQ25700_ADC_CHG_CTRL_MASK 0x04
312#define BQ25700_ADC_CHG_CTRL_SHIFT 2
313#define BQ25700_ADC_CHG_DISABLE 0
314#define BQ25700_ADC_CHG_ENABLE 1
315#define BQ25700_ADC_VSYS_CTRL_MASK 0x02
316#define BQ25700_ADC_VSYS_CTRL_SHIFT 1
317#define BQ25700_ADC_VSYS_DISABLE 0
318#define BQ25700_ADC_VSYS_ENABLE 1
319#define BQ25700_ADC_VBAT_CTRL_MASK 0x01
320#define BQ25700_ADC_VBAT_CTRL_SHIFT 0
321#define BQ25700_ADC_VBAT_DISABLE 0
322#define BQ25700_ADC_VBAT_ENABLE 1
323
324#define BQ25700_REG_CHARGER_STATUS 0x20
325#define BQ25700_AC_STAT_MASK 0x8000
326#define BQ25700_AC_STAT_SHIFT 15
327#define BQ25700_AC_STAT_NOT_PRES 0
328#define BQ25700_AC_STAT_PRES 1
329#define BQ25700_ICO_STAT_MASK 0x4000
330#define BQ25700_ICO_STAT_SHIFT 14
331#define BQ25700_ICO_STAT_IN_PROGRESS 0
332#define BQ25700_ICO_STAT_DONE 1
333#define BQ25700_VINDPM_STAT_MASK 0x1000
334#define BQ25700_VINDPM_STAT_SHIFT 12
335#define BQ25700_VINDPM_STAT_INACTIVE 0
336#define BQ25700_VINDPM_STAT_ACTIVE 1
337#define BQ25700_IINDPM_STAT_MASK 0x800
338#define BQ25700_IINDPM_STAT_SHIFT 11
339#define BQ25700_IINDPM_STAT_INACTIVE 0
340#define BQ25700_IINDPM_STAT_ACTIVE 1
341#define BQ25700_FAST_CHG_STAT_MASK 0x400
342#define BQ25700_FAST_CHG_STAT_SHIFT 10
343#define BQ25700_FAST_CHG_STAT_INACTIVE 0
344#define BQ25700_FAST_CHG_STAT_ACTIVE 1
345#define BQ25700_PRE_CHG_STAT_MASK 0x200
346#define BQ25700_PRE_CHG_STAT_SHIFT 9
347#define BQ25700_PRE_CHG_STAT_INACTIVE 0
348#define BQ25700_PRE_CHG_STAT_ACTIVE 1
349#define BQ25700_OTG_STAT_MASK 0x100
350#define BQ25700_OTG_STAT_SHIFT 8
351#define BQ25700_OTG_STAT_INACTIVE 0
352#define BQ25700_OTG_STAT_ACTIVE 1
353#define BQ25700_FAULT_ACOV_MASK 0x80
354#define BQ25700_FAULT_ACOV_SHIFT 7
355#define BQ25700_FAULT_ACOV_INACTIVE 0
356#define BQ25700_FAULT_ACOV_ACTIVE 1
357#define BQ25700_FAULT_BATOC_MASK 0x40
358#define BQ25700_FAULT_BATOC_SHIFT 6
359#define BQ25700_FAULT_BATOC_INACTIVE 0
360#define BQ25700_FAULT_BATOC_ACTIVE 1
361#define BQ25700_FAULT_ACOC_MASK 0x20
362#define BQ25700_FAULT_ACOC_SHIFT 5
363#define BQ25700_FAULT_ACOC_INACTIVE 0
364#define BQ25700_FAULT_ACOC_ACTIVE 1
365#define BQ25700_SYS_OVP_STAT_MASK 0x10
366#define BQ25700_SYS_OVP_STAT_SHIFT 4
367#define BQ25700_SYS_OVP_STAT_INACTIVE 0
368#define BQ25700_SYS_OVP_STAT_ACTIVE 1
369#define BQ25700_FAULT_LATCHOFF_MASK 0x04
370#define BQ25700_FAULT_LATCHOFF_SHIFT 2
371#define BQ25700_FAULT_LATCHOFF_INACTIVE 0
372#define BQ25700_FAULT_LATCHOFF_ACTIVE 1
373#define BQ25700_FAULT_OTG_OVP_MASK 0x02
374#define BQ25700_FAULT_OTG_OVP_SHIFT 1
375#define BQ25700_FAULT_OTG_OVP_INACTIVE 0
376#define BQ25700_FAULT_OTG_OVP_ACTIVE 1
377#define BQ25700_FAULT_OTG_UCP_MASK 0x01
378#define BQ25700_FAULT_OTG_UCP_SHIFT 0
379#define BQ25700_FAULT_OTG_UCP_INACTIVE 0
380#define BQ25700_FAULT_OTG_UCP_ACTIVE 1
381
382#define BQ25700_REG_PROCHOT_STATUS 0x21
383#define BQ25700_COMP_STAT_MASK 0x40
384#define BQ25700_COMP_STAT_SHIFT 6
385#define BQ25700_COMP_STAT_INACTIVE 0
386#define BQ25700_COMP_STAT_ACTIVE 1
387#define BQ25700_ICRIT_STAT_MASK 0x20
388#define BQ25700_ICRIT_STAT_SHIFT 5
389#define BQ25700_ICRIT_STAT_INACTIVE 0
390#define BQ25700_ICRIT_STAT_ACTIVE 1
391#define BQ25700_INOM_STAT_MASK 0x10
392#define BQ25700_INOM_STAT_SHIFT 4
393#define BQ25700_INOM_STAT_INACTIVE 0
394#define BQ25700_INOM_STAT_ACTIVE 1
395#define BQ25700_DSG_STAT_MASK 0x08
396#define BQ25700_DSG_STAT_SHIFT 3
397#define BQ25700_DSG_STAT_INACTIVE 0
398#define BQ25700_DSG_STAT_ACTIVE 1
399#define BQ25700_VSYS_STAT_MASK 0x04
400#define BQ25700_VSYS_STAT_SHIFT 2
401#define BQ25700_VSYS_STAT_INACTIVE 0
402#define BQ25700_VSYS_STAT_ACTIVE 1
403#define BQ25700_BAT_REMOVE_STAT_MASK 0x02
404#define BQ25700_BAT_REMOVE_STAT_SHIFT 1
405#define BQ25700_BAT_REMOVE_STAT_INACTIVE 0
406#define BQ25700_BAT_REMOVE_STAT_ACTIVE 1
407#define BQ25700_AC_REMOVE_STAT_MASK 0x01
408#define BQ25700_AC_REMOVE_STAT_SHIFT 0
409#define BQ25700_AC_REMOVE_STAT_INACTIVE 0
410#define BQ25700_AC_REMOVE_STAT_ACTIVE 1
411
412#define BQ25700_REG_CHARGE_CURRENT 0x14
413#define BQ25700_CHARGE_CURRENT_MASK 0x1FC0
414#define BQ25700_CHARGE_CURRENT_SHIFT 6
415#define BQ25700_CHARGE_CURRENT_BASE 0
416#define BQ25700_CHARGE_CURRENT_LSB 64
417
418#define BQ25700_REG_MAX_CHG_VOLT 0x15
419#define BQ25700_MAX_CHG_VOLT_MASK 0x7FF0
420#define BQ25700_MAX_CHG_VOLT_SHIFT 4
421#define BQ25700_MAX_CHG_VOLT_BASE 0
422#define BQ25700_MAX_CHG_VOLT_LSB 16
423
424#define BQ25700_REG_MIN_SYS_VOLT 0x3E
425#define BQ25700_MIN_SYS_VOLT_MASK 0x3F00
426#define BQ25700_MIN_SYS_VOLT_SHIFT 8
427#define BQ25700_MIN_SYS_VOLT_BASE 0
428#define BQ25700_MIN_SYS_VOLT_LSB 256
429
430#define BQ25700_REG_IIN_HOST 0x3F
431#define BQ25700_INLIM_HOST_MASK 0x7F00
432#define BQ25700_INLIM_HOST_SHIFT 8
433#define BQ25700_INLIM_HOST_BASE 0
434#define BQ25700_INLIM_HOST_LSB 50
435
436#define BQ25700_REG_IIN_DPM 0x22
437#define BQ25700_IIN_DPM_MASK 0x7F00
438#define BQ25700_IIN_DPM_SHIFT 8
439#define BQ25700_IIN_DPM_BASE 0
440#define BQ25700_IIN_DPM_LSB 50
441
442#define BQ25700_REG_VIN_DPM 0x3D
443#define BQ25700_VIN_DPM_MASK 0x3FC0
444#define BQ25700_VIN_DPM_SHIFT 6
445#define BQ25700_VIN_DPM_BASE 0
446#define BQ25700_VIN_DPM_LSB 64
447
448#define BQ25700_REG_OTG_VOLT 0x3B
449#define BQ25700_OTG_VOLT_MASK 0x3FC0
450#define BQ25700_OTG_VOLT_SHIFT 6
451#define BQ25700_OTG_VOLT_BASE 0
452#define BQ25700_OTG_VOLT_LSB 64
453
454#define BQ25700_REG_OTG_CURRENT 0x3C
455#define BQ25700_OTG_CURRENT_MASK 0x7F00
456#define BQ25700_OTG_CURRENT_SHIFT 8
457#define BQ25700_OTG_CURRENT_BASE 0
458#define BQ25700_OTG_CURRENT_LSB 64
459
460#define BQ25700_REG_ADC_VBUS_PSYS 0x23
461#define BQ25700_ADC_VBUS_VOLT_MASK 0xFF00
462#define BQ25700_ADC_VBUS_VOLT_SHIFT 8
463#define BQ25700_ADC_VBUS_VOLT_BASE 3200
464#define BQ25700_ADC_VBUS_VOLT_LSB 64
465#define BQ25700_ADC_PSYS_VOLT_MASK 0xFF
466#define BQ25700_ADC_PSYS_VOLT_SHIFT 0
467#define BQ25700_ADC_PSYS_VOLT_BASE 0
468#define BQ25700_ADC_PSYS_VOLT_LSB 12
469
470#define BQ25700_REG_ADC_IBAT 0x24
471#define BQ25700_ADC_CHG_CURRENT_MASK 0x7F00
472#define BQ25700_ADC_CHG_CURRENT_SHIFT 8
473#define BQ25700_ADC_CHG_CURRENT_BASE 0
474#define BQ25700_ADC_CHG_CURRENT_LSB 64
475#define BQ25700_ADC_DSG_CURRENT_MASK 0x7F
476#define BQ25700_ADC_DSG_CURRENT_SHIFT 0
477#define BQ25700_ADC_DSG_CURRENT_BASE 0
478#define BQ25700_ADC_DSG_CURRENT_LSB 256
479
480#define BQ25700_REG_ADC_IIN_CMPIN 0x25
481#define BQ25700_ADC_INPUT_CURRENT_MASK 0xFF00
482#define BQ25700_ADC_INPUT_CURRENT_SHIFT 8
483#define BQ25700_ADC_INPUT_CURRENT_BASE 0
484#define BQ25700_ADC_INPUT_CURRENT_LSB 50
485#define BQ25700_ADC_CMPIN_VOLT_MASK 0xFF
486#define BQ25700_ADC_CMPIN_VOLT_SHIFT 0
487#define BQ25700_ADC_CMPIN_VOLT_BASE 0
488#define BQ25700_ADC_CMPIN_VOLT_LSB 12
489
490#define BQ25700_REG_ADC_VSYS_VBAT 0x26
491#define BQ25700_ADC_SYS_VOLT_MASK 0xFF00
492#define BQ25700_ADC_SYS_VOLT_SHIFT 8
493#define BQ25700_ADC_SYS_VOLT_BASE 0
494#define BQ25700_ADC_SYS_VOLT_LSB 64
495#define BQ25700_ADC_BAT_VOLT_MASK 0xFF
496#define BQ25700_ADC_BAT_VOLT_SHIFT 0
497#define BQ25700_ADC_BAT_VOLT_BASE 0
498#define BQ25700_ADC_BAT_VOLT_LSB 64
499
500#define BQ25700_REG_MANUFACTURE_ID 0xFE
501#define BQ25700_MANUFACTURE_ID_MASK 0xFFFF
502#define BQ25700_MANUFACTURE_ID_SHIFT 0
503
504#define BQ25700_REG_DEVICE_ID 0xFF
505#define BQ25700_DEVICE_ID_MASK 0xFF
506#define BQ25700_DEVICE_ID_SHIFT 0
507
508#endif
generated by cgit v1.2.3 (git 2.39.2)