1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/device.h>
18#include <linux/hrtimer.h>
19#include <linux/interrupt.h>
20#include <linux/delay.h>
21#include <linux/slab.h>
22#include <linux/platform_device.h>
23#include <linux/power_supply.h>
24#include <linux/completion.h>
25#include <linux/workqueue.h>
26#include <linux/kobject.h>
27#include <linux/of.h>
28#include <linux/mfd/core.h>
29#include <linux/mfd/abx500.h>
30#include <linux/mfd/abx500/ab8500.h>
31#include <linux/mfd/abx500/ux500_chargalg.h>
32#include <linux/mfd/abx500/ab8500-bm.h>
33#include <linux/notifier.h>
34
35
36#define CHG_WD_INTERVAL (6 * HZ)
37
38
39#define EOC_COND_CNT 10
40
41
42#define ONE_HOUR_IN_SECONDS 3600
43
44
45#define FIVE_MINUTES_IN_SECONDS 300
46
47
48#define BAT_PLUS_MARGIN (100)
49
50#define CHARGALG_CURR_STEP_LOW 0
51#define CHARGALG_CURR_STEP_HIGH 100
52
53enum abx500_chargers {
54 NO_CHG,
55 AC_CHG,
56 USB_CHG,
57};
58
59struct abx500_chargalg_charger_info {
60 enum abx500_chargers conn_chg;
61 enum abx500_chargers prev_conn_chg;
62 enum abx500_chargers online_chg;
63 enum abx500_chargers prev_online_chg;
64 enum abx500_chargers charger_type;
65 bool usb_chg_ok;
66 bool ac_chg_ok;
67 int usb_volt;
68 int usb_curr;
69 int ac_volt;
70 int ac_curr;
71 int usb_vset;
72 int usb_iset;
73 int ac_vset;
74 int ac_iset;
75};
76
77struct abx500_chargalg_suspension_status {
78 bool suspended_change;
79 bool ac_suspended;
80 bool usb_suspended;
81};
82
83struct abx500_chargalg_current_step_status {
84 bool curr_step_change;
85 int curr_step;
86};
87
88struct abx500_chargalg_battery_data {
89 int temp;
90 int volt;
91 int avg_curr;
92 int inst_curr;
93 int percent;
94};
95
96enum abx500_chargalg_states {
97 STATE_HANDHELD_INIT,
98 STATE_HANDHELD,
99 STATE_CHG_NOT_OK_INIT,
100 STATE_CHG_NOT_OK,
101 STATE_HW_TEMP_PROTECT_INIT,
102 STATE_HW_TEMP_PROTECT,
103 STATE_NORMAL_INIT,
104 STATE_USB_PP_PRE_CHARGE,
105 STATE_NORMAL,
106 STATE_WAIT_FOR_RECHARGE_INIT,
107 STATE_WAIT_FOR_RECHARGE,
108 STATE_MAINTENANCE_A_INIT,
109 STATE_MAINTENANCE_A,
110 STATE_MAINTENANCE_B_INIT,
111 STATE_MAINTENANCE_B,
112 STATE_TEMP_UNDEROVER_INIT,
113 STATE_TEMP_UNDEROVER,
114 STATE_TEMP_LOWHIGH_INIT,
115 STATE_TEMP_LOWHIGH,
116 STATE_SUSPENDED_INIT,
117 STATE_SUSPENDED,
118 STATE_OVV_PROTECT_INIT,
119 STATE_OVV_PROTECT,
120 STATE_SAFETY_TIMER_EXPIRED_INIT,
121 STATE_SAFETY_TIMER_EXPIRED,
122 STATE_BATT_REMOVED_INIT,
123 STATE_BATT_REMOVED,
124 STATE_WD_EXPIRED_INIT,
125 STATE_WD_EXPIRED,
126};
127
128static const char *states[] = {
129 "HANDHELD_INIT",
130 "HANDHELD",
131 "CHG_NOT_OK_INIT",
132 "CHG_NOT_OK",
133 "HW_TEMP_PROTECT_INIT",
134 "HW_TEMP_PROTECT",
135 "NORMAL_INIT",
136 "USB_PP_PRE_CHARGE",
137 "NORMAL",
138 "WAIT_FOR_RECHARGE_INIT",
139 "WAIT_FOR_RECHARGE",
140 "MAINTENANCE_A_INIT",
141 "MAINTENANCE_A",
142 "MAINTENANCE_B_INIT",
143 "MAINTENANCE_B",
144 "TEMP_UNDEROVER_INIT",
145 "TEMP_UNDEROVER",
146 "TEMP_LOWHIGH_INIT",
147 "TEMP_LOWHIGH",
148 "SUSPENDED_INIT",
149 "SUSPENDED",
150 "OVV_PROTECT_INIT",
151 "OVV_PROTECT",
152 "SAFETY_TIMER_EXPIRED_INIT",
153 "SAFETY_TIMER_EXPIRED",
154 "BATT_REMOVED_INIT",
155 "BATT_REMOVED",
156 "WD_EXPIRED_INIT",
157 "WD_EXPIRED",
158};
159
160struct abx500_chargalg_events {
161 bool batt_unknown;
162 bool mainextchnotok;
163 bool batt_ovv;
164 bool batt_rem;
165 bool btemp_underover;
166 bool btemp_lowhigh;
167 bool main_thermal_prot;
168 bool usb_thermal_prot;
169 bool main_ovv;
170 bool vbus_ovv;
171 bool usbchargernotok;
172 bool safety_timer_expired;
173 bool maintenance_timer_expired;
174 bool ac_wd_expired;
175 bool usb_wd_expired;
176 bool ac_cv_active;
177 bool usb_cv_active;
178 bool vbus_collapsed;
179};
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196struct abx500_charge_curr_maximization {
197 int original_iset;
198 int current_iset;
199 int test_delta_i;
200 int condition_cnt;
201 int max_current;
202 int wait_cnt;
203 u8 level;
204};
205
206enum maxim_ret {
207 MAXIM_RET_NOACTION,
208 MAXIM_RET_CHANGE,
209 MAXIM_RET_IBAT_TOO_HIGH,
210};
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241struct abx500_chargalg {
242 struct device *dev;
243 int charge_status;
244 int eoc_cnt;
245 bool maintenance_chg;
246 int t_hyst_norm;
247 int t_hyst_lowhigh;
248 enum abx500_chargalg_states charge_state;
249 struct abx500_charge_curr_maximization ccm;
250 struct abx500_chargalg_charger_info chg_info;
251 struct abx500_chargalg_battery_data batt_data;
252 struct abx500_chargalg_suspension_status susp_status;
253 struct ab8500 *parent;
254 struct abx500_chargalg_current_step_status curr_status;
255 struct abx500_bm_data *bm;
256 struct power_supply *chargalg_psy;
257 struct ux500_charger *ac_chg;
258 struct ux500_charger *usb_chg;
259 struct abx500_chargalg_events events;
260 struct workqueue_struct *chargalg_wq;
261 struct delayed_work chargalg_periodic_work;
262 struct delayed_work chargalg_wd_work;
263 struct work_struct chargalg_work;
264 struct hrtimer safety_timer;
265 struct hrtimer maintenance_timer;
266 struct kobject chargalg_kobject;
267};
268
269
270BLOCKING_NOTIFIER_HEAD(charger_notifier_list);
271
272
273static enum power_supply_property abx500_chargalg_props[] = {
274 POWER_SUPPLY_PROP_STATUS,
275 POWER_SUPPLY_PROP_HEALTH,
276};
277
278struct abx500_chargalg_sysfs_entry {
279 struct attribute attr;
280 ssize_t (*show)(struct abx500_chargalg *, char *);
281 ssize_t (*store)(struct abx500_chargalg *, const char *, size_t);
282};
283
284
285
286
287
288
289
290
291static enum hrtimer_restart
292abx500_chargalg_safety_timer_expired(struct hrtimer *timer)
293{
294 struct abx500_chargalg *di = container_of(timer, struct abx500_chargalg,
295 safety_timer);
296 dev_err(di->dev, "Safety timer expired\n");
297 di->events.safety_timer_expired = true;
298
299
300 queue_work(di->chargalg_wq, &di->chargalg_work);
301
302 return HRTIMER_NORESTART;
303}
304
305
306
307
308
309
310
311
312
313static enum hrtimer_restart
314abx500_chargalg_maintenance_timer_expired(struct hrtimer *timer)
315{
316
317 struct abx500_chargalg *di = container_of(timer, struct abx500_chargalg,
318 maintenance_timer);
319
320 dev_dbg(di->dev, "Maintenance timer expired\n");
321 di->events.maintenance_timer_expired = true;
322
323
324 queue_work(di->chargalg_wq, &di->chargalg_work);
325
326 return HRTIMER_NORESTART;
327}
328
329
330
331
332
333
334
335static void abx500_chargalg_state_to(struct abx500_chargalg *di,
336 enum abx500_chargalg_states state)
337{
338 dev_dbg(di->dev,
339 "State changed: %s (From state: [%d] %s =to=> [%d] %s )\n",
340 di->charge_state == state ? "NO" : "YES",
341 di->charge_state,
342 states[di->charge_state],
343 state,
344 states[state]);
345
346 di->charge_state = state;
347}
348
349static int abx500_chargalg_check_charger_enable(struct abx500_chargalg *di)
350{
351 switch (di->charge_state) {
352 case STATE_NORMAL:
353 case STATE_MAINTENANCE_A:
354 case STATE_MAINTENANCE_B:
355 break;
356 default:
357 return 0;
358 }
359
360 if (di->chg_info.charger_type & USB_CHG) {
361 return di->usb_chg->ops.check_enable(di->usb_chg,
362 di->bm->bat_type[di->bm->batt_id].normal_vol_lvl,
363 di->bm->bat_type[di->bm->batt_id].normal_cur_lvl);
364 } else if ((di->chg_info.charger_type & AC_CHG) &&
365 !(di->ac_chg->external)) {
366 return di->ac_chg->ops.check_enable(di->ac_chg,
367 di->bm->bat_type[di->bm->batt_id].normal_vol_lvl,
368 di->bm->bat_type[di->bm->batt_id].normal_cur_lvl);
369 }
370 return 0;
371}
372
373
374
375
376
377
378
379
380static int abx500_chargalg_check_charger_connection(struct abx500_chargalg *di)
381{
382 if (di->chg_info.conn_chg != di->chg_info.prev_conn_chg ||
383 di->susp_status.suspended_change) {
384
385
386
387
388 if ((di->chg_info.conn_chg & AC_CHG) &&
389 !di->susp_status.ac_suspended) {
390 dev_dbg(di->dev, "Charging source is AC\n");
391 if (di->chg_info.charger_type != AC_CHG) {
392 di->chg_info.charger_type = AC_CHG;
393 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
394 }
395 } else if ((di->chg_info.conn_chg & USB_CHG) &&
396 !di->susp_status.usb_suspended) {
397 dev_dbg(di->dev, "Charging source is USB\n");
398 di->chg_info.charger_type = USB_CHG;
399 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
400 } else if (di->chg_info.conn_chg &&
401 (di->susp_status.ac_suspended ||
402 di->susp_status.usb_suspended)) {
403 dev_dbg(di->dev, "Charging is suspended\n");
404 di->chg_info.charger_type = NO_CHG;
405 abx500_chargalg_state_to(di, STATE_SUSPENDED_INIT);
406 } else {
407 dev_dbg(di->dev, "Charging source is OFF\n");
408 di->chg_info.charger_type = NO_CHG;
409 abx500_chargalg_state_to(di, STATE_HANDHELD_INIT);
410 }
411 di->chg_info.prev_conn_chg = di->chg_info.conn_chg;
412 di->susp_status.suspended_change = false;
413 }
414 return di->chg_info.conn_chg;
415}
416
417
418
419
420
421
422
423
424
425static void abx500_chargalg_check_current_step_status
426 (struct abx500_chargalg *di)
427{
428 if (di->curr_status.curr_step_change)
429 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
430 di->curr_status.curr_step_change = false;
431}
432
433
434
435
436
437
438
439
440static void abx500_chargalg_start_safety_timer(struct abx500_chargalg *di)
441{
442
443 int timer_expiration = 0;
444
445 switch (di->chg_info.charger_type) {
446 case AC_CHG:
447 timer_expiration = di->bm->main_safety_tmr_h;
448 break;
449
450 case USB_CHG:
451 timer_expiration = di->bm->usb_safety_tmr_h;
452 break;
453
454 default:
455 dev_err(di->dev, "Unknown charger to charge from\n");
456 break;
457 }
458
459 di->events.safety_timer_expired = false;
460 hrtimer_set_expires_range(&di->safety_timer,
461 ktime_set(timer_expiration * ONE_HOUR_IN_SECONDS, 0),
462 ktime_set(FIVE_MINUTES_IN_SECONDS, 0));
463 hrtimer_start_expires(&di->safety_timer, HRTIMER_MODE_REL);
464}
465
466
467
468
469
470
471
472static void abx500_chargalg_stop_safety_timer(struct abx500_chargalg *di)
473{
474 if (hrtimer_try_to_cancel(&di->safety_timer) >= 0)
475 di->events.safety_timer_expired = false;
476}
477
478
479
480
481
482
483
484
485
486
487static void abx500_chargalg_start_maintenance_timer(struct abx500_chargalg *di,
488 int duration)
489{
490 hrtimer_set_expires_range(&di->maintenance_timer,
491 ktime_set(duration * ONE_HOUR_IN_SECONDS, 0),
492 ktime_set(FIVE_MINUTES_IN_SECONDS, 0));
493 di->events.maintenance_timer_expired = false;
494 hrtimer_start_expires(&di->maintenance_timer, HRTIMER_MODE_REL);
495}
496
497
498
499
500
501
502
503
504static void abx500_chargalg_stop_maintenance_timer(struct abx500_chargalg *di)
505{
506 if (hrtimer_try_to_cancel(&di->maintenance_timer) >= 0)
507 di->events.maintenance_timer_expired = false;
508}
509
510
511
512
513
514
515
516
517static int abx500_chargalg_kick_watchdog(struct abx500_chargalg *di)
518{
519
520 if (di->ac_chg && di->ac_chg->ops.kick_wd &&
521 di->chg_info.online_chg & AC_CHG) {
522
523
524
525
526
527 if (di->ac_chg->external &&
528 di->usb_chg && di->usb_chg->ops.kick_wd)
529 di->usb_chg->ops.kick_wd(di->usb_chg);
530
531 return di->ac_chg->ops.kick_wd(di->ac_chg);
532 }
533 else if (di->usb_chg && di->usb_chg->ops.kick_wd &&
534 di->chg_info.online_chg & USB_CHG)
535 return di->usb_chg->ops.kick_wd(di->usb_chg);
536
537 return -ENXIO;
538}
539
540
541
542
543
544
545
546
547
548
549
550static int abx500_chargalg_ac_en(struct abx500_chargalg *di, int enable,
551 int vset, int iset)
552{
553 static int abx500_chargalg_ex_ac_enable_toggle;
554
555 if (!di->ac_chg || !di->ac_chg->ops.enable)
556 return -ENXIO;
557
558
559 if (di->ac_chg->max_out_volt)
560 vset = min(vset, di->ac_chg->max_out_volt);
561 if (di->ac_chg->max_out_curr)
562 iset = min(iset, di->ac_chg->max_out_curr);
563
564 di->chg_info.ac_iset = iset;
565 di->chg_info.ac_vset = vset;
566
567
568 if (enable && di->ac_chg->external &&
569 !abx500_chargalg_ex_ac_enable_toggle) {
570 blocking_notifier_call_chain(&charger_notifier_list,
571 0, di->dev);
572 abx500_chargalg_ex_ac_enable_toggle++;
573 }
574
575 return di->ac_chg->ops.enable(di->ac_chg, enable, vset, iset);
576}
577
578
579
580
581
582
583
584
585
586
587
588static int abx500_chargalg_usb_en(struct abx500_chargalg *di, int enable,
589 int vset, int iset)
590{
591 if (!di->usb_chg || !di->usb_chg->ops.enable)
592 return -ENXIO;
593
594
595 if (di->usb_chg->max_out_volt)
596 vset = min(vset, di->usb_chg->max_out_volt);
597 if (di->usb_chg->max_out_curr)
598 iset = min(iset, di->usb_chg->max_out_curr);
599
600 di->chg_info.usb_iset = iset;
601 di->chg_info.usb_vset = vset;
602
603 return di->usb_chg->ops.enable(di->usb_chg, enable, vset, iset);
604}
605
606
607
608
609
610
611
612
613static int ab8540_chargalg_usb_pp_en(struct abx500_chargalg *di, bool enable)
614{
615 if (!di->usb_chg || !di->usb_chg->ops.pp_enable)
616 return -ENXIO;
617
618 return di->usb_chg->ops.pp_enable(di->usb_chg, enable);
619}
620
621
622
623
624
625
626
627
628static int ab8540_chargalg_usb_pre_chg_en(struct abx500_chargalg *di,
629 bool enable)
630{
631 if (!di->usb_chg || !di->usb_chg->ops.pre_chg_enable)
632 return -ENXIO;
633
634 return di->usb_chg->ops.pre_chg_enable(di->usb_chg, enable);
635}
636
637
638
639
640
641
642
643
644
645static int abx500_chargalg_update_chg_curr(struct abx500_chargalg *di,
646 int iset)
647{
648
649 if (di->ac_chg && di->ac_chg->ops.update_curr &&
650 di->chg_info.charger_type & AC_CHG) {
651
652
653
654
655 if (di->ac_chg->max_out_curr)
656 iset = min(iset, di->ac_chg->max_out_curr);
657
658 di->chg_info.ac_iset = iset;
659
660 return di->ac_chg->ops.update_curr(di->ac_chg, iset);
661 } else if (di->usb_chg && di->usb_chg->ops.update_curr &&
662 di->chg_info.charger_type & USB_CHG) {
663
664
665
666
667 if (di->usb_chg->max_out_curr)
668 iset = min(iset, di->usb_chg->max_out_curr);
669
670 di->chg_info.usb_iset = iset;
671
672 return di->usb_chg->ops.update_curr(di->usb_chg, iset);
673 }
674
675 return -ENXIO;
676}
677
678
679
680
681
682
683
684
685
686static void abx500_chargalg_stop_charging(struct abx500_chargalg *di)
687{
688 abx500_chargalg_ac_en(di, false, 0, 0);
689 abx500_chargalg_usb_en(di, false, 0, 0);
690 abx500_chargalg_stop_safety_timer(di);
691 abx500_chargalg_stop_maintenance_timer(di);
692 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
693 di->maintenance_chg = false;
694 cancel_delayed_work(&di->chargalg_wd_work);
695 power_supply_changed(di->chargalg_psy);
696}
697
698
699
700
701
702
703
704
705
706static void abx500_chargalg_hold_charging(struct abx500_chargalg *di)
707{
708 abx500_chargalg_ac_en(di, false, 0, 0);
709 abx500_chargalg_usb_en(di, false, 0, 0);
710 abx500_chargalg_stop_safety_timer(di);
711 abx500_chargalg_stop_maintenance_timer(di);
712 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
713 di->maintenance_chg = false;
714 cancel_delayed_work(&di->chargalg_wd_work);
715 power_supply_changed(di->chargalg_psy);
716}
717
718
719
720
721
722
723
724
725
726
727static void abx500_chargalg_start_charging(struct abx500_chargalg *di,
728 int vset, int iset)
729{
730 switch (di->chg_info.charger_type) {
731 case AC_CHG:
732 dev_dbg(di->dev,
733 "AC parameters: Vset %d, Ich %d\n", vset, iset);
734 abx500_chargalg_usb_en(di, false, 0, 0);
735 abx500_chargalg_ac_en(di, true, vset, iset);
736 break;
737
738 case USB_CHG:
739 dev_dbg(di->dev,
740 "USB parameters: Vset %d, Ich %d\n", vset, iset);
741 abx500_chargalg_ac_en(di, false, 0, 0);
742 abx500_chargalg_usb_en(di, true, vset, iset);
743 break;
744
745 default:
746 dev_err(di->dev, "Unknown charger to charge from\n");
747 break;
748 }
749}
750
751
752
753
754
755
756
757
758static void abx500_chargalg_check_temp(struct abx500_chargalg *di)
759{
760 if (di->batt_data.temp > (di->bm->temp_low + di->t_hyst_norm) &&
761 di->batt_data.temp < (di->bm->temp_high - di->t_hyst_norm)) {
762
763 di->events.btemp_underover = false;
764 di->events.btemp_lowhigh = false;
765 di->t_hyst_norm = 0;
766 di->t_hyst_lowhigh = 0;
767 } else {
768 if (((di->batt_data.temp >= di->bm->temp_high) &&
769 (di->batt_data.temp <
770 (di->bm->temp_over - di->t_hyst_lowhigh))) ||
771 ((di->batt_data.temp >
772 (di->bm->temp_under + di->t_hyst_lowhigh)) &&
773 (di->batt_data.temp <= di->bm->temp_low))) {
774
775 di->events.btemp_underover = false;
776 di->events.btemp_lowhigh = true;
777 di->t_hyst_norm = di->bm->temp_hysteresis;
778 di->t_hyst_lowhigh = 0;
779 } else if (di->batt_data.temp <= di->bm->temp_under ||
780 di->batt_data.temp >= di->bm->temp_over) {
781
782 di->events.btemp_underover = true;
783 di->events.btemp_lowhigh = false;
784 di->t_hyst_norm = 0;
785 di->t_hyst_lowhigh = di->bm->temp_hysteresis;
786 } else {
787
788 dev_dbg(di->dev, "Within hysteresis limit temp: %d "
789 "hyst_lowhigh %d, hyst normal %d\n",
790 di->batt_data.temp, di->t_hyst_lowhigh,
791 di->t_hyst_norm);
792 }
793 }
794}
795
796
797
798
799
800
801
802static void abx500_chargalg_check_charger_voltage(struct abx500_chargalg *di)
803{
804 if (di->chg_info.usb_volt > di->bm->chg_params->usb_volt_max)
805 di->chg_info.usb_chg_ok = false;
806 else
807 di->chg_info.usb_chg_ok = true;
808
809 if (di->chg_info.ac_volt > di->bm->chg_params->ac_volt_max)
810 di->chg_info.ac_chg_ok = false;
811 else
812 di->chg_info.ac_chg_ok = true;
813
814}
815
816
817
818
819
820
821
822
823
824static void abx500_chargalg_end_of_charge(struct abx500_chargalg *di)
825{
826 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING &&
827 di->charge_state == STATE_NORMAL &&
828 !di->maintenance_chg && (di->batt_data.volt >=
829 di->bm->bat_type[di->bm->batt_id].termination_vol ||
830 di->events.usb_cv_active || di->events.ac_cv_active) &&
831 di->batt_data.avg_curr <
832 di->bm->bat_type[di->bm->batt_id].termination_curr &&
833 di->batt_data.avg_curr > 0) {
834 if (++di->eoc_cnt >= EOC_COND_CNT) {
835 di->eoc_cnt = 0;
836 if ((di->chg_info.charger_type & USB_CHG) &&
837 (di->usb_chg->power_path))
838 ab8540_chargalg_usb_pp_en(di, true);
839 di->charge_status = POWER_SUPPLY_STATUS_FULL;
840 di->maintenance_chg = true;
841 dev_dbg(di->dev, "EOC reached!\n");
842 power_supply_changed(di->chargalg_psy);
843 } else {
844 dev_dbg(di->dev,
845 " EOC limit reached for the %d"
846 " time, out of %d before EOC\n",
847 di->eoc_cnt,
848 EOC_COND_CNT);
849 }
850 } else {
851 di->eoc_cnt = 0;
852 }
853}
854
855static void init_maxim_chg_curr(struct abx500_chargalg *di)
856{
857 di->ccm.original_iset =
858 di->bm->bat_type[di->bm->batt_id].normal_cur_lvl;
859 di->ccm.current_iset =
860 di->bm->bat_type[di->bm->batt_id].normal_cur_lvl;
861 di->ccm.test_delta_i = di->bm->maxi->charger_curr_step;
862 di->ccm.max_current = di->bm->maxi->chg_curr;
863 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
864 di->ccm.level = 0;
865}
866
867
868
869
870
871
872
873
874
875
876static enum maxim_ret abx500_chargalg_chg_curr_maxim(struct abx500_chargalg *di)
877{
878 int delta_i;
879
880 if (!di->bm->maxi->ena_maxi)
881 return MAXIM_RET_NOACTION;
882
883 delta_i = di->ccm.original_iset - di->batt_data.inst_curr;
884
885 if (di->events.vbus_collapsed) {
886 dev_dbg(di->dev, "Charger voltage has collapsed %d\n",
887 di->ccm.wait_cnt);
888 if (di->ccm.wait_cnt == 0) {
889 dev_dbg(di->dev, "lowering current\n");
890 di->ccm.wait_cnt++;
891 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
892 di->ccm.max_current =
893 di->ccm.current_iset - di->ccm.test_delta_i;
894 di->ccm.current_iset = di->ccm.max_current;
895 di->ccm.level--;
896 return MAXIM_RET_CHANGE;
897 } else {
898 dev_dbg(di->dev, "waiting\n");
899
900 di->ccm.wait_cnt = (di->ccm.wait_cnt + 1) % 3;
901 return MAXIM_RET_NOACTION;
902 }
903 }
904
905 di->ccm.wait_cnt = 0;
906
907 if ((di->batt_data.inst_curr > di->ccm.original_iset)) {
908 dev_dbg(di->dev, " Maximization Ibat (%dmA) too high"
909 " (limit %dmA) (current iset: %dmA)!\n",
910 di->batt_data.inst_curr, di->ccm.original_iset,
911 di->ccm.current_iset);
912
913 if (di->ccm.current_iset == di->ccm.original_iset)
914 return MAXIM_RET_NOACTION;
915
916 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
917 di->ccm.current_iset = di->ccm.original_iset;
918 di->ccm.level = 0;
919
920 return MAXIM_RET_IBAT_TOO_HIGH;
921 }
922
923 if (delta_i > di->ccm.test_delta_i &&
924 (di->ccm.current_iset + di->ccm.test_delta_i) <
925 di->ccm.max_current) {
926 if (di->ccm.condition_cnt-- == 0) {
927
928 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
929 di->ccm.current_iset += di->ccm.test_delta_i;
930 di->ccm.level++;
931 dev_dbg(di->dev, " Maximization needed, increase"
932 " with %d mA to %dmA (Optimal ibat: %d)"
933 " Level %d\n",
934 di->ccm.test_delta_i,
935 di->ccm.current_iset,
936 di->ccm.original_iset,
937 di->ccm.level);
938 return MAXIM_RET_CHANGE;
939 } else {
940 return MAXIM_RET_NOACTION;
941 }
942 } else {
943 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
944 return MAXIM_RET_NOACTION;
945 }
946}
947
948static void handle_maxim_chg_curr(struct abx500_chargalg *di)
949{
950 enum maxim_ret ret;
951 int result;
952
953 ret = abx500_chargalg_chg_curr_maxim(di);
954 switch (ret) {
955 case MAXIM_RET_CHANGE:
956 result = abx500_chargalg_update_chg_curr(di,
957 di->ccm.current_iset);
958 if (result)
959 dev_err(di->dev, "failed to set chg curr\n");
960 break;
961 case MAXIM_RET_IBAT_TOO_HIGH:
962 result = abx500_chargalg_update_chg_curr(di,
963 di->bm->bat_type[di->bm->batt_id].normal_cur_lvl);
964 if (result)
965 dev_err(di->dev, "failed to set chg curr\n");
966 break;
967
968 case MAXIM_RET_NOACTION:
969 default:
970
971 break;
972 }
973}
974
975static int abx500_chargalg_get_ext_psy_data(struct device *dev, void *data)
976{
977 struct power_supply *psy;
978 struct power_supply *ext;
979 struct abx500_chargalg *di;
980 union power_supply_propval ret;
981 int i, j;
982 bool psy_found = false;
983 bool capacity_updated = false;
984
985 psy = (struct power_supply *)data;
986 ext = dev_get_drvdata(dev);
987 di = power_supply_get_drvdata(psy);
988
989 for (i = 0; i < ext->num_supplicants; i++) {
990 if (!strcmp(ext->supplied_to[i], psy->desc->name))
991 psy_found = true;
992 }
993 if (!psy_found)
994 return 0;
995
996
997
998
999
1000
1001 if (!power_supply_get_property(ext, POWER_SUPPLY_PROP_CAPACITY, &ret)) {
1002 di->batt_data.percent = ret.intval;
1003 capacity_updated = true;
1004 }
1005
1006
1007 for (j = 0; j < ext->desc->num_properties; j++) {
1008 enum power_supply_property prop;
1009 prop = ext->desc->properties[j];
1010
1011
1012
1013
1014 if (!di->ac_chg &&
1015 ext->desc->type == POWER_SUPPLY_TYPE_MAINS)
1016 di->ac_chg = psy_to_ux500_charger(ext);
1017 else if (!di->usb_chg &&
1018 ext->desc->type == POWER_SUPPLY_TYPE_USB)
1019 di->usb_chg = psy_to_ux500_charger(ext);
1020
1021 if (power_supply_get_property(ext, prop, &ret))
1022 continue;
1023 switch (prop) {
1024 case POWER_SUPPLY_PROP_PRESENT:
1025 switch (ext->desc->type) {
1026 case POWER_SUPPLY_TYPE_BATTERY:
1027
1028 if (ret.intval)
1029 di->events.batt_rem = false;
1030
1031 else
1032 di->events.batt_rem = true;
1033 break;
1034 case POWER_SUPPLY_TYPE_MAINS:
1035
1036 if (!ret.intval &&
1037 (di->chg_info.conn_chg & AC_CHG)) {
1038 di->chg_info.prev_conn_chg =
1039 di->chg_info.conn_chg;
1040 di->chg_info.conn_chg &= ~AC_CHG;
1041 }
1042
1043 else if (ret.intval &&
1044 !(di->chg_info.conn_chg & AC_CHG)) {
1045 di->chg_info.prev_conn_chg =
1046 di->chg_info.conn_chg;
1047 di->chg_info.conn_chg |= AC_CHG;
1048 }
1049 break;
1050 case POWER_SUPPLY_TYPE_USB:
1051
1052 if (!ret.intval &&
1053 (di->chg_info.conn_chg & USB_CHG)) {
1054 di->chg_info.prev_conn_chg =
1055 di->chg_info.conn_chg;
1056 di->chg_info.conn_chg &= ~USB_CHG;
1057 }
1058
1059 else if (ret.intval &&
1060 !(di->chg_info.conn_chg & USB_CHG)) {
1061 di->chg_info.prev_conn_chg =
1062 di->chg_info.conn_chg;
1063 di->chg_info.conn_chg |= USB_CHG;
1064 }
1065 break;
1066 default:
1067 break;
1068 }
1069 break;
1070
1071 case POWER_SUPPLY_PROP_ONLINE:
1072 switch (ext->desc->type) {
1073 case POWER_SUPPLY_TYPE_BATTERY:
1074 break;
1075 case POWER_SUPPLY_TYPE_MAINS:
1076
1077 if (!ret.intval &&
1078 (di->chg_info.online_chg & AC_CHG)) {
1079 di->chg_info.prev_online_chg =
1080 di->chg_info.online_chg;
1081 di->chg_info.online_chg &= ~AC_CHG;
1082 }
1083
1084 else if (ret.intval &&
1085 !(di->chg_info.online_chg & AC_CHG)) {
1086 di->chg_info.prev_online_chg =
1087 di->chg_info.online_chg;
1088 di->chg_info.online_chg |= AC_CHG;
1089 queue_delayed_work(di->chargalg_wq,
1090 &di->chargalg_wd_work, 0);
1091 }
1092 break;
1093 case POWER_SUPPLY_TYPE_USB:
1094
1095 if (!ret.intval &&
1096 (di->chg_info.online_chg & USB_CHG)) {
1097 di->chg_info.prev_online_chg =
1098 di->chg_info.online_chg;
1099 di->chg_info.online_chg &= ~USB_CHG;
1100 }
1101
1102 else if (ret.intval &&
1103 !(di->chg_info.online_chg & USB_CHG)) {
1104 di->chg_info.prev_online_chg =
1105 di->chg_info.online_chg;
1106 di->chg_info.online_chg |= USB_CHG;
1107 queue_delayed_work(di->chargalg_wq,
1108 &di->chargalg_wd_work, 0);
1109 }
1110 break;
1111 default:
1112 break;
1113 }
1114 break;
1115
1116 case POWER_SUPPLY_PROP_HEALTH:
1117 switch (ext->desc->type) {
1118 case POWER_SUPPLY_TYPE_BATTERY:
1119 break;
1120 case POWER_SUPPLY_TYPE_MAINS:
1121 switch (ret.intval) {
1122 case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
1123 di->events.mainextchnotok = true;
1124 di->events.main_thermal_prot = false;
1125 di->events.main_ovv = false;
1126 di->events.ac_wd_expired = false;
1127 break;
1128 case POWER_SUPPLY_HEALTH_DEAD:
1129 di->events.ac_wd_expired = true;
1130 di->events.mainextchnotok = false;
1131 di->events.main_ovv = false;
1132 di->events.main_thermal_prot = false;
1133 break;
1134 case POWER_SUPPLY_HEALTH_COLD:
1135 case POWER_SUPPLY_HEALTH_OVERHEAT:
1136 di->events.main_thermal_prot = true;
1137 di->events.mainextchnotok = false;
1138 di->events.main_ovv = false;
1139 di->events.ac_wd_expired = false;
1140 break;
1141 case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1142 di->events.main_ovv = true;
1143 di->events.mainextchnotok = false;
1144 di->events.main_thermal_prot = false;
1145 di->events.ac_wd_expired = false;
1146 break;
1147 case POWER_SUPPLY_HEALTH_GOOD:
1148 di->events.main_thermal_prot = false;
1149 di->events.mainextchnotok = false;
1150 di->events.main_ovv = false;
1151 di->events.ac_wd_expired = false;
1152 break;
1153 default:
1154 break;
1155 }
1156 break;
1157
1158 case POWER_SUPPLY_TYPE_USB:
1159 switch (ret.intval) {
1160 case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
1161 di->events.usbchargernotok = true;
1162 di->events.usb_thermal_prot = false;
1163 di->events.vbus_ovv = false;
1164 di->events.usb_wd_expired = false;
1165 break;
1166 case POWER_SUPPLY_HEALTH_DEAD:
1167 di->events.usb_wd_expired = true;
1168 di->events.usbchargernotok = false;
1169 di->events.usb_thermal_prot = false;
1170 di->events.vbus_ovv = false;
1171 break;
1172 case POWER_SUPPLY_HEALTH_COLD:
1173 case POWER_SUPPLY_HEALTH_OVERHEAT:
1174 di->events.usb_thermal_prot = true;
1175 di->events.usbchargernotok = false;
1176 di->events.vbus_ovv = false;
1177 di->events.usb_wd_expired = false;
1178 break;
1179 case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1180 di->events.vbus_ovv = true;
1181 di->events.usbchargernotok = false;
1182 di->events.usb_thermal_prot = false;
1183 di->events.usb_wd_expired = false;
1184 break;
1185 case POWER_SUPPLY_HEALTH_GOOD:
1186 di->events.usbchargernotok = false;
1187 di->events.usb_thermal_prot = false;
1188 di->events.vbus_ovv = false;
1189 di->events.usb_wd_expired = false;
1190 break;
1191 default:
1192 break;
1193 }
1194 default:
1195 break;
1196 }
1197 break;
1198
1199 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1200 switch (ext->desc->type) {
1201 case POWER_SUPPLY_TYPE_BATTERY:
1202 di->batt_data.volt = ret.intval / 1000;
1203 break;
1204 case POWER_SUPPLY_TYPE_MAINS:
1205 di->chg_info.ac_volt = ret.intval / 1000;
1206 break;
1207 case POWER_SUPPLY_TYPE_USB:
1208 di->chg_info.usb_volt = ret.intval / 1000;
1209 break;
1210 default:
1211 break;
1212 }
1213 break;
1214
1215 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
1216 switch (ext->desc->type) {
1217 case POWER_SUPPLY_TYPE_MAINS:
1218
1219
1220 if (ret.intval)
1221 di->events.ac_cv_active = true;
1222 else
1223 di->events.ac_cv_active = false;
1224
1225 break;
1226 case POWER_SUPPLY_TYPE_USB:
1227
1228
1229 if (ret.intval)
1230 di->events.usb_cv_active = true;
1231 else
1232 di->events.usb_cv_active = false;
1233
1234 break;
1235 default:
1236 break;
1237 }
1238 break;
1239
1240 case POWER_SUPPLY_PROP_TECHNOLOGY:
1241 switch (ext->desc->type) {
1242 case POWER_SUPPLY_TYPE_BATTERY:
1243 if (ret.intval)
1244 di->events.batt_unknown = false;
1245 else
1246 di->events.batt_unknown = true;
1247
1248 break;
1249 default:
1250 break;
1251 }
1252 break;
1253
1254 case POWER_SUPPLY_PROP_TEMP:
1255 di->batt_data.temp = ret.intval / 10;
1256 break;
1257
1258 case POWER_SUPPLY_PROP_CURRENT_NOW:
1259 switch (ext->desc->type) {
1260 case POWER_SUPPLY_TYPE_MAINS:
1261 di->chg_info.ac_curr =
1262 ret.intval / 1000;
1263 break;
1264 case POWER_SUPPLY_TYPE_USB:
1265 di->chg_info.usb_curr =
1266 ret.intval / 1000;
1267 break;
1268 case POWER_SUPPLY_TYPE_BATTERY:
1269 di->batt_data.inst_curr = ret.intval / 1000;
1270 break;
1271 default:
1272 break;
1273 }
1274 break;
1275
1276 case POWER_SUPPLY_PROP_CURRENT_AVG:
1277 switch (ext->desc->type) {
1278 case POWER_SUPPLY_TYPE_BATTERY:
1279 di->batt_data.avg_curr = ret.intval / 1000;
1280 break;
1281 case POWER_SUPPLY_TYPE_USB:
1282 if (ret.intval)
1283 di->events.vbus_collapsed = true;
1284 else
1285 di->events.vbus_collapsed = false;
1286 break;
1287 default:
1288 break;
1289 }
1290 break;
1291 case POWER_SUPPLY_PROP_CAPACITY:
1292 if (!capacity_updated)
1293 di->batt_data.percent = ret.intval;
1294 break;
1295 default:
1296 break;
1297 }
1298 }
1299 return 0;
1300}
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311static void abx500_chargalg_external_power_changed(struct power_supply *psy)
1312{
1313 struct abx500_chargalg *di = power_supply_get_drvdata(psy);
1314
1315
1316
1317
1318
1319 queue_work(di->chargalg_wq, &di->chargalg_work);
1320}
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330static void abx500_chargalg_algorithm(struct abx500_chargalg *di)
1331{
1332 int charger_status;
1333 int ret;
1334 int curr_step_lvl;
1335
1336
1337 class_for_each_device(power_supply_class, NULL,
1338 di->chargalg_psy, abx500_chargalg_get_ext_psy_data);
1339
1340 abx500_chargalg_end_of_charge(di);
1341 abx500_chargalg_check_temp(di);
1342 abx500_chargalg_check_charger_voltage(di);
1343
1344 charger_status = abx500_chargalg_check_charger_connection(di);
1345 abx500_chargalg_check_current_step_status(di);
1346
1347 if (is_ab8500(di->parent)) {
1348 ret = abx500_chargalg_check_charger_enable(di);
1349 if (ret < 0)
1350 dev_err(di->dev, "Checking charger is enabled error"
1351 ": Returned Value %d\n", ret);
1352 }
1353
1354
1355
1356
1357
1358
1359 if (!charger_status ||
1360 (di->events.batt_unknown && !di->bm->chg_unknown_bat)) {
1361 if (di->charge_state != STATE_HANDHELD) {
1362 di->events.safety_timer_expired = false;
1363 abx500_chargalg_state_to(di, STATE_HANDHELD_INIT);
1364 }
1365 }
1366
1367
1368 else if (di->charge_state == STATE_SUSPENDED_INIT ||
1369 di->charge_state == STATE_SUSPENDED) {
1370
1371 }
1372
1373
1374 else if (di->events.safety_timer_expired) {
1375 if (di->charge_state != STATE_SAFETY_TIMER_EXPIRED)
1376 abx500_chargalg_state_to(di,
1377 STATE_SAFETY_TIMER_EXPIRED_INIT);
1378 }
1379
1380
1381
1382
1383
1384
1385 else if (di->events.batt_rem) {
1386 if (di->charge_state != STATE_BATT_REMOVED)
1387 abx500_chargalg_state_to(di, STATE_BATT_REMOVED_INIT);
1388 }
1389
1390 else if (di->events.mainextchnotok || di->events.usbchargernotok) {
1391
1392
1393
1394
1395 if (di->charge_state != STATE_CHG_NOT_OK &&
1396 !di->events.vbus_collapsed)
1397 abx500_chargalg_state_to(di, STATE_CHG_NOT_OK_INIT);
1398 }
1399
1400 else if (di->events.vbus_ovv ||
1401 di->events.main_ovv ||
1402 di->events.batt_ovv ||
1403 !di->chg_info.usb_chg_ok ||
1404 !di->chg_info.ac_chg_ok) {
1405 if (di->charge_state != STATE_OVV_PROTECT)
1406 abx500_chargalg_state_to(di, STATE_OVV_PROTECT_INIT);
1407 }
1408
1409 else if (di->events.main_thermal_prot ||
1410 di->events.usb_thermal_prot) {
1411 if (di->charge_state != STATE_HW_TEMP_PROTECT)
1412 abx500_chargalg_state_to(di,
1413 STATE_HW_TEMP_PROTECT_INIT);
1414 }
1415
1416 else if (di->events.btemp_underover) {
1417 if (di->charge_state != STATE_TEMP_UNDEROVER)
1418 abx500_chargalg_state_to(di,
1419 STATE_TEMP_UNDEROVER_INIT);
1420 }
1421
1422 else if (di->events.ac_wd_expired ||
1423 di->events.usb_wd_expired) {
1424 if (di->charge_state != STATE_WD_EXPIRED)
1425 abx500_chargalg_state_to(di, STATE_WD_EXPIRED_INIT);
1426 }
1427
1428 else if (di->events.btemp_lowhigh) {
1429 if (di->charge_state != STATE_TEMP_LOWHIGH)
1430 abx500_chargalg_state_to(di, STATE_TEMP_LOWHIGH_INIT);
1431 }
1432
1433 dev_dbg(di->dev,
1434 "[CHARGALG] Vb %d Ib_avg %d Ib_inst %d Tb %d Cap %d Maint %d "
1435 "State %s Active_chg %d Chg_status %d AC %d USB %d "
1436 "AC_online %d USB_online %d AC_CV %d USB_CV %d AC_I %d "
1437 "USB_I %d AC_Vset %d AC_Iset %d USB_Vset %d USB_Iset %d\n",
1438 di->batt_data.volt,
1439 di->batt_data.avg_curr,
1440 di->batt_data.inst_curr,
1441 di->batt_data.temp,
1442 di->batt_data.percent,
1443 di->maintenance_chg,
1444 states[di->charge_state],
1445 di->chg_info.charger_type,
1446 di->charge_status,
1447 di->chg_info.conn_chg & AC_CHG,
1448 di->chg_info.conn_chg & USB_CHG,
1449 di->chg_info.online_chg & AC_CHG,
1450 di->chg_info.online_chg & USB_CHG,
1451 di->events.ac_cv_active,
1452 di->events.usb_cv_active,
1453 di->chg_info.ac_curr,
1454 di->chg_info.usb_curr,
1455 di->chg_info.ac_vset,
1456 di->chg_info.ac_iset,
1457 di->chg_info.usb_vset,
1458 di->chg_info.usb_iset);
1459
1460 switch (di->charge_state) {
1461 case STATE_HANDHELD_INIT:
1462 abx500_chargalg_stop_charging(di);
1463 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1464 abx500_chargalg_state_to(di, STATE_HANDHELD);
1465
1466
1467 case STATE_HANDHELD:
1468 break;
1469
1470 case STATE_SUSPENDED_INIT:
1471 if (di->susp_status.ac_suspended)
1472 abx500_chargalg_ac_en(di, false, 0, 0);
1473 if (di->susp_status.usb_suspended)
1474 abx500_chargalg_usb_en(di, false, 0, 0);
1475 abx500_chargalg_stop_safety_timer(di);
1476 abx500_chargalg_stop_maintenance_timer(di);
1477 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1478 di->maintenance_chg = false;
1479 abx500_chargalg_state_to(di, STATE_SUSPENDED);
1480 power_supply_changed(di->chargalg_psy);
1481
1482
1483 case STATE_SUSPENDED:
1484
1485 break;
1486
1487 case STATE_BATT_REMOVED_INIT:
1488 abx500_chargalg_stop_charging(di);
1489 abx500_chargalg_state_to(di, STATE_BATT_REMOVED);
1490
1491
1492 case STATE_BATT_REMOVED:
1493 if (!di->events.batt_rem)
1494 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1495 break;
1496
1497 case STATE_HW_TEMP_PROTECT_INIT:
1498 abx500_chargalg_stop_charging(di);
1499 abx500_chargalg_state_to(di, STATE_HW_TEMP_PROTECT);
1500
1501
1502 case STATE_HW_TEMP_PROTECT:
1503 if (!di->events.main_thermal_prot &&
1504 !di->events.usb_thermal_prot)
1505 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1506 break;
1507
1508 case STATE_OVV_PROTECT_INIT:
1509 abx500_chargalg_stop_charging(di);
1510 abx500_chargalg_state_to(di, STATE_OVV_PROTECT);
1511
1512
1513 case STATE_OVV_PROTECT:
1514 if (!di->events.vbus_ovv &&
1515 !di->events.main_ovv &&
1516 !di->events.batt_ovv &&
1517 di->chg_info.usb_chg_ok &&
1518 di->chg_info.ac_chg_ok)
1519 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1520 break;
1521
1522 case STATE_CHG_NOT_OK_INIT:
1523 abx500_chargalg_stop_charging(di);
1524 abx500_chargalg_state_to(di, STATE_CHG_NOT_OK);
1525
1526
1527 case STATE_CHG_NOT_OK:
1528 if (!di->events.mainextchnotok &&
1529 !di->events.usbchargernotok)
1530 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1531 break;
1532
1533 case STATE_SAFETY_TIMER_EXPIRED_INIT:
1534 abx500_chargalg_stop_charging(di);
1535 abx500_chargalg_state_to(di, STATE_SAFETY_TIMER_EXPIRED);
1536
1537
1538 case STATE_SAFETY_TIMER_EXPIRED:
1539
1540 break;
1541
1542 case STATE_NORMAL_INIT:
1543 if ((di->chg_info.charger_type & USB_CHG) &&
1544 di->usb_chg->power_path) {
1545 if (di->batt_data.volt >
1546 (di->bm->fg_params->lowbat_threshold +
1547 BAT_PLUS_MARGIN)) {
1548 ab8540_chargalg_usb_pre_chg_en(di, false);
1549 ab8540_chargalg_usb_pp_en(di, false);
1550 } else {
1551 ab8540_chargalg_usb_pp_en(di, true);
1552 ab8540_chargalg_usb_pre_chg_en(di, true);
1553 abx500_chargalg_state_to(di,
1554 STATE_USB_PP_PRE_CHARGE);
1555 break;
1556 }
1557 }
1558
1559 if (di->curr_status.curr_step == CHARGALG_CURR_STEP_LOW)
1560 abx500_chargalg_stop_charging(di);
1561 else {
1562 curr_step_lvl = di->bm->bat_type[
1563 di->bm->batt_id].normal_cur_lvl
1564 * di->curr_status.curr_step
1565 / CHARGALG_CURR_STEP_HIGH;
1566 abx500_chargalg_start_charging(di,
1567 di->bm->bat_type[di->bm->batt_id]
1568 .normal_vol_lvl, curr_step_lvl);
1569 }
1570
1571 abx500_chargalg_state_to(di, STATE_NORMAL);
1572 abx500_chargalg_start_safety_timer(di);
1573 abx500_chargalg_stop_maintenance_timer(di);
1574 init_maxim_chg_curr(di);
1575 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1576 di->eoc_cnt = 0;
1577 di->maintenance_chg = false;
1578 power_supply_changed(di->chargalg_psy);
1579
1580 break;
1581
1582 case STATE_USB_PP_PRE_CHARGE:
1583 if (di->batt_data.volt >
1584 (di->bm->fg_params->lowbat_threshold +
1585 BAT_PLUS_MARGIN))
1586 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1587 break;
1588
1589 case STATE_NORMAL:
1590 handle_maxim_chg_curr(di);
1591 if (di->charge_status == POWER_SUPPLY_STATUS_FULL &&
1592 di->maintenance_chg) {
1593 if (di->bm->no_maintenance)
1594 abx500_chargalg_state_to(di,
1595 STATE_WAIT_FOR_RECHARGE_INIT);
1596 else
1597 abx500_chargalg_state_to(di,
1598 STATE_MAINTENANCE_A_INIT);
1599 }
1600 break;
1601
1602
1603 case STATE_WAIT_FOR_RECHARGE_INIT:
1604 abx500_chargalg_hold_charging(di);
1605 abx500_chargalg_state_to(di, STATE_WAIT_FOR_RECHARGE);
1606
1607
1608 case STATE_WAIT_FOR_RECHARGE:
1609 if (di->batt_data.percent <=
1610 di->bm->bat_type[di->bm->batt_id].
1611 recharge_cap)
1612 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1613 break;
1614
1615 case STATE_MAINTENANCE_A_INIT:
1616 abx500_chargalg_stop_safety_timer(di);
1617 abx500_chargalg_start_maintenance_timer(di,
1618 di->bm->bat_type[
1619 di->bm->batt_id].maint_a_chg_timer_h);
1620 abx500_chargalg_start_charging(di,
1621 di->bm->bat_type[
1622 di->bm->batt_id].maint_a_vol_lvl,
1623 di->bm->bat_type[
1624 di->bm->batt_id].maint_a_cur_lvl);
1625 abx500_chargalg_state_to(di, STATE_MAINTENANCE_A);
1626 power_supply_changed(di->chargalg_psy);
1627
1628
1629 case STATE_MAINTENANCE_A:
1630 if (di->events.maintenance_timer_expired) {
1631 abx500_chargalg_stop_maintenance_timer(di);
1632 abx500_chargalg_state_to(di, STATE_MAINTENANCE_B_INIT);
1633 }
1634 break;
1635
1636 case STATE_MAINTENANCE_B_INIT:
1637 abx500_chargalg_start_maintenance_timer(di,
1638 di->bm->bat_type[
1639 di->bm->batt_id].maint_b_chg_timer_h);
1640 abx500_chargalg_start_charging(di,
1641 di->bm->bat_type[
1642 di->bm->batt_id].maint_b_vol_lvl,
1643 di->bm->bat_type[
1644 di->bm->batt_id].maint_b_cur_lvl);
1645 abx500_chargalg_state_to(di, STATE_MAINTENANCE_B);
1646 power_supply_changed(di->chargalg_psy);
1647
1648
1649 case STATE_MAINTENANCE_B:
1650 if (di->events.maintenance_timer_expired) {
1651 abx500_chargalg_stop_maintenance_timer(di);
1652 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1653 }
1654 break;
1655
1656 case STATE_TEMP_LOWHIGH_INIT:
1657 abx500_chargalg_start_charging(di,
1658 di->bm->bat_type[
1659 di->bm->batt_id].low_high_vol_lvl,
1660 di->bm->bat_type[
1661 di->bm->batt_id].low_high_cur_lvl);
1662 abx500_chargalg_stop_maintenance_timer(di);
1663 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1664 abx500_chargalg_state_to(di, STATE_TEMP_LOWHIGH);
1665 power_supply_changed(di->chargalg_psy);
1666
1667
1668 case STATE_TEMP_LOWHIGH:
1669 if (!di->events.btemp_lowhigh)
1670 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1671 break;
1672
1673 case STATE_WD_EXPIRED_INIT:
1674 abx500_chargalg_stop_charging(di);
1675 abx500_chargalg_state_to(di, STATE_WD_EXPIRED);
1676
1677
1678 case STATE_WD_EXPIRED:
1679 if (!di->events.ac_wd_expired &&
1680 !di->events.usb_wd_expired)
1681 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1682 break;
1683
1684 case STATE_TEMP_UNDEROVER_INIT:
1685 abx500_chargalg_stop_charging(di);
1686 abx500_chargalg_state_to(di, STATE_TEMP_UNDEROVER);
1687
1688
1689 case STATE_TEMP_UNDEROVER:
1690 if (!di->events.btemp_underover)
1691 abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1692 break;
1693 }
1694
1695
1696 if (di->charge_state == STATE_NORMAL_INIT ||
1697 di->charge_state == STATE_MAINTENANCE_A_INIT ||
1698 di->charge_state == STATE_MAINTENANCE_B_INIT)
1699 queue_work(di->chargalg_wq, &di->chargalg_work);
1700}
1701
1702
1703
1704
1705
1706
1707
1708static void abx500_chargalg_periodic_work(struct work_struct *work)
1709{
1710 struct abx500_chargalg *di = container_of(work,
1711 struct abx500_chargalg, chargalg_periodic_work.work);
1712
1713 abx500_chargalg_algorithm(di);
1714
1715
1716
1717
1718
1719 if (di->chg_info.conn_chg)
1720 queue_delayed_work(di->chargalg_wq,
1721 &di->chargalg_periodic_work,
1722 di->bm->interval_charging * HZ);
1723 else
1724 queue_delayed_work(di->chargalg_wq,
1725 &di->chargalg_periodic_work,
1726 di->bm->interval_not_charging * HZ);
1727}
1728
1729
1730
1731
1732
1733
1734
1735static void abx500_chargalg_wd_work(struct work_struct *work)
1736{
1737 int ret;
1738 struct abx500_chargalg *di = container_of(work,
1739 struct abx500_chargalg, chargalg_wd_work.work);
1740
1741 dev_dbg(di->dev, "abx500_chargalg_wd_work\n");
1742
1743 ret = abx500_chargalg_kick_watchdog(di);
1744 if (ret < 0)
1745 dev_err(di->dev, "failed to kick watchdog\n");
1746
1747 queue_delayed_work(di->chargalg_wq,
1748 &di->chargalg_wd_work, CHG_WD_INTERVAL);
1749}
1750
1751
1752
1753
1754
1755
1756
1757static void abx500_chargalg_work(struct work_struct *work)
1758{
1759 struct abx500_chargalg *di = container_of(work,
1760 struct abx500_chargalg, chargalg_work);
1761
1762 abx500_chargalg_algorithm(di);
1763}
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777static int abx500_chargalg_get_property(struct power_supply *psy,
1778 enum power_supply_property psp,
1779 union power_supply_propval *val)
1780{
1781 struct abx500_chargalg *di = power_supply_get_drvdata(psy);
1782
1783 switch (psp) {
1784 case POWER_SUPPLY_PROP_STATUS:
1785 val->intval = di->charge_status;
1786 break;
1787 case POWER_SUPPLY_PROP_HEALTH:
1788 if (di->events.batt_ovv) {
1789 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1790 } else if (di->events.btemp_underover) {
1791 if (di->batt_data.temp <= di->bm->temp_under)
1792 val->intval = POWER_SUPPLY_HEALTH_COLD;
1793 else
1794 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
1795 } else if (di->charge_state == STATE_SAFETY_TIMER_EXPIRED ||
1796 di->charge_state == STATE_SAFETY_TIMER_EXPIRED_INIT) {
1797 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1798 } else {
1799 val->intval = POWER_SUPPLY_HEALTH_GOOD;
1800 }
1801 break;
1802 default:
1803 return -EINVAL;
1804 }
1805 return 0;
1806}
1807
1808
1809
1810static ssize_t abx500_chargalg_curr_step_show(struct abx500_chargalg *di,
1811 char *buf)
1812{
1813 return sprintf(buf, "%d\n", di->curr_status.curr_step);
1814}
1815
1816static ssize_t abx500_chargalg_curr_step_store(struct abx500_chargalg *di,
1817 const char *buf, size_t length)
1818{
1819 long int param;
1820 int ret;
1821
1822 ret = kstrtol(buf, 10, ¶m);
1823 if (ret < 0)
1824 return ret;
1825
1826 di->curr_status.curr_step = param;
1827 if (di->curr_status.curr_step >= CHARGALG_CURR_STEP_LOW &&
1828 di->curr_status.curr_step <= CHARGALG_CURR_STEP_HIGH) {
1829 di->curr_status.curr_step_change = true;
1830 queue_work(di->chargalg_wq, &di->chargalg_work);
1831 } else
1832 dev_info(di->dev, "Wrong current step\n"
1833 "Enter 0. Disable AC/USB Charging\n"
1834 "1--100. Set AC/USB charging current step\n"
1835 "100. Enable AC/USB Charging\n");
1836
1837 return strlen(buf);
1838}
1839
1840
1841static ssize_t abx500_chargalg_en_show(struct abx500_chargalg *di,
1842 char *buf)
1843{
1844 return sprintf(buf, "%d\n",
1845 di->susp_status.ac_suspended &&
1846 di->susp_status.usb_suspended);
1847}
1848
1849static ssize_t abx500_chargalg_en_store(struct abx500_chargalg *di,
1850 const char *buf, size_t length)
1851{
1852 long int param;
1853 int ac_usb;
1854 int ret;
1855
1856 ret = kstrtol(buf, 10, ¶m);
1857 if (ret < 0)
1858 return ret;
1859
1860 ac_usb = param;
1861 switch (ac_usb) {
1862 case 0:
1863
1864 di->susp_status.ac_suspended = true;
1865 di->susp_status.usb_suspended = true;
1866 di->susp_status.suspended_change = true;
1867
1868 queue_work(di->chargalg_wq,
1869 &di->chargalg_work);
1870 break;
1871 case 1:
1872
1873 di->susp_status.ac_suspended = false;
1874 di->susp_status.suspended_change = true;
1875
1876 queue_work(di->chargalg_wq,
1877 &di->chargalg_work);
1878 break;
1879 case 2:
1880
1881 di->susp_status.usb_suspended = false;
1882 di->susp_status.suspended_change = true;
1883
1884 queue_work(di->chargalg_wq,
1885 &di->chargalg_work);
1886 break;
1887 default:
1888 dev_info(di->dev, "Wrong input\n"
1889 "Enter 0. Disable AC/USB Charging\n"
1890 "1. Enable AC charging\n"
1891 "2. Enable USB Charging\n");
1892 };
1893 return strlen(buf);
1894}
1895
1896static struct abx500_chargalg_sysfs_entry abx500_chargalg_en_charger =
1897 __ATTR(chargalg, 0644, abx500_chargalg_en_show,
1898 abx500_chargalg_en_store);
1899
1900static struct abx500_chargalg_sysfs_entry abx500_chargalg_curr_step =
1901 __ATTR(chargalg_curr_step, 0644, abx500_chargalg_curr_step_show,
1902 abx500_chargalg_curr_step_store);
1903
1904static ssize_t abx500_chargalg_sysfs_show(struct kobject *kobj,
1905 struct attribute *attr, char *buf)
1906{
1907 struct abx500_chargalg_sysfs_entry *entry = container_of(attr,
1908 struct abx500_chargalg_sysfs_entry, attr);
1909
1910 struct abx500_chargalg *di = container_of(kobj,
1911 struct abx500_chargalg, chargalg_kobject);
1912
1913 if (!entry->show)
1914 return -EIO;
1915
1916 return entry->show(di, buf);
1917}
1918
1919static ssize_t abx500_chargalg_sysfs_charger(struct kobject *kobj,
1920 struct attribute *attr, const char *buf, size_t length)
1921{
1922 struct abx500_chargalg_sysfs_entry *entry = container_of(attr,
1923 struct abx500_chargalg_sysfs_entry, attr);
1924
1925 struct abx500_chargalg *di = container_of(kobj,
1926 struct abx500_chargalg, chargalg_kobject);
1927
1928 if (!entry->store)
1929 return -EIO;
1930
1931 return entry->store(di, buf, length);
1932}
1933
1934static struct attribute *abx500_chargalg_chg[] = {
1935 &abx500_chargalg_en_charger.attr,
1936 &abx500_chargalg_curr_step.attr,
1937 NULL,
1938};
1939
1940static const struct sysfs_ops abx500_chargalg_sysfs_ops = {
1941 .show = abx500_chargalg_sysfs_show,
1942 .store = abx500_chargalg_sysfs_charger,
1943};
1944
1945static struct kobj_type abx500_chargalg_ktype = {
1946 .sysfs_ops = &abx500_chargalg_sysfs_ops,
1947 .default_attrs = abx500_chargalg_chg,
1948};
1949
1950
1951
1952
1953
1954
1955
1956static void abx500_chargalg_sysfs_exit(struct abx500_chargalg *di)
1957{
1958 kobject_del(&di->chargalg_kobject);
1959}
1960
1961
1962
1963
1964
1965
1966
1967
1968static int abx500_chargalg_sysfs_init(struct abx500_chargalg *di)
1969{
1970 int ret = 0;
1971
1972 ret = kobject_init_and_add(&di->chargalg_kobject,
1973 &abx500_chargalg_ktype,
1974 NULL, "abx500_chargalg");
1975 if (ret < 0)
1976 dev_err(di->dev, "failed to create sysfs entry\n");
1977
1978 return ret;
1979}
1980
1981
1982#if defined(CONFIG_PM)
1983static int abx500_chargalg_resume(struct platform_device *pdev)
1984{
1985 struct abx500_chargalg *di = platform_get_drvdata(pdev);
1986
1987
1988 if (di->chg_info.online_chg)
1989 queue_delayed_work(di->chargalg_wq, &di->chargalg_wd_work, 0);
1990
1991
1992
1993
1994
1995 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1996
1997 return 0;
1998}
1999
2000static int abx500_chargalg_suspend(struct platform_device *pdev,
2001 pm_message_t state)
2002{
2003 struct abx500_chargalg *di = platform_get_drvdata(pdev);
2004
2005 if (di->chg_info.online_chg)
2006 cancel_delayed_work_sync(&di->chargalg_wd_work);
2007
2008 cancel_delayed_work_sync(&di->chargalg_periodic_work);
2009
2010 return 0;
2011}
2012#else
2013#define abx500_chargalg_suspend NULL
2014#define abx500_chargalg_resume NULL
2015#endif
2016
2017static int abx500_chargalg_remove(struct platform_device *pdev)
2018{
2019 struct abx500_chargalg *di = platform_get_drvdata(pdev);
2020
2021
2022 abx500_chargalg_sysfs_exit(di);
2023
2024 hrtimer_cancel(&di->safety_timer);
2025 hrtimer_cancel(&di->maintenance_timer);
2026
2027 cancel_delayed_work_sync(&di->chargalg_periodic_work);
2028 cancel_delayed_work_sync(&di->chargalg_wd_work);
2029 cancel_work_sync(&di->chargalg_work);
2030
2031
2032 destroy_workqueue(di->chargalg_wq);
2033
2034 power_supply_unregister(di->chargalg_psy);
2035
2036 return 0;
2037}
2038
2039static char *supply_interface[] = {
2040 "ab8500_fg",
2041};
2042
2043static const struct power_supply_desc abx500_chargalg_desc = {
2044 .name = "abx500_chargalg",
2045 .type = POWER_SUPPLY_TYPE_BATTERY,
2046 .properties = abx500_chargalg_props,
2047 .num_properties = ARRAY_SIZE(abx500_chargalg_props),
2048 .get_property = abx500_chargalg_get_property,
2049 .external_power_changed = abx500_chargalg_external_power_changed,
2050};
2051
2052static int abx500_chargalg_probe(struct platform_device *pdev)
2053{
2054 struct device_node *np = pdev->dev.of_node;
2055 struct abx500_bm_data *plat = pdev->dev.platform_data;
2056 struct power_supply_config psy_cfg = {};
2057 struct abx500_chargalg *di;
2058 int ret = 0;
2059
2060 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
2061 if (!di) {
2062 dev_err(&pdev->dev, "%s no mem for ab8500_chargalg\n", __func__);
2063 return -ENOMEM;
2064 }
2065
2066 if (!plat) {
2067 dev_err(&pdev->dev, "no battery management data supplied\n");
2068 return -EINVAL;
2069 }
2070 di->bm = plat;
2071
2072 if (np) {
2073 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
2074 if (ret) {
2075 dev_err(&pdev->dev, "failed to get battery information\n");
2076 return ret;
2077 }
2078 }
2079
2080
2081 di->dev = &pdev->dev;
2082 di->parent = dev_get_drvdata(pdev->dev.parent);
2083
2084 psy_cfg.supplied_to = supply_interface;
2085 psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
2086 psy_cfg.drv_data = di;
2087
2088
2089 hrtimer_init(&di->safety_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
2090 di->safety_timer.function = abx500_chargalg_safety_timer_expired;
2091
2092
2093 hrtimer_init(&di->maintenance_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
2094 di->maintenance_timer.function =
2095 abx500_chargalg_maintenance_timer_expired;
2096
2097
2098 di->chargalg_wq =
2099 create_singlethread_workqueue("abx500_chargalg_wq");
2100 if (di->chargalg_wq == NULL) {
2101 dev_err(di->dev, "failed to create work queue\n");
2102 return -ENOMEM;
2103 }
2104
2105
2106 INIT_DEFERRABLE_WORK(&di->chargalg_periodic_work,
2107 abx500_chargalg_periodic_work);
2108 INIT_DEFERRABLE_WORK(&di->chargalg_wd_work,
2109 abx500_chargalg_wd_work);
2110
2111
2112 INIT_WORK(&di->chargalg_work, abx500_chargalg_work);
2113
2114
2115 di->chg_info.prev_conn_chg = -1;
2116
2117
2118 di->chargalg_psy = power_supply_register(di->dev, &abx500_chargalg_desc,
2119 &psy_cfg);
2120 if (IS_ERR(di->chargalg_psy)) {
2121 dev_err(di->dev, "failed to register chargalg psy\n");
2122 ret = PTR_ERR(di->chargalg_psy);
2123 goto free_chargalg_wq;
2124 }
2125
2126 platform_set_drvdata(pdev, di);
2127
2128
2129 ret = abx500_chargalg_sysfs_init(di);
2130 if (ret) {
2131 dev_err(di->dev, "failed to create sysfs entry\n");
2132 goto free_psy;
2133 }
2134 di->curr_status.curr_step = CHARGALG_CURR_STEP_HIGH;
2135
2136
2137 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
2138
2139 dev_info(di->dev, "probe success\n");
2140 return ret;
2141
2142free_psy:
2143 power_supply_unregister(di->chargalg_psy);
2144free_chargalg_wq:
2145 destroy_workqueue(di->chargalg_wq);
2146 return ret;
2147}
2148
2149static const struct of_device_id ab8500_chargalg_match[] = {
2150 { .compatible = "stericsson,ab8500-chargalg", },
2151 { },
2152};
2153
2154static struct platform_driver abx500_chargalg_driver = {
2155 .probe = abx500_chargalg_probe,
2156 .remove = abx500_chargalg_remove,
2157 .suspend = abx500_chargalg_suspend,
2158 .resume = abx500_chargalg_resume,
2159 .driver = {
2160 .name = "ab8500-chargalg",
2161 .of_match_table = ab8500_chargalg_match,
2162 },
2163};
2164
2165module_platform_driver(abx500_chargalg_driver);
2166
2167MODULE_LICENSE("GPL v2");
2168MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
2169MODULE_ALIAS("platform:abx500-chargalg");
2170MODULE_DESCRIPTION("abx500 battery charging algorithm");
2171