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