This source file includes following definitions.
- ab8500_fg_get
- ab8500_volt_to_regval
- ab8500_fg_is_low_curr
- ab8500_fg_add_cap_sample
- ab8500_fg_clear_cap_samples
- ab8500_fg_fill_cap_sample
- ab8500_fg_coulomb_counter
- ab8500_fg_inst_curr_start
- ab8500_fg_inst_curr_started
- ab8500_fg_inst_curr_done
- ab8500_fg_inst_curr_finalize
- ab8500_fg_inst_curr_blocking
- ab8500_fg_acc_cur_work
- ab8500_fg_bat_voltage
- ab8500_fg_volt_to_capacity
- ab8500_fg_uncomp_volt_to_capacity
- ab8500_fg_battery_resistance
- ab8500_fg_load_comp_volt_to_capacity
- ab8500_fg_convert_mah_to_permille
- ab8500_fg_convert_permille_to_mah
- ab8500_fg_convert_mah_to_uwh
- ab8500_fg_calc_cap_charging
- ab8500_fg_calc_cap_discharge_voltage
- ab8500_fg_calc_cap_discharge_fg
- ab8500_fg_capacity_level
- ab8500_fg_calculate_scaled_capacity
- ab8500_fg_update_cap_scalers
- ab8500_fg_check_capacity_limits
- ab8500_fg_charge_state_to
- ab8500_fg_discharge_state_to
- ab8500_fg_algorithm_charging
- force_capacity
- check_sysfs_capacity
- ab8500_fg_algorithm_discharging
- ab8500_fg_algorithm_calibrate
- ab8500_fg_algorithm
- ab8500_fg_periodic_work
- ab8500_fg_check_hw_failure_work
- ab8500_fg_low_bat_work
- ab8500_fg_battok_calc
- ab8500_fg_battok_init_hw_register
- ab8500_fg_instant_work
- ab8500_fg_cc_data_end_handler
- ab8500_fg_cc_int_calib_handler
- ab8500_fg_cc_convend_handler
- ab8500_fg_batt_ovv_handler
- ab8500_fg_lowbatf_handler
- ab8500_fg_get_property
- ab8500_fg_get_ext_psy_data
- ab8500_fg_init_hw_registers
- ab8500_fg_external_power_changed
- ab8500_fg_reinit_work
- charge_full_show
- charge_full_store
- charge_now_show
- charge_now_store
- ab8500_fg_show
- ab8500_fg_store
- ab8500_fg_sysfs_exit
- ab8500_fg_sysfs_init
- ab8505_powercut_flagtime_read
- ab8505_powercut_flagtime_write
- ab8505_powercut_maxtime_read
- ab8505_powercut_maxtime_write
- ab8505_powercut_restart_read
- ab8505_powercut_restart_write
- ab8505_powercut_timer_read
- ab8505_powercut_restart_counter_read
- ab8505_powercut_read
- ab8505_powercut_write
- ab8505_powercut_flag_read
- ab8505_powercut_debounce_read
- ab8505_powercut_debounce_write
- ab8505_powercut_enable_status_read
- ab8500_fg_sysfs_psy_create_attrs
- ab8500_fg_sysfs_psy_remove_attrs
- ab8500_fg_resume
- ab8500_fg_suspend
- ab8500_fg_remove
- ab8500_fg_probe
- ab8500_fg_init
- ab8500_fg_exit
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
65 struct ab8500_fg_interrupts {
66 char *name;
67 irqreturn_t (*isr)(int irq, void *data);
68 };
69
70 enum 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
80 static 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
90 enum ab8500_fg_charge_state {
91 AB8500_FG_CHARGE_INIT,
92 AB8500_FG_CHARGE_READOUT,
93 };
94
95 static char *charge_state[] = {
96 "CHARGE_INIT",
97 "CHARGE_READOUT",
98 };
99
100 enum ab8500_fg_calibration_state {
101 AB8500_FG_CALIB_INIT,
102 AB8500_FG_CALIB_WAIT,
103 AB8500_FG_CALIB_END,
104 };
105
106 struct 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
115 struct ab8500_fg_cap_scaling {
116 bool enable;
117 int cap_to_scale[2];
118 int disable_cap_level;
119 int scaled_cap;
120 };
121
122 struct 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
135 struct 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
150 struct 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
198 struct 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 };
240 static LIST_HEAD(ab8500_fg_list);
241
242
243
244
245
246 struct 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
253 static 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
271 static 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
338 static 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
361 static 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
380 static 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
414 static 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
437 static 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
464 static 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;
519 cc_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
533 int 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;
574 fail:
575 mutex_unlock(&di->cc_lock);
576 return ret;
577 }
578
579
580
581
582
583
584
585 int 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
596 int 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
610 int 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;
694 fail:
695 mutex_unlock(&di->cc_lock);
696 return ret;
697 }
698
699
700
701
702
703
704
705
706 int 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;
741 fail:
742 disable_irq(di->irq);
743 mutex_unlock(&di->cc_lock);
744 return ret;
745 }
746
747
748
749
750
751
752
753
754 static 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;
817 exit:
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
830 static int ab8500_fg_bat_voltage(struct ab8500_fg *di)
831 {
832 int vbat;
833 static int prev;
834
835 vbat = ab8500_gpadc_convert(di->gpadc, MAIN_BAT_V);
836 if (vbat < 0) {
837 dev_err(di->dev,
838 "%s gpadc 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
854 static int ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage)
855 {
856 int i, tbl_size;
857 const struct abx500_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 = interpolate(voltage,
870 tbl[i].voltage,
871 tbl[i].capacity * 10,
872 tbl[i-1].voltage,
873 tbl[i-1].capacity * 10);
874 } else if (i == 0) {
875 cap = 1000;
876 } else {
877 cap = 0;
878 }
879
880 dev_dbg(di->dev, "%s Vbat: %d, Cap: %d per mille",
881 __func__, voltage, cap);
882
883 return cap;
884 }
885
886
887
888
889
890
891
892
893 static int ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di)
894 {
895 di->vbat = ab8500_fg_bat_voltage(di);
896 return ab8500_fg_volt_to_capacity(di, di->vbat);
897 }
898
899
900
901
902
903
904
905
906 static int ab8500_fg_battery_resistance(struct ab8500_fg *di)
907 {
908 int i, tbl_size;
909 const struct batres_vs_temp *tbl;
910 int resist = 0;
911
912 tbl = di->bm->bat_type[di->bm->batt_id].batres_tbl;
913 tbl_size = di->bm->bat_type[di->bm->batt_id].n_batres_tbl_elements;
914
915 for (i = 0; i < tbl_size; ++i) {
916 if (di->bat_temp / 10 > tbl[i].temp)
917 break;
918 }
919
920 if ((i > 0) && (i < tbl_size)) {
921 resist = interpolate(di->bat_temp / 10,
922 tbl[i].temp,
923 tbl[i].resist,
924 tbl[i-1].temp,
925 tbl[i-1].resist);
926 } else if (i == 0) {
927 resist = tbl[0].resist;
928 } else {
929 resist = tbl[tbl_size - 1].resist;
930 }
931
932 dev_dbg(di->dev, "%s Temp: %d battery internal resistance: %d"
933 " fg resistance %d, total: %d (mOhm)\n",
934 __func__, di->bat_temp, resist, di->bm->fg_res / 10,
935 (di->bm->fg_res / 10) + resist);
936
937
938 resist += di->bm->fg_res / 10;
939
940 return resist;
941 }
942
943
944
945
946
947
948
949
950 static int ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di)
951 {
952 int vbat_comp, res;
953 int i = 0;
954 int vbat = 0;
955
956 ab8500_fg_inst_curr_start(di);
957
958 do {
959 vbat += ab8500_fg_bat_voltage(di);
960 i++;
961 usleep_range(5000, 6000);
962 } while (!ab8500_fg_inst_curr_done(di));
963
964 ab8500_fg_inst_curr_finalize(di, &di->inst_curr);
965
966 di->vbat = vbat / i;
967 res = ab8500_fg_battery_resistance(di);
968
969
970 vbat_comp = di->vbat - (di->inst_curr * res) / 1000;
971
972 dev_dbg(di->dev, "%s Measured Vbat: %dmV,Compensated Vbat %dmV, "
973 "R: %dmOhm, Current: %dmA Vbat Samples: %d\n",
974 __func__, di->vbat, vbat_comp, res, di->inst_curr, i);
975
976 return ab8500_fg_volt_to_capacity(di, vbat_comp);
977 }
978
979
980
981
982
983
984
985
986 static int ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah)
987 {
988 return (cap_mah * 1000) / di->bat_cap.max_mah_design;
989 }
990
991
992
993
994
995
996
997
998 static int ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm)
999 {
1000 return cap_pm * di->bat_cap.max_mah_design / 1000;
1001 }
1002
1003
1004
1005
1006
1007
1008
1009
1010 static int ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah)
1011 {
1012 u64 div_res;
1013 u32 div_rem;
1014
1015 div_res = ((u64) cap_mah) * ((u64) di->vbat_nom);
1016 div_rem = do_div(div_res, 1000);
1017
1018
1019 if (div_rem >= 1000 / 2)
1020 div_res++;
1021
1022 return (int) div_res;
1023 }
1024
1025
1026
1027
1028
1029
1030
1031
1032 static int ab8500_fg_calc_cap_charging(struct ab8500_fg *di)
1033 {
1034 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1035 __func__,
1036 di->bat_cap.mah,
1037 di->accu_charge);
1038
1039
1040 if (di->bat_cap.mah + di->accu_charge > 0)
1041 di->bat_cap.mah += di->accu_charge;
1042 else
1043 di->bat_cap.mah = 0;
1044
1045
1046
1047
1048 if (di->bat_cap.mah >= di->bat_cap.max_mah_design ||
1049 di->flags.force_full) {
1050 di->bat_cap.mah = di->bat_cap.max_mah_design;
1051 }
1052
1053 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1054 di->bat_cap.permille =
1055 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1056
1057
1058 di->vbat = ab8500_fg_bat_voltage(di);
1059 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1060
1061 return di->bat_cap.mah;
1062 }
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073 static int ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di, bool comp)
1074 {
1075 int permille, mah;
1076
1077 if (comp)
1078 permille = ab8500_fg_load_comp_volt_to_capacity(di);
1079 else
1080 permille = ab8500_fg_uncomp_volt_to_capacity(di);
1081
1082 mah = ab8500_fg_convert_permille_to_mah(di, permille);
1083
1084 di->bat_cap.mah = ab8500_fg_add_cap_sample(di, mah);
1085 di->bat_cap.permille =
1086 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1087
1088 return di->bat_cap.mah;
1089 }
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099 static int ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di)
1100 {
1101 int permille_volt, permille;
1102
1103 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1104 __func__,
1105 di->bat_cap.mah,
1106 di->accu_charge);
1107
1108
1109 if (di->bat_cap.mah + di->accu_charge > 0)
1110 di->bat_cap.mah += di->accu_charge;
1111 else
1112 di->bat_cap.mah = 0;
1113
1114 if (di->bat_cap.mah >= di->bat_cap.max_mah_design)
1115 di->bat_cap.mah = di->bat_cap.max_mah_design;
1116
1117
1118
1119
1120
1121 permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1122 permille_volt = ab8500_fg_uncomp_volt_to_capacity(di);
1123
1124 if (permille < permille_volt) {
1125 di->bat_cap.permille = permille_volt;
1126 di->bat_cap.mah = ab8500_fg_convert_permille_to_mah(di,
1127 di->bat_cap.permille);
1128
1129 dev_dbg(di->dev, "%s voltage based: perm %d perm_volt %d\n",
1130 __func__,
1131 permille,
1132 permille_volt);
1133
1134 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1135 } else {
1136 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1137 di->bat_cap.permille =
1138 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1139 }
1140
1141 return di->bat_cap.mah;
1142 }
1143
1144
1145
1146
1147
1148
1149
1150 static int ab8500_fg_capacity_level(struct ab8500_fg *di)
1151 {
1152 int ret, percent;
1153
1154 percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1155
1156 if (percent <= di->bm->cap_levels->critical ||
1157 di->flags.low_bat)
1158 ret = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
1159 else if (percent <= di->bm->cap_levels->low)
1160 ret = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
1161 else if (percent <= di->bm->cap_levels->normal)
1162 ret = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
1163 else if (percent <= di->bm->cap_levels->high)
1164 ret = POWER_SUPPLY_CAPACITY_LEVEL_HIGH;
1165 else
1166 ret = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
1167
1168 return ret;
1169 }
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179 static int ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di)
1180 {
1181 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1182 int capacity = di->bat_cap.prev_percent;
1183
1184 if (!cs->enable)
1185 return capacity;
1186
1187
1188
1189
1190
1191 if (di->flags.fully_charged) {
1192 cs->cap_to_scale[0] = 100;
1193 cs->cap_to_scale[1] =
1194 max(capacity, di->bm->fg_params->maint_thres);
1195 dev_dbg(di->dev, "Scale cap with %d/%d\n",
1196 cs->cap_to_scale[0], cs->cap_to_scale[1]);
1197 }
1198
1199
1200 if ((cs->cap_to_scale[0] != cs->cap_to_scale[1])
1201 && (cs->cap_to_scale[1] > 0))
1202 capacity = min(100,
1203 DIV_ROUND_CLOSEST(di->bat_cap.prev_percent *
1204 cs->cap_to_scale[0],
1205 cs->cap_to_scale[1]));
1206
1207 if (di->flags.charging) {
1208 if (capacity < cs->disable_cap_level) {
1209 cs->disable_cap_level = capacity;
1210 dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n",
1211 cs->disable_cap_level);
1212 } else if (!di->flags.fully_charged) {
1213 if (di->bat_cap.prev_percent >=
1214 cs->disable_cap_level) {
1215 dev_dbg(di->dev, "Disabling scaled capacity\n");
1216 cs->enable = false;
1217 capacity = di->bat_cap.prev_percent;
1218 } else {
1219 dev_dbg(di->dev,
1220 "Waiting in cap to level %d%%\n",
1221 cs->disable_cap_level);
1222 capacity = cs->disable_cap_level;
1223 }
1224 }
1225 }
1226
1227 return capacity;
1228 }
1229
1230
1231
1232
1233
1234
1235
1236
1237 static void ab8500_fg_update_cap_scalers(struct ab8500_fg *di)
1238 {
1239 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1240
1241 if (!cs->enable)
1242 return;
1243 if (di->flags.charging) {
1244 di->bat_cap.cap_scale.disable_cap_level =
1245 di->bat_cap.cap_scale.scaled_cap;
1246 dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n",
1247 di->bat_cap.cap_scale.disable_cap_level);
1248 } else {
1249 if (cs->scaled_cap != 100) {
1250 cs->cap_to_scale[0] = cs->scaled_cap;
1251 cs->cap_to_scale[1] = di->bat_cap.prev_percent;
1252 } else {
1253 cs->cap_to_scale[0] = 100;
1254 cs->cap_to_scale[1] =
1255 max(di->bat_cap.prev_percent,
1256 di->bm->fg_params->maint_thres);
1257 }
1258
1259 dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n",
1260 cs->cap_to_scale[0], cs->cap_to_scale[1]);
1261 }
1262 }
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272 static void ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init)
1273 {
1274 bool changed = false;
1275 int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1276
1277 di->bat_cap.level = ab8500_fg_capacity_level(di);
1278
1279 if (di->bat_cap.level != di->bat_cap.prev_level) {
1280
1281
1282
1283
1284 if (!(!di->flags.charging && di->bat_cap.level >
1285 di->bat_cap.prev_level) || init) {
1286 dev_dbg(di->dev, "level changed from %d to %d\n",
1287 di->bat_cap.prev_level,
1288 di->bat_cap.level);
1289 di->bat_cap.prev_level = di->bat_cap.level;
1290 changed = true;
1291 } else {
1292 dev_dbg(di->dev, "level not allowed to go up "
1293 "since no charger is connected: %d to %d\n",
1294 di->bat_cap.prev_level,
1295 di->bat_cap.level);
1296 }
1297 }
1298
1299
1300
1301
1302
1303 if (di->flags.low_bat) {
1304 dev_dbg(di->dev, "Battery low, set capacity to 0\n");
1305 di->bat_cap.prev_percent = 0;
1306 di->bat_cap.permille = 0;
1307 percent = 0;
1308 di->bat_cap.prev_mah = 0;
1309 di->bat_cap.mah = 0;
1310 changed = true;
1311 } else if (di->flags.fully_charged) {
1312
1313
1314
1315
1316 if (di->flags.force_full) {
1317 di->bat_cap.prev_percent = percent;
1318 di->bat_cap.prev_mah = di->bat_cap.mah;
1319
1320 changed = true;
1321
1322 if (!di->bat_cap.cap_scale.enable &&
1323 di->bm->capacity_scaling) {
1324 di->bat_cap.cap_scale.enable = true;
1325 di->bat_cap.cap_scale.cap_to_scale[0] = 100;
1326 di->bat_cap.cap_scale.cap_to_scale[1] =
1327 di->bat_cap.prev_percent;
1328 di->bat_cap.cap_scale.disable_cap_level = 100;
1329 }
1330 } else if (di->bat_cap.prev_percent != percent) {
1331 dev_dbg(di->dev,
1332 "battery reported full "
1333 "but capacity dropping: %d\n",
1334 percent);
1335 di->bat_cap.prev_percent = percent;
1336 di->bat_cap.prev_mah = di->bat_cap.mah;
1337
1338 changed = true;
1339 }
1340 } else if (di->bat_cap.prev_percent != percent) {
1341 if (percent == 0) {
1342
1343
1344
1345
1346
1347 di->bat_cap.prev_percent = 1;
1348 percent = 1;
1349
1350 changed = true;
1351 } else if (!(!di->flags.charging &&
1352 percent > di->bat_cap.prev_percent) || init) {
1353
1354
1355
1356
1357 dev_dbg(di->dev,
1358 "capacity changed from %d to %d (%d)\n",
1359 di->bat_cap.prev_percent,
1360 percent,
1361 di->bat_cap.permille);
1362 di->bat_cap.prev_percent = percent;
1363 di->bat_cap.prev_mah = di->bat_cap.mah;
1364
1365 changed = true;
1366 } else {
1367 dev_dbg(di->dev, "capacity not allowed to go up since "
1368 "no charger is connected: %d to %d (%d)\n",
1369 di->bat_cap.prev_percent,
1370 percent,
1371 di->bat_cap.permille);
1372 }
1373 }
1374
1375 if (changed) {
1376 if (di->bm->capacity_scaling) {
1377 di->bat_cap.cap_scale.scaled_cap =
1378 ab8500_fg_calculate_scaled_capacity(di);
1379
1380 dev_info(di->dev, "capacity=%d (%d)\n",
1381 di->bat_cap.prev_percent,
1382 di->bat_cap.cap_scale.scaled_cap);
1383 }
1384 power_supply_changed(di->fg_psy);
1385 if (di->flags.fully_charged && di->flags.force_full) {
1386 dev_dbg(di->dev, "Battery full, notifying.\n");
1387 di->flags.force_full = false;
1388 sysfs_notify(&di->fg_kobject, NULL, "charge_full");
1389 }
1390 sysfs_notify(&di->fg_kobject, NULL, "charge_now");
1391 }
1392 }
1393
1394 static void ab8500_fg_charge_state_to(struct ab8500_fg *di,
1395 enum ab8500_fg_charge_state new_state)
1396 {
1397 dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n",
1398 di->charge_state,
1399 charge_state[di->charge_state],
1400 new_state,
1401 charge_state[new_state]);
1402
1403 di->charge_state = new_state;
1404 }
1405
1406 static void ab8500_fg_discharge_state_to(struct ab8500_fg *di,
1407 enum ab8500_fg_discharge_state new_state)
1408 {
1409 dev_dbg(di->dev, "Discharge state from %d [%s] to %d [%s]\n",
1410 di->discharge_state,
1411 discharge_state[di->discharge_state],
1412 new_state,
1413 discharge_state[new_state]);
1414
1415 di->discharge_state = new_state;
1416 }
1417
1418
1419
1420
1421
1422
1423
1424 static void ab8500_fg_algorithm_charging(struct ab8500_fg *di)
1425 {
1426
1427
1428
1429
1430 if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY)
1431 ab8500_fg_discharge_state_to(di,
1432 AB8500_FG_DISCHARGE_INIT_RECOVERY);
1433
1434 switch (di->charge_state) {
1435 case AB8500_FG_CHARGE_INIT:
1436 di->fg_samples = SEC_TO_SAMPLE(
1437 di->bm->fg_params->accu_charging);
1438
1439 ab8500_fg_coulomb_counter(di, true);
1440 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_READOUT);
1441
1442 break;
1443
1444 case AB8500_FG_CHARGE_READOUT:
1445
1446
1447
1448 mutex_lock(&di->cc_lock);
1449 if (!di->flags.conv_done && !di->flags.force_full) {
1450
1451 mutex_unlock(&di->cc_lock);
1452 dev_dbg(di->dev, "%s CC conv not done\n",
1453 __func__);
1454
1455 break;
1456 }
1457 di->flags.conv_done = false;
1458 mutex_unlock(&di->cc_lock);
1459
1460 ab8500_fg_calc_cap_charging(di);
1461
1462 break;
1463
1464 default:
1465 break;
1466 }
1467
1468
1469 ab8500_fg_check_capacity_limits(di, false);
1470 }
1471
1472 static void force_capacity(struct ab8500_fg *di)
1473 {
1474 int cap;
1475
1476 ab8500_fg_clear_cap_samples(di);
1477 cap = di->bat_cap.user_mah;
1478 if (cap > di->bat_cap.max_mah_design) {
1479 dev_dbg(di->dev, "Remaining cap %d can't be bigger than total"
1480 " %d\n", cap, di->bat_cap.max_mah_design);
1481 cap = di->bat_cap.max_mah_design;
1482 }
1483 ab8500_fg_fill_cap_sample(di, di->bat_cap.user_mah);
1484 di->bat_cap.permille = ab8500_fg_convert_mah_to_permille(di, cap);
1485 di->bat_cap.mah = cap;
1486 ab8500_fg_check_capacity_limits(di, true);
1487 }
1488
1489 static bool check_sysfs_capacity(struct ab8500_fg *di)
1490 {
1491 int cap, lower, upper;
1492 int cap_permille;
1493
1494 cap = di->bat_cap.user_mah;
1495
1496 cap_permille = ab8500_fg_convert_mah_to_permille(di,
1497 di->bat_cap.user_mah);
1498
1499 lower = di->bat_cap.permille - di->bm->fg_params->user_cap_limit * 10;
1500 upper = di->bat_cap.permille + di->bm->fg_params->user_cap_limit * 10;
1501
1502 if (lower < 0)
1503 lower = 0;
1504
1505 if (upper > 1000)
1506 upper = 1000;
1507
1508 dev_dbg(di->dev, "Capacity limits:"
1509 " (Lower: %d User: %d Upper: %d) [user: %d, was: %d]\n",
1510 lower, cap_permille, upper, cap, di->bat_cap.mah);
1511
1512
1513 if (cap_permille > lower && cap_permille < upper) {
1514 dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap);
1515 force_capacity(di);
1516 return true;
1517 }
1518 dev_dbg(di->dev, "Capacity from user out of limits, ignoring");
1519 return false;
1520 }
1521
1522
1523
1524
1525
1526
1527
1528 static void ab8500_fg_algorithm_discharging(struct ab8500_fg *di)
1529 {
1530 int sleep_time;
1531
1532
1533 if (di->charge_state != AB8500_FG_CHARGE_INIT)
1534 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
1535
1536 switch (di->discharge_state) {
1537 case AB8500_FG_DISCHARGE_INIT:
1538
1539 di->init_cnt = 0;
1540 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
1541 ab8500_fg_coulomb_counter(di, true);
1542 ab8500_fg_discharge_state_to(di,
1543 AB8500_FG_DISCHARGE_INITMEASURING);
1544
1545
1546 case AB8500_FG_DISCHARGE_INITMEASURING:
1547
1548
1549
1550
1551
1552
1553 sleep_time = di->bm->fg_params->init_timer;
1554
1555
1556 if (di->init_cnt > di->bm->fg_params->init_discard_time) {
1557 ab8500_fg_calc_cap_discharge_voltage(di, true);
1558
1559 ab8500_fg_check_capacity_limits(di, true);
1560 }
1561
1562 di->init_cnt += sleep_time;
1563 if (di->init_cnt > di->bm->fg_params->init_total_time)
1564 ab8500_fg_discharge_state_to(di,
1565 AB8500_FG_DISCHARGE_READOUT_INIT);
1566
1567 break;
1568
1569 case AB8500_FG_DISCHARGE_INIT_RECOVERY:
1570 di->recovery_cnt = 0;
1571 di->recovery_needed = true;
1572 ab8500_fg_discharge_state_to(di,
1573 AB8500_FG_DISCHARGE_RECOVERY);
1574
1575
1576
1577 case AB8500_FG_DISCHARGE_RECOVERY:
1578 sleep_time = di->bm->fg_params->recovery_sleep_timer;
1579
1580
1581
1582
1583
1584
1585
1586 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1587
1588 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1589 if (di->recovery_cnt >
1590 di->bm->fg_params->recovery_total_time) {
1591 di->fg_samples = SEC_TO_SAMPLE(
1592 di->bm->fg_params->accu_high_curr);
1593 ab8500_fg_coulomb_counter(di, true);
1594 ab8500_fg_discharge_state_to(di,
1595 AB8500_FG_DISCHARGE_READOUT);
1596 di->recovery_needed = false;
1597 } else {
1598 queue_delayed_work(di->fg_wq,
1599 &di->fg_periodic_work,
1600 sleep_time * HZ);
1601 }
1602 di->recovery_cnt += sleep_time;
1603 } else {
1604 di->fg_samples = SEC_TO_SAMPLE(
1605 di->bm->fg_params->accu_high_curr);
1606 ab8500_fg_coulomb_counter(di, true);
1607 ab8500_fg_discharge_state_to(di,
1608 AB8500_FG_DISCHARGE_READOUT);
1609 }
1610 break;
1611
1612 case AB8500_FG_DISCHARGE_READOUT_INIT:
1613 di->fg_samples = SEC_TO_SAMPLE(
1614 di->bm->fg_params->accu_high_curr);
1615 ab8500_fg_coulomb_counter(di, true);
1616 ab8500_fg_discharge_state_to(di,
1617 AB8500_FG_DISCHARGE_READOUT);
1618 break;
1619
1620 case AB8500_FG_DISCHARGE_READOUT:
1621 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1622
1623 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1624
1625 if (di->high_curr_mode) {
1626 di->high_curr_mode = false;
1627 di->high_curr_cnt = 0;
1628 }
1629
1630 if (di->recovery_needed) {
1631 ab8500_fg_discharge_state_to(di,
1632 AB8500_FG_DISCHARGE_INIT_RECOVERY);
1633
1634 queue_delayed_work(di->fg_wq,
1635 &di->fg_periodic_work, 0);
1636
1637 break;
1638 }
1639
1640 ab8500_fg_calc_cap_discharge_voltage(di, true);
1641 } else {
1642 mutex_lock(&di->cc_lock);
1643 if (!di->flags.conv_done) {
1644
1645 mutex_unlock(&di->cc_lock);
1646 dev_dbg(di->dev, "%s CC conv not done\n",
1647 __func__);
1648
1649 break;
1650 }
1651 di->flags.conv_done = false;
1652 mutex_unlock(&di->cc_lock);
1653
1654
1655 if (!di->high_curr_mode) {
1656 di->high_curr_mode = true;
1657 di->high_curr_cnt = 0;
1658 }
1659
1660 di->high_curr_cnt +=
1661 di->bm->fg_params->accu_high_curr;
1662 if (di->high_curr_cnt >
1663 di->bm->fg_params->high_curr_time)
1664 di->recovery_needed = true;
1665
1666 ab8500_fg_calc_cap_discharge_fg(di);
1667 }
1668
1669 ab8500_fg_check_capacity_limits(di, false);
1670
1671 break;
1672
1673 case AB8500_FG_DISCHARGE_WAKEUP:
1674 ab8500_fg_calc_cap_discharge_voltage(di, true);
1675
1676 di->fg_samples = SEC_TO_SAMPLE(
1677 di->bm->fg_params->accu_high_curr);
1678 ab8500_fg_coulomb_counter(di, true);
1679 ab8500_fg_discharge_state_to(di,
1680 AB8500_FG_DISCHARGE_READOUT);
1681
1682 ab8500_fg_check_capacity_limits(di, false);
1683
1684 break;
1685
1686 default:
1687 break;
1688 }
1689 }
1690
1691
1692
1693
1694
1695
1696 static void ab8500_fg_algorithm_calibrate(struct ab8500_fg *di)
1697 {
1698 int ret;
1699
1700 switch (di->calib_state) {
1701 case AB8500_FG_CALIB_INIT:
1702 dev_dbg(di->dev, "Calibration ongoing...\n");
1703
1704 ret = abx500_mask_and_set_register_interruptible(di->dev,
1705 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1706 CC_INT_CAL_N_AVG_MASK, CC_INT_CAL_SAMPLES_8);
1707 if (ret < 0)
1708 goto err;
1709
1710 ret = abx500_mask_and_set_register_interruptible(di->dev,
1711 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1712 CC_INTAVGOFFSET_ENA, CC_INTAVGOFFSET_ENA);
1713 if (ret < 0)
1714 goto err;
1715 di->calib_state = AB8500_FG_CALIB_WAIT;
1716 break;
1717 case AB8500_FG_CALIB_END:
1718 ret = abx500_mask_and_set_register_interruptible(di->dev,
1719 AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
1720 CC_MUXOFFSET, CC_MUXOFFSET);
1721 if (ret < 0)
1722 goto err;
1723 di->flags.calibrate = false;
1724 dev_dbg(di->dev, "Calibration done...\n");
1725 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1726 break;
1727 case AB8500_FG_CALIB_WAIT:
1728 dev_dbg(di->dev, "Calibration WFI\n");
1729 default:
1730 break;
1731 }
1732 return;
1733 err:
1734
1735 dev_err(di->dev, "failed to calibrate the CC\n");
1736 di->flags.calibrate = false;
1737 di->calib_state = AB8500_FG_CALIB_INIT;
1738 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1739 }
1740
1741
1742
1743
1744
1745
1746
1747 static void ab8500_fg_algorithm(struct ab8500_fg *di)
1748 {
1749 if (di->flags.calibrate)
1750 ab8500_fg_algorithm_calibrate(di);
1751 else {
1752 if (di->flags.charging)
1753 ab8500_fg_algorithm_charging(di);
1754 else
1755 ab8500_fg_algorithm_discharging(di);
1756 }
1757
1758 dev_dbg(di->dev, "[FG_DATA] %d %d %d %d %d %d %d %d %d %d "
1759 "%d %d %d %d %d %d %d\n",
1760 di->bat_cap.max_mah_design,
1761 di->bat_cap.max_mah,
1762 di->bat_cap.mah,
1763 di->bat_cap.permille,
1764 di->bat_cap.level,
1765 di->bat_cap.prev_mah,
1766 di->bat_cap.prev_percent,
1767 di->bat_cap.prev_level,
1768 di->vbat,
1769 di->inst_curr,
1770 di->avg_curr,
1771 di->accu_charge,
1772 di->flags.charging,
1773 di->charge_state,
1774 di->discharge_state,
1775 di->high_curr_mode,
1776 di->recovery_needed);
1777 }
1778
1779
1780
1781
1782
1783
1784
1785 static void ab8500_fg_periodic_work(struct work_struct *work)
1786 {
1787 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1788 fg_periodic_work.work);
1789
1790 if (di->init_capacity) {
1791
1792 ab8500_fg_calc_cap_discharge_voltage(di, true);
1793 ab8500_fg_check_capacity_limits(di, true);
1794 di->init_capacity = false;
1795
1796 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1797 } else if (di->flags.user_cap) {
1798 if (check_sysfs_capacity(di)) {
1799 ab8500_fg_check_capacity_limits(di, true);
1800 if (di->flags.charging)
1801 ab8500_fg_charge_state_to(di,
1802 AB8500_FG_CHARGE_INIT);
1803 else
1804 ab8500_fg_discharge_state_to(di,
1805 AB8500_FG_DISCHARGE_READOUT_INIT);
1806 }
1807 di->flags.user_cap = false;
1808 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1809 } else
1810 ab8500_fg_algorithm(di);
1811
1812 }
1813
1814
1815
1816
1817
1818
1819
1820 static void ab8500_fg_check_hw_failure_work(struct work_struct *work)
1821 {
1822 int ret;
1823 u8 reg_value;
1824
1825 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1826 fg_check_hw_failure_work.work);
1827
1828
1829
1830
1831
1832 ret = abx500_get_register_interruptible(di->dev,
1833 AB8500_CHARGER, AB8500_CH_STAT_REG,
1834 ®_value);
1835 if (ret < 0) {
1836 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1837 return;
1838 }
1839 if ((reg_value & BATT_OVV) == BATT_OVV) {
1840 if (!di->flags.bat_ovv) {
1841 dev_dbg(di->dev, "Battery OVV\n");
1842 di->flags.bat_ovv = true;
1843 power_supply_changed(di->fg_psy);
1844 }
1845
1846 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work,
1847 HZ);
1848 } else {
1849 dev_dbg(di->dev, "Battery recovered from OVV\n");
1850 di->flags.bat_ovv = false;
1851 power_supply_changed(di->fg_psy);
1852 }
1853 }
1854
1855
1856
1857
1858
1859
1860
1861 static void ab8500_fg_low_bat_work(struct work_struct *work)
1862 {
1863 int vbat;
1864
1865 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1866 fg_low_bat_work.work);
1867
1868 vbat = ab8500_fg_bat_voltage(di);
1869
1870
1871 if (vbat < di->bm->fg_params->lowbat_threshold) {
1872
1873 if (di->low_bat_cnt < 1) {
1874 di->flags.low_bat = true;
1875 dev_warn(di->dev, "Shut down pending...\n");
1876 } else {
1877
1878
1879
1880
1881
1882 di->low_bat_cnt--;
1883 dev_warn(di->dev, "Battery voltage still LOW\n");
1884 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
1885 round_jiffies(LOW_BAT_CHECK_INTERVAL));
1886 }
1887 } else {
1888 di->flags.low_bat_delay = false;
1889 di->low_bat_cnt = 10;
1890 dev_warn(di->dev, "Battery voltage OK again\n");
1891 }
1892
1893
1894 ab8500_fg_check_capacity_limits(di, false);
1895 }
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907 static int ab8500_fg_battok_calc(struct ab8500_fg *di, int target)
1908 {
1909 if (target > BATT_OK_MIN +
1910 (BATT_OK_INCREMENT * BATT_OK_MAX_NR_INCREMENTS))
1911 return BATT_OK_MAX_NR_INCREMENTS;
1912 if (target < BATT_OK_MIN)
1913 return 0;
1914 return (target - BATT_OK_MIN) / BATT_OK_INCREMENT;
1915 }
1916
1917
1918
1919
1920
1921
1922
1923 static int ab8500_fg_battok_init_hw_register(struct ab8500_fg *di)
1924 {
1925 int selected;
1926 int sel0;
1927 int sel1;
1928 int cbp_sel0;
1929 int cbp_sel1;
1930 int ret;
1931 int new_val;
1932
1933 sel0 = di->bm->fg_params->battok_falling_th_sel0;
1934 sel1 = di->bm->fg_params->battok_raising_th_sel1;
1935
1936 cbp_sel0 = ab8500_fg_battok_calc(di, sel0);
1937 cbp_sel1 = ab8500_fg_battok_calc(di, sel1);
1938
1939 selected = BATT_OK_MIN + cbp_sel0 * BATT_OK_INCREMENT;
1940
1941 if (selected != sel0)
1942 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1943 sel0, selected, cbp_sel0);
1944
1945 selected = BATT_OK_MIN + cbp_sel1 * BATT_OK_INCREMENT;
1946
1947 if (selected != sel1)
1948 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1949 sel1, selected, cbp_sel1);
1950
1951 new_val = cbp_sel0 | (cbp_sel1 << 4);
1952
1953 dev_dbg(di->dev, "using: %x %d %d\n", new_val, cbp_sel0, cbp_sel1);
1954 ret = abx500_set_register_interruptible(di->dev, AB8500_SYS_CTRL2_BLOCK,
1955 AB8500_BATT_OK_REG, new_val);
1956 return ret;
1957 }
1958
1959
1960
1961
1962
1963
1964
1965 static void ab8500_fg_instant_work(struct work_struct *work)
1966 {
1967 struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work);
1968
1969 ab8500_fg_algorithm(di);
1970 }
1971
1972
1973
1974
1975
1976
1977
1978
1979 static irqreturn_t ab8500_fg_cc_data_end_handler(int irq, void *_di)
1980 {
1981 struct ab8500_fg *di = _di;
1982 if (!di->nbr_cceoc_irq_cnt) {
1983 di->nbr_cceoc_irq_cnt++;
1984 complete(&di->ab8500_fg_started);
1985 } else {
1986 di->nbr_cceoc_irq_cnt = 0;
1987 complete(&di->ab8500_fg_complete);
1988 }
1989 return IRQ_HANDLED;
1990 }
1991
1992
1993
1994
1995
1996
1997
1998
1999 static irqreturn_t ab8500_fg_cc_int_calib_handler(int irq, void *_di)
2000 {
2001 struct ab8500_fg *di = _di;
2002 di->calib_state = AB8500_FG_CALIB_END;
2003 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2004 return IRQ_HANDLED;
2005 }
2006
2007
2008
2009
2010
2011
2012
2013
2014 static irqreturn_t ab8500_fg_cc_convend_handler(int irq, void *_di)
2015 {
2016 struct ab8500_fg *di = _di;
2017
2018 queue_work(di->fg_wq, &di->fg_acc_cur_work);
2019
2020 return IRQ_HANDLED;
2021 }
2022
2023
2024
2025
2026
2027
2028
2029
2030 static irqreturn_t ab8500_fg_batt_ovv_handler(int irq, void *_di)
2031 {
2032 struct ab8500_fg *di = _di;
2033
2034 dev_dbg(di->dev, "Battery OVV\n");
2035
2036
2037 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0);
2038
2039 return IRQ_HANDLED;
2040 }
2041
2042
2043
2044
2045
2046
2047
2048
2049 static irqreturn_t ab8500_fg_lowbatf_handler(int irq, void *_di)
2050 {
2051 struct ab8500_fg *di = _di;
2052
2053
2054 if (!di->flags.low_bat_delay) {
2055 dev_warn(di->dev, "Battery voltage is below LOW threshold\n");
2056 di->flags.low_bat_delay = true;
2057
2058
2059
2060
2061 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
2062 round_jiffies(LOW_BAT_CHECK_INTERVAL));
2063 }
2064 return IRQ_HANDLED;
2065 }
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085 static int ab8500_fg_get_property(struct power_supply *psy,
2086 enum power_supply_property psp,
2087 union power_supply_propval *val)
2088 {
2089 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2090
2091
2092
2093
2094
2095
2096
2097
2098 switch (psp) {
2099 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2100 if (di->flags.bat_ovv)
2101 val->intval = BATT_OVV_VALUE * 1000;
2102 else
2103 val->intval = di->vbat * 1000;
2104 break;
2105 case POWER_SUPPLY_PROP_CURRENT_NOW:
2106 val->intval = di->inst_curr * 1000;
2107 break;
2108 case POWER_SUPPLY_PROP_CURRENT_AVG:
2109 val->intval = di->avg_curr * 1000;
2110 break;
2111 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
2112 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2113 di->bat_cap.max_mah_design);
2114 break;
2115 case POWER_SUPPLY_PROP_ENERGY_FULL:
2116 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2117 di->bat_cap.max_mah);
2118 break;
2119 case POWER_SUPPLY_PROP_ENERGY_NOW:
2120 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2121 di->flags.batt_id_received)
2122 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2123 di->bat_cap.max_mah);
2124 else
2125 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2126 di->bat_cap.prev_mah);
2127 break;
2128 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
2129 val->intval = di->bat_cap.max_mah_design;
2130 break;
2131 case POWER_SUPPLY_PROP_CHARGE_FULL:
2132 val->intval = di->bat_cap.max_mah;
2133 break;
2134 case POWER_SUPPLY_PROP_CHARGE_NOW:
2135 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2136 di->flags.batt_id_received)
2137 val->intval = di->bat_cap.max_mah;
2138 else
2139 val->intval = di->bat_cap.prev_mah;
2140 break;
2141 case POWER_SUPPLY_PROP_CAPACITY:
2142 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2143 di->flags.batt_id_received)
2144 val->intval = 100;
2145 else
2146 val->intval = di->bat_cap.prev_percent;
2147 break;
2148 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
2149 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2150 di->flags.batt_id_received)
2151 val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
2152 else
2153 val->intval = di->bat_cap.prev_level;
2154 break;
2155 default:
2156 return -EINVAL;
2157 }
2158 return 0;
2159 }
2160
2161 static int ab8500_fg_get_ext_psy_data(struct device *dev, void *data)
2162 {
2163 struct power_supply *psy;
2164 struct power_supply *ext = dev_get_drvdata(dev);
2165 const char **supplicants = (const char **)ext->supplied_to;
2166 struct ab8500_fg *di;
2167 union power_supply_propval ret;
2168 int j;
2169
2170 psy = (struct power_supply *)data;
2171 di = power_supply_get_drvdata(psy);
2172
2173
2174
2175
2176
2177 j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
2178 if (j < 0)
2179 return 0;
2180
2181
2182 for (j = 0; j < ext->desc->num_properties; j++) {
2183 enum power_supply_property prop;
2184 prop = ext->desc->properties[j];
2185
2186 if (power_supply_get_property(ext, prop, &ret))
2187 continue;
2188
2189 switch (prop) {
2190 case POWER_SUPPLY_PROP_STATUS:
2191 switch (ext->desc->type) {
2192 case POWER_SUPPLY_TYPE_BATTERY:
2193 switch (ret.intval) {
2194 case POWER_SUPPLY_STATUS_UNKNOWN:
2195 case POWER_SUPPLY_STATUS_DISCHARGING:
2196 case POWER_SUPPLY_STATUS_NOT_CHARGING:
2197 if (!di->flags.charging)
2198 break;
2199 di->flags.charging = false;
2200 di->flags.fully_charged = false;
2201 if (di->bm->capacity_scaling)
2202 ab8500_fg_update_cap_scalers(di);
2203 queue_work(di->fg_wq, &di->fg_work);
2204 break;
2205 case POWER_SUPPLY_STATUS_FULL:
2206 if (di->flags.fully_charged)
2207 break;
2208 di->flags.fully_charged = true;
2209 di->flags.force_full = true;
2210
2211 di->bat_cap.max_mah = di->bat_cap.mah;
2212 queue_work(di->fg_wq, &di->fg_work);
2213 break;
2214 case POWER_SUPPLY_STATUS_CHARGING:
2215 if (di->flags.charging &&
2216 !di->flags.fully_charged)
2217 break;
2218 di->flags.charging = true;
2219 di->flags.fully_charged = false;
2220 if (di->bm->capacity_scaling)
2221 ab8500_fg_update_cap_scalers(di);
2222 queue_work(di->fg_wq, &di->fg_work);
2223 break;
2224 };
2225 default:
2226 break;
2227 };
2228 break;
2229 case POWER_SUPPLY_PROP_TECHNOLOGY:
2230 switch (ext->desc->type) {
2231 case POWER_SUPPLY_TYPE_BATTERY:
2232 if (!di->flags.batt_id_received &&
2233 di->bm->batt_id != BATTERY_UNKNOWN) {
2234 const struct abx500_battery_type *b;
2235
2236 b = &(di->bm->bat_type[di->bm->batt_id]);
2237
2238 di->flags.batt_id_received = true;
2239
2240 di->bat_cap.max_mah_design =
2241 MILLI_TO_MICRO *
2242 b->charge_full_design;
2243
2244 di->bat_cap.max_mah =
2245 di->bat_cap.max_mah_design;
2246
2247 di->vbat_nom = b->nominal_voltage;
2248 }
2249
2250 if (ret.intval)
2251 di->flags.batt_unknown = false;
2252 else
2253 di->flags.batt_unknown = true;
2254 break;
2255 default:
2256 break;
2257 }
2258 break;
2259 case POWER_SUPPLY_PROP_TEMP:
2260 switch (ext->desc->type) {
2261 case POWER_SUPPLY_TYPE_BATTERY:
2262 if (di->flags.batt_id_received)
2263 di->bat_temp = ret.intval;
2264 break;
2265 default:
2266 break;
2267 }
2268 break;
2269 default:
2270 break;
2271 }
2272 }
2273 return 0;
2274 }
2275
2276
2277
2278
2279
2280
2281
2282 static int ab8500_fg_init_hw_registers(struct ab8500_fg *di)
2283 {
2284 int ret;
2285
2286
2287 ret = abx500_mask_and_set_register_interruptible(di->dev,
2288 AB8500_CHARGER,
2289 AB8500_BATT_OVV,
2290 BATT_OVV_TH_4P75,
2291 BATT_OVV_TH_4P75);
2292 if (ret) {
2293 dev_err(di->dev, "failed to set BATT_OVV\n");
2294 goto out;
2295 }
2296
2297
2298 ret = abx500_mask_and_set_register_interruptible(di->dev,
2299 AB8500_CHARGER,
2300 AB8500_BATT_OVV,
2301 BATT_OVV_ENA,
2302 BATT_OVV_ENA);
2303 if (ret) {
2304 dev_err(di->dev, "failed to enable BATT_OVV\n");
2305 goto out;
2306 }
2307
2308
2309 ret = abx500_set_register_interruptible(di->dev,
2310 AB8500_SYS_CTRL2_BLOCK,
2311 AB8500_LOW_BAT_REG,
2312 ab8500_volt_to_regval(
2313 di->bm->fg_params->lowbat_threshold) << 1 |
2314 LOW_BAT_ENABLE);
2315 if (ret) {
2316 dev_err(di->dev, "%s write failed\n", __func__);
2317 goto out;
2318 }
2319
2320
2321 ret = ab8500_fg_battok_init_hw_register(di);
2322 if (ret) {
2323 dev_err(di->dev, "BattOk init write failed.\n");
2324 goto out;
2325 }
2326
2327 if (is_ab8505(di->parent)) {
2328 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2329 AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time);
2330
2331 if (ret) {
2332 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__);
2333 goto out;
2334 };
2335
2336 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2337 AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time);
2338
2339 if (ret) {
2340 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__);
2341 goto out;
2342 };
2343
2344 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2345 AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart);
2346
2347 if (ret) {
2348 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__);
2349 goto out;
2350 };
2351
2352 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2353 AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time);
2354
2355 if (ret) {
2356 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__);
2357 goto out;
2358 };
2359
2360 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2361 AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable);
2362
2363 if (ret) {
2364 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__);
2365 goto out;
2366 };
2367 }
2368 out:
2369 return ret;
2370 }
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381 static void ab8500_fg_external_power_changed(struct power_supply *psy)
2382 {
2383 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2384
2385 class_for_each_device(power_supply_class, NULL,
2386 di->fg_psy, ab8500_fg_get_ext_psy_data);
2387 }
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397 static void ab8500_fg_reinit_work(struct work_struct *work)
2398 {
2399 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
2400 fg_reinit_work.work);
2401
2402 if (di->flags.calibrate == false) {
2403 dev_dbg(di->dev, "Resetting FG state machine to init.\n");
2404 ab8500_fg_clear_cap_samples(di);
2405 ab8500_fg_calc_cap_discharge_voltage(di, true);
2406 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
2407 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
2408 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2409
2410 } else {
2411 dev_err(di->dev, "Residual offset calibration ongoing "
2412 "retrying..\n");
2413
2414 queue_delayed_work(di->fg_wq, &di->fg_reinit_work,
2415 round_jiffies(1));
2416 }
2417 }
2418
2419
2420
2421 struct ab8500_fg_sysfs_entry {
2422 struct attribute attr;
2423 ssize_t (*show)(struct ab8500_fg *, char *);
2424 ssize_t (*store)(struct ab8500_fg *, const char *, size_t);
2425 };
2426
2427 static ssize_t charge_full_show(struct ab8500_fg *di, char *buf)
2428 {
2429 return sprintf(buf, "%d\n", di->bat_cap.max_mah);
2430 }
2431
2432 static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf,
2433 size_t count)
2434 {
2435 unsigned long charge_full;
2436 int ret;
2437
2438 ret = kstrtoul(buf, 10, &charge_full);
2439 if (ret)
2440 return ret;
2441
2442 di->bat_cap.max_mah = (int) charge_full;
2443 return count;
2444 }
2445
2446 static ssize_t charge_now_show(struct ab8500_fg *di, char *buf)
2447 {
2448 return sprintf(buf, "%d\n", di->bat_cap.prev_mah);
2449 }
2450
2451 static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf,
2452 size_t count)
2453 {
2454 unsigned long charge_now;
2455 int ret;
2456
2457 ret = kstrtoul(buf, 10, &charge_now);
2458 if (ret)
2459 return ret;
2460
2461 di->bat_cap.user_mah = (int) charge_now;
2462 di->flags.user_cap = true;
2463 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2464 return count;
2465 }
2466
2467 static struct ab8500_fg_sysfs_entry charge_full_attr =
2468 __ATTR(charge_full, 0644, charge_full_show, charge_full_store);
2469
2470 static struct ab8500_fg_sysfs_entry charge_now_attr =
2471 __ATTR(charge_now, 0644, charge_now_show, charge_now_store);
2472
2473 static ssize_t
2474 ab8500_fg_show(struct kobject *kobj, struct attribute *attr, char *buf)
2475 {
2476 struct ab8500_fg_sysfs_entry *entry;
2477 struct ab8500_fg *di;
2478
2479 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
2480 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2481
2482 if (!entry->show)
2483 return -EIO;
2484
2485 return entry->show(di, buf);
2486 }
2487 static ssize_t
2488 ab8500_fg_store(struct kobject *kobj, struct attribute *attr, const char *buf,
2489 size_t count)
2490 {
2491 struct ab8500_fg_sysfs_entry *entry;
2492 struct ab8500_fg *di;
2493
2494 entry = container_of(attr, struct ab8500_fg_sysfs_entry, attr);
2495 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2496
2497 if (!entry->store)
2498 return -EIO;
2499
2500 return entry->store(di, buf, count);
2501 }
2502
2503 static const struct sysfs_ops ab8500_fg_sysfs_ops = {
2504 .show = ab8500_fg_show,
2505 .store = ab8500_fg_store,
2506 };
2507
2508 static struct attribute *ab8500_fg_attrs[] = {
2509 &charge_full_attr.attr,
2510 &charge_now_attr.attr,
2511 NULL,
2512 };
2513
2514 static struct kobj_type ab8500_fg_ktype = {
2515 .sysfs_ops = &ab8500_fg_sysfs_ops,
2516 .default_attrs = ab8500_fg_attrs,
2517 };
2518
2519
2520
2521
2522
2523
2524
2525 static void ab8500_fg_sysfs_exit(struct ab8500_fg *di)
2526 {
2527 kobject_del(&di->fg_kobject);
2528 }
2529
2530
2531
2532
2533
2534
2535
2536
2537 static int ab8500_fg_sysfs_init(struct ab8500_fg *di)
2538 {
2539 int ret = 0;
2540
2541 ret = kobject_init_and_add(&di->fg_kobject,
2542 &ab8500_fg_ktype,
2543 NULL, "battery");
2544 if (ret < 0)
2545 dev_err(di->dev, "failed to create sysfs entry\n");
2546
2547 return ret;
2548 }
2549
2550 static ssize_t ab8505_powercut_flagtime_read(struct device *dev,
2551 struct device_attribute *attr,
2552 char *buf)
2553 {
2554 int ret;
2555 u8 reg_value;
2556 struct power_supply *psy = dev_get_drvdata(dev);
2557 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2558
2559 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2560 AB8505_RTC_PCUT_FLAG_TIME_REG, ®_value);
2561
2562 if (ret < 0) {
2563 dev_err(dev, "Failed to read AB8505_RTC_PCUT_FLAG_TIME_REG\n");
2564 goto fail;
2565 }
2566
2567 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2568
2569 fail:
2570 return ret;
2571 }
2572
2573 static ssize_t ab8505_powercut_flagtime_write(struct device *dev,
2574 struct device_attribute *attr,
2575 const char *buf, size_t count)
2576 {
2577 int ret;
2578 int reg_value;
2579 struct power_supply *psy = dev_get_drvdata(dev);
2580 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2581
2582 if (kstrtoint(buf, 10, ®_value))
2583 goto fail;
2584
2585 if (reg_value > 0x7F) {
2586 dev_err(dev, "Incorrect parameter, echo 0 (1.98s) - 127 (15.625ms) for flagtime\n");
2587 goto fail;
2588 }
2589
2590 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2591 AB8505_RTC_PCUT_FLAG_TIME_REG, (u8)reg_value);
2592
2593 if (ret < 0)
2594 dev_err(dev, "Failed to set AB8505_RTC_PCUT_FLAG_TIME_REG\n");
2595
2596 fail:
2597 return count;
2598 }
2599
2600 static ssize_t ab8505_powercut_maxtime_read(struct device *dev,
2601 struct device_attribute *attr,
2602 char *buf)
2603 {
2604 int ret;
2605 u8 reg_value;
2606 struct power_supply *psy = dev_get_drvdata(dev);
2607 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2608
2609 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2610 AB8505_RTC_PCUT_MAX_TIME_REG, ®_value);
2611
2612 if (ret < 0) {
2613 dev_err(dev, "Failed to read AB8505_RTC_PCUT_MAX_TIME_REG\n");
2614 goto fail;
2615 }
2616
2617 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2618
2619 fail:
2620 return ret;
2621
2622 }
2623
2624 static ssize_t ab8505_powercut_maxtime_write(struct device *dev,
2625 struct device_attribute *attr,
2626 const char *buf, size_t count)
2627 {
2628 int ret;
2629 int reg_value;
2630 struct power_supply *psy = dev_get_drvdata(dev);
2631 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2632
2633 if (kstrtoint(buf, 10, ®_value))
2634 goto fail;
2635
2636 if (reg_value > 0x7F) {
2637 dev_err(dev, "Incorrect parameter, echo 0 (0.0s) - 127 (1.98s) for maxtime\n");
2638 goto fail;
2639 }
2640
2641 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2642 AB8505_RTC_PCUT_MAX_TIME_REG, (u8)reg_value);
2643
2644 if (ret < 0)
2645 dev_err(dev, "Failed to set AB8505_RTC_PCUT_MAX_TIME_REG\n");
2646
2647 fail:
2648 return count;
2649 }
2650
2651 static ssize_t ab8505_powercut_restart_read(struct device *dev,
2652 struct device_attribute *attr,
2653 char *buf)
2654 {
2655 int ret;
2656 u8 reg_value;
2657 struct power_supply *psy = dev_get_drvdata(dev);
2658 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2659
2660 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2661 AB8505_RTC_PCUT_RESTART_REG, ®_value);
2662
2663 if (ret < 0) {
2664 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
2665 goto fail;
2666 }
2667
2668 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF));
2669
2670 fail:
2671 return ret;
2672 }
2673
2674 static ssize_t ab8505_powercut_restart_write(struct device *dev,
2675 struct device_attribute *attr,
2676 const char *buf, size_t count)
2677 {
2678 int ret;
2679 int reg_value;
2680 struct power_supply *psy = dev_get_drvdata(dev);
2681 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2682
2683 if (kstrtoint(buf, 10, ®_value))
2684 goto fail;
2685
2686 if (reg_value > 0xF) {
2687 dev_err(dev, "Incorrect parameter, echo 0 - 15 for number of restart\n");
2688 goto fail;
2689 }
2690
2691 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2692 AB8505_RTC_PCUT_RESTART_REG, (u8)reg_value);
2693
2694 if (ret < 0)
2695 dev_err(dev, "Failed to set AB8505_RTC_PCUT_RESTART_REG\n");
2696
2697 fail:
2698 return count;
2699
2700 }
2701
2702 static ssize_t ab8505_powercut_timer_read(struct device *dev,
2703 struct device_attribute *attr,
2704 char *buf)
2705 {
2706 int ret;
2707 u8 reg_value;
2708 struct power_supply *psy = dev_get_drvdata(dev);
2709 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2710
2711 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2712 AB8505_RTC_PCUT_TIME_REG, ®_value);
2713
2714 if (ret < 0) {
2715 dev_err(dev, "Failed to read AB8505_RTC_PCUT_TIME_REG\n");
2716 goto fail;
2717 }
2718
2719 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7F));
2720
2721 fail:
2722 return ret;
2723 }
2724
2725 static ssize_t ab8505_powercut_restart_counter_read(struct device *dev,
2726 struct device_attribute *attr,
2727 char *buf)
2728 {
2729 int ret;
2730 u8 reg_value;
2731 struct power_supply *psy = dev_get_drvdata(dev);
2732 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2733
2734 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2735 AB8505_RTC_PCUT_RESTART_REG, ®_value);
2736
2737 if (ret < 0) {
2738 dev_err(dev, "Failed to read AB8505_RTC_PCUT_RESTART_REG\n");
2739 goto fail;
2740 }
2741
2742 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0xF0) >> 4);
2743
2744 fail:
2745 return ret;
2746 }
2747
2748 static ssize_t ab8505_powercut_read(struct device *dev,
2749 struct device_attribute *attr,
2750 char *buf)
2751 {
2752 int ret;
2753 u8 reg_value;
2754 struct power_supply *psy = dev_get_drvdata(dev);
2755 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2756
2757 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2758 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value);
2759
2760 if (ret < 0)
2761 goto fail;
2762
2763 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x1));
2764
2765 fail:
2766 return ret;
2767 }
2768
2769 static ssize_t ab8505_powercut_write(struct device *dev,
2770 struct device_attribute *attr,
2771 const char *buf, size_t count)
2772 {
2773 int ret;
2774 int reg_value;
2775 struct power_supply *psy = dev_get_drvdata(dev);
2776 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2777
2778 if (kstrtoint(buf, 10, ®_value))
2779 goto fail;
2780
2781 if (reg_value > 0x1) {
2782 dev_err(dev, "Incorrect parameter, echo 0/1 to disable/enable Pcut feature\n");
2783 goto fail;
2784 }
2785
2786 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2787 AB8505_RTC_PCUT_CTL_STATUS_REG, (u8)reg_value);
2788
2789 if (ret < 0)
2790 dev_err(dev, "Failed to set AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2791
2792 fail:
2793 return count;
2794 }
2795
2796 static ssize_t ab8505_powercut_flag_read(struct device *dev,
2797 struct device_attribute *attr,
2798 char *buf)
2799 {
2800
2801 int ret;
2802 u8 reg_value;
2803 struct power_supply *psy = dev_get_drvdata(dev);
2804 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2805
2806 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2807 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value);
2808
2809 if (ret < 0) {
2810 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2811 goto fail;
2812 }
2813
2814 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x10) >> 4));
2815
2816 fail:
2817 return ret;
2818 }
2819
2820 static ssize_t ab8505_powercut_debounce_read(struct device *dev,
2821 struct device_attribute *attr,
2822 char *buf)
2823 {
2824 int ret;
2825 u8 reg_value;
2826 struct power_supply *psy = dev_get_drvdata(dev);
2827 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2828
2829 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2830 AB8505_RTC_PCUT_DEBOUNCE_REG, ®_value);
2831
2832 if (ret < 0) {
2833 dev_err(dev, "Failed to read AB8505_RTC_PCUT_DEBOUNCE_REG\n");
2834 goto fail;
2835 }
2836
2837 return scnprintf(buf, PAGE_SIZE, "%d\n", (reg_value & 0x7));
2838
2839 fail:
2840 return ret;
2841 }
2842
2843 static ssize_t ab8505_powercut_debounce_write(struct device *dev,
2844 struct device_attribute *attr,
2845 const char *buf, size_t count)
2846 {
2847 int ret;
2848 int reg_value;
2849 struct power_supply *psy = dev_get_drvdata(dev);
2850 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2851
2852 if (kstrtoint(buf, 10, ®_value))
2853 goto fail;
2854
2855 if (reg_value > 0x7) {
2856 dev_err(dev, "Incorrect parameter, echo 0 to 7 for debounce setting\n");
2857 goto fail;
2858 }
2859
2860 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2861 AB8505_RTC_PCUT_DEBOUNCE_REG, (u8)reg_value);
2862
2863 if (ret < 0)
2864 dev_err(dev, "Failed to set AB8505_RTC_PCUT_DEBOUNCE_REG\n");
2865
2866 fail:
2867 return count;
2868 }
2869
2870 static ssize_t ab8505_powercut_enable_status_read(struct device *dev,
2871 struct device_attribute *attr,
2872 char *buf)
2873 {
2874 int ret;
2875 u8 reg_value;
2876 struct power_supply *psy = dev_get_drvdata(dev);
2877 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2878
2879 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2880 AB8505_RTC_PCUT_CTL_STATUS_REG, ®_value);
2881
2882 if (ret < 0) {
2883 dev_err(dev, "Failed to read AB8505_RTC_PCUT_CTL_STATUS_REG\n");
2884 goto fail;
2885 }
2886
2887 return scnprintf(buf, PAGE_SIZE, "%d\n", ((reg_value & 0x20) >> 5));
2888
2889 fail:
2890 return ret;
2891 }
2892
2893 static struct device_attribute ab8505_fg_sysfs_psy_attrs[] = {
2894 __ATTR(powercut_flagtime, (S_IRUGO | S_IWUSR | S_IWGRP),
2895 ab8505_powercut_flagtime_read, ab8505_powercut_flagtime_write),
2896 __ATTR(powercut_maxtime, (S_IRUGO | S_IWUSR | S_IWGRP),
2897 ab8505_powercut_maxtime_read, ab8505_powercut_maxtime_write),
2898 __ATTR(powercut_restart_max, (S_IRUGO | S_IWUSR | S_IWGRP),
2899 ab8505_powercut_restart_read, ab8505_powercut_restart_write),
2900 __ATTR(powercut_timer, S_IRUGO, ab8505_powercut_timer_read, NULL),
2901 __ATTR(powercut_restart_counter, S_IRUGO,
2902 ab8505_powercut_restart_counter_read, NULL),
2903 __ATTR(powercut_enable, (S_IRUGO | S_IWUSR | S_IWGRP),
2904 ab8505_powercut_read, ab8505_powercut_write),
2905 __ATTR(powercut_flag, S_IRUGO, ab8505_powercut_flag_read, NULL),
2906 __ATTR(powercut_debounce_time, (S_IRUGO | S_IWUSR | S_IWGRP),
2907 ab8505_powercut_debounce_read, ab8505_powercut_debounce_write),
2908 __ATTR(powercut_enable_status, S_IRUGO,
2909 ab8505_powercut_enable_status_read, NULL),
2910 };
2911
2912 static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di)
2913 {
2914 unsigned int i;
2915
2916 if (is_ab8505(di->parent)) {
2917 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
2918 if (device_create_file(&di->fg_psy->dev,
2919 &ab8505_fg_sysfs_psy_attrs[i]))
2920 goto sysfs_psy_create_attrs_failed_ab8505;
2921 }
2922 return 0;
2923 sysfs_psy_create_attrs_failed_ab8505:
2924 dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n");
2925 while (i--)
2926 device_remove_file(&di->fg_psy->dev,
2927 &ab8505_fg_sysfs_psy_attrs[i]);
2928
2929 return -EIO;
2930 }
2931
2932 static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di)
2933 {
2934 unsigned int i;
2935
2936 if (is_ab8505(di->parent)) {
2937 for (i = 0; i < ARRAY_SIZE(ab8505_fg_sysfs_psy_attrs); i++)
2938 (void)device_remove_file(&di->fg_psy->dev,
2939 &ab8505_fg_sysfs_psy_attrs[i]);
2940 }
2941 }
2942
2943
2944
2945 #if defined(CONFIG_PM)
2946 static int ab8500_fg_resume(struct platform_device *pdev)
2947 {
2948 struct ab8500_fg *di = platform_get_drvdata(pdev);
2949
2950
2951
2952
2953
2954 if (!di->flags.charging) {
2955 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP);
2956 queue_work(di->fg_wq, &di->fg_work);
2957 }
2958
2959 return 0;
2960 }
2961
2962 static int ab8500_fg_suspend(struct platform_device *pdev,
2963 pm_message_t state)
2964 {
2965 struct ab8500_fg *di = platform_get_drvdata(pdev);
2966
2967 flush_delayed_work(&di->fg_periodic_work);
2968 flush_work(&di->fg_work);
2969 flush_work(&di->fg_acc_cur_work);
2970 flush_delayed_work(&di->fg_reinit_work);
2971 flush_delayed_work(&di->fg_low_bat_work);
2972 flush_delayed_work(&di->fg_check_hw_failure_work);
2973
2974
2975
2976
2977
2978 if (di->flags.fg_enabled && !di->flags.charging)
2979 ab8500_fg_coulomb_counter(di, false);
2980
2981 return 0;
2982 }
2983 #else
2984 #define ab8500_fg_suspend NULL
2985 #define ab8500_fg_resume NULL
2986 #endif
2987
2988 static int ab8500_fg_remove(struct platform_device *pdev)
2989 {
2990 int ret = 0;
2991 struct ab8500_fg *di = platform_get_drvdata(pdev);
2992
2993 list_del(&di->node);
2994
2995
2996 ret = ab8500_fg_coulomb_counter(di, false);
2997 if (ret)
2998 dev_err(di->dev, "failed to disable coulomb counter\n");
2999
3000 destroy_workqueue(di->fg_wq);
3001 ab8500_fg_sysfs_exit(di);
3002
3003 flush_scheduled_work();
3004 ab8500_fg_sysfs_psy_remove_attrs(di);
3005 power_supply_unregister(di->fg_psy);
3006 return ret;
3007 }
3008
3009
3010 static struct ab8500_fg_interrupts ab8500_fg_irq_th[] = {
3011 {"NCONV_ACCU", ab8500_fg_cc_convend_handler},
3012 {"BATT_OVV", ab8500_fg_batt_ovv_handler},
3013 {"LOW_BAT_F", ab8500_fg_lowbatf_handler},
3014 {"CC_INT_CALIB", ab8500_fg_cc_int_calib_handler},
3015 };
3016
3017 static struct ab8500_fg_interrupts ab8500_fg_irq_bh[] = {
3018 {"CCEOC", ab8500_fg_cc_data_end_handler},
3019 };
3020
3021 static char *supply_interface[] = {
3022 "ab8500_chargalg",
3023 "ab8500_usb",
3024 };
3025
3026 static const struct power_supply_desc ab8500_fg_desc = {
3027 .name = "ab8500_fg",
3028 .type = POWER_SUPPLY_TYPE_BATTERY,
3029 .properties = ab8500_fg_props,
3030 .num_properties = ARRAY_SIZE(ab8500_fg_props),
3031 .get_property = ab8500_fg_get_property,
3032 .external_power_changed = ab8500_fg_external_power_changed,
3033 };
3034
3035 static int ab8500_fg_probe(struct platform_device *pdev)
3036 {
3037 struct device_node *np = pdev->dev.of_node;
3038 struct abx500_bm_data *plat = pdev->dev.platform_data;
3039 struct power_supply_config psy_cfg = {};
3040 struct ab8500_fg *di;
3041 int i, irq;
3042 int ret = 0;
3043
3044 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
3045 if (!di) {
3046 dev_err(&pdev->dev, "%s no mem for ab8500_fg\n", __func__);
3047 return -ENOMEM;
3048 }
3049
3050 if (!plat) {
3051 dev_err(&pdev->dev, "no battery management data supplied\n");
3052 return -EINVAL;
3053 }
3054 di->bm = plat;
3055
3056 if (np) {
3057 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
3058 if (ret) {
3059 dev_err(&pdev->dev, "failed to get battery information\n");
3060 return ret;
3061 }
3062 }
3063
3064 mutex_init(&di->cc_lock);
3065
3066
3067 di->dev = &pdev->dev;
3068 di->parent = dev_get_drvdata(pdev->dev.parent);
3069 di->gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
3070
3071 psy_cfg.supplied_to = supply_interface;
3072 psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
3073 psy_cfg.drv_data = di;
3074
3075 di->bat_cap.max_mah_design = MILLI_TO_MICRO *
3076 di->bm->bat_type[di->bm->batt_id].charge_full_design;
3077
3078 di->bat_cap.max_mah = di->bat_cap.max_mah_design;
3079
3080 di->vbat_nom = di->bm->bat_type[di->bm->batt_id].nominal_voltage;
3081
3082 di->init_capacity = true;
3083
3084 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
3085 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
3086
3087
3088 di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM);
3089 if (di->fg_wq == NULL) {
3090 dev_err(di->dev, "failed to create work queue\n");
3091 return -ENOMEM;
3092 }
3093
3094
3095 INIT_WORK(&di->fg_work, ab8500_fg_instant_work);
3096
3097
3098 INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work);
3099
3100
3101 INIT_DEFERRABLE_WORK(&di->fg_reinit_work,
3102 ab8500_fg_reinit_work);
3103
3104
3105 INIT_DEFERRABLE_WORK(&di->fg_periodic_work,
3106 ab8500_fg_periodic_work);
3107
3108
3109 INIT_DEFERRABLE_WORK(&di->fg_low_bat_work,
3110 ab8500_fg_low_bat_work);
3111
3112
3113 INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work,
3114 ab8500_fg_check_hw_failure_work);
3115
3116
3117 di->flags.low_bat = false;
3118
3119
3120 di->low_bat_cnt = 10;
3121
3122
3123 ret = ab8500_fg_init_hw_registers(di);
3124 if (ret) {
3125 dev_err(di->dev, "failed to initialize registers\n");
3126 goto free_inst_curr_wq;
3127 }
3128
3129
3130 di->flags.batt_unknown = true;
3131 di->flags.batt_id_received = false;
3132
3133
3134 di->fg_psy = power_supply_register(di->dev, &ab8500_fg_desc, &psy_cfg);
3135 if (IS_ERR(di->fg_psy)) {
3136 dev_err(di->dev, "failed to register FG psy\n");
3137 ret = PTR_ERR(di->fg_psy);
3138 goto free_inst_curr_wq;
3139 }
3140
3141 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
3142 ab8500_fg_coulomb_counter(di, true);
3143
3144
3145
3146
3147
3148 init_completion(&di->ab8500_fg_started);
3149 init_completion(&di->ab8500_fg_complete);
3150
3151
3152 for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq_th); i++) {
3153 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_th[i].name);
3154 ret = request_irq(irq, ab8500_fg_irq_th[i].isr,
3155 IRQF_SHARED | IRQF_NO_SUSPEND,
3156 ab8500_fg_irq_th[i].name, di);
3157
3158 if (ret != 0) {
3159 dev_err(di->dev, "failed to request %s IRQ %d: %d\n",
3160 ab8500_fg_irq_th[i].name, irq, ret);
3161 goto free_irq;
3162 }
3163 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3164 ab8500_fg_irq_th[i].name, irq, ret);
3165 }
3166
3167
3168 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_bh[0].name);
3169 ret = request_threaded_irq(irq, NULL, ab8500_fg_irq_bh[0].isr,
3170 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT,
3171 ab8500_fg_irq_bh[0].name, di);
3172
3173 if (ret != 0) {
3174 dev_err(di->dev, "failed to request %s IRQ %d: %d\n",
3175 ab8500_fg_irq_bh[0].name, irq, ret);
3176 goto free_irq;
3177 }
3178 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3179 ab8500_fg_irq_bh[0].name, irq, ret);
3180
3181 di->irq = platform_get_irq_byname(pdev, "CCEOC");
3182 disable_irq(di->irq);
3183 di->nbr_cceoc_irq_cnt = 0;
3184
3185 platform_set_drvdata(pdev, di);
3186
3187 ret = ab8500_fg_sysfs_init(di);
3188 if (ret) {
3189 dev_err(di->dev, "failed to create sysfs entry\n");
3190 goto free_irq;
3191 }
3192
3193 ret = ab8500_fg_sysfs_psy_create_attrs(di);
3194 if (ret) {
3195 dev_err(di->dev, "failed to create FG psy\n");
3196 ab8500_fg_sysfs_exit(di);
3197 goto free_irq;
3198 }
3199
3200
3201 di->flags.calibrate = true;
3202 di->calib_state = AB8500_FG_CALIB_INIT;
3203
3204
3205 di->bat_temp = 210;
3206
3207
3208 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
3209
3210 list_add_tail(&di->node, &ab8500_fg_list);
3211
3212 return ret;
3213
3214 free_irq:
3215 power_supply_unregister(di->fg_psy);
3216
3217
3218 for (i = 0; i < ARRAY_SIZE(ab8500_fg_irq_th); i++) {
3219 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_th[i].name);
3220 free_irq(irq, di);
3221 }
3222 irq = platform_get_irq_byname(pdev, ab8500_fg_irq_bh[0].name);
3223 free_irq(irq, di);
3224 free_inst_curr_wq:
3225 destroy_workqueue(di->fg_wq);
3226 return ret;
3227 }
3228
3229 static const struct of_device_id ab8500_fg_match[] = {
3230 { .compatible = "stericsson,ab8500-fg", },
3231 { },
3232 };
3233
3234 static struct platform_driver ab8500_fg_driver = {
3235 .probe = ab8500_fg_probe,
3236 .remove = ab8500_fg_remove,
3237 .suspend = ab8500_fg_suspend,
3238 .resume = ab8500_fg_resume,
3239 .driver = {
3240 .name = "ab8500-fg",
3241 .of_match_table = ab8500_fg_match,
3242 },
3243 };
3244
3245 static int __init ab8500_fg_init(void)
3246 {
3247 return platform_driver_register(&ab8500_fg_driver);
3248 }
3249
3250 static void __exit ab8500_fg_exit(void)
3251 {
3252 platform_driver_unregister(&ab8500_fg_driver);
3253 }
3254
3255 subsys_initcall_sync(ab8500_fg_init);
3256 module_exit(ab8500_fg_exit);
3257
3258 MODULE_LICENSE("GPL v2");
3259 MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
3260 MODULE_ALIAS("platform:ab8500-fg");
3261 MODULE_DESCRIPTION("AB8500 Fuel Gauge driver");