Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

Linux/drivers/power/abx500_chargalg.c

  1 /*
  2  * Copyright (C) ST-Ericsson SA 2012
  3  * Copyright (c) 2012 Sony Mobile Communications AB
  4  *
  5  * Charging algorithm driver for abx500 variants
  6  *
  7  * License Terms: GNU General Public License v2
  8  * Authors:
  9  *      Johan Palsson <johan.palsson@stericsson.com>
 10  *      Karl Komierowski <karl.komierowski@stericsson.com>
 11  *      Arun R Murthy <arun.murthy@stericsson.com>
 12  *      Author: Imre Sunyi <imre.sunyi@sonymobile.com>
 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 /* Watchdog kick interval */
 36 #define CHG_WD_INTERVAL                 (6 * HZ)
 37 
 38 /* End-of-charge criteria counter */
 39 #define EOC_COND_CNT                    10
 40 
 41 /* One hour expressed in seconds */
 42 #define ONE_HOUR_IN_SECONDS            3600
 43 
 44 /* Five minutes expressed in seconds */
 45 #define FIVE_MINUTES_IN_SECONDS        300
 46 
 47 /* Plus margin for the low battery threshold */
 48 #define BAT_PLUS_MARGIN                (100)
 49 
 50 #define CHARGALG_CURR_STEP_LOW          0
 51 #define CHARGALG_CURR_STEP_HIGH 100
 52 
 53 enum abx500_chargers {
 54         NO_CHG,
 55         AC_CHG,
 56         USB_CHG,
 57 };
 58 
 59 struct 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 
 77 struct abx500_chargalg_suspension_status {
 78         bool suspended_change;
 79         bool ac_suspended;
 80         bool usb_suspended;
 81 };
 82 
 83 struct abx500_chargalg_current_step_status {
 84         bool curr_step_change;
 85         int curr_step;
 86 };
 87 
 88 struct abx500_chargalg_battery_data {
 89         int temp;
 90         int volt;
 91         int avg_curr;
 92         int inst_curr;
 93         int percent;
 94 };
 95 
 96 enum 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 
