1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/init.h>
19#include <linux/module.h>
20#include <linux/component.h>
21#include <linux/device.h>
22#include <linux/interrupt.h>
23#include <linux/platform_device.h>
24#include <linux/power_supply.h>
25#include <linux/kobject.h>
26#include <linux/slab.h>
27#include <linux/delay.h>
28#include <linux/time.h>
29#include <linux/time64.h>
30#include <linux/of.h>
31#include <linux/completion.h>
32#include <linux/mfd/core.h>
33#include <linux/mfd/abx500.h>
34#include <linux/mfd/abx500/ab8500.h>
35#include <linux/iio/consumer.h>
36#include <linux/kernel.h>
37#include <linux/fixp-arith.h>
38
39#include "ab8500-bm.h"
40
41#define MILLI_TO_MICRO 1000
42#define FG_LSB_IN_MA 1627
43#define QLSB_NANO_AMP_HOURS_X10 1071
44#define INS_CURR_TIMEOUT (3 * HZ)
45
46#define SEC_TO_SAMPLE(S) (S * 4)
47
48#define NBR_AVG_SAMPLES 20
49
50#define LOW_BAT_CHECK_INTERVAL (HZ / 16)
51
52#define VALID_CAPACITY_SEC (45 * 60)
53#define BATT_OK_MIN 2360
54#define BATT_OK_INCREMENT 50
55#define BATT_OK_MAX_NR_INCREMENTS 0xE
56
57
58#define BATT_OVV 0x01
59
60
61
62
63
64
65struct ab8500_fg_interrupts {
66 char *name;
67 irqreturn_t (*isr)(int irq, void *data);
68};
69
70enum ab8500_fg_discharge_state {
71 AB8500_FG_DISCHARGE_INIT,
72 AB8500_FG_DISCHARGE_INITMEASURING,
73 AB8500_FG_DISCHARGE_INIT_RECOVERY,
74 AB8500_FG_DISCHARGE_RECOVERY,
75 AB8500_FG_DISCHARGE_READOUT_INIT,
76 AB8500_FG_DISCHARGE_READOUT,
77 AB8500_FG_DISCHARGE_WAKEUP,
78};
79
80static char *discharge_state[] = {
81 "DISCHARGE_INIT",
82 "DISCHARGE_INITMEASURING",
83 "DISCHARGE_INIT_RECOVERY",
84 "DISCHARGE_RECOVERY",
85 "DISCHARGE_READOUT_INIT",
86 "DISCHARGE_READOUT",
87 "DISCHARGE_WAKEUP",
88};
89
90enum ab8500_fg_charge_state {
91 AB8500_FG_CHARGE_INIT,
92 AB8500_FG_CHARGE_READOUT,
93};
94
95static char *charge_state[] = {
96 "CHARGE_INIT",
97 "CHARGE_READOUT",
98};
99
100enum ab8500_fg_calibration_state {
101 AB8500_FG_CALIB_INIT,
102 AB8500_FG_CALIB_WAIT,
103 AB8500_FG_CALIB_END,
104};
105
106struct ab8500_fg_avg_cap {
107 int avg;
108 int samples[NBR_AVG_SAMPLES];
109 time64_t time_stamps[NBR_AVG_SAMPLES];
110 int pos;
111 int nbr_samples;
112 int sum;
113};
114
115struct ab8500_fg_cap_scaling {
116 bool enable;
117 int cap_to_scale[2];
118 int disable_cap_level;
119 int scaled_cap;
120};
121
122struct ab8500_fg_battery_capacity {
123 int max_mah_design;
124 int max_mah;
125 int mah;
126 int permille;
127 int level;
128 int prev_mah;
129 int prev_percent;
130 int prev_level;
131 int user_mah;
132 struct ab8500_fg_cap_scaling cap_scale;
133};
134
135struct ab8500_fg_flags {
136 bool fg_enabled;
137 bool conv_done;
138 bool charging;
139 bool fully_charged;
140 bool force_full;
141 bool low_bat_delay;
142 bool low_bat;
143 bool bat_ovv;
144 bool batt_unknown;
145 bool calibrate;
146 bool user_cap;
147 bool batt_id_received;
148};
149
150struct inst_curr_result_list {
151 struct list_head list;
152 int *result;
153};
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198struct ab8500_fg {
199 struct device *dev;
200 struct list_head node;
201 int irq;
202 int vbat;
203 int vbat_nom;
204 int inst_curr;
205 int avg_curr;
206 int bat_temp;
207 int fg_samples;
208 int accu_charge;
209 int recovery_cnt;
210 int high_curr_cnt;
211 int init_cnt;
212 int low_bat_cnt;
213 int nbr_cceoc_irq_cnt;
214 bool recovery_needed;
215 bool high_curr_mode;
216 bool init_capacity;
217 bool turn_off_fg;
218 enum ab8500_fg_calibration_state calib_state;
219 enum ab8500_fg_discharge_state discharge_state;
220 enum ab8500_fg_charge_state charge_state;
221 struct completion ab8500_fg_started;
222 struct completion ab8500_fg_complete;
223 struct ab8500_fg_flags flags;
224 struct ab8500_fg_battery_capacity bat_cap;
225 struct ab8500_fg_avg_cap avg_cap;
226 struct ab8500 *parent;
227 struct iio_channel *main_bat_v;
228 struct ab8500_bm_data *bm;
229 struct power_supply *fg_psy;
230 struct workqueue_struct *fg_wq;
231 struct delayed_work fg_periodic_work;
232 struct delayed_work fg_low_bat_work;
233 struct delayed_work fg_reinit_work;
234 struct work_struct fg_work;
235 struct work_struct fg_acc_cur_work;
236 struct delayed_work fg_check_hw_failure_work;
237 struct mutex cc_lock;
238 struct kobject fg_kobject;
239};
240static LIST_HEAD(ab8500_fg_list);
241
242
243
244
245
246struct ab8500_fg *ab8500_fg_get(void)
247{
248 return list_first_entry_or_null(&ab8500_fg_list, struct ab8500_fg,
249 node);
250}
251
252
253static enum power_supply_property ab8500_fg_props[] = {
254 POWER_SUPPLY_PROP_VOLTAGE_NOW,
255 POWER_SUPPLY_PROP_CURRENT_NOW,
256 POWER_SUPPLY_PROP_CURRENT_AVG,
257 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
258 POWER_SUPPLY_PROP_ENERGY_FULL,
259 POWER_SUPPLY_PROP_ENERGY_NOW,
260 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
261 POWER_SUPPLY_PROP_CHARGE_FULL,
262 POWER_SUPPLY_PROP_CHARGE_NOW,
263 POWER_SUPPLY_PROP_CAPACITY,
264 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
265};
266
267
268
269
270
271static int ab8500_fg_lowbat_voltage_map[] = {
272 2300 ,
273 2325 ,
274 2350 ,
275 2375 ,
276 2400 ,
277 2425 ,
278 2450 ,
279 2475 ,
280 2500 ,
281 2525 ,
282 2550 ,
283 2575 ,
284 2600 ,
285 2625 ,
286 2650 ,
287 2675 ,
288 2700 ,
289 2725 ,
290 2750 ,
291 2775 ,
292 2800 ,
293 2825 ,
294 2850 ,
295 2875 ,
296 2900 ,
297 2925 ,
298 2950 ,
299 2975 ,
300 3000 ,
301 3025 ,
302 3050 ,
303 3075 ,
304 3100 ,
305 3125 ,
306 3150 ,
307 3175 ,
308 3200 ,
309 3225 ,
310 3250 ,
311 3275 ,
312 3300 ,
313 3325 ,
314 3350 ,
315 3375 ,
316 3400 ,
317 3425 ,
318 3450 ,
319 3475 ,
320 3500 ,
321 3525 ,
322 3550 ,
323 3575 ,
324 3600 ,
325 3625 ,
326 3650 ,
327 3675 ,
328 3700 ,
329 3725 ,
330 3750 ,
331 3775 ,
332 3800 ,
333 3825 ,
334 3850 ,
335 3850 ,
336};
337
338static u8 ab8500_volt_to_regval(int voltage)
339{
340 int i;
341
342 if (voltage < ab8500_fg_lowbat_voltage_map[0])
343 return 0;
344
345 for (i = 0; i < ARRAY_SIZE(ab8500_fg_lowbat_voltage_map); i++) {
346 if (voltage < ab8500_fg_lowbat_voltage_map[i])
347 return (u8) i - 1;
348 }
349
350
351 return (u8) ARRAY_SIZE(ab8500_fg_lowbat_voltage_map) - 1;
352}
353
354
355
356
357
358
359
360
361static int ab8500_fg_is_low_curr(struct ab8500_fg *di, int curr)
362{
363
364
365
366 if (curr > -di->bm->fg_params->high_curr_threshold)
367 return true;
368 else
369 return false;
370}
371
372
373
374
375
376
377
378
379
380static int ab8500_fg_add_cap_sample(struct ab8500_fg *di, int sample)
381{
382 time64_t now = ktime_get_boottime_seconds();
383 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
384
385 do {
386 avg->sum += sample - avg->samples[avg->pos];
387 avg->samples[avg->pos] = sample;
388 avg->time_stamps[avg->pos] = now;
389 avg->pos++;
390
391 if (avg->pos == NBR_AVG_SAMPLES)
392 avg->pos = 0;
393
394 if (avg->nbr_samples < NBR_AVG_SAMPLES)
395 avg->nbr_samples++;
396
397
398
399
400
401 } while (now - VALID_CAPACITY_SEC > avg->time_stamps[avg->pos]);
402
403 avg->avg = avg->sum / avg->nbr_samples;
404
405 return avg->avg;
406}
407
408
409
410
411
412
413
414static void ab8500_fg_clear_cap_samples(struct ab8500_fg *di)
415{
416 int i;
417 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
418
419 avg->pos = 0;
420 avg->nbr_samples = 0;
421 avg->sum = 0;
422 avg->avg = 0;
423
424 for (i = 0; i < NBR_AVG_SAMPLES; i++) {
425 avg->samples[i] = 0;
426 avg->time_stamps[i] = 0;
427 }
428}
429
430
431
432
433
434
435
436
437static void ab8500_fg_fill_cap_sample(struct ab8500_fg *di, int sample)
438{
439 int i;
440 time64_t now;
441 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
442
443 now = ktime_get_boottime_seconds();
444
445 for (i = 0; i < NBR_AVG_SAMPLES; i++) {
446 avg->samples[i] = sample;
447 avg->time_stamps[i] = now;
448 }
449
450 avg->pos = 0;
451 avg->nbr_samples = NBR_AVG_SAMPLES;
452 avg->sum = sample * NBR_AVG_SAMPLES;
453 avg->avg = sample;
454}
455
456
457
458
459
460
461
462
463
464static int ab8500_fg_coulomb_counter(struct ab8500_fg *di, bool enable)
465{
466 int ret = 0;
467 mutex_lock(&di->cc_lock);
468 if (enable) {
469
470
471 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
472 AB8500_RTC_CC_CONF_REG, 0x00);
473 if (ret)
474 goto cc_err;
475
476
477 ret = abx500_set_register_interruptible(di->dev,
478 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
479 di->fg_samples);
480 if (ret)
481 goto cc_err;
482
483
484 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
485 AB8500_RTC_CC_CONF_REG,
486 (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA));
487 if (ret)
488 goto cc_err;
489
490 di->flags.fg_enabled = true;
491 } else {
492
493 ret = abx500_mask_and_set_register_interruptible(di->dev,
494 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
495 (RESET_ACCU | READ_REQ), 0);
496 if (ret)
497 goto cc_err;
498
499 ret = abx500_set_register_interruptible(di->dev,
500 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU_CTRL, 0);
501 if (ret)
502 goto cc_err;
503
504
505 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
506 AB8500_RTC_CC_CONF_REG, 0);
507 if (ret)
508 goto cc_err;
509
510 di->flags.fg_enabled = false;
511
512 }
513 dev_dbg(di->dev, " CC enabled: %d Samples: %d\n",
514 enable, di->fg_samples);
515
516 mutex_unlock(&di->cc_lock);
517
518 return ret;
519cc_err:
520 dev_err(di->dev, "%s Enabling coulomb counter failed\n", __func__);
521 mutex_unlock(&di->cc_lock);
522 return ret;
523}
524
525
526
527
528
529
530
531
532
533int ab8500_fg_inst_curr_start(struct ab8500_fg *di)
534{
535 u8 reg_val;
536 int ret;
537
538 mutex_lock(&di->cc_lock);
539
540 di->nbr_cceoc_irq_cnt = 0;
541 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
542 AB8500_RTC_CC_CONF_REG, ®_val);
543 if (ret < 0)
544 goto fail;
545
546 if (!(reg_val & CC_PWR_UP_ENA)) {
547 dev_dbg(di->dev, "%s Enable FG\n", __func__);
548 di->turn_off_fg = true;
549
550
551 ret = abx500_set_register_interruptible(di->dev,
552 AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
553 SEC_TO_SAMPLE(10));
554 if (ret)
555 goto fail;
556
557
558 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
559 AB8500_RTC_CC_CONF_REG,
560 (CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA));
561 if (ret)
562 goto fail;
563 } else {
564 di->turn_off_fg = false;
565 }
566
567
568 reinit_completion(&di->ab8500_fg_started);
569 reinit_completion(&di->ab8500_fg_complete);
570 enable_irq(di->irq);
571
572
573 return 0;
574fail:
575 mutex_unlock(&di->cc_lock);
576 return ret;
577}
578
579
580
581
582
583
584
585int ab8500_fg_inst_curr_started(struct ab8500_fg *di)
586{
587 return completion_done(&di->ab8500_fg_started);
588}
589
590
591
592
593
594
595
596int ab8500_fg_inst_curr_done(struct ab8500_fg *di)
597{
598 return completion_done(&di->ab8500_fg_complete);
599}
600
601
602
603
604
605
606
607
608
609
610int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *res)
611{
612 u8 low, high;
613 int val;
614 int ret;
615 unsigned long timeout;
616
617 if (!completion_done(&di->ab8500_fg_complete)) {
618 timeout = wait_for_completion_timeout(
619 &di->ab8500_fg_complete,
620 INS_CURR_TIMEOUT);
621 dev_dbg(di->dev, "Finalize time: %d ms\n",
622 jiffies_to_msecs(INS_CURR_TIMEOUT - timeout));
623 if (!timeout) {
624 ret = -ETIME;
625 disable_irq(di->irq);
626 di->nbr_cceoc_irq_cnt = 0;
627 dev_err(di->dev, "completion timed out [%d]\n",
628 __LINE__);
629 goto fail;
630 }
631 }
632
633 disable_irq(di->irq);
634 di->nbr_cceoc_irq_cnt = 0;
635
636 ret = abx500_mask_and_set_register_interruptible(di->dev,
637 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
638 READ_REQ, READ_REQ);
639
640
641 usleep_range(100, 100);
642
643
644 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
645 AB8500_GASG_CC_SMPL_CNVL_REG, &low);
646 if (ret < 0)
647 goto fail;
648
649 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
650 AB8500_GASG_CC_SMPL_CNVH_REG, &high);
651 if (ret < 0)
652 goto fail;
653
654
655
656
657
658 if (high & 0x10)
659 val = (low | (high << 8) | 0xFFFFE000);
660 else
661 val = (low | (high << 8));
662
663
664
665
666
667
668
669
670
671
672 val = (val * QLSB_NANO_AMP_HOURS_X10 * 36 * 4) /
673 (1000 * di->bm->fg_res);
674
675 if (di->turn_off_fg) {
676 dev_dbg(di->dev, "%s Disable FG\n", __func__);
677
678
679 ret = abx500_set_register_interruptible(di->dev,
680 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 0);
681 if (ret)
682 goto fail;
683
684
685 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
686 AB8500_RTC_CC_CONF_REG, 0);
687 if (ret)
688 goto fail;
689 }
690 mutex_unlock(&di->cc_lock);
691 (*res) = val;
692
693 return 0;
694fail:
695 mutex_unlock(&di->cc_lock);
696 return ret;
697}
698
699
700
701
702
703
704
705
706int ab8500_fg_inst_curr_blocking(struct ab8500_fg *di)
707{
708 int ret;
709 unsigned long timeout;
710 int res = 0;
711
712 ret = ab8500_fg_inst_curr_start(di);
713 if (ret) {
714 dev_err(di->dev, "Failed to initialize fg_inst\n");
715 return 0;
716 }
717
718
719 if (!completion_done(&di->ab8500_fg_started)) {
720 timeout = wait_for_completion_timeout(
721 &di->ab8500_fg_started,
722 INS_CURR_TIMEOUT);
723 dev_dbg(di->dev, "Start time: %d ms\n",
724 jiffies_to_msecs(INS_CURR_TIMEOUT - timeout));
725 if (!timeout) {
726 ret = -ETIME;
727 dev_err(di->dev, "completion timed out [%d]\n",
728 __LINE__);
729 goto fail;
730 }
731 }
732
733 ret = ab8500_fg_inst_curr_finalize(di, &res);
734 if (ret) {
735 dev_err(di->dev, "Failed to finalize fg_inst\n");
736 return 0;
737 }
738
739 dev_dbg(di->dev, "%s instant current: %d", __func__, res);
740 return res;
741fail:
742 disable_irq(di->irq);
743 mutex_unlock(&di->cc_lock);
744 return ret;
745}
746
747
748
749
750
751
752
753
754static void ab8500_fg_acc_cur_work(struct work_struct *work)
755{
756 int val;
757 int ret;
758 u8 low, med, high;
759
760 struct ab8500_fg *di = container_of(work,
761 struct ab8500_fg, fg_acc_cur_work);
762
763 mutex_lock(&di->cc_lock);
764 ret = abx500_set_register_interruptible(di->dev, AB8500_GAS_GAUGE,
765 AB8500_GASG_CC_NCOV_ACCU_CTRL, RD_NCONV_ACCU_REQ);
766 if (ret)
767 goto exit;
768
769 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
770 AB8500_GASG_CC_NCOV_ACCU_LOW, &low);
771 if (ret < 0)
772 goto exit;
773
774 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
775 AB8500_GASG_CC_NCOV_ACCU_MED, &med);
776 if (ret < 0)
777 goto exit;
778
779 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
780 AB8500_GASG_CC_NCOV_ACCU_HIGH, &high);
781 if (ret < 0)
782 goto exit;
783
784
785 if (high & 0x10)
786 val = (low | (med << 8) | (high << 16) | 0xFFE00000);
787 else
788 val = (low | (med << 8) | (high << 16));
789
790
791
792
793
794
795
796 di->accu_charge = (val * QLSB_NANO_AMP_HOURS_X10) /
797 (100 * di->bm->fg_res);
798
799
800
801
802
803
804
805 di->avg_curr = (val * QLSB_NANO_AMP_HOURS_X10 * 36) /
806 (1000 * di->bm->fg_res * (di->fg_samples / 4));
807
808 di->flags.conv_done = true;
809
810 mutex_unlock(&di->cc_lock);
811
812 queue_work(di->fg_wq, &di->fg_work);
813
814 dev_dbg(di->dev, "fg_res: %d, fg_samples: %d, gasg: %d, accu_charge: %d \n",
815 di->bm->fg_res, di->fg_samples, val, di->accu_charge);
816 return;
817exit:
818 dev_err(di->dev,
819 "Failed to read or write gas gauge registers\n");
820 mutex_unlock(&di->cc_lock);
821 queue_work(di->fg_wq, &di->fg_work);
822}
823
824
825
826
827
828
829
830static int ab8500_fg_bat_voltage(struct ab8500_fg *di)
831{
832 int vbat, ret;
833 static int prev;
834
835 ret = iio_read_channel_processed(di->main_bat_v, &vbat);
836 if (ret < 0) {
837 dev_err(di->dev,
838 "%s ADC conversion failed, using previous value\n",
839 __func__);
840 return prev;
841 }
842
843 prev = vbat;
844 return vbat;
845}
846
847
848
849
850
851
852
853
854static int ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage)
855{
856 int i, tbl_size;
857 const struct ab8500_v_to_cap *tbl;
858 int cap = 0;
859
860 tbl = di->bm->bat_type[di->bm->batt_id].v_to_cap_tbl;
861 tbl_size = di->bm->bat_type[di->bm->batt_id].n_v_cap_tbl_elements;
862
863 for (i = 0; i < tbl_size; ++i) {
864 if (voltage > tbl[i].voltage)
865 break;
866 }
867
868 if ((i > 0) && (i < tbl_size)) {
869 cap = fixp_linear_interpolate(
870 tbl[i].voltage,
871 tbl[i].capacity * 10,
872 tbl[i-1].voltage,
873 tbl[i-1].capacity * 10,
874 voltage);
875 } else if (i == 0) {
876 cap = 1000;
877 } else {
878 cap = 0;
879 }
880
881 dev_dbg(di->dev, "%s Vbat: %d, Cap: %d per mille",
882 __func__, voltage, cap);
883
884 return cap;
885}
886
887
888
889
890
891
892
893
894static int ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di)
895{
896 di->vbat = ab8500_fg_bat_voltage(di);
897 return ab8500_fg_volt_to_capacity(di, di->vbat);
898}
899
900
901
902
903
904
905
906
907static int ab8500_fg_battery_resistance(struct ab8500_fg *di)
908{
909 int i, tbl_size;
910 const struct batres_vs_temp *tbl;
911 int resist = 0;
912
913 tbl = di->bm->bat_type[di->bm->batt_id].batres_tbl;
914 tbl_size = di->bm->bat_type[di->bm->batt_id].n_batres_tbl_elements;
915
916 for (i = 0; i < tbl_size; ++i) {
917 if (di->bat_temp / 10 > tbl[i].temp)
918 break;
919 }
920
921 if ((i > 0) && (i < tbl_size)) {
922 resist = fixp_linear_interpolate(
923 tbl[i].temp,
924 tbl[i].resist,
925 tbl[i-1].temp,
926 tbl[i-1].resist,
927 di->bat_temp / 10);
928 } else if (i == 0) {
929 resist = tbl[0].resist;
930 } else {
931 resist = tbl[tbl_size - 1].resist;
932 }
933
934 dev_dbg(di->dev, "%s Temp: %d battery internal resistance: %d"
935 " fg resistance %d, total: %d (mOhm)\n",
936 __func__, di->bat_temp, resist, di->bm->fg_res / 10,
937 (di->bm->fg_res / 10) + resist);
938
939
940 resist += di->bm->fg_res / 10;
941
942 return resist;
943}
944
945
946
947
948
949
950
951
952static int ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di)
953{
954 int vbat_comp, res;
955 int i = 0;
956 int vbat = 0;
957
958 ab8500_fg_inst_curr_start(di);
959
960 do {
961 vbat += ab8500_fg_bat_voltage(di);
962 i++;
963 usleep_range(5000, 6000);
964 } while (!ab8500_fg_inst_curr_done(di));
965
966 ab8500_fg_inst_curr_finalize(di, &di->inst_curr);
967
968 di->vbat = vbat / i;
969 res = ab8500_fg_battery_resistance(di);
970
971
972 vbat_comp = di->vbat - (di->inst_curr * res) / 1000;
973
974 dev_dbg(di->dev, "%s Measured Vbat: %dmV,Compensated Vbat %dmV, "
975 "R: %dmOhm, Current: %dmA Vbat Samples: %d\n",
976 __func__, di->vbat, vbat_comp, res, di->inst_curr, i);
977
978 return ab8500_fg_volt_to_capacity(di, vbat_comp);
979}
980
981
982
983
984
985
986
987
988static int ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah)
989{
990 return (cap_mah * 1000) / di->bat_cap.max_mah_design;
991}
992
993
994
995
996
997
998
999
1000static int ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm)
1001{
1002 return cap_pm * di->bat_cap.max_mah_design / 1000;
1003}
1004
1005
1006
1007
1008
1009
1010
1011
1012static int ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah)
1013{
1014 u64 div_res;
1015 u32 div_rem;
1016
1017 div_res = ((u64) cap_mah) * ((u64) di->vbat_nom);
1018 div_rem = do_div(div_res, 1000);
1019
1020
1021 if (div_rem >= 1000 / 2)
1022 div_res++;
1023
1024 return (int) div_res;
1025}
1026
1027
1028
1029
1030
1031
1032
1033
1034static int ab8500_fg_calc_cap_charging(struct ab8500_fg *di)
1035{
1036 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1037 __func__,
1038 di->bat_cap.mah,
1039 di->accu_charge);
1040
1041
1042 if (di->bat_cap.mah + di->accu_charge > 0)
1043 di->bat_cap.mah += di->accu_charge;
1044 else
1045 di->bat_cap.mah = 0;
1046
1047
1048
1049
1050 if (di->bat_cap.mah >= di->bat_cap.max_mah_design ||
1051 di->flags.force_full) {
1052 di->bat_cap.mah = di->bat_cap.max_mah_design;
1053 }
1054
1055 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1056 di->bat_cap.permille =
1057 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1058
1059
1060 di->vbat = ab8500_fg_bat_voltage(di);
1061 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1062
1063 return di->bat_cap.mah;
1064}
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075static int ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di, bool comp)
1076{
1077 int permille, mah;
1078
1079 if (comp)
1080 permille = ab8500_fg_load_comp_volt_to_capacity(di);
1081 else
1082 permille = ab8500_fg_uncomp_volt_to_capacity(di);
1083
1084 mah = ab8500_fg_convert_permille_to_mah(di, permille);
1085
1086 di->bat_cap.mah = ab8500_fg_add_cap_sample(di, mah);
1087 di->bat_cap.permille =
1088 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1089
1090 return di->bat_cap.mah;
1091}
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101static int ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di)
1102{
1103 int permille_volt, permille;
1104
1105 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1106 __func__,
1107 di->bat_cap.mah,
1108 di->accu_charge);
1109
1110
1111 if (di->bat_cap.mah + di->accu_charge > 0)
1112 di->bat_cap.mah += di->accu_charge;
1113 else
1114 di->bat_cap.mah = 0;
1115
1116 if (di->bat_cap.mah >= di->bat_cap.max_mah_design)
1117 di->bat_cap.mah = di->bat_cap.max_mah_design;
1118
1119
1120
1121
1122
1123 permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1124 permille_volt = ab8500_fg_uncomp_volt_to_capacity(di);
1125
1126 if (permille < permille_volt) {
1127 di->bat_cap.permille = permille_volt;
1128 di->bat_cap.mah = ab8500_fg_convert_permille_to_mah(di,
1129 di->bat_cap.permille);
1130
1131 dev_dbg(di->dev, "%s voltage based: perm %d perm_volt %d\n",
1132 __func__,
1133 permille,
1134 permille_volt);
1135
1136 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1137 } else {
1138 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1139 di->bat_cap.permille =
1140 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1141 }
1142
1143 return di->bat_cap.mah;
1144}
1145
1146
1147
1148
1149
1150
1151
1152static int ab8500_fg_capacity_level(struct ab8500_fg *di)
1153{
1154 int ret, percent;
1155
1156 percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1157
1158 if (percent <= di->bm->cap_levels->critical ||
1159 di->flags.low_bat)
1160 ret = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1161 else if (percent <= di->bm->cap_levels->low)
1162 ret = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1163 else if (percent <= di->bm->cap_levels->normal)
1164 ret = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1165 else if (percent <= di->bm->cap_levels->high)
1166 ret = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
1167 else
1168 ret = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1169
1170 return ret;
1171}
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181static int ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di)
1182{
1183 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1184 int capacity = di->bat_cap.prev_percent;
1185
1186 if (!cs->enable)
1187 return capacity;
1188
1189
1190
1191
1192
1193 if (di->flags.fully_charged) {
1194 cs->cap_to_scale[0] = 100;
1195 cs->cap_to_scale[1] =
1196 max(capacity, di->bm->fg_params->maint_thres);
1197 dev_dbg(di->dev, "Scale cap with %d/%d\n",
1198 cs->cap_to_scale[0], cs->cap_to_scale[1]);
1199 }
1200
1201
1202 if ((cs->cap_to_scale[0] != cs->cap_to_scale[1])
1203 && (cs->cap_to_scale[1] > 0))
1204 capacity = min(100,
1205 DIV_ROUND_CLOSEST(di->bat_cap.prev_percent *
1206 cs->cap_to_scale[0],
1207 cs->cap_to_scale[1]));
1208
1209 if (di->flags.charging) {
1210 if (capacity < cs->disable_cap_level) {
1211 cs->disable_cap_level = capacity;
1212 dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n",
1213 cs->disable_cap_level);
1214 } else if (!di->flags.fully_charged) {
1215 if (di->bat_cap.prev_percent >=
1216 cs->disable_cap_level) {
1217 dev_dbg(di->dev, "Disabling scaled capacity\n");
1218 cs->enable = false;
1219 capacity = di->bat_cap.prev_percent;
1220 } else {
1221 dev_dbg(di->dev,
1222 "Waiting in cap to level %d%%\n",
1223 cs->disable_cap_level);
1224 capacity = cs->disable_cap_level;
1225 }
1226 }
1227 }
1228
1229 return capacity;
1230}
1231
1232
1233
1234
1235
1236
1237
1238
1239static void ab8500_fg_update_cap_scalers(struct ab8500_fg *di)
1240{
1241 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1242
1243 if (!cs->enable)
1244 return;
1245 if (di->flags.charging) {
1246 di->bat_cap.cap_scale.disable_cap_level =
1247 di->bat_cap.cap_scale.scaled_cap;
1248 dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n",
1249 di->bat_cap.cap_scale.disable_cap_level);
1250 } else {
1251 if (cs->scaled_cap != 100) {
1252 cs->cap_to_scale[0] = cs->scaled_cap;
1253 cs->cap_to_scale[1] = di->bat_cap.prev_percent;
1254 } else {
1255 cs->cap_to_scale[0] = 100;
1256 cs->cap_to_scale[1] =
1257 max(di->bat_cap.prev_percent,
1258 di->bm->fg_params->maint_thres);
1259 }
1260
1261 dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n",
1262 cs->cap_to_scale[0], cs->cap_to_scale[1]);
1263 }
1264}
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274static void ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init)
1275{
1276 bool changed = false;
1277 int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1278
1279 di->bat_cap.level = ab8500_fg_capacity_level(di);
1280
1281 if (di->bat_cap.level != di->bat_cap.prev_level) {
1282
1283
1284
1285
1286 if (!(!di->flags.charging && di->bat_cap.level >
1287 di->bat_cap.prev_level) || init) {
1288 dev_dbg(di->dev, "level changed from %d to %d\n",
1289 di->bat_cap.prev_level,
1290 di->bat_cap.level);
1291 di->bat_cap.prev_level = di->bat_cap.level;
1292 changed = true;
1293 } else {
1294 dev_dbg(di->dev, "level not allowed to go up "
1295 "since no charger is connected: %d to %d\n",
1296 di->bat_cap.prev_level,
1297 di->bat_cap.level);
1298 }
1299 }
1300
1301
1302
1303
1304
1305 if (di->flags.low_bat) {
1306 dev_dbg(di->dev, "Battery low, set capacity to 0\n");
1307 di->bat_cap.prev_percent = 0;
1308 di->bat_cap.permille = 0;
1309 percent = 0;
1310 di->bat_cap.prev_mah = 0;
1311 di->bat_cap.mah = 0;
1312 changed = true;
1313 } else if (di->flags.fully_charged) {
1314
1315
1316
1317
1318 if (di->flags.force_full) {
1319 di->bat_cap.prev_percent = percent;
1320 di->bat_cap.prev_mah = di->bat_cap.mah;
1321
1322 changed = true;
1323
1324 if (!di->bat_cap.cap_scale.enable &&
1325 di->bm->capacity_scaling) {
1326 di->bat_cap.cap_scale.enable = true;
1327 di->bat_cap.cap_scale.cap_to_scale[0] = 100;
1328 di->bat_cap.cap_scale.cap_to_scale[1] =
1329 di->bat_cap.prev_percent;
1330 di->bat_cap.cap_scale.disable_cap_level = 100;
1331 }
1332 } else if (di->bat_cap.prev_percent != percent) {
1333 dev_dbg(di->dev,
1334 "battery reported full "
1335 "but capacity dropping: %d\n",
1336 percent);
1337 di->bat_cap.prev_percent = percent;
1338 di->bat_cap.prev_mah = di->bat_cap.mah;
1339
1340 changed = true;
1341 }
1342 } else if (di->bat_cap.prev_percent != percent) {
1343 if (percent == 0) {
1344
1345
1346
1347
1348
1349 di->bat_cap.prev_percent = 1;
1350 percent = 1;
1351
1352 changed = true;
1353 } else if (!(!di->flags.charging &&
1354 percent > di->bat_cap.prev_percent) || init) {
1355
1356
1357
1358
1359 dev_dbg(di->dev,
1360 "capacity changed from %d to %d (%d)\n",
1361 di->bat_cap.prev_percent,
1362 percent,
1363 di->bat_cap.permille);
1364 di->bat_cap.prev_percent = percent;
1365 di->bat_cap.prev_mah = di->bat_cap.mah;
1366
1367 changed = true;
1368 } else {
1369 dev_dbg(di->dev, "capacity not allowed to go up since "
1370 "no charger is connected: %d to %d (%d)\n",
1371 di->bat_cap.prev_percent,
1372 percent,
1373 di->bat_cap.permille);
1374 }
1375 }
1376
1377 if (changed) {
1378 if (di->bm->capacity_scaling) {
1379 di->bat_cap.cap_scale.scaled_cap =
1380 ab8500_fg_calculate_scaled_capacity(di);
1381
1382 dev_info(di->dev, "capacity=%d (%d)\n",
1383 di->bat_cap.prev_percent,
1384 di->bat_cap.cap_scale.scaled_cap);
1385 }
1386 power_supply_changed(di->fg_psy);
1387 if (di->flags.fully_charged && di->flags.force_full) {
1388 dev_dbg(di->dev, "Battery full, notifying.\n");
1389 di->flags.force_full = false;
1390 sysfs_notify(&di->fg_kobject, NULL, "charge_full");
1391 }
1392 sysfs_notify(&di->fg_kobject, NULL, "charge_now");
1393 }
1394}
1395
1396static void ab8500_fg_charge_state_to(struct ab8500_fg *di,
1397 enum ab8500_fg_charge_state new_state)
1398{
1399 dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n",
1400 di->charge_state,
1401 charge_state[di->charge_state],
1402 new_state,
1403 charge_state[new_state]);
1404
1405 di->charge_state = new_state;
1406}
1407
1408static void ab8500_fg_discharge_state_to(struct ab8500_fg *di,
1409 enum ab8500_fg_discharge_state new_state)
1410{
1411 dev_dbg(di->dev, "Discharge state from %d [%s] to %d [%s]\n",
1412 di->discharge_state,
1413 discharge_state[di->discharge_state],
1414 new_state,
1415 discharge_state[new_state]);
1416
1417 di->discharge_state = new_state;
1418}
1419
1420
1421
1422
1423
1424
1425
1426static void ab8500_fg_algorithm_charging(struct ab8500_fg *di)
1427{
1428
1429
1430
1431
1432 if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY)
1433 ab8500_fg_discharge_state_to(di,
1434 AB8500_FG_DISCHARGE_INIT_RECOVERY);
1435
1436 switch (di->charge_state) {
1437 case AB8500_FG_CHARGE_INIT:
1438 di->fg_samples = SEC_TO_SAMPLE(
1439 di->bm->fg_params->accu_charging);
1440
1441 ab8500_fg_coulomb_counter(di, true);
1442 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_READOUT);
1443
1444 break;
1445
1446 case AB8500_FG_CHARGE_READOUT:
1447
1448
1449
1450 mutex_lock(&di->cc_lock);
1451 if (!di->flags.conv_done && !di->flags.force_full) {
1452
1453 mutex_unlock(&di->cc_lock);
1454 dev_dbg(di->dev, "%s CC conv not done\n",
1455 __func__);
1456
1457 break;
1458 }
1459 di->flags.conv_done = false;
1460 mutex_unlock(&di->cc_lock);
1461
1462 ab8500_fg_calc_cap_charging(di);
1463
1464 break;
1465
1466 default:
1467 break;
1468 }
1469
1470
1471 ab8500_fg_check_capacity_limits(di, false);
1472}
1473
1474static void force_capacity(struct ab8500_fg *di)
1475{
1476 int cap;
1477
1478 ab8500_fg_clear_cap_samples(di);
1479 cap = di->bat_cap.user_mah;
1480 if (cap > di->bat_cap.max_mah_design) {
1481 dev_dbg(di->dev, "Remaining cap %d can't be bigger than total"
1482 " %d\n", cap, di->bat_cap.max_mah_design);
1483 cap = di->bat_cap.max_mah_design;
1484 }
1485 ab8500_fg_fill_cap_sample(di, di->bat_cap.user_mah);
1486 di->bat_cap.permille = ab8500_fg_convert_mah_to_permille(di, cap);
1487 di->bat_cap.mah = cap;
1488 ab8500_fg_check_capacity_limits(di, true);
1489}
1490
1491static bool check_sysfs_capacity(struct ab8500_fg *di)
1492{
1493 int cap, lower, upper;
1494 int cap_permille;
1495
1496 cap = di->bat_cap.user_mah;
1497
1498 cap_permille = ab8500_fg_convert_mah_to_permille(di,
1499 di->bat_cap.user_mah);
1500
1501 lower = di->bat_cap.permille - di->bm->fg_params->user_cap_limit * 10;
1502 upper = di->bat_cap.permille + di->bm->fg_params->user_cap_limit * 10;
1503
1504 if (lower < 0)
1505 lower = 0;
1506
1507 if (upper > 1000)
1508 upper = 1000;
1509
1510 dev_dbg(di->dev, "Capacity limits:"
1511 " (Lower: %d User: %d Upper: %d) [user: %d, was: %d]\n",
1512 lower, cap_permille, upper, cap, di->bat_cap.mah);
1513
1514
1515 if (cap_permille > lower && cap_permille < upper) {
1516 dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap);
1517 force_capacity(di);
1518 return true;
1519 }
1520 dev_dbg(di->dev, "Capacity from user out of limits, ignoring");
1521 return false;
1522}
1523
1524
1525
1526
1527
1528
1529
1530static void ab8500_fg_algorithm_discharging(struct ab8500_fg *di)
1531{
1532 int sleep_time;
1533
1534
1535 if (di->charge_state != AB8500_FG_CHARGE_INIT)
1536 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
1537
1538 switch (di->discharge_state) {
1539 case AB8500_FG_DISCHARGE_INIT:
1540
1541 di->init_cnt = 0;
1542 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
1543 ab8500_fg_coulomb_counter(di, true);
1544 ab8500_fg_discharge_state_to(di,
1545 AB8500_FG_DISCHARGE_INITMEASURING);
1546
1547 fallthrough;
1548 case AB8500_FG_DISCHARGE_INITMEASURING:
1549
1550
1551
1552
1553
1554
1555 sleep_time = di->bm->fg_params->init_timer;
1556
1557
1558 if (di->init_cnt > di->bm->fg_params->init_discard_time) {
1559 ab8500_fg_calc_cap_discharge_voltage(di, true);
1560
1561 ab8500_fg_check_capacity_limits(di, true);
1562 }
1563
1564 di->init_cnt += sleep_time;
1565 if (di->init_cnt > di->bm->fg_params->init_total_time)
1566 ab8500_fg_discharge_state_to(di,
1567 AB8500_FG_DISCHARGE_READOUT_INIT);
1568
1569 break;
1570
1571 case AB8500_FG_DISCHARGE_INIT_RECOVERY:
1572 di->recovery_cnt = 0;
1573 di->recovery_needed = true;
1574 ab8500_fg_discharge_state_to(di,
1575 AB8500_FG_DISCHARGE_RECOVERY);
1576
1577 fallthrough;
1578
1579 case AB8500_FG_DISCHARGE_RECOVERY:
1580 sleep_time = di->bm->fg_params->recovery_sleep_timer;
1581
1582
1583
1584
1585
1586
1587
1588 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1589
1590 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1591 if (di->recovery_cnt >
1592 di->bm->fg_params->recovery_total_time) {
1593 di->fg_samples = SEC_TO_SAMPLE(
1594 di->bm->fg_params->accu_high_curr);
1595 ab8500_fg_coulomb_counter(di, true);
1596 ab8500_fg_discharge_state_to(di,
1597 AB8500_FG_DISCHARGE_READOUT);
1598 di->recovery_needed = false;
1599 } else {
1600 queue_delayed_work(di->fg_wq,
1601 &di->fg_periodic_work,
1602 sleep_time * HZ);
1603 }
1604 di->recovery_cnt += sleep_time;
1605 } else {
1606 di->fg_samples = SEC_TO_SAMPLE(
1607 di->bm->fg_params->accu_high_curr);
1608 ab8500_fg_coulomb_counter(di, true);
1609 ab8500_fg_discharge_state_to(di,
1610 AB8500_FG_DISCHARGE_READOUT);
1611 }
1612 break;
1613
1614 case AB8500_FG_DISCHARGE_READOUT_INIT:
1615 di->fg_samples = SEC_TO_SAMPLE(
1616 di->bm->fg_params->accu_high_curr);
1617 ab8500_fg_coulomb_counter(di, true);
1618 ab8500_fg_discharge_state_to(di,
1619 AB8500_FG_DISCHARGE_READOUT);
1620 break;
1621
1622 case AB8500_FG_DISCHARGE_READOUT:
1623 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1624
1625 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1626
1627 if (di->high_curr_mode) {
1628 di->high_curr_mode = false;
1629 di->high_curr_cnt = 0;
1630 }
1631
1632 if (di->recovery_needed) {
1633 ab8500_fg_discharge_state_to(di,
1634 AB8500_FG_DISCHARGE_INIT_RECOVERY);
1635
1636 queue_delayed_work(di->fg_wq,
1637 &di->fg_periodic_work, 0);
1638
1639 break;
1640 }
1641
1642 ab8500_fg_calc_cap_discharge_voltage(di, true);
1643 } else {
1644 mutex_lock(&di->cc_lock);
1645 if (!di->flags.conv_done) {
1646
1647 mutex_unlock(&di->cc_lock);
1648 dev_dbg(di->dev, "%s CC conv not done\n",
1649 __func__);
1650
1651 break;
1652 }
1653 di->flags.conv_done = false;
1654 mutex_unlock(&di->cc_lock);
1655
1656
1657 if (!di->high_curr_mode) {
1658 di->high_curr_mode = true;
1659 di->high_curr_cnt = 0;
1660 }
1661
1662 di->high_curr_cnt +=
1663 di->bm->fg_params->accu_high_curr;
1664 if (di->high_curr_cnt >
1665 di->bm->fg_params->high_curr_time)
1666 di->recovery_needed = true;
1667
1668 ab8500_fg_calc_cap_discharge_fg(di);
1669 }
1670
1671 ab8500_fg_check_capacity_limits(di, false);
1672
1673 break;
1674
1675 case AB8500_FG_DISCHARGE_WAKEUP:
1676 ab8500_fg_calc_cap_discharge_voltage(di, true);
1677
1678 di->fg_samples = SEC_TO_SAMPLE(
1679 di->bm->fg_params->accu_high_curr);
1680 ab8500_fg_coulomb_counter(di, true);
1681 ab8500_fg_discharge_state_to(di,
1682 AB8500_FG_DISCHARGE_READOUT);
1683
1684 ab8500_fg_check_capacity_limits(di, false);
1685
1686 break;
1687
1688 default:
1689 break;
1690 }
1691}
1692
1693
1694
1695
1696
1697
1698static void ab8500_fg_algorithm_calibrate(struct ab8500_fg *di)
1699{
1700 int ret;
1701
1702 switch (di->calib_state) {
1703 case AB8500_FG_CALIB_INIT:
1704 dev_dbg(di->dev, "Calibration ongoing...\n");
1705
1706 ret = abx500_mask_and_set_register_interruptible(di->dev,
1707 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1708 CC_INT_CAL_N_AVG_MASK, CC_INT_CAL_SAMPLES_8);
1709 if (ret < 0)
1710 goto err;
1711
1712 ret = abx500_mask_and_set_register_interruptible(di->dev,
1713 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1714 CC_INTAVGOFFSET_ENA, CC_INTAVGOFFSET_ENA);
1715 if (ret < 0)
1716 goto err;
1717 di->calib_state = AB8500_FG_CALIB_WAIT;
1718 break;
1719 case AB8500_FG_CALIB_END:
1720 ret = abx500_mask_and_set_register_interruptible(di->dev,
1721 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1722 CC_MUXOFFSET, CC_MUXOFFSET);
1723 if (ret < 0)
1724 goto err;
1725 di->flags.calibrate = false;
1726 dev_dbg(di->dev, "Calibration done...\n");
1727 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1728 break;
1729 case AB8500_FG_CALIB_WAIT:
1730 dev_dbg(di->dev, "Calibration WFI\n");
1731 break;
1732 default:
1733 break;
1734 }
1735 return;
1736err:
1737
1738 dev_err(di->dev, "failed to calibrate the CC\n");
1739 di->flags.calibrate = false;
1740 di->calib_state = AB8500_FG_CALIB_INIT;
1741 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1742}
1743
1744
1745
1746
1747
1748
1749
1750static void ab8500_fg_algorithm(struct ab8500_fg *di)
1751{
1752 if (di->flags.calibrate)
1753 ab8500_fg_algorithm_calibrate(di);
1754 else {
1755 if (di->flags.charging)
1756 ab8500_fg_algorithm_charging(di);
1757 else
1758 ab8500_fg_algorithm_discharging(di);
1759 }
1760
1761 dev_dbg(di->dev, "[FG_DATA] %d %d %d %d %d %d %d %d %d %d "
1762 "%d %d %d %d %d %d %d\n",
1763 di->bat_cap.max_mah_design,
1764 di->bat_cap.max_mah,
1765 di->bat_cap.mah,
1766 di->bat_cap.permille,
1767 di->bat_cap.level,
1768 di->bat_cap.prev_mah,
1769 di->bat_cap.prev_percent,
1770 di->bat_cap.prev_level,
1771 di->vbat,
1772 di->inst_curr,
1773 di->avg_curr,
1774 di->accu_charge,
1775 di->flags.charging,
1776 di->charge_state,
1777 di->discharge_state,
1778 di->high_curr_mode,
1779 di->recovery_needed);
1780}
1781
1782
1783
1784
1785
1786
1787
1788static void ab8500_fg_periodic_work(struct work_struct *work)
1789{
1790 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1791 fg_periodic_work.work);
1792
1793 if (di->init_capacity) {
1794
1795 ab8500_fg_calc_cap_discharge_voltage(di, true);
1796 ab8500_fg_check_capacity_limits(di, true);
1797 di->init_capacity = false;
1798
1799 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1800 } else if (di->flags.user_cap) {
1801 if (check_sysfs_capacity(di)) {
1802 ab8500_fg_check_capacity_limits(di, true);
1803 if (di->flags.charging)
1804 ab8500_fg_charge_state_to(di,
1805 AB8500_FG_CHARGE_INIT);
1806 else
1807 ab8500_fg_discharge_state_to(di,
1808 AB8500_FG_DISCHARGE_READOUT_INIT);
1809 }
1810 di->flags.user_cap = false;
1811 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1812 } else
1813 ab8500_fg_algorithm(di);
1814
1815}
1816
1817
1818
1819
1820
1821
1822
1823static void ab8500_fg_check_hw_failure_work(struct work_struct *work)
1824{
1825 int ret;
1826 u8 reg_value;
1827
1828 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1829 fg_check_hw_failure_work.work);
1830
1831
1832
1833
1834
1835 ret = abx500_get_register_interruptible(di->dev,
1836 AB8500_CHARGER, AB8500_CH_STAT_REG,
1837 ®_value);
1838 if (ret < 0) {
1839 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1840 return;
1841 }
1842 if ((reg_value & BATT_OVV) == BATT_OVV) {
1843 if (!di->flags.bat_ovv) {
1844 dev_dbg(di->dev, "Battery OVV\n");
1845 di->flags.bat_ovv = true;
1846 power_supply_changed(di->fg_psy);
1847 }
1848
1849 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work,
1850 HZ);
1851 } else {
1852 dev_dbg(di->dev, "Battery recovered from OVV\n");
1853 di->flags.bat_ovv = false;
1854 power_supply_changed(di->fg_psy);
1855 }
1856}
1857
1858
1859
1860
1861
1862
1863
1864static void ab8500_fg_low_bat_work(struct work_struct *work)
1865{
1866 int vbat;
1867
1868 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1869 fg_low_bat_work.work);
1870
1871 vbat = ab8500_fg_bat_voltage(di);
1872
1873
1874 if (vbat < di->bm->fg_params->lowbat_threshold) {
1875
1876 if (di->low_bat_cnt < 1) {
1877 di->flags.low_bat = true;
1878 dev_warn(di->dev, "Shut down pending...\n");
1879 } else {
1880
1881
1882
1883
1884
1885 di->low_bat_cnt--;
1886 dev_warn(di->dev, "Battery voltage still LOW\n");
1887 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
1888 round_jiffies(LOW_BAT_CHECK_INTERVAL));
1889 }
1890 } else {
1891 di->flags.low_bat_delay = false;
1892 di->low_bat_cnt = 10;
1893 dev_warn(di->dev, "Battery voltage OK again\n");
1894 }
1895
1896
1897 ab8500_fg_check_capacity_limits(di, false);
1898}
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910static int ab8500_fg_battok_calc(struct ab8500_fg *di, int target)
1911{
1912 if (target > BATT_OK_MIN +
1913 (BATT_OK_INCREMENT * BATT_OK_MAX_NR_INCREMENTS))
1914 return BATT_OK_MAX_NR_INCREMENTS;
1915 if (target < BATT_OK_MIN)
1916 return 0;
1917 return (target - BATT_OK_MIN) / BATT_OK_INCREMENT;
1918}
1919
1920
1921
1922
1923
1924
1925
1926static int ab8500_fg_battok_init_hw_register(struct ab8500_fg *di)
1927{
1928 int selected;
1929 int sel0;
1930 int sel1;
1931 int cbp_sel0;
1932 int cbp_sel1;
1933 int ret;
1934 int new_val;
1935
1936 sel0 = di->bm->fg_params->battok_falling_th_sel0;
1937 sel1 = di->bm->fg_params->battok_raising_th_sel1;
1938
1939 cbp_sel0 = ab8500_fg_battok_calc(di, sel0);
1940 cbp_sel1 = ab8500_fg_battok_calc(di, sel1);
1941
1942 selected = BATT_OK_MIN + cbp_sel0 * BATT_OK_INCREMENT;
1943
1944 if (selected != sel0)
1945 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1946 sel0, selected, cbp_sel0);
1947
1948 selected = BATT_OK_MIN + cbp_sel1 * BATT_OK_INCREMENT;
1949
1950 if (selected != sel1)
1951 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1952 sel1, selected, cbp_sel1);
1953
1954 new_val = cbp_sel0 | (cbp_sel1 << 4);
1955
1956 dev_dbg(di->dev, "using: %x %d %d\n", new_val, cbp_sel0, cbp_sel1);
1957 ret = abx500_set_register_interruptible(di->dev, AB8500_SYS_CTRL2_BLOCK,
1958 AB8500_BATT_OK_REG, new_val);
1959 return ret;
1960}
1961
1962
1963
1964
1965
1966
1967
1968static void ab8500_fg_instant_work(struct work_struct *work)
1969{
1970 struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work);
1971
1972 ab8500_fg_algorithm(di);
1973}
1974
1975
1976
1977
1978
1979
1980
1981
1982static irqreturn_t ab8500_fg_cc_data_end_handler(int irq, void *_di)
1983{
1984 struct ab8500_fg *di = _di;
1985 if (!di->nbr_cceoc_irq_cnt) {
1986 di->nbr_cceoc_irq_cnt++;
1987 complete(&di->ab8500_fg_started);
1988 } else {
1989 di->nbr_cceoc_irq_cnt = 0;
1990 complete(&di->ab8500_fg_complete);
1991 }
1992 return IRQ_HANDLED;
1993}
1994
1995
1996
1997
1998
1999
2000
2001
2002static irqreturn_t ab8500_fg_cc_int_calib_handler(int irq, void *_di)
2003{
2004 struct ab8500_fg *di = _di;
2005 di->calib_state = AB8500_FG_CALIB_END;
2006 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2007 return IRQ_HANDLED;
2008}
2009
2010
2011
2012
2013
2014
2015
2016
2017static irqreturn_t ab8500_fg_cc_convend_handler(int irq, void *_di)
2018{
2019 struct ab8500_fg *di = _di;
2020
2021 queue_work(di->fg_wq, &di->fg_acc_cur_work);
2022
2023 return IRQ_HANDLED;
2024}
2025
2026
2027
2028
2029
2030
2031
2032
2033static irqreturn_t ab8500_fg_batt_ovv_handler(int irq, void *_di)
2034{
2035 struct ab8500_fg *di = _di;
2036
2037 dev_dbg(di->dev, "Battery OVV\n");
2038
2039
2040 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0);
2041
2042 return IRQ_HANDLED;
2043}
2044
2045
2046
2047
2048
2049
2050
2051
2052static irqreturn_t ab8500_fg_lowbatf_handler(int irq, void *_di)
2053{
2054 struct ab8500_fg *di = _di;
2055
2056
2057 if (!di->flags.low_bat_delay) {
2058 dev_warn(di->dev, "Battery voltage is below LOW threshold\n");
2059 di->flags.low_bat_delay = true;
2060
2061
2062
2063
2064 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
2065 round_jiffies(LOW_BAT_CHECK_INTERVAL));
2066 }
2067 return IRQ_HANDLED;
2068}
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088static int ab8500_fg_get_property(struct power_supply *psy,
2089 enum power_supply_property psp,
2090 union power_supply_propval *val)
2091{
2092 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2093
2094
2095
2096
2097
2098
2099
2100
2101 switch (psp) {
2102 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2103 if (di->flags.bat_ovv)
2104 val->intval = BATT_OVV_VALUE * 1000;
2105 else
2106 val->intval = di->vbat * 1000;
2107 break;
2108 case POWER_SUPPLY_PROP_CURRENT_NOW:
2109 val->intval = di->inst_curr * 1000;
2110 break;
2111 case POWER_SUPPLY_PROP_CURRENT_AVG:
2112 val->intval = di->avg_curr * 1000;
2113 break;
2114 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
2115 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2116 di->bat_cap.max_mah_design);
2117 break;
2118 case POWER_SUPPLY_PROP_ENERGY_FULL:
2119 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2120 di->bat_cap.max_mah);
2121 break;
2122 case POWER_SUPPLY_PROP_ENERGY_NOW:
2123 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2124 di->flags.batt_id_received)
2125 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2126 di->bat_cap.max_mah);
2127 else
2128 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2129 di->bat_cap.prev_mah);
2130 break;
2131 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
2132 val->intval = di->bat_cap.max_mah_design;
2133 break;
2134 case POWER_SUPPLY_PROP_CHARGE_FULL:
2135 val->intval = di->bat_cap.max_mah;
2136 break;
2137 case POWER_SUPPLY_PROP_CHARGE_NOW:
2138 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2139 di->flags.batt_id_received)
2140 val->intval = di->bat_cap.max_mah;
2141 else
2142 val->intval = di->bat_cap.prev_mah;
2143 break;
2144 case POWER_SUPPLY_PROP_CAPACITY:
2145 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2146 di->flags.batt_id_received)
2147 val->intval = 100;
2148 else
2149 val->intval = di->bat_cap.prev_percent;
2150 break;
2151 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
2152 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2153 di->flags.batt_id_received)
2154 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
2155 else
2156 val->intval = di->bat_cap.prev_level;
2157 break;
2158 default:
2159 return -EINVAL;
2160 }
2161 return 0;
2162}
2163
2164static int ab8500_fg_get_ext_psy_data(struct device *dev, void *data)
2165{
2166 struct power_supply *psy;
2167 struct power_supply *ext = dev_get_drvdata(dev);
2168 const char **supplicants = (const char **)ext->supplied_to;
2169 struct ab8500_fg *di;
2170 union power_supply_propval ret;
2171 int j;
2172
2173 psy = (struct power_supply *)data;
2174 di = power_supply_get_drvdata(psy);
2175
2176
2177
2178
2179
2180 j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
2181 if (j < 0)
2182 return 0;
2183
2184
2185 for (j = 0; j < ext->desc->num_properties; j++) {
2186 enum power_supply_property prop;
2187 prop = ext->desc->properties[j];
2188
2189 if (power_supply_get_property(ext, prop, &ret))
2190 continue;
2191
2192 switch (prop) {
2193 case POWER_SUPPLY_PROP_STATUS:
2194 switch (ext->desc->type) {
2195 case POWER_SUPPLY_TYPE_BATTERY:
2196 switch (ret.intval) {
2197 case POWER_SUPPLY_STATUS_UNKNOWN:
2198 case POWER_SUPPLY_STATUS_DISCHARGING:
2199 case POWER_SUPPLY_STATUS_NOT_CHARGING:
2200 if (!di->flags.charging)
2201 break;
2202 di->flags.charging = false;
2203 di->flags.fully_charged = false;
2204 if (di->bm->capacity_scaling)
2205 ab8500_fg_update_cap_scalers(di);
2206 queue_work(di->fg_wq, &di->fg_work);
2207 break;
2208 case POWER_SUPPLY_STATUS_FULL:
2209 if (di->flags.fully_charged)
2210 break;
2211 di->flags.fully_charged = true;
2212 di->flags.force_full = true;
2213
2214 di->bat_cap.max_mah = di->bat_cap.mah;
2215 queue_work(di->fg_wq, &di->fg_work);
2216 break;
2217 case POWER_SUPPLY_STATUS_CHARGING:
2218 if (di->flags.charging &&
2219 !di->flags.fully_charged)
2220 break;
2221 di->flags.charging = true;
2222 di->flags.fully_charged = false;
2223 if (di->bm->capacity_scaling)
2224 ab8500_fg_update_cap_scalers(di);
2225 queue_work(di->fg_wq, &di->fg_work);
2226 break;
2227 }
2228 break;
2229 default:
2230 break;
2231 }
2232 break;
2233 case POWER_SUPPLY_PROP_TECHNOLOGY:
2234 switch (ext->desc->type) {
2235 case POWER_SUPPLY_TYPE_BATTERY:
2236 if (!di->flags.batt_id_received &&
2237 di->bm->batt_id != BATTERY_UNKNOWN) {
2238 const struct ab8500_battery_type *b;
2239
2240 b = &(di->bm->bat_type[di->bm->batt_id]);
2241
2242 di->flags.batt_id_received = true;
2243
2244 di->bat_cap.max_mah_design =
2245 MILLI_TO_MICRO *
2246 b->charge_full_design;
2247
2248 di->bat_cap.max_mah =
2249 di->bat_cap.max_mah_design;
2250
2251 di->vbat_nom = b->nominal_voltage;
2252 }
2253
2254 if (ret.intval)
2255 di->flags.batt_unknown = false;
2256 else
2257 di->flags.batt_unknown = true;
2258 break;
2259 default:
2260 break;
2261 }
2262 break;
2263 case POWER_SUPPLY_PROP_TEMP:
2264 switch (ext->desc->type) {
2265 case POWER_SUPPLY_TYPE_BATTERY:
2266 if (di->flags.batt_id_received)
2267 di->bat_temp = ret.intval;
2268 break;
2269 default:
2270 break;
2271 }
2272 break;
2273 default:
2274 break;
2275 }
2276 }
2277 return 0;
2278}
2279
2280
2281
2282
2283
2284
2285
2286static int ab8500_fg_init_hw_registers(struct ab8500_fg *di)
2287{
2288 int ret;
2289
2290
2291 ret = abx500_mask_and_set_register_interruptible(di->dev,
2292 AB8500_CHARGER,
2293 AB8500_BATT_OVV,
2294 BATT_OVV_TH_4P75,
2295 BATT_OVV_TH_4P75);
2296 if (ret) {
2297 dev_err(di->dev, "failed to set BATT_OVV\n");
2298 goto out;
2299 }
2300
2301
2302 ret = abx500_mask_and_set_register_interruptible(di->dev,
2303 AB8500_CHARGER,
2304 AB8500_BATT_OVV,
2305 BATT_OVV_ENA,
2306 BATT_OVV_ENA);
2307 if (ret) {
2308 dev_err(di->dev, "failed to enable BATT_OVV\n");
2309 goto out;
2310 }
2311
2312
2313 ret = abx500_set_register_interruptible(di->dev,
2314 AB8500_SYS_CTRL2_BLOCK,
2315 AB8500_LOW_BAT_REG,
2316 ab8500_volt_to_regval(
2317 di->bm->fg_params->lowbat_threshold) << 1 |
2318 LOW_BAT_ENABLE);
2319 if (ret) {
2320 dev_err(di->dev, "%s write failed\n", __func__);
2321 goto out;
2322 }
2323
2324
2325 ret = ab8500_fg_battok_init_hw_register(di);
2326 if (ret) {
2327 dev_err(di->dev, "BattOk init write failed.\n");
2328 goto out;
2329 }
2330
2331 if (is_ab8505(di->parent)) {
2332 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2333 AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time);
2334
2335 if (ret) {
2336 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__);
2337 goto out;
2338 }
2339
2340 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2341 AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time);
2342
2343 if (ret) {
2344 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__);
2345 goto out;
2346 }
2347
2348 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2349 AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart);
2350
2351 if (ret) {
2352 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__);
2353 goto out;
2354 }
2355
2356 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2357 AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time);
2358
2359 if (ret) {
2360 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__);
2361 goto out;
2362 }
2363
2364 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2365 AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable);
2366
2367 if (ret) {
2368 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__);
2369 goto out;
2370 }
2371 }
2372out:
2373 return ret;
2374}
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385static void ab8500_fg_external_power_changed(struct power_supply *psy)
2386{
2387 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2388
2389 class_for_each_device(power_supply_class, NULL,
2390 di->fg_psy, ab8500_fg_get_ext_psy_data);
2391}
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401static void ab8500_fg_reinit_work(struct work_struct *work)
2402{
2403 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
2404 fg_reinit_work.work);
2405
2406 if (!di->flags.calibrate) {
2407 dev_dbg(di->dev, "Resetting FG state machine to init.\n");
2408 ab8500_fg_clear_cap_samples(di);
2409 ab8500_fg_calc_cap_discharge_voltage(di, true);
2410 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
2411 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
2412 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2413
2414 } else {
2415 dev_err(di->dev, "Residual offset calibration ongoing "
2416 "retrying..\n");
2417
2418 queue_delayed_work(di->fg_wq, &di->fg_reinit_work,
2419 round_jiffies(1));
2420 }
2421}
2422
2423
2424
2425struct ab8500_fg_sysfs_entry {
2426 struct attribute attr;
2427 ssize_t (*show)(struct ab8500_fg *, char *);
2428 ssize_t (*store)(struct ab8500_fg *, const char *, size_t);
2429};
2430
2431static ssize_t charge_full_show(struct ab8500_fg *di, char *buf)
2432{
2433 return sprintf(buf, "%d\n", di->bat_cap.max_mah);
2434}
2435
2436static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf,
2437 size_t count)
2438{
2439 unsigned long charge_full;
2440 int ret;
2441
2442 ret = kstrtoul(buf, 10, &charge_full);
2443 if (ret)
2444 return ret;
2445
2446 di->bat_cap.max_mah = (int) charge_full;
2447 return count;
2448}
2449
2450static ssize_t charge_now_show(struct ab8500_fg *di, char *buf)
2451{
2452 return sprintf(buf, "%d\n", di->bat_cap.prev_mah);
2453}
2454
2455static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf,
2456 size_t count)
2457{
2458 unsigned long charge_now;
2459 int ret;
2460
2461 ret = kstrtoul(buf, 10, &charge_now);
2462 if (ret)
2463 return ret;
2464
2465 di->bat_cap.user_mah = (int) charge_now;
2466 di->flags.user_cap = true;
2467 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2468 return count;
2469}
2470
2471static struct ab8500_fg_sysfs_entry charge_full_attr =
2472 __ATTR(charge_full, 0644, charge_full_show, charge_full_store);
2473
2474static struct ab8500_fg_sysfs_entry charge_now_attr =
2475 __ATTR(charge_now, 0644, charge_now_show, charge_now_store);
2476
2477static ssize_t
2478ab8500_fg_show(struct kobject *kobj, struct attribute *attr, char *buf)
2479{
2480 struct ab8500_fg_sysfs_entry *entry;
2481 struct ab8500_fg *di;
2482
2483 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
2484 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2485
2486 if (!entry->show)
2487 return -EIO;
2488
2489 return entry->show(di, buf);
2490}
2491static ssize_t
2492ab8500_fg_store(struct kobject *kobj, struct attribute *attr, const char *buf,
2493 size_t count)
2494{
2495 struct ab8500_fg_sysfs_entry *entry;
2496 struct ab8500_fg *di;
2497
2498 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
2499 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2500
2501 if (!entry->store)
2502 return -EIO;
2503
2504 return entry->store(di, buf, count);
2505}
2506
2507static const struct sysfs_ops ab8500_fg_sysfs_ops = {
2508 .show = ab8500_fg_show,
2509 .store = ab8500_fg_store,
2510};
2511
2512static struct attribute *ab8500_fg_attrs[] = {
2513 &charge_full_attr.attr,
2514 &charge_now_attr.attr,
2515 NULL,
2516};
2517
2518static struct kobj_type ab8500_fg_ktype = {
2519 .sysfs_ops = &ab8500_fg_sysfs_ops,
2520 .default_attrs = ab8500_fg_attrs,
2521};
2522
2523
2524
2525
2526
2527
2528
2529static void ab8500_fg_sysfs_exit(struct ab8500_fg *di)
2530{
2531 kobject_del(&di->fg_kobject);
2532}
2533
2534
2535
2536
2537
2538
2539
2540
2541static int ab8500_fg_sysfs_init(struct ab8500_fg *di)
2542{
2543 int ret = 0;
2544
2545 ret = kobject_init_and_add(&di->fg_kobject,
2546 &ab8500_fg_ktype,
2547 NULL, "battery");
2548 if (ret < 0)
2549 dev_err(di->dev, "failed to create sysfs entry\n");
2550
2551 return ret;
2552}
2553
2554static ssize_t ab8505_powercut_flagtime_read(struct device *dev,
2555 struct device_attribute *attr,
2556 char *buf)
2557{
2558 int ret;
2559 u8 reg_value;
2560 struct power_supply *psy = dev_get_drvdata(dev);
2561 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2562
2563 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2564 AB8505_RTC_PCUT_FLAG_TIME_REG, ®_value);
2565
2566 if (ret < 0) {
2567 dev_err(dev, "Failed to read AB8505_RTC_PCUT_FLAG_TIME_REG\n");
2568 goto fail;
2569 }
2570
2571 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2572
2573fail:
2574 return ret;
2575}
2576
2577static ssize_t ab8505_powercut_flagtime_write(struct device *dev,
2578 struct device_attribute *attr,
2579 const char *buf, size_t count)
2580{
2581 int ret;
2582 int reg_value;
2583 struct power_supply *psy = dev_get_drvdata(dev);
2584 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2585
2586 if (kstrtoint(buf, 10, ®_value))
2587 goto fail;
2588
2589 if (reg_value > 0x7F) {
2590 dev_err(dev, "Incorrect parameter, echo 0 (1.98s) - 127 (15.625ms) for flagtime\n");
2591 goto fail;
2592 }
2593
2594 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2595 AB8505_RTC_PCUT_FLAG_TIME_REG, (u8)reg_value);
2596
2597 if (ret < 0)
2598 dev_err(dev, "Failed to set AB8505_RTC_PCUT_FLAG_TIME_REG\n");
2599
2600fail:
2601 return count;
2602}
2603
2604static ssize_t ab8505_powercut_maxtime_read(struct device *dev,
2605 struct device_attribute *attr,
2606 char *buf)
2607{
2608 int ret;
2609 u8 reg_value;
2610 struct power_supply *psy = dev_get_drvdata(dev);
2611 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2612
2613 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2614 AB8505_RTC_PCUT_MAX_TIME_REG, ®_value);
2615
2616 if (ret < 0) {
2617 dev_err(dev, "Failed to read AB8505_RTC_PCUT_MAX_TIME_REG\n");
2618 goto fail;
2619 }
2620
2621 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2622
2623fail:
2624 return ret;
2625
2626}
2627
2628static ssize_t ab8505_powercut_maxtime_write(struct device *dev,
2629 struct device_attribute *attr,
2630 const char *buf, size_t count)
2631{
2632 int ret;
2633 int reg_value;
2634 struct power_supply *psy = dev_get_drvdata(dev);
2635 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2636
2637 if (kstrtoint(buf, 10, ®_value))
2638 goto fail;
2639
2640 if (reg_value > 0x7F) {
2641 dev_err(dev, "Incorrect parameter, echo 0 (0.0s) - 127 (1.98s) for maxtime\n");
2642 goto fail;
2643 }
2644
2645 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2646 AB8505_RTC_PCUT_MAX_TIME_REG, (u8)reg_value);
2647
2648 if (ret < 0)
2649 dev_err(dev, "Failed to set AB8505_RTC_PCUT_MAX_TIME_REG\n");
2650
2651fail:
2652 return count;
2653}
2654
2655static ssize_t ab8505_powercut_restart_read(struct device *dev,
2656 struct device_attribute *attr,
2657 char *buf)
2658{
2659 int ret;
2660 u8 reg_value;
2661 struct power_supply *psy = dev_get_drvdata(dev);
2662 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2663
2664 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2665 AB8505_RTC_PCUT_RESTART_REG, ®_value);
2666
2667 if (ret < 0) {
2668 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
2669 goto fail;
2670 }
2671
2672 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF));
2673
2674fail:
2675 return ret;
2676}
2677
2678static ssize_t ab8505_powercut_restart_write(struct device *dev,
2679 struct device_attribute *attr,
2680 const char *buf, size_t count)
2681{
2682 int ret;
2683 int reg_value;
2684 struct power_supply *psy = dev_get_drvdata(dev);
2685 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2686
2687 if (kstrtoint(buf, 10, ®_value))
2688 goto fail;
2689
2690 if (reg_value > 0xF) {
2691 dev_err(dev, "Incorrect parameter, echo 0 - 15 for number of restart\n");
2692 goto fail;
2693 }
2694
2695 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2696 AB8505_RTC_PCUT_RESTART_REG, (u8)reg_value);
2697
2698 if (ret < 0)
2699 dev_err(dev, "Failed to set AB8505_RTC_PCUT_RESTART_REG\n");
2700
2701fail:
2702 return count;
2703
2704}
2705
2706static ssize_t ab8505_powercut_timer_read(struct device *dev,
2707 struct device_attribute *attr,
2708 char *buf)
2709{
2710 int ret;
2711 u8 reg_value;
2712 struct power_supply *psy = dev_get_drvdata(dev);
2713 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2714
2715 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2716 AB8505_RTC_PCUT_TIME_REG, ®_value);
2717
2718 if (ret < 0) {
2719 dev_err(dev, "Failed to read AB8505_RTC_PCUT_TIME_REG\n");
2720 goto fail;
2721 }
2722
2723 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2724
2725fail:
2726 return ret;
2727}
2728
2729static ssize_t ab8505_powercut_restart_counter_read(struct device *dev,
2730 struct device_attribute *attr,
2731 char *buf)
2732{
2733 int ret;
2734 u8 reg_value;
2735 struct power_supply *psy = dev_get_drvdata(dev);
2736 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2737
2738 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2739 AB8505_RTC_PCUT_RESTART_REG, ®_value);
2740
2741 if (ret < 0) {
2742 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
2743 goto fail;
2744 }
2745
2746 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF0) >> 4);
2747
2748fail:
2749 return ret;
2750}
2751
2752static ssize_t ab8505_powercut_read(struct device *dev,
2753 struct device_attribute *attr,
2754 char *buf)
2755{
2756 int ret;
2757 u8 reg_value;
2758 struct power_supply *psy = dev_get_drvdata(dev);
2759 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2760
2761 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2762 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value);
2763
2764 if (ret < 0)
2765 goto fail;
2766
2767 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x1));
2768
2769fail:
2770 return ret;
2771}
2772
2773static ssize_t ab8505_powercut_write(struct device *dev,
2774 struct device_attribute *attr,
2775 const char *buf, size_t count)
2776{
2777 int ret;
2778 int reg_value;
2779 struct power_supply *psy = dev_get_drvdata(dev);
2780 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2781
2782 if (kstrtoint(buf, 10, ®_value))
2783 goto fail;
2784
2785 if (reg_value > 0x1) {
2786 dev_err(dev, "Incorrect parameter, echo 0/1 to disable/enable Pcut feature\n");
2787 goto fail;
2788 }
2789
2790 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2791 AB8505_RTC_PCUT_CTL_STATUS_REG, (u8)reg_value);
2792
2793 if (ret < 0)
2794 dev_err(dev, "Failed to set AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2795
2796fail:
2797 return count;
2798}
2799
2800static ssize_t ab8505_powercut_flag_read(struct device *dev,
2801 struct device_attribute *attr,
2802 char *buf)
2803{
2804
2805 int ret;
2806 u8 reg_value;
2807 struct power_supply *psy = dev_get_drvdata(dev);
2808 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2809
2810 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2811 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value);
2812
2813 if (ret < 0) {
2814 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2815 goto fail;
2816 }
2817
2818 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x10) >> 4));
2819
2820fail:
2821 return ret;
2822}
2823
2824static ssize_t ab8505_powercut_debounce_read(struct device *dev,
2825 struct device_attribute *attr,
2826 char *buf)
2827{
2828 int ret;
2829 u8 reg_value;
2830 struct power_supply *psy = dev_get_drvdata(dev);
2831 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2832
2833 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2834 AB8505_RTC_PCUT_DEBOUNCE_REG, ®_value);
2835
2836 if (ret < 0) {
2837 dev_err(dev, "Failed to read AB8505_RTC_PCUT_DEBOUNCE_REG\n");
2838 goto fail;
2839 }
2840
2841 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7));
2842
2843fail:
2844 return ret;
2845}
2846
2847static ssize_t ab8505_powercut_debounce_write(struct device *dev,
2848 struct device_attribute *attr,
2849 const char *buf, size_t count)
2850{
2851 int ret;
2852 int reg_value;
2853 struct power_supply *psy = dev_get_drvdata(dev);
2854 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2855
2856 if (kstrtoint(buf, 10, ®_value))
2857 goto fail;
2858
2859 if (reg_value > 0x7) {
2860 dev_err(dev, "Incorrect parameter, echo 0 to 7 for debounce setting\n");
2861 goto fail;
2862 }
2863
2864 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2865 AB8505_RTC_PCUT_DEBOUNCE_REG, (u8)reg_value);
2866
2867 if (ret < 0)
2868 dev_err(dev, "Failed to set AB8505_RTC_PCUT_DEBOUNCE_REG\n");
2869
2870fail:
2871 return count;
2872}
2873
2874static ssize_t ab8505_powercut_enable_status_read(struct device *dev,
2875 struct device_attribute *attr,
2876 char *buf)
2877{
2878 int ret;
2879 u8 reg_value;
2880 struct power_supply *psy = dev_get_drvdata(dev);
2881 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2882
2883 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2884 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value);
2885
2886 if (ret < 0) {
2887 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2888 goto fail;
2889 }
2890
2891 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x20) >> 5));
2892
2893fail:
2894 return ret;
2895}
2896
2897static struct device_attribute ab8505_fg_sysfs_psy_attrs[] = {
2898 __ATTR(powercut_flagtime, (S_IRUGO | S_IWUSR | S_IWGRP),
2899 ab8505_powercut_flagtime_read, ab8505_powercut_flagtime_write),
2900 __ATTR(powercut_maxtime, (S_IRUGO | S_IWUSR | S_IWGRP),
2901 ab8505_powercut_maxtime_read, ab8505_powercut_maxtime_write),
2902 __ATTR(powercut_restart_max, (S_IRUGO | S_IWUSR | S_IWGRP),
2903 ab8505_powercut_restart_read, ab8505_powercut_restart_write),
2904 __ATTR(powercut_timer, S_IRUGO, ab8505_powercut_timer_read, NULL),
2905 __ATTR(powercut_restart_counter, S_IRUGO,
2906 ab8505_powercut_restart_counter_read, NULL),
2907 __ATTR(powercut_enable, (S_IRUGO | S_IWUSR | S_IWGRP),
2908 ab8505_powercut_read, ab8505_powercut_write),
2909 __ATTR(powercut_flag, S_IRUGO, ab8505_powercut_flag_read, NULL),
2910 __ATTR(powercut_debounce_time, (S_IRUGO | S_IWUSR | S_IWGRP),
2911 ab8505_powercut_debounce_read, ab8505_powercut_debounce_write),
2912 __ATTR(powercut_enable_status, S_IRUGO,
2913 ab8505_powercut_enable_status_read, NULL),
2914};
2915
2916static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di)
2917{
2918 unsigned int i;
2919
2920 if (is_ab8505(di->parent)) {
2921 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
2922 if (device_create_file(&di->fg_psy->dev,
2923 &ab8505_fg_sysfs_psy_attrs[i]))
2924 goto sysfs_psy_create_attrs_failed_ab8505;
2925 }
2926 return 0;
2927sysfs_psy_create_attrs_failed_ab8505:
2928 dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n");
2929 while (i--)
2930 device_remove_file(&di->fg_psy->dev,
2931 &ab8505_fg_sysfs_psy_attrs[i]);
2932
2933 return -EIO;
2934}
2935
2936static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di)
2937{
2938 unsigned int i;
2939
2940 if (is_ab8505(di->parent)) {
2941 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
2942 (void)device_remove_file(&di->fg_psy->dev,
2943 &ab8505_fg_sysfs_psy_attrs[i]);
2944 }
2945}
2946
2947
2948
2949static int __maybe_unused ab8500_fg_resume(struct device *dev)
2950{
2951 struct ab8500_fg *di = dev_get_drvdata(dev);
2952
2953
2954
2955
2956
2957 if (!di->flags.charging) {
2958 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP);
2959 queue_work(di->fg_wq, &di->fg_work);
2960 }
2961
2962 return 0;
2963}
2964
2965static int __maybe_unused ab8500_fg_suspend(struct device *dev)
2966{
2967 struct ab8500_fg *di = dev_get_drvdata(dev);
2968
2969 flush_delayed_work(&di->fg_periodic_work);
2970 flush_work(&di->fg_work);
2971 flush_work(&di->fg_acc_cur_work);
2972 flush_delayed_work(&di->fg_reinit_work);
2973 flush_delayed_work(&di->fg_low_bat_work);
2974 flush_delayed_work(&di->fg_check_hw_failure_work);
2975
2976
2977
2978
2979
2980 if (di->flags.fg_enabled && !di->flags.charging)
2981 ab8500_fg_coulomb_counter(di, false);
2982
2983 return 0;
2984}
2985
2986
2987static struct ab8500_fg_interrupts ab8500_fg_irq[] = {
2988 {"NCONV_ACCU", ab8500_fg_cc_convend_handler},
2989 {"BATT_OVV", ab8500_fg_batt_ovv_handler},
2990 {"LOW_BAT_F", ab8500_fg_lowbatf_handler},
2991 {"CC_INT_CALIB", ab8500_fg_cc_int_calib_handler},
2992 {"CCEOC", ab8500_fg_cc_data_end_handler},
2993};
2994
2995static char *supply_interface[] = {
2996 "ab8500_chargalg",
2997 "ab8500_usb",
2998};
2999
3000static const struct power_supply_desc ab8500_fg_desc = {
3001 .name = "ab8500_fg",
3002 .type = POWER_SUPPLY_TYPE_BATTERY,
3003 .properties = ab8500_fg_props,
3004 .num_properties = ARRAY_SIZE(ab8500_fg_props),
3005 .get_property = ab8500_fg_get_property,
3006 .external_power_changed = ab8500_fg_external_power_changed,
3007};
3008
3009static int ab8500_fg_bind(struct device *dev, struct device *master,
3010 void *data)
3011{
3012 struct ab8500_fg *di = dev_get_drvdata(dev);
3013
3014
3015 di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM);
3016 if (di->fg_wq == NULL) {
3017 dev_err(dev, "failed to create work queue\n");
3018 return -ENOMEM;
3019 }
3020
3021
3022 ab8500_fg_coulomb_counter(di, true);
3023
3024 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
3025
3026 return 0;
3027}
3028
3029static void ab8500_fg_unbind(struct device *dev, struct device *master,
3030 void *data)
3031{
3032 struct ab8500_fg *di = dev_get_drvdata(dev);
3033 int ret;
3034
3035
3036 ret = ab8500_fg_coulomb_counter(di, false);
3037 if (ret)
3038 dev_err(dev, "failed to disable coulomb counter\n");
3039
3040 destroy_workqueue(di->fg_wq);
3041 flush_scheduled_work();
3042}
3043
3044static const struct component_ops ab8500_fg_component_ops = {
3045 .bind = ab8500_fg_bind,
3046 .unbind = ab8500_fg_unbind,
3047};
3048
3049static int ab8500_fg_probe(struct platform_device *pdev)
3050{
3051 struct device *dev = &pdev->dev;
3052 struct power_supply_config psy_cfg = {};
3053 struct ab8500_fg *di;
3054 int i, irq;
3055 int ret = 0;
3056
3057 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
3058 if (!di)
3059 return -ENOMEM;
3060
3061 di->bm = &ab8500_bm_data;
3062
3063 mutex_init(&di->cc_lock);
3064
3065
3066 di->dev = dev;
3067 di->parent = dev_get_drvdata(pdev->dev.parent);
3068
3069 di->main_bat_v = devm_iio_channel_get(dev, "main_bat_v");
3070 if (IS_ERR(di->main_bat_v)) {
3071 ret = dev_err_probe(dev, PTR_ERR(di->main_bat_v),
3072 "failed to get main battery ADC channel\n");
3073 return ret;
3074 }
3075
3076 psy_cfg.supplied_to = supply_interface;
3077 psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3078 psy_cfg.drv_data = di;
3079
3080 di->bat_cap.max_mah_design = MILLI_TO_MICRO *
3081 di->bm->bat_type[di->bm->batt_id].charge_full_design;
3082
3083 di->bat_cap.max_mah = di->bat_cap.max_mah_design;
3084
3085 di->vbat_nom = di->bm->bat_type[di->bm->batt_id].nominal_voltage;
3086
3087 di->init_capacity = true;
3088
3089 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
3090 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
3091
3092
3093 INIT_WORK(&di->fg_work, ab8500_fg_instant_work);
3094
3095
3096 INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work);
3097
3098
3099 INIT_DEFERRABLE_WORK(&di->fg_reinit_work,
3100 ab8500_fg_reinit_work);
3101
3102
3103 INIT_DEFERRABLE_WORK(&di->fg_periodic_work,
3104 ab8500_fg_periodic_work);
3105
3106
3107 INIT_DEFERRABLE_WORK(&di->fg_low_bat_work,
3108 ab8500_fg_low_bat_work);
3109
3110
3111 INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work,
3112 ab8500_fg_check_hw_failure_work);
3113
3114
3115 di->flags.low_bat = false;
3116
3117
3118 di->low_bat_cnt = 10;
3119
3120
3121 ret = ab8500_fg_init_hw_registers(di);
3122 if (ret) {
3123 dev_err(dev, "failed to initialize registers\n");
3124 return ret;
3125 }
3126
3127
3128 di->flags.batt_unknown = true;
3129 di->flags.batt_id_received = false;
3130
3131
3132 di->fg_psy = devm_power_supply_register(dev, &ab8500_fg_desc, &psy_cfg);
3133 if (IS_ERR(di->fg_psy)) {
3134 dev_err(dev, "failed to register FG psy\n");
3135 return PTR_ERR(di->fg_psy);
3136 }
3137
3138 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
3139
3140
3141
3142
3143
3144 init_completion(&di->ab8500_fg_started);
3145 init_completion(&di->ab8500_fg_complete);
3146
3147
3148 for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq); i++) {
3149 irq = platform_get_irq_byname(pdev, ab8500_fg_irq[i].name);
3150 if (irq < 0)
3151 return irq;
3152
3153 ret = devm_request_threaded_irq(dev, irq, NULL,
3154 ab8500_fg_irq[i].isr,
3155 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3156 ab8500_fg_irq[i].name, di);
3157
3158 if (ret != 0) {
3159 dev_err(dev, "failed to request %s IRQ %d: %d\n",
3160 ab8500_fg_irq[i].name, irq, ret);
3161 return ret;
3162 }
3163 dev_dbg(dev, "Requested %s IRQ %d: %d\n",
3164 ab8500_fg_irq[i].name, irq, ret);
3165 }
3166
3167 di->irq = platform_get_irq_byname(pdev, "CCEOC");
3168 disable_irq(di->irq);
3169 di->nbr_cceoc_irq_cnt = 0;
3170
3171 platform_set_drvdata(pdev, di);
3172
3173 ret = ab8500_fg_sysfs_init(di);
3174 if (ret) {
3175 dev_err(dev, "failed to create sysfs entry\n");
3176 return ret;
3177 }
3178
3179 ret = ab8500_fg_sysfs_psy_create_attrs(di);
3180 if (ret) {
3181 dev_err(dev, "failed to create FG psy\n");
3182 ab8500_fg_sysfs_exit(di);
3183 return ret;
3184 }
3185
3186
3187 di->flags.calibrate = true;
3188 di->calib_state = AB8500_FG_CALIB_INIT;
3189
3190
3191 di->bat_temp = 210;
3192
3193 list_add_tail(&di->node, &ab8500_fg_list);
3194
3195 return component_add(dev, &ab8500_fg_component_ops);
3196}
3197
3198static int ab8500_fg_remove(struct platform_device *pdev)
3199{
3200 int ret = 0;
3201 struct ab8500_fg *di = platform_get_drvdata(pdev);
3202
3203 component_del(&pdev->dev, &ab8500_fg_component_ops);
3204 list_del(&di->node);
3205 ab8500_fg_sysfs_exit(di);
3206 ab8500_fg_sysfs_psy_remove_attrs(di);
3207
3208 return ret;
3209}
3210
3211static SIMPLE_DEV_PM_OPS(ab8500_fg_pm_ops, ab8500_fg_suspend, ab8500_fg_resume);
3212
3213static const struct of_device_id ab8500_fg_match[] = {
3214 { .compatible = "stericsson,ab8500-fg", },
3215 { },
3216};
3217MODULE_DEVICE_TABLE(of, ab8500_fg_match);
3218
3219struct platform_driver ab8500_fg_driver = {
3220 .probe = ab8500_fg_probe,
3221 .remove = ab8500_fg_remove,
3222 .driver = {
3223 .name = "ab8500-fg",
3224 .of_match_table = ab8500_fg_match,
3225 .pm = &ab8500_fg_pm_ops,
3226 },
3227};
3228MODULE_LICENSE("GPL v2");
3229MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
3230MODULE_ALIAS("platform:ab8500-fg");
3231MODULE_DESCRIPTION("AB8500 Fuel Gauge driver");
3232