128 static 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 
160 struct 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  * struct abx500_charge_curr_maximization - Charger maximization parameters
183  * @original_iset:      the non optimized/maximised charger current
184  * @current_iset:       the charging current used at this moment
185  * @test_delta_i:       the delta between the current we want to charge and the
186                         current that is really going into the battery
187  * @condition_cnt:      number of iterations needed before a new charger current
188                         is set
189  * @max_current:        maximum charger current
190  * @wait_cnt:           to avoid too fast current step down in case of charger
191  *                      voltage collapse, we insert this delay between step
192  *                      down
193  * @level:              tells in how many steps the charging current has been
194                         increased
195  */
196 struct 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 
206 enum maxim_ret {
207         MAXIM_RET_NOACTION,
208         MAXIM_RET_CHANGE,
209         MAXIM_RET_IBAT_TOO_HIGH,
210 };
211 
212 /**
213  * struct abx500_chargalg - abx500 Charging algorithm device information
214  * @dev:                pointer to the structure device
215  * @charge_status:      battery operating status
216  * @eoc_cnt:            counter used to determine end-of_charge
217  * @maintenance_chg:    indicate if maintenance charge is active
218  * @t_hyst_norm         temperature hysteresis when the temperature has been
219  *                      over or under normal limits
220  * @t_hyst_lowhigh      temperature hysteresis when the temperature has been
221  *                      over or under the high or low limits
222  * @charge_state:       current state of the charging algorithm
223  * @ccm                 charging current maximization parameters
224  * @chg_info:           information about connected charger types
225  * @batt_data:          data of the battery
226  * @susp_status:        current charger suspension status
227  * @bm:                 Platform specific battery management information
228  * @curr_status:        Current step status for over-current protection
229  * @parent:             pointer to the struct abx500
230  * @chargalg_psy:       structure that holds the battery properties exposed by
231  *                      the charging algorithm
232  * @events:             structure for information about events triggered
233  * @chargalg_wq:                work queue for running the charging algorithm
234  * @chargalg_periodic_work:     work to run the charging algorithm periodically
235  * @chargalg_wd_work:           work to kick the charger watchdog periodically
236  * @chargalg_work:              work to run the charging algorithm instantly
237  * @safety_timer:               charging safety timer
238  * @maintenance_timer:          maintenance charging timer
239  * @chargalg_kobject:           structure of type kobject
240  */
241 struct 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 /*External charger prepare notifier*/
270 BLOCKING_NOTIFIER_HEAD(charger_notifier_list);
271 
272 /* Main battery properties */
273 static enum power_supply_property abx500_chargalg_props[] = {
274         POWER_SUPPLY_PROP_STATUS,
275         POWER_SUPPLY_PROP_HEALTH,
276 };
277 
278 struct 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  * abx500_chargalg_safety_timer_expired() - Expiration of the safety timer
286  * @timer:     pointer to the hrtimer structure
287  *
288  * This function gets called when the safety timer for the charger
289  * expires
290  */
291 static enum hrtimer_restart
292 abx500_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         /* Trigger execution of the algorithm instantly */
300         queue_work(di->chargalg_wq, &di->chargalg_work);
301 
302         return HRTIMER_NORESTART;
303 }
304 
305 /**
306  * abx500_chargalg_maintenance_timer_expired() - Expiration of
307  * the maintenance timer
308  * @timer:     pointer to the timer structure
309  *
310  * This function gets called when the maintenence timer
311  * expires
312  */
313 static enum hrtimer_restart
314 abx500_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         /* Trigger execution of the algorithm instantly */
324         queue_work(di->chargalg_wq, &di->chargalg_work);
325 
326         return HRTIMER_NORESTART;
327 }
328 
329 /**
330  * abx500_chargalg_state_to() - Change charge state
331  * @di:         pointer to the abx500_chargalg structure
332  *
333  * This function gets called when a charge state change should occur
334  */
335 static 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 
349 static 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  * abx500_chargalg_check_charger_connection() - Check charger connection change
375  * @di:         pointer to the abx500_chargalg structure
376  *
377  * This function will check if there is a change in the charger connection
378  * and change charge state accordingly. AC has precedence over USB.
379  */
380 static 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                  * Charger state changed or suspension
386                  * has changed since last update
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  * abx500_chargalg_check_current_step_status() - Check charging current
419  * step status.
420  * @di:         pointer to the abx500_chargalg structure
421  *
422  * This function will check if there is a change in the charging current step
423  * and change charge state accordingly.
424  */
425 static 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  * abx500_chargalg_start_safety_timer() - Start charging safety timer
435  * @di:         pointer to the abx500_chargalg structure
436  *
437  * The safety timer is used to avoid overcharging of old or bad batteries.
438  * There are different timers for AC and USB
439  */
440 static void abx500_chargalg_start_safety_timer(struct abx500_chargalg *di)
441 {
442         /* Charger-dependent expiration time in hours*/
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  * abx500_chargalg_stop_safety_timer() - Stop charging safety timer
468  * @di:         pointer to the abx500_chargalg structure
469  *
470  * The safety timer is stopped whenever the NORMAL state is exited
471  */
472 static 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  * abx500_chargalg_start_maintenance_timer() - Start charging maintenance timer
480  * @di:         pointer to the abx500_chargalg structure
481  * @duration:   duration of ther maintenance timer in hours
482  *
483  * The maintenance timer is used to maintain the charge in the battery once
484  * the battery is considered full. These timers are chosen to match the
485  * discharge curve of the battery
486  */
487 static 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  * abx500_chargalg_stop_maintenance_timer() - Stop maintenance timer
499  * @di:         pointer to the abx500_chargalg structure
500  *
501  * The maintenance timer is stopped whenever maintenance ends or when another
502  * state is entered
503  */
504 static 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  * abx500_chargalg_kick_watchdog() - Kick charger watchdog
512  * @di:         pointer to the abx500_chargalg structure
513  *
514  * The charger watchdog have to be kicked periodically whenever the charger is
515  * on, else the ABB will reset the system
516  */
517 static int abx500_chargalg_kick_watchdog(struct abx500_chargalg *di)
518 {
519         /* Check if charger exists and kick watchdog if charging */
520         if (di->ac_chg && di->ac_chg->ops.kick_wd &&
521             di->chg_info.online_chg & AC_CHG) {
522                 /*
523                  * If AB charger watchdog expired, pm2xxx charging
524                  * gets disabled. To be safe, kick both AB charger watchdog
525                  * and pm2xxx watchdog.
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  * abx500_chargalg_ac_en() - Turn on/off the AC charger
542  * @di:         pointer to the abx500_chargalg structure
543  * @enable:     charger on/off
544  * @vset:       requested charger output voltage
545  * @iset:       requested charger output current
546  *
547  * The AC charger will be turned on/off with the requested charge voltage and
548  * current
549  */
550 static 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         /* Select maximum of what both the charger and the battery supports */
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         /* Enable external charger */
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  * abx500_chargalg_usb_en() - Turn on/off the USB charger
580  * @di:         pointer to the abx500_chargalg structure
581  * @enable:     charger on/off
582  * @vset:       requested charger output voltage
583  * @iset:       requested charger output current
584  *
585  * The USB charger will be turned on/off with the requested charge voltage and
586  * current
587  */
588 static 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         /* Select maximum of what both the charger and the battery supports */
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  * ab8540_chargalg_usb_pp_en() - Enable/ disable USB power path
608  * @di:                pointer to the abx500_chargalg structure
609  * @enable:    power path enable/disable
610  *
611  * The USB power path will be enable/ disable
612  */
613 static 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  * ab8540_chargalg_usb_pre_chg_en() - Enable/ disable USB pre-charge
623  * @di:                pointer to the abx500_chargalg structure
624  * @enable:    USB pre-charge enable/disable
625  *
626  * The USB USB pre-charge will be enable/ disable
627  */
628 static 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  * abx500_chargalg_update_chg_curr() - Update charger current
639  * @di:         pointer to the abx500_chargalg structure
640  * @iset:       requested charger output current
641  *
642  * The charger output current will be updated for the charger
643  * that is currently in use
644  */
645 static int abx500_chargalg_update_chg_curr(struct abx500_chargalg *di,
646                 int iset)
647 {
648         /* Check if charger exists and update current if charging */
649         if (di->ac_chg && di->ac_chg->ops.update_curr &&
650                         di->chg_info.charger_type & AC_CHG) {
651                 /*
652                  * Select maximum of what both the charger
653                  * and the battery supports
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                  * Select maximum of what both the charger
665                  * and the battery supports
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  * abx500_chargalg_stop_charging() - Stop charging
680  * @di:         pointer to the abx500_chargalg structure
681  *
682  * This function is called from any state where charging should be stopped.
683  * All charging is disabled and all status parameters and timers are changed
684  * accordingly
685  */
686 static 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  * abx500_chargalg_hold_charging() - Pauses charging
700  * @di:         pointer to the abx500_chargalg structure
701  *
702  * This function is called in the case where maintenance charging has been
703  * disabled and instead a battery voltage mode is entered to check when the
704  * battery voltage has reached a certain recharge voltage
705  */
706 static 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  * abx500_chargalg_start_charging() - Start the charger
720  * @di:         pointer to the abx500_chargalg structure
721  * @vset:       requested charger output voltage
722  * @iset:       requested charger output current
723  *
724  * A charger will be enabled depending on the requested charger type that was
725  * detected previously.
726  */
727 static 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  * abx500_chargalg_check_temp() - Check battery temperature ranges
753  * @di:         pointer to the abx500_chargalg structure
754  *
755  * The battery temperature is checked against the predefined limits and the
756  * charge state is changed accordingly
757  */
758 static 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                 /* Temp OK! */
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                         /* TEMP minor!!!!! */
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                         /* TEMP major!!!!! */
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                 /* Within hysteresis */
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  * abx500_chargalg_check_charger_voltage() - Check charger voltage
798  * @di:         pointer to the abx500_chargalg structure
799  *
800  * Charger voltage is checked against maximum limit
801  */
802 static 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  * abx500_chargalg_end_of_charge() - Check if end-of-charge criteria is fulfilled
818  * @di:         pointer to the abx500_chargalg structure
819  *
820  * End-of-charge criteria is fulfilled when the battery voltage is above a
821  * certain limit and the battery current is below a certain limit for a
822  * predefined number of consecutive seconds. If true, the battery is full
823  */
824 static 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 
855 static 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  * abx500_chargalg_chg_curr_maxim - increases the charger current to
869  *                      compensate for the system load
870  * @di          pointer to the abx500_chargalg structure
871  *
872  * This maximization function is used to raise the charger current to get the
873  * battery current as close to the optimal value as possible. The battery
874  * current during charging is affected by the system load
875  */
876 static 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                         /* Let's go in here twice before lowering curr again */
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                         /* Increse the iset with cco.test_delta_i */
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 
948 static 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                 /* Do nothing..*/
971                 break;
972         }
973 }
974 
975 static int abx500_chargalg_get_ext_psy_data(struct device *dev, void *data)
976 {
977         struct power_supply *psy;
978         struct power_supply *ext = dev_get_drvdata(dev);
979         const char **supplicants = (const char **)ext->supplied_to;
980         struct abx500_chargalg *di;
981         union power_supply_propval ret;
982         int j;
983         bool capacity_updated = false;
984 
985         psy = (struct power_supply *)data;
986         di = power_supply_get_drvdata(psy);
987         /* For all psy where the driver name appears in any supplied_to */
988         j = match_string(supplicants, ext->num_supplicants, psy->desc->name);
989         if (j < 0)
990                 return 0;
991 
992         /*
993          *  If external is not registering 'POWER_SUPPLY_PROP_CAPACITY' to its
994          * property because of handling that sysfs entry on its own, this is
995          * the place to get the battery capacity.
996          */
997         if (!power_supply_get_property(ext, POWER_SUPPLY_PROP_CAPACITY, &ret)) {
998                 di->batt_data.percent = ret.intval;
999                 capacity_updated = true;
1000         }
1001 
1002         /* Go through all properties for the psy */
1003         for (j = 0; j < ext->desc->num_properties; j++) {
1004                 enum power_supply_property prop;
1005                 prop = ext->desc->properties[j];
1006 
1007                 /*
1008                  * Initialize chargers if not already done.
1009                  * The ab8500_charger*/
1010                 if (!di->ac_chg &&
1011                         ext->desc->type == POWER_SUPPLY_TYPE_MAINS)
1012                         di->ac_chg = psy_to_ux500_charger(ext);
1013                 else if (!di->usb_chg &&
1014                         ext->desc->type == POWER_SUPPLY_TYPE_USB)
1015                         di->usb_chg = psy_to_ux500_charger(ext);
1016 
1017                 if (power_supply_get_property(ext, prop, &ret))
1018                         continue;
1019                 switch (prop) {
1020                 case POWER_SUPPLY_PROP_PRESENT:
1021                         switch (ext->desc->type) {
1022                         case POWER_SUPPLY_TYPE_BATTERY:
1023                                 /* Battery present */
1024                                 if (ret.intval)
1025                                         di->events.batt_rem = false;
1026                                 /* Battery removed */
1027                                 else
1028                                         di->events.batt_rem = true;
1029                                 break;
1030                         case POWER_SUPPLY_TYPE_MAINS:
1031                                 /* AC disconnected */
1032                                 if (!ret.intval &&
1033                                         (di->chg_info.conn_chg & AC_CHG)) {
1034                                         di->chg_info.prev_conn_chg =
1035                                                 di->chg_info.conn_chg;
1036                                         di->chg_info.conn_chg &= ~AC_CHG;
1037                                 }
1038                                 /* AC connected */
1039                                 else if (ret.intval &&
1040                                         !(di->chg_info.conn_chg & AC_CHG)) {
1041                                         di->chg_info.prev_conn_chg =
1042                                                 di->chg_info.conn_chg;
1043                                         di->chg_info.conn_chg |= AC_CHG;
1044                                 }
1045                                 break;
1046                         case POWER_SUPPLY_TYPE_USB:
1047                                 /* USB disconnected */
1048                                 if (!ret.intval &&
1049                                         (di->chg_info.conn_chg & USB_CHG)) {
1050                                         di->chg_info.prev_conn_chg =
1051                                                 di->chg_info.conn_chg;
1052                                         di->chg_info.conn_chg &= ~USB_CHG;
1053                                 }
1054                                 /* USB connected */
1055                                 else if (ret.intval &&
1056                                         !(di->chg_info.conn_chg & USB_CHG)) {
1057                                         di->chg_info.prev_conn_chg =
1058                                                 di->chg_info.conn_chg;
1059                                         di->chg_info.conn_chg |= USB_CHG;
1060                                 }
1061                                 break;
1062                         default:
1063                                 break;
1064                         }
1065                         break;
1066 
1067                 case POWER_SUPPLY_PROP_ONLINE:
1068                         switch (ext->desc->type) {
1069                         case POWER_SUPPLY_TYPE_BATTERY:
1070                                 break;
1071                         case POWER_SUPPLY_TYPE_MAINS:
1072                                 /* AC offline */
1073                                 if (!ret.intval &&
1074                                         (di->chg_info.online_chg & AC_CHG)) {
1075                                         di->chg_info.prev_online_chg =
1076                                                 di->chg_info.online_chg;
1077                                         di->chg_info.online_chg &= ~AC_CHG;
1078                                 }
1079                                 /* AC online */
1080                                 else if (ret.intval &&
1081                                         !(di->chg_info.online_chg & AC_CHG)) {
1082                                         di->chg_info.prev_online_chg =
1083                                                 di->chg_info.online_chg;
1084                                         di->chg_info.online_chg |= AC_CHG;
1085                                         queue_delayed_work(di->chargalg_wq,
1086                                                 &di->chargalg_wd_work, 0);
1087                                 }
1088                                 break;
1089                         case POWER_SUPPLY_TYPE_USB:
1090                                 /* USB offline */
1091                                 if (!ret.intval &&
1092                                         (di->chg_info.online_chg & USB_CHG)) {
1093                                         di->chg_info.prev_online_chg =
1094                                                 di->chg_info.online_chg;
1095                                         di->chg_info.online_chg &= ~USB_CHG;
1096                                 }
1097                                 /* USB online */
1098                                 else if (ret.intval &&
1099                                         !(di->chg_info.online_chg & USB_CHG)) {
1100                                         di->chg_info.prev_online_chg =
1101                                                 di->chg_info.online_chg;
1102                                         di->chg_info.online_chg |= USB_CHG;
1103                                         queue_delayed_work(di->chargalg_wq,
1104                                                 &di->chargalg_wd_work, 0);
1105                                 }
1106                                 break;
1107                         default:
1108                                 break;
1109                         }
1110                         break;
1111 
1112                 case POWER_SUPPLY_PROP_HEALTH:
1113                         switch (ext->desc->type) {
1114                         case POWER_SUPPLY_TYPE_BATTERY:
1115                                 break;
1116                         case POWER_SUPPLY_TYPE_MAINS:
1117                                 switch (ret.intval) {
1118                                 case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
1119                                         di->events.mainextchnotok = true;
1120                                         di->events.main_thermal_prot = false;
1121                                         di->events.main_ovv = false;
1122                                         di->events.ac_wd_expired = false;
1123                                         break;
1124                                 case POWER_SUPPLY_HEALTH_DEAD:
1125                                         di->events.ac_wd_expired = true;
1126                                         di->events.mainextchnotok = false;
1127                                         di->events.main_ovv = false;
1128                                         di->events.main_thermal_prot = false;
1129                                         break;
1130                                 case POWER_SUPPLY_HEALTH_COLD:
1131                                 case POWER_SUPPLY_HEALTH_OVERHEAT:
1132                                         di->events.main_thermal_prot = true;
1133                                         di->events.mainextchnotok = false;
1134                                         di->events.main_ovv = false;
1135                                         di->events.ac_wd_expired = false;
1136                                         break;
1137                                 case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1138                                         di->events.main_ovv = true;
1139                                         di->events.mainextchnotok = false;
1140                                         di->events.main_thermal_prot = false;
1141                                         di->events.ac_wd_expired = false;
1142                                         break;
1143                                 case POWER_SUPPLY_HEALTH_GOOD:
1144                                         di->events.main_thermal_prot = false;
1145                                         di->events.mainextchnotok = false;
1146                                         di->events.main_ovv = false;
1147                                         di->events.ac_wd_expired = false;
1148                                         break;
1149                                 default:
1150                                         break;
1151                                 }
1152                                 break;
1153 
1154                         case POWER_SUPPLY_TYPE_USB:
1155                                 switch (ret.intval) {
1156                                 case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
1157                                         di->events.usbchargernotok = true;
1158                                         di->events.usb_thermal_prot = false;
1159                                         di->events.vbus_ovv = false;
1160                                         di->events.usb_wd_expired = false;
1161                                         break;
1162                                 case POWER_SUPPLY_HEALTH_DEAD:
1163                                         di->events.usb_wd_expired = true;
1164                                         di->events.usbchargernotok = false;
1165                                         di->events.usb_thermal_prot = false;
1166                                         di->events.vbus_ovv = false;
1167                                         break;
1168                                 case POWER_SUPPLY_HEALTH_COLD:
1169                                 case POWER_SUPPLY_HEALTH_OVERHEAT:
1170                                         di->events.usb_thermal_prot = true;
1171                                         di->events.usbchargernotok = false;
1172                                         di->events.vbus_ovv = false;
1173                                         di->events.usb_wd_expired = false;
1174                                         break;
1175                                 case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
1176                                         di->events.vbus_ovv = true;
1177                                         di->events.usbchargernotok = false;
1178                                         di->events.usb_thermal_prot = false;
1179                                         di->events.usb_wd_expired = false;
1180                                         break;
1181                                 case POWER_SUPPLY_HEALTH_GOOD:
1182                                         di->events.usbchargernotok = false;
1183                                         di->events.usb_thermal_prot = false;
1184                                         di->events.vbus_ovv = false;
1185                                         di->events.usb_wd_expired = false;
1186                                         break;
1187                                 default:
1188                                         break;
1189                                 }
1190                         default:
1191                                 break;
1192                         }
1193                         break;
1194 
1195                 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1196                         switch (ext->desc->type) {
1197                         case POWER_SUPPLY_TYPE_BATTERY:
1198                                 di->batt_data.volt = ret.intval / 1000;
1199                                 break;
1200                         case POWER_SUPPLY_TYPE_MAINS:
1201                                 di->chg_info.ac_volt = ret.intval / 1000;
1202                                 break;
1203                         case POWER_SUPPLY_TYPE_USB:
1204                                 di->chg_info.usb_volt = ret.intval / 1000;
1205                                 break;
1206                         default:
1207                                 break;
1208                         }
1209                         break;
1210 
1211                 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
1212                         switch (ext->desc->type) {
1213                         case POWER_SUPPLY_TYPE_MAINS:
1214                                 /* AVG is used to indicate when we are
1215                                  * in CV mode */
1216                                 if (ret.intval)
1217                                         di->events.ac_cv_active = true;
1218                                 else
1219                                         di->events.ac_cv_active = false;
1220 
1221                                 break;
1222                         case POWER_SUPPLY_TYPE_USB:
1223                                 /* AVG is used to indicate when we are
1224                                  * in CV mode */
1225                                 if (ret.intval)
1226                                         di->events.usb_cv_active = true;
1227                                 else
1228                                         di->events.usb_cv_active = false;
1229 
1230                                 break;
1231                         default:
1232                                 break;
1233                         }
1234                         break;
1235 
1236                 case POWER_SUPPLY_PROP_TECHNOLOGY:
1237                         switch (ext->desc->type) {
1238                         case POWER_SUPPLY_TYPE_BATTERY:
1239                                 if (ret.intval)
1240                                         di->events.batt_unknown = false;
1241                                 else
1242                                         di->events.batt_unknown = true;
1243 
1244                                 break;
1245                         default:
1246                                 break;
1247                         }
1248                         break;
1249 
1250                 case POWER_SUPPLY_PROP_TEMP:
1251                         di->batt_data.temp = ret.intval / 10;
1252                         break;
1253 
1254                 case POWER_SUPPLY_PROP_CURRENT_NOW:
1255                         switch (ext->desc->type) {
1256                         case POWER_SUPPLY_TYPE_MAINS:
1257                                         di->chg_info.ac_curr =
1258                                                 ret.intval / 1000;
1259                                         break;
1260                         case POWER_SUPPLY_TYPE_USB:
1261                                         di->chg_info.usb_curr =
1262                                                 ret.intval / 1000;
1263                                 break;
1264                         case POWER_SUPPLY_TYPE_BATTERY:
1265                                 di->batt_data.inst_curr = ret.intval / 1000;
1266                                 break;
1267                         default:
1268                                 break;
1269                         }
1270                         break;
1271 
1272                 case POWER_SUPPLY_PROP_CURRENT_AVG:
1273                         switch (ext->desc->type) {
1274                         case POWER_SUPPLY_TYPE_BATTERY:
1275                                 di->batt_data.avg_curr = ret.intval / 1000;
1276                                 break;
1277                         case POWER_SUPPLY_TYPE_USB:
1278                                 if (ret.intval)
1279                                         di->events.vbus_collapsed = true;
1280                                 else
1281                                         di->events.vbus_collapsed = false;
1282                                 break;
1283                         default:
1284                                 break;
1285                         }
1286                         break;
1287                 case POWER_SUPPLY_PROP_CAPACITY:
1288                         if (!capacity_updated)
1289                                 di->batt_data.percent = ret.intval;
1290                         break;
1291                 default:
1292                         break;
1293                 }
1294         }
1295         return 0;
1296 }
1297 
1298 /**
1299  * abx500_chargalg_external_power_changed() - callback for power supply changes
1300  * @psy:       pointer to the structure power_supply
1301  *
1302  * This function is the entry point of the pointer external_power_changed
1303  * of the structure power_supply.
1304  * This function gets executed when there is a change in any external power
1305  * supply that this driver needs to be notified of.
1306  */
1307 static void abx500_chargalg_external_power_changed(struct power_supply *psy)
1308 {
1309         struct abx500_chargalg *di = power_supply_get_drvdata(psy);
1310 
1311         /*
1312          * Trigger execution of the algorithm instantly and read
1313          * all power_supply properties there instead
1314          */
1315         queue_work(di->chargalg_wq, &di->chargalg_work);
1316 }
1317 
1318 /**
1319  * abx500_chargalg_algorithm() - Main function for the algorithm
1320  * @di:         pointer to the abx500_chargalg structure
1321  *
1322  * This is the main control function for the charging algorithm.
1323  * It is called periodically or when something happens that will
1324  * trigger a state change
1325  */
1326 static void abx500_chargalg_algorithm(struct abx500_chargalg *di)
1327 {
1328         int charger_status;
1329         int ret;
1330         int curr_step_lvl;
1331 
1332         /* Collect data from all power_supply class devices */
1333         class_for_each_device(power_supply_class, NULL,
1334                 di->chargalg_psy, abx500_chargalg_get_ext_psy_data);
1335 
1336         abx500_chargalg_end_of_charge(di);
1337         abx500_chargalg_check_temp(di);
1338         abx500_chargalg_check_charger_voltage(di);
1339 
1340         charger_status = abx500_chargalg_check_charger_connection(di);
1341         abx500_chargalg_check_current_step_status(di);
1342 
1343         if (is_ab8500(di->parent)) {
1344                 ret = abx500_chargalg_check_charger_enable(di);
1345                 if (ret < 0)
1346                         dev_err(di->dev, "Checking charger is enabled error"
1347                                         ": Returned Value %d\n", ret);
1348         }
1349 
1350         /*
1351          * First check if we have a charger connected.
1352          * Also we don't allow charging of unknown batteries if configured
1353          * this way
1354          */
1355         if (!charger_status ||
1356                 (di->events.batt_unknown && !di->bm->chg_unknown_bat)) {
1357                 if (di->charge_state != STATE_HANDHELD) {
1358                         di->events.safety_timer_expired = false;
1359                         abx500_chargalg_state_to(di, STATE_HANDHELD_INIT);
1360                 }
1361         }
1362 
1363         /* If suspended, we should not continue checking the flags */
1364         else if (di->charge_state == STATE_SUSPENDED_INIT ||
1365                 di->charge_state == STATE_SUSPENDED) {
1366                 /* We don't do anything here, just don,t continue */
1367         }
1368 
1369         /* Safety timer expiration */
1370         else if (di->events.safety_timer_expired) {
1371                 if (di->charge_state != STATE_SAFETY_TIMER_EXPIRED)
1372                         abx500_chargalg_state_to(di,
1373                                 STATE_SAFETY_TIMER_EXPIRED_INIT);
1374         }
1375         /*
1376          * Check if any interrupts has occured
1377          * that will prevent us from charging
1378          */
1379 
1380         /* Battery removed */
1381         else if (di->events.batt_rem) {
1382                 if (di->charge_state != STATE_BATT_REMOVED)
1383                         abx500_chargalg_state_to(di, STATE_BATT_REMOVED_INIT);
1384         }
1385         /* Main or USB charger not ok. */
1386         else if (di->events.mainextchnotok || di->events.usbchargernotok) {
1387                 /*
1388                  * If vbus_collapsed is set, we have to lower the charger
1389                  * current, which is done in the normal state below
1390                  */
1391                 if (di->charge_state != STATE_CHG_NOT_OK &&
1392                                 !di->events.vbus_collapsed)
1393                         abx500_chargalg_state_to(di, STATE_CHG_NOT_OK_INIT);
1394         }
1395         /* VBUS, Main or VBAT OVV. */
1396         else if (di->events.vbus_ovv ||
1397                         di->events.main_ovv ||
1398                         di->events.batt_ovv ||
1399                         !di->chg_info.usb_chg_ok ||
1400                         !di->chg_info.ac_chg_ok) {
1401                 if (di->charge_state != STATE_OVV_PROTECT)
1402                         abx500_chargalg_state_to(di, STATE_OVV_PROTECT_INIT);
1403         }
1404         /* USB Thermal, stop charging */
1405         else if (di->events.main_thermal_prot ||
1406                 di->events.usb_thermal_prot) {
1407                 if (di->charge_state != STATE_HW_TEMP_PROTECT)
1408                         abx500_chargalg_state_to(di,
1409                                 STATE_HW_TEMP_PROTECT_INIT);
1410         }
1411         /* Battery temp over/under */
1412         else if (di->events.btemp_underover) {
1413                 if (di->charge_state != STATE_TEMP_UNDEROVER)
1414                         abx500_chargalg_state_to(di,
1415                                 STATE_TEMP_UNDEROVER_INIT);
1416         }
1417         /* Watchdog expired */
1418         else if (di->events.ac_wd_expired ||
1419                 di->events.usb_wd_expired) {
1420                 if (di->charge_state != STATE_WD_EXPIRED)
1421                         abx500_chargalg_state_to(di, STATE_WD_EXPIRED_INIT);
1422         }
1423         /* Battery temp high/low */
1424         else if (di->events.btemp_lowhigh) {
1425                 if (di->charge_state != STATE_TEMP_LOWHIGH)
1426                         abx500_chargalg_state_to(di, STATE_TEMP_LOWHIGH_INIT);
1427         }
1428 
1429         dev_dbg(di->dev,
1430                 "[CHARGALG] Vb %d Ib_avg %d Ib_inst %d Tb %d Cap %d Maint %d "
1431                 "State %s Active_chg %d Chg_status %d AC %d USB %d "
1432                 "AC_online %d USB_online %d AC_CV %d USB_CV %d AC_I %d "
1433                 "USB_I %d AC_Vset %d AC_Iset %d USB_Vset %d USB_Iset %d\n",
1434                 di->batt_data.volt,
1435                 di->batt_data.avg_curr,
1436                 di->batt_data.inst_curr,
1437                 di->batt_data.temp,
1438                 di->batt_data.percent,
1439                 di->maintenance_chg,
1440                 states[di->charge_state],
1441                 di->chg_info.charger_type,
1442                 di->charge_status,
1443                 di->chg_info.conn_chg & AC_CHG,
1444                 di->chg_info.conn_chg & USB_CHG,
1445                 di->chg_info.online_chg & AC_CHG,
1446                 di->chg_info.online_chg & USB_CHG,
1447                 di->events.ac_cv_active,
1448                 di->events.usb_cv_active,
1449                 di->chg_info.ac_curr,
1450                 di->chg_info.usb_curr,
1451                 di->chg_info.ac_vset,
1452                 di->chg_info.ac_iset,
1453                 di->chg_info.usb_vset,
1454                 di->chg_info.usb_iset);
1455 
1456         switch (di->charge_state) {
1457         case STATE_HANDHELD_INIT:
1458                 abx500_chargalg_stop_charging(di);
1459                 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1460                 abx500_chargalg_state_to(di, STATE_HANDHELD);
1461                 /* Intentional fallthrough */
1462 
1463         case STATE_HANDHELD:
1464                 break;
1465 
1466         case STATE_SUSPENDED_INIT:
1467                 if (di->susp_status.ac_suspended)
1468                         abx500_chargalg_ac_en(di, false, 0, 0);
1469                 if (di->susp_status.usb_suspended)
1470                         abx500_chargalg_usb_en(di, false, 0, 0);
1471                 abx500_chargalg_stop_safety_timer(di);
1472                 abx500_chargalg_stop_maintenance_timer(di);
1473                 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1474                 di->maintenance_chg = false;
1475                 abx500_chargalg_state_to(di, STATE_SUSPENDED);
1476                 power_supply_changed(di->chargalg_psy);
1477                 /* Intentional fallthrough */
1478 
1479         case STATE_SUSPENDED:
1480                 /* CHARGING is suspended */
1481                 break;
1482 
1483         case STATE_BATT_REMOVED_INIT:
1484                 abx500_chargalg_stop_charging(di);
1485                 abx500_chargalg_state_to(di, STATE_BATT_REMOVED);
1486                 /* Intentional fallthrough */
1487 
1488         case STATE_BATT_REMOVED:
1489                 if (!di->events.batt_rem)
1490                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1491                 break;
1492 
1493         case STATE_HW_TEMP_PROTECT_INIT:
1494                 abx500_chargalg_stop_charging(di);
1495                 abx500_chargalg_state_to(di, STATE_HW_TEMP_PROTECT);
1496                 /* Intentional fallthrough */
1497 
1498         case STATE_HW_TEMP_PROTECT:
1499                 if (!di->events.main_thermal_prot &&
1500                                 !di->events.usb_thermal_prot)
1501                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1502                 break;
1503 
1504         case STATE_OVV_PROTECT_INIT:
1505                 abx500_chargalg_stop_charging(di);
1506                 abx500_chargalg_state_to(di, STATE_OVV_PROTECT);
1507                 /* Intentional fallthrough */
1508 
1509         case STATE_OVV_PROTECT:
1510                 if (!di->events.vbus_ovv &&
1511                                 !di->events.main_ovv &&
1512                                 !di->events.batt_ovv &&
1513                                 di->chg_info.usb_chg_ok &&
1514                                 di->chg_info.ac_chg_ok)
1515                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1516                 break;
1517 
1518         case STATE_CHG_NOT_OK_INIT:
1519                 abx500_chargalg_stop_charging(di);
1520                 abx500_chargalg_state_to(di, STATE_CHG_NOT_OK);
1521                 /* Intentional fallthrough */
1522 
1523         case STATE_CHG_NOT_OK:
1524                 if (!di->events.mainextchnotok &&
1525                                 !di->events.usbchargernotok)
1526                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1527                 break;
1528 
1529         case STATE_SAFETY_TIMER_EXPIRED_INIT:
1530                 abx500_chargalg_stop_charging(di);
1531                 abx500_chargalg_state_to(di, STATE_SAFETY_TIMER_EXPIRED);
1532                 /* Intentional fallthrough */
1533 
1534         case STATE_SAFETY_TIMER_EXPIRED:
1535                 /* We exit this state when charger is removed */
1536                 break;
1537 
1538         case STATE_NORMAL_INIT:
1539                 if ((di->chg_info.charger_type & USB_CHG) &&
1540                                 di->usb_chg->power_path) {
1541                         if (di->batt_data.volt >
1542                             (di->bm->fg_params->lowbat_threshold +
1543                              BAT_PLUS_MARGIN)) {
1544                                 ab8540_chargalg_usb_pre_chg_en(di, false);
1545                                 ab8540_chargalg_usb_pp_en(di, false);
1546                         } else {
1547                                 ab8540_chargalg_usb_pp_en(di, true);
1548                                 ab8540_chargalg_usb_pre_chg_en(di, true);
1549                                 abx500_chargalg_state_to(di,
1550                                         STATE_USB_PP_PRE_CHARGE);
1551                                 break;
1552                         }
1553                 }
1554 
1555                 if (di->curr_status.curr_step == CHARGALG_CURR_STEP_LOW)
1556                         abx500_chargalg_stop_charging(di);
1557                 else {
1558                         curr_step_lvl = di->bm->bat_type[
1559                                 di->bm->batt_id].normal_cur_lvl
1560                                 * di->curr_status.curr_step
1561                                 / CHARGALG_CURR_STEP_HIGH;
1562                         abx500_chargalg_start_charging(di,
1563                                 di->bm->bat_type[di->bm->batt_id]
1564                                 .normal_vol_lvl, curr_step_lvl);
1565                 }
1566 
1567                 abx500_chargalg_state_to(di, STATE_NORMAL);
1568                 abx500_chargalg_start_safety_timer(di);
1569                 abx500_chargalg_stop_maintenance_timer(di);
1570                 init_maxim_chg_curr(di);
1571                 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1572                 di->eoc_cnt = 0;
1573                 di->maintenance_chg = false;
1574                 power_supply_changed(di->chargalg_psy);
1575 
1576                 break;
1577 
1578         case STATE_USB_PP_PRE_CHARGE:
1579                 if (di->batt_data.volt >
1580                         (di->bm->fg_params->lowbat_threshold +
1581                         BAT_PLUS_MARGIN))
1582                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1583                 break;
1584 
1585         case STATE_NORMAL:
1586                 handle_maxim_chg_curr(di);
1587                 if (di->charge_status == POWER_SUPPLY_STATUS_FULL &&
1588                         di->maintenance_chg) {
1589                         if (di->bm->no_maintenance)
1590                                 abx500_chargalg_state_to(di,
1591                                         STATE_WAIT_FOR_RECHARGE_INIT);
1592                         else
1593                                 abx500_chargalg_state_to(di,
1594                                         STATE_MAINTENANCE_A_INIT);
1595                 }
1596                 break;
1597 
1598         /* This state will be used when the maintenance state is disabled */
1599         case STATE_WAIT_FOR_RECHARGE_INIT:
1600                 abx500_chargalg_hold_charging(di);
1601                 abx500_chargalg_state_to(di, STATE_WAIT_FOR_RECHARGE);
1602                 /* Intentional fallthrough */
1603 
1604         case STATE_WAIT_FOR_RECHARGE:
1605                 if (di->batt_data.percent <=
1606                     di->bm->bat_type[di->bm->batt_id].
1607                     recharge_cap)
1608                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1609                 break;
1610 
1611         case STATE_MAINTENANCE_A_INIT:
1612                 abx500_chargalg_stop_safety_timer(di);
1613                 abx500_chargalg_start_maintenance_timer(di,
1614                         di->bm->bat_type[
1615                                 di->bm->batt_id].maint_a_chg_timer_h);
1616                 abx500_chargalg_start_charging(di,
1617                         di->bm->bat_type[
1618                                 di->bm->batt_id].maint_a_vol_lvl,
1619                         di->bm->bat_type[
1620                                 di->bm->batt_id].maint_a_cur_lvl);
1621                 abx500_chargalg_state_to(di, STATE_MAINTENANCE_A);
1622                 power_supply_changed(di->chargalg_psy);
1623                 /* Intentional fallthrough*/
1624 
1625         case STATE_MAINTENANCE_A:
1626                 if (di->events.maintenance_timer_expired) {
1627                         abx500_chargalg_stop_maintenance_timer(di);
1628                         abx500_chargalg_state_to(di, STATE_MAINTENANCE_B_INIT);
1629                 }
1630                 break;
1631 
1632         case STATE_MAINTENANCE_B_INIT:
1633                 abx500_chargalg_start_maintenance_timer(di,
1634                         di->bm->bat_type[
1635                                 di->bm->batt_id].maint_b_chg_timer_h);
1636                 abx500_chargalg_start_charging(di,
1637                         di->bm->bat_type[
1638                                 di->bm->batt_id].maint_b_vol_lvl,
1639                         di->bm->bat_type[
1640                                 di->bm->batt_id].maint_b_cur_lvl);
1641                 abx500_chargalg_state_to(di, STATE_MAINTENANCE_B);
1642                 power_supply_changed(di->chargalg_psy);
1643                 /* Intentional fallthrough*/
1644 
1645         case STATE_MAINTENANCE_B:
1646                 if (di->events.maintenance_timer_expired) {
1647                         abx500_chargalg_stop_maintenance_timer(di);
1648                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1649                 }
1650                 break;
1651 
1652         case STATE_TEMP_LOWHIGH_INIT:
1653                 abx500_chargalg_start_charging(di,
1654                         di->bm->bat_type[
1655                                 di->bm->batt_id].low_high_vol_lvl,
1656                         di->bm->bat_type[
1657                                 di->bm->batt_id].low_high_cur_lvl);
1658                 abx500_chargalg_stop_maintenance_timer(di);
1659                 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1660                 abx500_chargalg_state_to(di, STATE_TEMP_LOWHIGH);
1661                 power_supply_changed(di->chargalg_psy);
1662                 /* Intentional fallthrough */
1663 
1664         case STATE_TEMP_LOWHIGH:
1665                 if (!di->events.btemp_lowhigh)
1666                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1667                 break;
1668 
1669         case STATE_WD_EXPIRED_INIT:
1670                 abx500_chargalg_stop_charging(di);
1671                 abx500_chargalg_state_to(di, STATE_WD_EXPIRED);
1672                 /* Intentional fallthrough */
1673 
1674         case STATE_WD_EXPIRED:
1675                 if (!di->events.ac_wd_expired &&
1676                                 !di->events.usb_wd_expired)
1677                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1678                 break;
1679 
1680         case STATE_TEMP_UNDEROVER_INIT:
1681                 abx500_chargalg_stop_charging(di);
1682                 abx500_chargalg_state_to(di, STATE_TEMP_UNDEROVER);
1683                 /* Intentional fallthrough */
1684 
1685         case STATE_TEMP_UNDEROVER:
1686                 if (!di->events.btemp_underover)
1687                         abx500_chargalg_state_to(di, STATE_NORMAL_INIT);
1688                 break;
1689         }
1690 
1691         /* Start charging directly if the new state is a charge state */
1692         if (di->charge_state == STATE_NORMAL_INIT ||
1693                         di->charge_state == STATE_MAINTENANCE_A_INIT ||
1694                         di->charge_state == STATE_MAINTENANCE_B_INIT)
1695                 queue_work(di->chargalg_wq, &di->chargalg_work);
1696 }
1697 
1698 /**
1699  * abx500_chargalg_periodic_work() - Periodic work for the algorithm
1700  * @work:       pointer to the work_struct structure
1701  *
1702  * Work queue function for the charging algorithm
1703  */
1704 static void abx500_chargalg_periodic_work(struct work_struct *work)
1705 {
1706         struct abx500_chargalg *di = container_of(work,
1707                 struct abx500_chargalg, chargalg_periodic_work.work);
1708 
1709         abx500_chargalg_algorithm(di);
1710 
1711         /*
1712          * If a charger is connected then the battery has to be monitored
1713          * frequently, else the work can be delayed.
1714          */
1715         if (di->chg_info.conn_chg)
1716                 queue_delayed_work(di->chargalg_wq,
1717                         &di->chargalg_periodic_work,
1718                         di->bm->interval_charging * HZ);
1719         else
1720                 queue_delayed_work(di->chargalg_wq,
1721                         &di->chargalg_periodic_work,
1722                         di->bm->interval_not_charging * HZ);
1723 }
1724 
1725 /**
1726  * abx500_chargalg_wd_work() - periodic work to kick the charger watchdog
1727  * @work:       pointer to the work_struct structure
1728  *
1729  * Work queue function for kicking the charger watchdog
1730  */
1731 static void abx500_chargalg_wd_work(struct work_struct *work)
1732 {
1733         int ret;
1734         struct abx500_chargalg *di = container_of(work,
1735                 struct abx500_chargalg, chargalg_wd_work.work);
1736 
1737         dev_dbg(di->dev, "abx500_chargalg_wd_work\n");
1738 
1739         ret = abx500_chargalg_kick_watchdog(di);
1740         if (ret < 0)
1741                 dev_err(di->dev, "failed to kick watchdog\n");
1742 
1743         queue_delayed_work(di->chargalg_wq,
1744                 &di->chargalg_wd_work, CHG_WD_INTERVAL);
1745 }
1746 
1747 /**
1748  * abx500_chargalg_work() - Work to run the charging algorithm instantly
1749  * @work:       pointer to the work_struct structure
1750  *
1751  * Work queue function for calling the charging algorithm
1752  */
1753 static void abx500_chargalg_work(struct work_struct *work)
1754 {
1755         struct abx500_chargalg *di = container_of(work,
1756                 struct abx500_chargalg, chargalg_work);
1757 
1758         abx500_chargalg_algorithm(di);
1759 }
1760 
1761 /**
1762  * abx500_chargalg_get_property() - get the chargalg properties
1763  * @psy:        pointer to the power_supply structure
1764  * @psp:        pointer to the power_supply_property structure
1765  * @val:        pointer to the power_supply_propval union
1766  *
1767  * This function gets called when an application tries to get the
1768  * chargalg properties by reading the sysfs files.
1769  * status:     charging/discharging/full/unknown
1770  * health:     health of the battery
1771  * Returns error code in case of failure else 0 on success
1772  */
1773 static int abx500_chargalg_get_property(struct power_supply *psy,
1774         enum power_supply_property psp,
1775         union power_supply_propval *val)
1776 {
1777         struct abx500_chargalg *di = power_supply_get_drvdata(psy);
1778 
1779         switch (psp) {
1780         case POWER_SUPPLY_PROP_STATUS:
1781                 val->intval = di->charge_status;
1782                 break;
1783         case POWER_SUPPLY_PROP_HEALTH:
1784                 if (di->events.batt_ovv) {
1785                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
1786                 } else if (di->events.btemp_underover) {
1787                         if (di->batt_data.temp <= di->bm->temp_under)
1788                                 val->intval = POWER_SUPPLY_HEALTH_COLD;
1789                         else
1790                                 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
1791                 } else if (di->charge_state == STATE_SAFETY_TIMER_EXPIRED ||
1792                            di->charge_state == STATE_SAFETY_TIMER_EXPIRED_INIT) {
1793                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
1794                 } else {
1795                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
1796                 }
1797                 break;
1798         default:
1799                 return -EINVAL;
1800         }
1801         return 0;
1802 }
1803 
1804 /* Exposure to the sysfs interface */
1805 
1806 static ssize_t abx500_chargalg_curr_step_show(struct abx500_chargalg *di,
1807                                               char *buf)
1808 {
1809         return sprintf(buf, "%d\n", di->curr_status.curr_step);
1810 }
1811 
1812 static ssize_t abx500_chargalg_curr_step_store(struct abx500_chargalg *di,
1813                                                const char *buf, size_t length)
1814 {
1815         long int param;
1816         int ret;
1817 
1818         ret = kstrtol(buf, 10, &param);
1819         if (ret < 0)
1820                 return ret;
1821 
1822         di->curr_status.curr_step = param;
1823         if (di->curr_status.curr_step >= CHARGALG_CURR_STEP_LOW &&
1824                 di->curr_status.curr_step <= CHARGALG_CURR_STEP_HIGH) {
1825                 di->curr_status.curr_step_change = true;
1826                 queue_work(di->chargalg_wq, &di->chargalg_work);
1827         } else
1828                 dev_info(di->dev, "Wrong current step\n"
1829                         "Enter 0. Disable AC/USB Charging\n"
1830                         "1--100. Set AC/USB charging current step\n"
1831                         "100. Enable AC/USB Charging\n");
1832 
1833         return strlen(buf);
1834 }
1835 
1836 
1837 static ssize_t abx500_chargalg_en_show(struct abx500_chargalg *di,
1838                                        char *buf)
1839 {
1840         return sprintf(buf, "%d\n",
1841                        di->susp_status.ac_suspended &&
1842                        di->susp_status.usb_suspended);
1843 }
1844 
1845 static ssize_t abx500_chargalg_en_store(struct abx500_chargalg *di,
1846         const char *buf, size_t length)
1847 {
1848         long int param;
1849         int ac_usb;
1850         int ret;
1851 
1852         ret = kstrtol(buf, 10, &param);
1853         if (ret < 0)
1854                 return ret;
1855 
1856         ac_usb = param;
1857         switch (ac_usb) {
1858         case 0:
1859                 /* Disable charging */
1860                 di->susp_status.ac_suspended = true;
1861                 di->susp_status.usb_suspended = true;
1862                 di->susp_status.suspended_change = true;
1863                 /* Trigger a state change */
1864                 queue_work(di->chargalg_wq,
1865                         &di->chargalg_work);
1866                 break;
1867         case 1:
1868                 /* Enable AC Charging */
1869                 di->susp_status.ac_suspended = false;
1870                 di->susp_status.suspended_change = true;
1871                 /* Trigger a state change */
1872                 queue_work(di->chargalg_wq,
1873                         &di->chargalg_work);
1874                 break;
1875         case 2:
1876                 /* Enable USB charging */
1877                 di->susp_status.usb_suspended = false;
1878                 di->susp_status.suspended_change = true;
1879                 /* Trigger a state change */
1880                 queue_work(di->chargalg_wq,
1881                         &di->chargalg_work);
1882                 break;
1883         default:
1884                 dev_info(di->dev, "Wrong input\n"
1885                         "Enter 0. Disable AC/USB Charging\n"
1886                         "1. Enable AC charging\n"
1887                         "2. Enable USB Charging\n");
1888         };
1889         return strlen(buf);
1890 }
1891 
1892 static struct abx500_chargalg_sysfs_entry abx500_chargalg_en_charger =
1893         __ATTR(chargalg, 0644, abx500_chargalg_en_show,
1894                                 abx500_chargalg_en_store);
1895 
1896 static struct abx500_chargalg_sysfs_entry abx500_chargalg_curr_step =
1897         __ATTR(chargalg_curr_step, 0644, abx500_chargalg_curr_step_show,
1898                                         abx500_chargalg_curr_step_store);
1899 
1900 static ssize_t abx500_chargalg_sysfs_show(struct kobject *kobj,
1901         struct attribute *attr, char *buf)
1902 {
1903         struct abx500_chargalg_sysfs_entry *entry = container_of(attr,
1904                 struct abx500_chargalg_sysfs_entry, attr);
1905 
1906         struct abx500_chargalg *di = container_of(kobj,
1907                 struct abx500_chargalg, chargalg_kobject);
1908 
1909         if (!entry->show)
1910                 return -EIO;
1911 
1912         return entry->show(di, buf);
1913 }
1914 
1915 static ssize_t abx500_chargalg_sysfs_charger(struct kobject *kobj,
1916         struct attribute *attr, const char *buf, size_t length)
1917 {
1918         struct abx500_chargalg_sysfs_entry *entry = container_of(attr,
1919                 struct abx500_chargalg_sysfs_entry, attr);
1920 
1921         struct abx500_chargalg *di = container_of(kobj,
1922                 struct abx500_chargalg, chargalg_kobject);
1923 
1924         if (!entry->store)
1925                 return -EIO;
1926 
1927         return entry->store(di, buf, length);
1928 }
1929 
1930 static struct attribute *abx500_chargalg_chg[] = {
1931         &abx500_chargalg_en_charger.attr,
1932         &abx500_chargalg_curr_step.attr,
1933         NULL,
1934 };
1935 
1936 static const struct sysfs_ops abx500_chargalg_sysfs_ops = {
1937         .show = abx500_chargalg_sysfs_show,
1938         .store = abx500_chargalg_sysfs_charger,
1939 };
1940 
1941 static struct kobj_type abx500_chargalg_ktype = {
1942         .sysfs_ops = &abx500_chargalg_sysfs_ops,
1943         .default_attrs = abx500_chargalg_chg,
1944 };
1945 
1946 /**
1947  * abx500_chargalg_sysfs_exit() - de-init of sysfs entry
1948  * @di:                pointer to the struct abx500_chargalg
1949  *
1950  * This function removes the entry in sysfs.
1951  */
1952 static void abx500_chargalg_sysfs_exit(struct abx500_chargalg *di)
1953 {
1954         kobject_del(&di->chargalg_kobject);
1955 }
1956 
1957 /**
1958  * abx500_chargalg_sysfs_init() - init of sysfs entry
1959  * @di:                pointer to the struct abx500_chargalg
1960  *
1961  * This function adds an entry in sysfs.
1962  * Returns error code in case of failure else 0(on success)
1963  */
1964 static int abx500_chargalg_sysfs_init(struct abx500_chargalg *di)
1965 {
1966         int ret = 0;
1967 
1968         ret = kobject_init_and_add(&di->chargalg_kobject,
1969                 &abx500_chargalg_ktype,
1970                 NULL, "abx500_chargalg");
1971         if (ret < 0)
1972                 dev_err(di->dev, "failed to create sysfs entry\n");
1973 
1974         return ret;
1975 }
1976 /* Exposure to the sysfs interface <<END>> */
1977 
1978 #if defined(CONFIG_PM)
1979 static int abx500_chargalg_resume(struct platform_device *pdev)
1980 {
1981         struct abx500_chargalg *di = platform_get_drvdata(pdev);
1982 
1983         /* Kick charger watchdog if charging (any charger online) */
1984         if (di->chg_info.online_chg)
1985                 queue_delayed_work(di->chargalg_wq, &di->chargalg_wd_work, 0);
1986 
1987         /*
1988          * Run the charging algorithm directly to be sure we don't
1989          * do it too seldom
1990          */
1991         queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1992 
1993         return 0;
1994 }
1995 
1996 static int abx500_chargalg_suspend(struct platform_device *pdev,
1997         pm_message_t state)
1998 {
1999         struct abx500_chargalg *di = platform_get_drvdata(pdev);
2000 
2001         if (di->chg_info.online_chg)
2002                 cancel_delayed_work_sync(&di->chargalg_wd_work);
2003 
2004         cancel_delayed_work_sync(&di->chargalg_periodic_work);
2005 
2006         return 0;
2007 }
2008 #else
2009 #define abx500_chargalg_suspend      NULL
2010 #define abx500_chargalg_resume       NULL
2011 #endif
2012 
2013 static int abx500_chargalg_remove(struct platform_device *pdev)
2014 {
2015         struct abx500_chargalg *di = platform_get_drvdata(pdev);
2016 
2017         /* sysfs interface to enable/disbale charging from user space */
2018         abx500_chargalg_sysfs_exit(di);
2019 
2020         hrtimer_cancel(&di->safety_timer);
2021         hrtimer_cancel(&di->maintenance_timer);
2022 
2023         cancel_delayed_work_sync(&di->chargalg_periodic_work);
2024         cancel_delayed_work_sync(&di->chargalg_wd_work);
2025         cancel_work_sync(&di->chargalg_work);
2026 
2027         /* Delete the work queue */
2028         destroy_workqueue(di->chargalg_wq);
2029 
2030         power_supply_unregister(di->chargalg_psy);
2031 
2032         return 0;
2033 }
2034 
2035 static char *supply_interface[] = {
2036         "ab8500_fg",
2037 };
2038 
2039 static const struct power_supply_desc abx500_chargalg_desc = {
2040         .name                   = "abx500_chargalg",
2041         .type                   = POWER_SUPPLY_TYPE_BATTERY,
2042         .properties             = abx500_chargalg_props,
2043         .num_properties         = ARRAY_SIZE(abx500_chargalg_props),
2044         .get_property           = abx500_chargalg_get_property,
2045         .external_power_changed = abx500_chargalg_external_power_changed,
2046 };
2047 
2048 static int abx500_chargalg_probe(struct platform_device *pdev)
2049 {
2050         struct device_node *np = pdev->dev.of_node;
2051         struct abx500_bm_data *plat = pdev->dev.platform_data;
2052         struct power_supply_config psy_cfg = {};
2053         struct abx500_chargalg *di;
2054         int ret = 0;
2055 
2056         di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
2057         if (!di) {
2058                 dev_err(&pdev->dev, "%s no mem for ab8500_chargalg\n", __func__);
2059                 return -ENOMEM;
2060         }
2061 
2062         if (!plat) {
2063                 dev_err(&pdev->dev, "no battery management data supplied\n");
2064                 return -EINVAL;
2065         }
2066         di->bm = plat;
2067 
2068         if (np) {
2069                 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
2070                 if (ret) {
2071                         dev_err(&pdev->dev, "failed to get battery information\n");
2072                         return ret;
2073                 }
2074         }
2075 
2076         /* get device struct and parent */
2077         di->dev = &pdev->dev;
2078         di->parent = dev_get_drvdata(pdev->dev.parent);
2079 
2080         psy_cfg.supplied_to = supply_interface;
2081         psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface);
2082         psy_cfg.drv_data = di;
2083 
2084         /* Initilialize safety timer */
2085         hrtimer_init(&di->safety_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
2086         di->safety_timer.function = abx500_chargalg_safety_timer_expired;
2087 
2088         /* Initilialize maintenance timer */
2089         hrtimer_init(&di->maintenance_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
2090         di->maintenance_timer.function =
2091                 abx500_chargalg_maintenance_timer_expired;
2092 
2093         /* Create a work queue for the chargalg */
2094         di->chargalg_wq =
2095                 create_singlethread_workqueue("abx500_chargalg_wq");
2096         if (di->chargalg_wq == NULL) {
2097                 dev_err(di->dev, "failed to create work queue\n");
2098                 return -ENOMEM;
2099         }
2100 
2101         /* Init work for chargalg */
2102         INIT_DEFERRABLE_WORK(&di->chargalg_periodic_work,
2103                 abx500_chargalg_periodic_work);
2104         INIT_DEFERRABLE_WORK(&di->chargalg_wd_work,
2105                 abx500_chargalg_wd_work);
2106 
2107         /* Init work for chargalg */
2108         INIT_WORK(&di->chargalg_work, abx500_chargalg_work);
2109 
2110         /* To detect charger at startup */
2111         di->chg_info.prev_conn_chg = -1;
2112 
2113         /* Register chargalg power supply class */
2114         di->chargalg_psy = power_supply_register(di->dev, &abx500_chargalg_desc,
2115                                                  &psy_cfg);
2116         if (IS_ERR(di->chargalg_psy)) {
2117                 dev_err(di->dev, "failed to register chargalg psy\n");
2118                 ret = PTR_ERR(di->chargalg_psy);
2119                 goto free_chargalg_wq;
2120         }
2121 
2122         platform_set_drvdata(pdev, di);
2123 
2124         /* sysfs interface to enable/disable charging from user space */
2125         ret = abx500_chargalg_sysfs_init(di);
2126         if (ret) {
2127                 dev_err(di->dev, "failed to create sysfs entry\n");
2128                 goto free_psy;
2129         }
2130         di->curr_status.curr_step = CHARGALG_CURR_STEP_HIGH;
2131 
2132         /* Run the charging algorithm */
2133         queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
2134 
2135         dev_info(di->dev, "probe success\n");
2136         return ret;
2137 
2138 free_psy:
2139         power_supply_unregister(di->chargalg_psy);
2140 free_chargalg_wq:
2141         destroy_workqueue(di->chargalg_wq);
2142         return ret;
2143 }
2144 
2145 static const struct of_device_id ab8500_chargalg_match[] = {
2146         { .compatible = "stericsson,ab8500-chargalg", },
2147         { },
2148 };
2149 
2150 static struct platform_driver abx500_chargalg_driver = {
2151         .probe = abx500_chargalg_probe,
2152         .remove = abx500_chargalg_remove,
2153         .suspend = abx500_chargalg_suspend,
2154         .resume = abx500_chargalg_resume,
2155         .driver = {
2156                 .name = "ab8500-chargalg",
2157                 .of_match_table = ab8500_chargalg_match,
2158         },
2159 };
2160 
2161 module_platform_driver(abx500_chargalg_driver);
2162 
2163 MODULE_LICENSE("GPL v2");
2164 MODULE_AUTHOR("Johan Palsson, Karl Komierowski");
2165 MODULE_ALIAS("platform:abx500-chargalg");
2166 MODULE_DESCRIPTION("abx500 battery charging algorithm");
2167 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us