1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) ST-Ericsson SA 2012 4 * Copyright (c) 2012 Sony Mobile Communications AB 5 * 6 * Charging algorithm driver for AB8500 7 * 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/component.h> 19 #include <linux/hrtimer.h> 20 #include <linux/interrupt.h> 21 #include <linux/delay.h> 22 #include <linux/slab.h> 23 #include <linux/platform_device.h> 24 #include <linux/power_supply.h> 25 #include <linux/completion.h> 26 #include <linux/workqueue.h> 27 #include <linux/kobject.h> 28 #include <linux/of.h> 29 #include <linux/mfd/core.h> 30 #include <linux/mfd/abx500.h> 31 #include <linux/mfd/abx500/ab8500.h> 32 #include <linux/notifier.h> 33 34 #include "ab8500-bm.h" 35 #include "ab8500-chargalg.h" 36 37 /* Watchdog kick interval */ 38 #define CHG_WD_INTERVAL (6 * HZ) 39 40 /* End-of-charge criteria counter */ 41 #define EOC_COND_CNT 10 42 43 /* One hour expressed in seconds */ 44 #define ONE_HOUR_IN_SECONDS 3600 45 46 /* Five minutes expressed in seconds */ 47 #define FIVE_MINUTES_IN_SECONDS 300 48 49 /* 50 * This is the battery capacity limit that will trigger a new 51 * full charging cycle in the case where maintenance charging 52 * has been disabled 53 */ 54 #define AB8500_RECHARGE_CAP 95 55 56 enum ab8500_chargers { 57 NO_CHG, 58 AC_CHG, 59 USB_CHG, 60 }; 61 62 struct ab8500_chargalg_charger_info { 63 enum ab8500_chargers conn_chg; 64 enum ab8500_chargers prev_conn_chg; 65 enum ab8500_chargers online_chg; 66 enum ab8500_chargers prev_online_chg; 67 enum ab8500_chargers charger_type; 68 bool usb_chg_ok; 69 bool ac_chg_ok; 70 int usb_volt_uv; 71 int usb_curr_ua; 72 int ac_volt_uv; 73 int ac_curr_ua; 74 int usb_vset_uv; 75 int usb_iset_ua; 76 int ac_vset_uv; 77 int ac_iset_ua; 78 }; 79 80 struct ab8500_chargalg_suspension_status { 81 bool suspended_change; 82 bool ac_suspended; 83 bool usb_suspended; 84 }; 85 86 struct ab8500_chargalg_battery_data { 87 int temp; 88 int volt_uv; 89 int avg_curr_ua; 90 int inst_curr_ua; 91 int percent; 92 }; 93 94 enum ab8500_chargalg_states { 95 STATE_HANDHELD_INIT, 96 STATE_HANDHELD, 97 STATE_CHG_NOT_OK_INIT, 98 STATE_CHG_NOT_OK, 99 STATE_HW_TEMP_PROTECT_INIT, 100 STATE_HW_TEMP_PROTECT, 101 STATE_NORMAL_INIT, 102 STATE_NORMAL, 103 STATE_WAIT_FOR_RECHARGE_INIT, 104 STATE_WAIT_FOR_RECHARGE, 105 STATE_MAINTENANCE_A_INIT, 106 STATE_MAINTENANCE_A, 107 STATE_MAINTENANCE_B_INIT, 108 STATE_MAINTENANCE_B, 109 STATE_TEMP_UNDEROVER_INIT, 110 STATE_TEMP_UNDEROVER, 111 STATE_TEMP_LOWHIGH_INIT, 112 STATE_TEMP_LOWHIGH, 113 STATE_SUSPENDED_INIT, 114 STATE_SUSPENDED, 115 STATE_OVV_PROTECT_INIT, 116 STATE_OVV_PROTECT, 117 STATE_SAFETY_TIMER_EXPIRED_INIT, 118 STATE_SAFETY_TIMER_EXPIRED, 119 STATE_BATT_REMOVED_INIT, 120 STATE_BATT_REMOVED, 121 STATE_WD_EXPIRED_INIT, 122 STATE_WD_EXPIRED, 123 }; 124 125 static const char * const states[] = { 126 "HANDHELD_INIT", 127 "HANDHELD", 128 "CHG_NOT_OK_INIT", 129 "CHG_NOT_OK", 130 "HW_TEMP_PROTECT_INIT", 131 "HW_TEMP_PROTECT", 132 "NORMAL_INIT", 133 "NORMAL", 134 "WAIT_FOR_RECHARGE_INIT", 135 "WAIT_FOR_RECHARGE", 136 "MAINTENANCE_A_INIT", 137 "MAINTENANCE_A", 138 "MAINTENANCE_B_INIT", 139 "MAINTENANCE_B", 140 "TEMP_UNDEROVER_INIT", 141 "TEMP_UNDEROVER", 142 "TEMP_LOWHIGH_INIT", 143 "TEMP_LOWHIGH", 144 "SUSPENDED_INIT", 145 "SUSPENDED", 146 "OVV_PROTECT_INIT", 147 "OVV_PROTECT", 148 "SAFETY_TIMER_EXPIRED_INIT", 149 "SAFETY_TIMER_EXPIRED", 150 "BATT_REMOVED_INIT", 151 "BATT_REMOVED", 152 "WD_EXPIRED_INIT", 153 "WD_EXPIRED", 154 }; 155 156 struct ab8500_chargalg_events { 157 bool batt_unknown; 158 bool mainextchnotok; 159 bool batt_ovv; 160 bool batt_rem; 161 bool btemp_underover; 162 bool btemp_lowhigh; 163 bool main_thermal_prot; 164 bool usb_thermal_prot; 165 bool main_ovv; 166 bool vbus_ovv; 167 bool usbchargernotok; 168 bool safety_timer_expired; 169 bool maintenance_timer_expired; 170 bool ac_wd_expired; 171 bool usb_wd_expired; 172 bool ac_cv_active; 173 bool usb_cv_active; 174 bool vbus_collapsed; 175 }; 176 177 /** 178 * struct ab8500_charge_curr_maximization - Charger maximization parameters 179 * @original_iset_ua: the non optimized/maximised charger current 180 * @current_iset_ua: the charging current used at this moment 181 * @condition_cnt: number of iterations needed before a new charger current 182 is set 183 * @max_current_ua: maximum charger current 184 * @wait_cnt: to avoid too fast current step down in case of charger 185 * voltage collapse, we insert this delay between step 186 * down 187 * @level: tells in how many steps the charging current has been 188 increased 189 */ 190 struct ab8500_charge_curr_maximization { 191 int original_iset_ua; 192 int current_iset_ua; 193 int condition_cnt; 194 int max_current_ua; 195 int wait_cnt; 196 u8 level; 197 }; 198 199 enum maxim_ret { 200 MAXIM_RET_NOACTION, 201 MAXIM_RET_CHANGE, 202 MAXIM_RET_IBAT_TOO_HIGH, 203 }; 204 205 /** 206 * struct ab8500_chargalg - ab8500 Charging algorithm device information 207 * @dev: pointer to the structure device 208 * @charge_status: battery operating status 209 * @eoc_cnt: counter used to determine end-of_charge 210 * @maintenance_chg: indicate if maintenance charge is active 211 * @t_hyst_norm temperature hysteresis when the temperature has been 212 * over or under normal limits 213 * @t_hyst_lowhigh temperature hysteresis when the temperature has been 214 * over or under the high or low limits 215 * @charge_state: current state of the charging algorithm 216 * @ccm charging current maximization parameters 217 * @chg_info: information about connected charger types 218 * @batt_data: data of the battery 219 * @susp_status: current charger suspension status 220 * @bm: Platform specific battery management information 221 * @parent: pointer to the struct ab8500 222 * @chargalg_psy: structure that holds the battery properties exposed by 223 * the charging algorithm 224 * @events: structure for information about events triggered 225 * @chargalg_wq: work queue for running the charging algorithm 226 * @chargalg_periodic_work: work to run the charging algorithm periodically 227 * @chargalg_wd_work: work to kick the charger watchdog periodically 228 * @chargalg_work: work to run the charging algorithm instantly 229 * @safety_timer: charging safety timer 230 * @maintenance_timer: maintenance charging timer 231 * @chargalg_kobject: structure of type kobject 232 */ 233 struct ab8500_chargalg { 234 struct device *dev; 235 int charge_status; 236 int eoc_cnt; 237 bool maintenance_chg; 238 int t_hyst_norm; 239 int t_hyst_lowhigh; 240 enum ab8500_chargalg_states charge_state; 241 struct ab8500_charge_curr_maximization ccm; 242 struct ab8500_chargalg_charger_info chg_info; 243 struct ab8500_chargalg_battery_data batt_data; 244 struct ab8500_chargalg_suspension_status susp_status; 245 struct ab8500 *parent; 246 struct ab8500_bm_data *bm; 247 struct power_supply *chargalg_psy; 248 struct ux500_charger *ac_chg; 249 struct ux500_charger *usb_chg; 250 struct ab8500_chargalg_events events; 251 struct workqueue_struct *chargalg_wq; 252 struct delayed_work chargalg_periodic_work; 253 struct delayed_work chargalg_wd_work; 254 struct work_struct chargalg_work; 255 struct hrtimer safety_timer; 256 struct hrtimer maintenance_timer; 257 struct kobject chargalg_kobject; 258 }; 259 260 /*External charger prepare notifier*/ 261 BLOCKING_NOTIFIER_HEAD(charger_notifier_list); 262 263 /* Main battery properties */ 264 static enum power_supply_property ab8500_chargalg_props[] = { 265 POWER_SUPPLY_PROP_STATUS, 266 POWER_SUPPLY_PROP_HEALTH, 267 }; 268 269 struct ab8500_chargalg_sysfs_entry { 270 struct attribute attr; 271 ssize_t (*show)(struct ab8500_chargalg *di, char *buf); 272 ssize_t (*store)(struct ab8500_chargalg *di, const char *buf, size_t length); 273 }; 274 275 /** 276 * ab8500_chargalg_safety_timer_expired() - Expiration of the safety timer 277 * @timer: pointer to the hrtimer structure 278 * 279 * This function gets called when the safety timer for the charger 280 * expires 281 */ 282 static enum hrtimer_restart 283 ab8500_chargalg_safety_timer_expired(struct hrtimer *timer) 284 { 285 struct ab8500_chargalg *di = container_of(timer, struct ab8500_chargalg, 286 safety_timer); 287 dev_err(di->dev, "Safety timer expired\n"); 288 di->events.safety_timer_expired = true; 289 290 /* Trigger execution of the algorithm instantly */ 291 queue_work(di->chargalg_wq, &di->chargalg_work); 292 293 return HRTIMER_NORESTART; 294 } 295 296 /** 297 * ab8500_chargalg_maintenance_timer_expired() - Expiration of 298 * the maintenance timer 299 * @timer: pointer to the timer structure 300 * 301 * This function gets called when the maintenence timer 302 * expires 303 */ 304 static enum hrtimer_restart 305 ab8500_chargalg_maintenance_timer_expired(struct hrtimer *timer) 306 { 307 308 struct ab8500_chargalg *di = container_of(timer, struct ab8500_chargalg, 309 maintenance_timer); 310 311 dev_dbg(di->dev, "Maintenance timer expired\n"); 312 di->events.maintenance_timer_expired = true; 313 314 /* Trigger execution of the algorithm instantly */ 315 queue_work(di->chargalg_wq, &di->chargalg_work); 316 317 return HRTIMER_NORESTART; 318 } 319 320 /** 321 * ab8500_chargalg_state_to() - Change charge state 322 * @di: pointer to the ab8500_chargalg structure 323 * 324 * This function gets called when a charge state change should occur 325 */ 326 static void ab8500_chargalg_state_to(struct ab8500_chargalg *di, 327 enum ab8500_chargalg_states state) 328 { 329 dev_dbg(di->dev, 330 "State changed: %s (From state: [%d] %s =to=> [%d] %s )\n", 331 di->charge_state == state ? "NO" : "YES", 332 di->charge_state, 333 states[di->charge_state], 334 state, 335 states[state]); 336 337 di->charge_state = state; 338 } 339 340 static int ab8500_chargalg_check_charger_enable(struct ab8500_chargalg *di) 341 { 342 struct power_supply_battery_info *bi = di->bm->bi; 343 344 switch (di->charge_state) { 345 case STATE_NORMAL: 346 case STATE_MAINTENANCE_A: 347 case STATE_MAINTENANCE_B: 348 break; 349 default: 350 return 0; 351 } 352 353 if (di->chg_info.charger_type & USB_CHG) { 354 return di->usb_chg->ops.check_enable(di->usb_chg, 355 bi->constant_charge_voltage_max_uv, 356 bi->constant_charge_current_max_ua); 357 } else if ((di->chg_info.charger_type & AC_CHG) && 358 !(di->ac_chg->external)) { 359 return di->ac_chg->ops.check_enable(di->ac_chg, 360 bi->constant_charge_voltage_max_uv, 361 bi->constant_charge_current_max_ua); 362 } 363 return 0; 364 } 365 366 /** 367 * ab8500_chargalg_check_charger_connection() - Check charger connection change 368 * @di: pointer to the ab8500_chargalg structure 369 * 370 * This function will check if there is a change in the charger connection 371 * and change charge state accordingly. AC has precedence over USB. 372 */ 373 static int ab8500_chargalg_check_charger_connection(struct ab8500_chargalg *di) 374 { 375 if (di->chg_info.conn_chg != di->chg_info.prev_conn_chg || 376 di->susp_status.suspended_change) { 377 /* 378 * Charger state changed or suspension 379 * has changed since last update 380 */ 381 if ((di->chg_info.conn_chg & AC_CHG) && 382 !di->susp_status.ac_suspended) { 383 dev_dbg(di->dev, "Charging source is AC\n"); 384 if (di->chg_info.charger_type != AC_CHG) { 385 di->chg_info.charger_type = AC_CHG; 386 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 387 } 388 } else if ((di->chg_info.conn_chg & USB_CHG) && 389 !di->susp_status.usb_suspended) { 390 dev_dbg(di->dev, "Charging source is USB\n"); 391 di->chg_info.charger_type = USB_CHG; 392 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 393 } else if (di->chg_info.conn_chg && 394 (di->susp_status.ac_suspended || 395 di->susp_status.usb_suspended)) { 396 dev_dbg(di->dev, "Charging is suspended\n"); 397 di->chg_info.charger_type = NO_CHG; 398 ab8500_chargalg_state_to(di, STATE_SUSPENDED_INIT); 399 } else { 400 dev_dbg(di->dev, "Charging source is OFF\n"); 401 di->chg_info.charger_type = NO_CHG; 402 ab8500_chargalg_state_to(di, STATE_HANDHELD_INIT); 403 } 404 di->chg_info.prev_conn_chg = di->chg_info.conn_chg; 405 di->susp_status.suspended_change = false; 406 } 407 return di->chg_info.conn_chg; 408 } 409 410 /** 411 * ab8500_chargalg_start_safety_timer() - Start charging safety timer 412 * @di: pointer to the ab8500_chargalg structure 413 * 414 * The safety timer is used to avoid overcharging of old or bad batteries. 415 * There are different timers for AC and USB 416 */ 417 static void ab8500_chargalg_start_safety_timer(struct ab8500_chargalg *di) 418 { 419 /* Charger-dependent expiration time in hours*/ 420 int timer_expiration = 0; 421 422 switch (di->chg_info.charger_type) { 423 case AC_CHG: 424 timer_expiration = di->bm->main_safety_tmr_h; 425 break; 426 427 case USB_CHG: 428 timer_expiration = di->bm->usb_safety_tmr_h; 429 break; 430 431 default: 432 dev_err(di->dev, "Unknown charger to charge from\n"); 433 break; 434 } 435 436 di->events.safety_timer_expired = false; 437 hrtimer_set_expires_range(&di->safety_timer, 438 ktime_set(timer_expiration * ONE_HOUR_IN_SECONDS, 0), 439 ktime_set(FIVE_MINUTES_IN_SECONDS, 0)); 440 hrtimer_start_expires(&di->safety_timer, HRTIMER_MODE_REL); 441 } 442 443 /** 444 * ab8500_chargalg_stop_safety_timer() - Stop charging safety timer 445 * @di: pointer to the ab8500_chargalg structure 446 * 447 * The safety timer is stopped whenever the NORMAL state is exited 448 */ 449 static void ab8500_chargalg_stop_safety_timer(struct ab8500_chargalg *di) 450 { 451 if (hrtimer_try_to_cancel(&di->safety_timer) >= 0) 452 di->events.safety_timer_expired = false; 453 } 454 455 /** 456 * ab8500_chargalg_start_maintenance_timer() - Start charging maintenance timer 457 * @di: pointer to the ab8500_chargalg structure 458 * @duration: duration of ther maintenance timer in hours 459 * 460 * The maintenance timer is used to maintain the charge in the battery once 461 * the battery is considered full. These timers are chosen to match the 462 * discharge curve of the battery 463 */ 464 static void ab8500_chargalg_start_maintenance_timer(struct ab8500_chargalg *di, 465 int duration) 466 { 467 hrtimer_set_expires_range(&di->maintenance_timer, 468 ktime_set(duration * ONE_HOUR_IN_SECONDS, 0), 469 ktime_set(FIVE_MINUTES_IN_SECONDS, 0)); 470 di->events.maintenance_timer_expired = false; 471 hrtimer_start_expires(&di->maintenance_timer, HRTIMER_MODE_REL); 472 } 473 474 /** 475 * ab8500_chargalg_stop_maintenance_timer() - Stop maintenance timer 476 * @di: pointer to the ab8500_chargalg structure 477 * 478 * The maintenance timer is stopped whenever maintenance ends or when another 479 * state is entered 480 */ 481 static void ab8500_chargalg_stop_maintenance_timer(struct ab8500_chargalg *di) 482 { 483 if (hrtimer_try_to_cancel(&di->maintenance_timer) >= 0) 484 di->events.maintenance_timer_expired = false; 485 } 486 487 /** 488 * ab8500_chargalg_kick_watchdog() - Kick charger watchdog 489 * @di: pointer to the ab8500_chargalg structure 490 * 491 * The charger watchdog have to be kicked periodically whenever the charger is 492 * on, else the ABB will reset the system 493 */ 494 static int ab8500_chargalg_kick_watchdog(struct ab8500_chargalg *di) 495 { 496 /* Check if charger exists and kick watchdog if charging */ 497 if (di->ac_chg && di->ac_chg->ops.kick_wd && 498 di->chg_info.online_chg & AC_CHG) { 499 /* 500 * If AB charger watchdog expired, pm2xxx charging 501 * gets disabled. To be safe, kick both AB charger watchdog 502 * and pm2xxx watchdog. 503 */ 504 if (di->ac_chg->external && 505 di->usb_chg && di->usb_chg->ops.kick_wd) 506 di->usb_chg->ops.kick_wd(di->usb_chg); 507 508 return di->ac_chg->ops.kick_wd(di->ac_chg); 509 } else if (di->usb_chg && di->usb_chg->ops.kick_wd && 510 di->chg_info.online_chg & USB_CHG) 511 return di->usb_chg->ops.kick_wd(di->usb_chg); 512 513 return -ENXIO; 514 } 515 516 /** 517 * ab8500_chargalg_ac_en() - Turn on/off the AC charger 518 * @di: pointer to the ab8500_chargalg structure 519 * @enable: charger on/off 520 * @vset_uv: requested charger output voltage in microvolt 521 * @iset_ua: requested charger output current in microampere 522 * 523 * The AC charger will be turned on/off with the requested charge voltage and 524 * current 525 */ 526 static int ab8500_chargalg_ac_en(struct ab8500_chargalg *di, int enable, 527 int vset_uv, int iset_ua) 528 { 529 static int ab8500_chargalg_ex_ac_enable_toggle; 530 531 if (!di->ac_chg || !di->ac_chg->ops.enable) 532 return -ENXIO; 533 534 /* Select maximum of what both the charger and the battery supports */ 535 if (di->ac_chg->max_out_volt_uv) 536 vset_uv = min(vset_uv, di->ac_chg->max_out_volt_uv); 537 if (di->ac_chg->max_out_curr_ua) 538 iset_ua = min(iset_ua, di->ac_chg->max_out_curr_ua); 539 540 di->chg_info.ac_iset_ua = iset_ua; 541 di->chg_info.ac_vset_uv = vset_uv; 542 543 /* Enable external charger */ 544 if (enable && di->ac_chg->external && 545 !ab8500_chargalg_ex_ac_enable_toggle) { 546 blocking_notifier_call_chain(&charger_notifier_list, 547 0, di->dev); 548 ab8500_chargalg_ex_ac_enable_toggle++; 549 } 550 551 return di->ac_chg->ops.enable(di->ac_chg, enable, vset_uv, iset_ua); 552 } 553 554 /** 555 * ab8500_chargalg_usb_en() - Turn on/off the USB charger 556 * @di: pointer to the ab8500_chargalg structure 557 * @enable: charger on/off 558 * @vset_uv: requested charger output voltage in microvolt 559 * @iset_ua: requested charger output current in microampere 560 * 561 * The USB charger will be turned on/off with the requested charge voltage and 562 * current 563 */ 564 static int ab8500_chargalg_usb_en(struct ab8500_chargalg *di, int enable, 565 int vset_uv, int iset_ua) 566 { 567 if (!di->usb_chg || !di->usb_chg->ops.enable) 568 return -ENXIO; 569 570 /* Select maximum of what both the charger and the battery supports */ 571 if (di->usb_chg->max_out_volt_uv) 572 vset_uv = min(vset_uv, di->usb_chg->max_out_volt_uv); 573 if (di->usb_chg->max_out_curr_ua) 574 iset_ua = min(iset_ua, di->usb_chg->max_out_curr_ua); 575 576 di->chg_info.usb_iset_ua = iset_ua; 577 di->chg_info.usb_vset_uv = vset_uv; 578 579 return di->usb_chg->ops.enable(di->usb_chg, enable, vset_uv, iset_ua); 580 } 581 582 /** 583 * ab8500_chargalg_update_chg_curr() - Update charger current 584 * @di: pointer to the ab8500_chargalg structure 585 * @iset_ua: requested charger output current in microampere 586 * 587 * The charger output current will be updated for the charger 588 * that is currently in use 589 */ 590 static int ab8500_chargalg_update_chg_curr(struct ab8500_chargalg *di, 591 int iset_ua) 592 { 593 /* Check if charger exists and update current if charging */ 594 if (di->ac_chg && di->ac_chg->ops.update_curr && 595 di->chg_info.charger_type & AC_CHG) { 596 /* 597 * Select maximum of what both the charger 598 * and the battery supports 599 */ 600 if (di->ac_chg->max_out_curr_ua) 601 iset_ua = min(iset_ua, di->ac_chg->max_out_curr_ua); 602 603 di->chg_info.ac_iset_ua = iset_ua; 604 605 return di->ac_chg->ops.update_curr(di->ac_chg, iset_ua); 606 } else if (di->usb_chg && di->usb_chg->ops.update_curr && 607 di->chg_info.charger_type & USB_CHG) { 608 /* 609 * Select maximum of what both the charger 610 * and the battery supports 611 */ 612 if (di->usb_chg->max_out_curr_ua) 613 iset_ua = min(iset_ua, di->usb_chg->max_out_curr_ua); 614 615 di->chg_info.usb_iset_ua = iset_ua; 616 617 return di->usb_chg->ops.update_curr(di->usb_chg, iset_ua); 618 } 619 620 return -ENXIO; 621 } 622 623 /** 624 * ab8500_chargalg_stop_charging() - Stop charging 625 * @di: pointer to the ab8500_chargalg structure 626 * 627 * This function is called from any state where charging should be stopped. 628 * All charging is disabled and all status parameters and timers are changed 629 * accordingly 630 */ 631 static void ab8500_chargalg_stop_charging(struct ab8500_chargalg *di) 632 { 633 ab8500_chargalg_ac_en(di, false, 0, 0); 634 ab8500_chargalg_usb_en(di, false, 0, 0); 635 ab8500_chargalg_stop_safety_timer(di); 636 ab8500_chargalg_stop_maintenance_timer(di); 637 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING; 638 di->maintenance_chg = false; 639 cancel_delayed_work(&di->chargalg_wd_work); 640 power_supply_changed(di->chargalg_psy); 641 } 642 643 /** 644 * ab8500_chargalg_hold_charging() - Pauses charging 645 * @di: pointer to the ab8500_chargalg structure 646 * 647 * This function is called in the case where maintenance charging has been 648 * disabled and instead a battery voltage mode is entered to check when the 649 * battery voltage has reached a certain recharge voltage 650 */ 651 static void ab8500_chargalg_hold_charging(struct ab8500_chargalg *di) 652 { 653 ab8500_chargalg_ac_en(di, false, 0, 0); 654 ab8500_chargalg_usb_en(di, false, 0, 0); 655 ab8500_chargalg_stop_safety_timer(di); 656 ab8500_chargalg_stop_maintenance_timer(di); 657 di->charge_status = POWER_SUPPLY_STATUS_CHARGING; 658 di->maintenance_chg = false; 659 cancel_delayed_work(&di->chargalg_wd_work); 660 power_supply_changed(di->chargalg_psy); 661 } 662 663 /** 664 * ab8500_chargalg_start_charging() - Start the charger 665 * @di: pointer to the ab8500_chargalg structure 666 * @vset_uv: requested charger output voltage in microvolt 667 * @iset_ua: requested charger output current in microampere 668 * 669 * A charger will be enabled depending on the requested charger type that was 670 * detected previously. 671 */ 672 static void ab8500_chargalg_start_charging(struct ab8500_chargalg *di, 673 int vset_uv, int iset_ua) 674 { 675 switch (di->chg_info.charger_type) { 676 case AC_CHG: 677 dev_dbg(di->dev, 678 "AC parameters: Vset %d, Ich %d\n", vset_uv, iset_ua); 679 ab8500_chargalg_usb_en(di, false, 0, 0); 680 ab8500_chargalg_ac_en(di, true, vset_uv, iset_ua); 681 break; 682 683 case USB_CHG: 684 dev_dbg(di->dev, 685 "USB parameters: Vset %d, Ich %d\n", vset_uv, iset_ua); 686 ab8500_chargalg_ac_en(di, false, 0, 0); 687 ab8500_chargalg_usb_en(di, true, vset_uv, iset_ua); 688 break; 689 690 default: 691 dev_err(di->dev, "Unknown charger to charge from\n"); 692 break; 693 } 694 } 695 696 /** 697 * ab8500_chargalg_check_temp() - Check battery temperature ranges 698 * @di: pointer to the ab8500_chargalg structure 699 * 700 * The battery temperature is checked against the predefined limits and the 701 * charge state is changed accordingly 702 */ 703 static void ab8500_chargalg_check_temp(struct ab8500_chargalg *di) 704 { 705 struct power_supply_battery_info *bi = di->bm->bi; 706 707 if (di->batt_data.temp > (bi->temp_alert_min + di->t_hyst_norm) && 708 di->batt_data.temp < (bi->temp_alert_max - di->t_hyst_norm)) { 709 /* Temp OK! */ 710 di->events.btemp_underover = false; 711 di->events.btemp_lowhigh = false; 712 di->t_hyst_norm = 0; 713 di->t_hyst_lowhigh = 0; 714 } else { 715 if (((di->batt_data.temp >= bi->temp_alert_max) && 716 (di->batt_data.temp < 717 (bi->temp_max - di->t_hyst_lowhigh))) || 718 ((di->batt_data.temp > 719 (bi->temp_min + di->t_hyst_lowhigh)) && 720 (di->batt_data.temp <= bi->temp_alert_min))) { 721 /* TEMP minor!!!!! */ 722 di->events.btemp_underover = false; 723 di->events.btemp_lowhigh = true; 724 di->t_hyst_norm = di->bm->temp_hysteresis; 725 di->t_hyst_lowhigh = 0; 726 } else if (di->batt_data.temp <= bi->temp_min || 727 di->batt_data.temp >= bi->temp_max) { 728 /* TEMP major!!!!! */ 729 di->events.btemp_underover = true; 730 di->events.btemp_lowhigh = false; 731 di->t_hyst_norm = 0; 732 di->t_hyst_lowhigh = di->bm->temp_hysteresis; 733 } else { 734 /* Within hysteresis */ 735 dev_dbg(di->dev, "Within hysteresis limit temp: %d " 736 "hyst_lowhigh %d, hyst normal %d\n", 737 di->batt_data.temp, di->t_hyst_lowhigh, 738 di->t_hyst_norm); 739 } 740 } 741 } 742 743 /** 744 * ab8500_chargalg_check_charger_voltage() - Check charger voltage 745 * @di: pointer to the ab8500_chargalg structure 746 * 747 * Charger voltage is checked against maximum limit 748 */ 749 static void ab8500_chargalg_check_charger_voltage(struct ab8500_chargalg *di) 750 { 751 if (di->chg_info.usb_volt_uv > di->bm->chg_params->usb_volt_max_uv) 752 di->chg_info.usb_chg_ok = false; 753 else 754 di->chg_info.usb_chg_ok = true; 755 756 if (di->chg_info.ac_volt_uv > di->bm->chg_params->ac_volt_max_uv) 757 di->chg_info.ac_chg_ok = false; 758 else 759 di->chg_info.ac_chg_ok = true; 760 761 } 762 763 /** 764 * ab8500_chargalg_end_of_charge() - Check if end-of-charge criteria is fulfilled 765 * @di: pointer to the ab8500_chargalg structure 766 * 767 * End-of-charge criteria is fulfilled when the battery voltage is above a 768 * certain limit and the battery current is below a certain limit for a 769 * predefined number of consecutive seconds. If true, the battery is full 770 */ 771 static void ab8500_chargalg_end_of_charge(struct ab8500_chargalg *di) 772 { 773 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING && 774 di->charge_state == STATE_NORMAL && 775 !di->maintenance_chg && (di->batt_data.volt_uv >= 776 di->bm->bi->voltage_max_design_uv || 777 di->events.usb_cv_active || di->events.ac_cv_active) && 778 di->batt_data.avg_curr_ua < 779 di->bm->bi->charge_term_current_ua && 780 di->batt_data.avg_curr_ua > 0) { 781 if (++di->eoc_cnt >= EOC_COND_CNT) { 782 di->eoc_cnt = 0; 783 di->charge_status = POWER_SUPPLY_STATUS_FULL; 784 di->maintenance_chg = true; 785 dev_dbg(di->dev, "EOC reached!\n"); 786 power_supply_changed(di->chargalg_psy); 787 } else { 788 dev_dbg(di->dev, 789 " EOC limit reached for the %d" 790 " time, out of %d before EOC\n", 791 di->eoc_cnt, 792 EOC_COND_CNT); 793 } 794 } else { 795 di->eoc_cnt = 0; 796 } 797 } 798 799 static void init_maxim_chg_curr(struct ab8500_chargalg *di) 800 { 801 struct power_supply_battery_info *bi = di->bm->bi; 802 803 di->ccm.original_iset_ua = bi->constant_charge_current_max_ua; 804 di->ccm.current_iset_ua = bi->constant_charge_current_max_ua; 805 di->ccm.max_current_ua = di->bm->maxi->chg_curr_ua; 806 di->ccm.condition_cnt = di->bm->maxi->wait_cycles; 807 di->ccm.level = 0; 808 } 809 810 /** 811 * ab8500_chargalg_chg_curr_maxim - increases the charger current to 812 * compensate for the system load 813 * @di pointer to the ab8500_chargalg structure 814 * 815 * This maximization function is used to raise the charger current to get the 816 * battery current as close to the optimal value as possible. The battery 817 * current during charging is affected by the system load 818 */ 819 static enum maxim_ret ab8500_chargalg_chg_curr_maxim(struct ab8500_chargalg *di) 820 { 821 int delta_i_ua; 822 823 if (!di->bm->maxi->ena_maxi) 824 return MAXIM_RET_NOACTION; 825 826 delta_i_ua = di->ccm.original_iset_ua - di->batt_data.inst_curr_ua; 827 828 if (di->events.vbus_collapsed) { 829 dev_dbg(di->dev, "Charger voltage has collapsed %d\n", 830 di->ccm.wait_cnt); 831 if (di->ccm.wait_cnt == 0) { 832 dev_dbg(di->dev, "lowering current\n"); 833 di->ccm.wait_cnt++; 834 di->ccm.condition_cnt = di->bm->maxi->wait_cycles; 835 di->ccm.max_current_ua = di->ccm.current_iset_ua; 836 di->ccm.current_iset_ua = di->ccm.max_current_ua; 837 di->ccm.level--; 838 return MAXIM_RET_CHANGE; 839 } else { 840 dev_dbg(di->dev, "waiting\n"); 841 /* Let's go in here twice before lowering curr again */ 842 di->ccm.wait_cnt = (di->ccm.wait_cnt + 1) % 3; 843 return MAXIM_RET_NOACTION; 844 } 845 } 846 847 di->ccm.wait_cnt = 0; 848 849 if (di->batt_data.inst_curr_ua > di->ccm.original_iset_ua) { 850 dev_dbg(di->dev, " Maximization Ibat (%duA) too high" 851 " (limit %duA) (current iset: %duA)!\n", 852 di->batt_data.inst_curr_ua, di->ccm.original_iset_ua, 853 di->ccm.current_iset_ua); 854 855 if (di->ccm.current_iset_ua == di->ccm.original_iset_ua) 856 return MAXIM_RET_NOACTION; 857 858 di->ccm.condition_cnt = di->bm->maxi->wait_cycles; 859 di->ccm.current_iset_ua = di->ccm.original_iset_ua; 860 di->ccm.level = 0; 861 862 return MAXIM_RET_IBAT_TOO_HIGH; 863 } 864 865 di->ccm.condition_cnt = di->bm->maxi->wait_cycles; 866 return MAXIM_RET_NOACTION; 867 } 868 869 static void handle_maxim_chg_curr(struct ab8500_chargalg *di) 870 { 871 struct power_supply_battery_info *bi = di->bm->bi; 872 enum maxim_ret ret; 873 int result; 874 875 ret = ab8500_chargalg_chg_curr_maxim(di); 876 switch (ret) { 877 case MAXIM_RET_CHANGE: 878 result = ab8500_chargalg_update_chg_curr(di, 879 di->ccm.current_iset_ua); 880 if (result) 881 dev_err(di->dev, "failed to set chg curr\n"); 882 break; 883 case MAXIM_RET_IBAT_TOO_HIGH: 884 result = ab8500_chargalg_update_chg_curr(di, 885 bi->constant_charge_current_max_ua); 886 if (result) 887 dev_err(di->dev, "failed to set chg curr\n"); 888 break; 889 890 case MAXIM_RET_NOACTION: 891 default: 892 /* Do nothing..*/ 893 break; 894 } 895 } 896 897 static int ab8500_chargalg_get_ext_psy_data(struct device *dev, void *data) 898 { 899 struct power_supply *psy; 900 struct power_supply *ext = dev_get_drvdata(dev); 901 const char **supplicants = (const char **)ext->supplied_to; 902 struct ab8500_chargalg *di; 903 union power_supply_propval ret; 904 int j; 905 bool capacity_updated = false; 906 907 psy = (struct power_supply *)data; 908 di = power_supply_get_drvdata(psy); 909 /* For all psy where the driver name appears in any supplied_to */ 910 j = match_string(supplicants, ext->num_supplicants, psy->desc->name); 911 if (j < 0) 912 return 0; 913 914 /* 915 * If external is not registering 'POWER_SUPPLY_PROP_CAPACITY' to its 916 * property because of handling that sysfs entry on its own, this is 917 * the place to get the battery capacity. 918 */ 919 if (!power_supply_get_property(ext, POWER_SUPPLY_PROP_CAPACITY, &ret)) { 920 di->batt_data.percent = ret.intval; 921 capacity_updated = true; 922 } 923 924 /* Go through all properties for the psy */ 925 for (j = 0; j < ext->desc->num_properties; j++) { 926 enum power_supply_property prop; 927 prop = ext->desc->properties[j]; 928 929 /* 930 * Initialize chargers if not already done. 931 * The ab8500_charger*/ 932 if (!di->ac_chg && 933 ext->desc->type == POWER_SUPPLY_TYPE_MAINS) 934 di->ac_chg = psy_to_ux500_charger(ext); 935 else if (!di->usb_chg && 936 ext->desc->type == POWER_SUPPLY_TYPE_USB) 937 di->usb_chg = psy_to_ux500_charger(ext); 938 939 if (power_supply_get_property(ext, prop, &ret)) 940 continue; 941 switch (prop) { 942 case POWER_SUPPLY_PROP_PRESENT: 943 switch (ext->desc->type) { 944 case POWER_SUPPLY_TYPE_BATTERY: 945 /* Battery present */ 946 if (ret.intval) 947 di->events.batt_rem = false; 948 /* Battery removed */ 949 else 950 di->events.batt_rem = true; 951 break; 952 case POWER_SUPPLY_TYPE_MAINS: 953 /* AC disconnected */ 954 if (!ret.intval && 955 (di->chg_info.conn_chg & AC_CHG)) { 956 di->chg_info.prev_conn_chg = 957 di->chg_info.conn_chg; 958 di->chg_info.conn_chg &= ~AC_CHG; 959 } 960 /* AC connected */ 961 else if (ret.intval && 962 !(di->chg_info.conn_chg & AC_CHG)) { 963 di->chg_info.prev_conn_chg = 964 di->chg_info.conn_chg; 965 di->chg_info.conn_chg |= AC_CHG; 966 } 967 break; 968 case POWER_SUPPLY_TYPE_USB: 969 /* USB disconnected */ 970 if (!ret.intval && 971 (di->chg_info.conn_chg & USB_CHG)) { 972 di->chg_info.prev_conn_chg = 973 di->chg_info.conn_chg; 974 di->chg_info.conn_chg &= ~USB_CHG; 975 } 976 /* USB connected */ 977 else if (ret.intval && 978 !(di->chg_info.conn_chg & USB_CHG)) { 979 di->chg_info.prev_conn_chg = 980 di->chg_info.conn_chg; 981 di->chg_info.conn_chg |= USB_CHG; 982 } 983 break; 984 default: 985 break; 986 } 987 break; 988 989 case POWER_SUPPLY_PROP_ONLINE: 990 switch (ext->desc->type) { 991 case POWER_SUPPLY_TYPE_BATTERY: 992 break; 993 case POWER_SUPPLY_TYPE_MAINS: 994 /* AC offline */ 995 if (!ret.intval && 996 (di->chg_info.online_chg & AC_CHG)) { 997 di->chg_info.prev_online_chg = 998 di->chg_info.online_chg; 999 di->chg_info.online_chg &= ~AC_CHG; 1000 } 1001 /* AC online */ 1002 else if (ret.intval && 1003 !(di->chg_info.online_chg & AC_CHG)) { 1004 di->chg_info.prev_online_chg = 1005 di->chg_info.online_chg; 1006 di->chg_info.online_chg |= AC_CHG; 1007 queue_delayed_work(di->chargalg_wq, 1008 &di->chargalg_wd_work, 0); 1009 } 1010 break; 1011 case POWER_SUPPLY_TYPE_USB: 1012 /* USB offline */ 1013 if (!ret.intval && 1014 (di->chg_info.online_chg & USB_CHG)) { 1015 di->chg_info.prev_online_chg = 1016 di->chg_info.online_chg; 1017 di->chg_info.online_chg &= ~USB_CHG; 1018 } 1019 /* USB online */ 1020 else if (ret.intval && 1021 !(di->chg_info.online_chg & USB_CHG)) { 1022 di->chg_info.prev_online_chg = 1023 di->chg_info.online_chg; 1024 di->chg_info.online_chg |= USB_CHG; 1025 queue_delayed_work(di->chargalg_wq, 1026 &di->chargalg_wd_work, 0); 1027 } 1028 break; 1029 default: 1030 break; 1031 } 1032 break; 1033 1034 case POWER_SUPPLY_PROP_HEALTH: 1035 switch (ext->desc->type) { 1036 case POWER_SUPPLY_TYPE_BATTERY: 1037 break; 1038 case POWER_SUPPLY_TYPE_MAINS: 1039 switch (ret.intval) { 1040 case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE: 1041 di->events.mainextchnotok = true; 1042 di->events.main_thermal_prot = false; 1043 di->events.main_ovv = false; 1044 di->events.ac_wd_expired = false; 1045 break; 1046 case POWER_SUPPLY_HEALTH_DEAD: 1047 di->events.ac_wd_expired = true; 1048 di->events.mainextchnotok = false; 1049 di->events.main_ovv = false; 1050 di->events.main_thermal_prot = false; 1051 break; 1052 case POWER_SUPPLY_HEALTH_COLD: 1053 case POWER_SUPPLY_HEALTH_OVERHEAT: 1054 di->events.main_thermal_prot = true; 1055 di->events.mainextchnotok = false; 1056 di->events.main_ovv = false; 1057 di->events.ac_wd_expired = false; 1058 break; 1059 case POWER_SUPPLY_HEALTH_OVERVOLTAGE: 1060 di->events.main_ovv = true; 1061 di->events.mainextchnotok = false; 1062 di->events.main_thermal_prot = false; 1063 di->events.ac_wd_expired = false; 1064 break; 1065 case POWER_SUPPLY_HEALTH_GOOD: 1066 di->events.main_thermal_prot = false; 1067 di->events.mainextchnotok = false; 1068 di->events.main_ovv = false; 1069 di->events.ac_wd_expired = false; 1070 break; 1071 default: 1072 break; 1073 } 1074 break; 1075 1076 case POWER_SUPPLY_TYPE_USB: 1077 switch (ret.intval) { 1078 case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE: 1079 di->events.usbchargernotok = true; 1080 di->events.usb_thermal_prot = false; 1081 di->events.vbus_ovv = false; 1082 di->events.usb_wd_expired = false; 1083 break; 1084 case POWER_SUPPLY_HEALTH_DEAD: 1085 di->events.usb_wd_expired = true; 1086 di->events.usbchargernotok = false; 1087 di->events.usb_thermal_prot = false; 1088 di->events.vbus_ovv = false; 1089 break; 1090 case POWER_SUPPLY_HEALTH_COLD: 1091 case POWER_SUPPLY_HEALTH_OVERHEAT: 1092 di->events.usb_thermal_prot = true; 1093 di->events.usbchargernotok = false; 1094 di->events.vbus_ovv = false; 1095 di->events.usb_wd_expired = false; 1096 break; 1097 case POWER_SUPPLY_HEALTH_OVERVOLTAGE: 1098 di->events.vbus_ovv = true; 1099 di->events.usbchargernotok = false; 1100 di->events.usb_thermal_prot = false; 1101 di->events.usb_wd_expired = false; 1102 break; 1103 case POWER_SUPPLY_HEALTH_GOOD: 1104 di->events.usbchargernotok = false; 1105 di->events.usb_thermal_prot = false; 1106 di->events.vbus_ovv = false; 1107 di->events.usb_wd_expired = false; 1108 break; 1109 default: 1110 break; 1111 } 1112 break; 1113 default: 1114 break; 1115 } 1116 break; 1117 1118 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 1119 switch (ext->desc->type) { 1120 case POWER_SUPPLY_TYPE_BATTERY: 1121 di->batt_data.volt_uv = ret.intval; 1122 break; 1123 case POWER_SUPPLY_TYPE_MAINS: 1124 di->chg_info.ac_volt_uv = ret.intval; 1125 break; 1126 case POWER_SUPPLY_TYPE_USB: 1127 di->chg_info.usb_volt_uv = ret.intval; 1128 break; 1129 default: 1130 break; 1131 } 1132 break; 1133 1134 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 1135 switch (ext->desc->type) { 1136 case POWER_SUPPLY_TYPE_MAINS: 1137 /* AVG is used to indicate when we are 1138 * in CV mode */ 1139 if (ret.intval) 1140 di->events.ac_cv_active = true; 1141 else 1142 di->events.ac_cv_active = false; 1143 1144 break; 1145 case POWER_SUPPLY_TYPE_USB: 1146 /* AVG is used to indicate when we are 1147 * in CV mode */ 1148 if (ret.intval) 1149 di->events.usb_cv_active = true; 1150 else 1151 di->events.usb_cv_active = false; 1152 1153 break; 1154 default: 1155 break; 1156 } 1157 break; 1158 1159 case POWER_SUPPLY_PROP_TECHNOLOGY: 1160 switch (ext->desc->type) { 1161 case POWER_SUPPLY_TYPE_BATTERY: 1162 if (ret.intval) 1163 di->events.batt_unknown = false; 1164 else 1165 di->events.batt_unknown = true; 1166 1167 break; 1168 default: 1169 break; 1170 } 1171 break; 1172 1173 case POWER_SUPPLY_PROP_TEMP: 1174 di->batt_data.temp = ret.intval / 10; 1175 break; 1176 1177 case POWER_SUPPLY_PROP_CURRENT_NOW: 1178 switch (ext->desc->type) { 1179 case POWER_SUPPLY_TYPE_MAINS: 1180 di->chg_info.ac_curr_ua = ret.intval; 1181 break; 1182 case POWER_SUPPLY_TYPE_USB: 1183 di->chg_info.usb_curr_ua = ret.intval; 1184 break; 1185 case POWER_SUPPLY_TYPE_BATTERY: 1186 di->batt_data.inst_curr_ua = ret.intval; 1187 break; 1188 default: 1189 break; 1190 } 1191 break; 1192 1193 case POWER_SUPPLY_PROP_CURRENT_AVG: 1194 switch (ext->desc->type) { 1195 case POWER_SUPPLY_TYPE_BATTERY: 1196 di->batt_data.avg_curr_ua = ret.intval; 1197 break; 1198 case POWER_SUPPLY_TYPE_USB: 1199 if (ret.intval) 1200 di->events.vbus_collapsed = true; 1201 else 1202 di->events.vbus_collapsed = false; 1203 break; 1204 default: 1205 break; 1206 } 1207 break; 1208 case POWER_SUPPLY_PROP_CAPACITY: 1209 if (!capacity_updated) 1210 di->batt_data.percent = ret.intval; 1211 break; 1212 default: 1213 break; 1214 } 1215 } 1216 return 0; 1217 } 1218 1219 /** 1220 * ab8500_chargalg_external_power_changed() - callback for power supply changes 1221 * @psy: pointer to the structure power_supply 1222 * 1223 * This function is the entry point of the pointer external_power_changed 1224 * of the structure power_supply. 1225 * This function gets executed when there is a change in any external power 1226 * supply that this driver needs to be notified of. 1227 */ 1228 static void ab8500_chargalg_external_power_changed(struct power_supply *psy) 1229 { 1230 struct ab8500_chargalg *di = power_supply_get_drvdata(psy); 1231 1232 /* 1233 * Trigger execution of the algorithm instantly and read 1234 * all power_supply properties there instead 1235 */ 1236 if (di->chargalg_wq) 1237 queue_work(di->chargalg_wq, &di->chargalg_work); 1238 } 1239 1240 /** 1241 * ab8500_chargalg_algorithm() - Main function for the algorithm 1242 * @di: pointer to the ab8500_chargalg structure 1243 * 1244 * This is the main control function for the charging algorithm. 1245 * It is called periodically or when something happens that will 1246 * trigger a state change 1247 */ 1248 static void ab8500_chargalg_algorithm(struct ab8500_chargalg *di) 1249 { 1250 struct power_supply_battery_info *bi = di->bm->bi; 1251 int charger_status; 1252 int ret; 1253 1254 /* Collect data from all power_supply class devices */ 1255 class_for_each_device(power_supply_class, NULL, 1256 di->chargalg_psy, ab8500_chargalg_get_ext_psy_data); 1257 1258 ab8500_chargalg_end_of_charge(di); 1259 ab8500_chargalg_check_temp(di); 1260 ab8500_chargalg_check_charger_voltage(di); 1261 1262 charger_status = ab8500_chargalg_check_charger_connection(di); 1263 1264 if (is_ab8500(di->parent)) { 1265 ret = ab8500_chargalg_check_charger_enable(di); 1266 if (ret < 0) 1267 dev_err(di->dev, "Checking charger is enabled error" 1268 ": Returned Value %d\n", ret); 1269 } 1270 1271 /* 1272 * First check if we have a charger connected. 1273 * Also we don't allow charging of unknown batteries if configured 1274 * this way 1275 */ 1276 if (!charger_status || 1277 (di->events.batt_unknown && !di->bm->chg_unknown_bat)) { 1278 if (di->charge_state != STATE_HANDHELD) { 1279 di->events.safety_timer_expired = false; 1280 ab8500_chargalg_state_to(di, STATE_HANDHELD_INIT); 1281 } 1282 } 1283 1284 /* If suspended, we should not continue checking the flags */ 1285 else if (di->charge_state == STATE_SUSPENDED_INIT || 1286 di->charge_state == STATE_SUSPENDED) { 1287 /* We don't do anything here, just don,t continue */ 1288 } 1289 1290 /* Safety timer expiration */ 1291 else if (di->events.safety_timer_expired) { 1292 if (di->charge_state != STATE_SAFETY_TIMER_EXPIRED) 1293 ab8500_chargalg_state_to(di, 1294 STATE_SAFETY_TIMER_EXPIRED_INIT); 1295 } 1296 /* 1297 * Check if any interrupts has occured 1298 * that will prevent us from charging 1299 */ 1300 1301 /* Battery removed */ 1302 else if (di->events.batt_rem) { 1303 if (di->charge_state != STATE_BATT_REMOVED) 1304 ab8500_chargalg_state_to(di, STATE_BATT_REMOVED_INIT); 1305 } 1306 /* Main or USB charger not ok. */ 1307 else if (di->events.mainextchnotok || di->events.usbchargernotok) { 1308 /* 1309 * If vbus_collapsed is set, we have to lower the charger 1310 * current, which is done in the normal state below 1311 */ 1312 if (di->charge_state != STATE_CHG_NOT_OK && 1313 !di->events.vbus_collapsed) 1314 ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK_INIT); 1315 } 1316 /* VBUS, Main or VBAT OVV. */ 1317 else if (di->events.vbus_ovv || 1318 di->events.main_ovv || 1319 di->events.batt_ovv || 1320 !di->chg_info.usb_chg_ok || 1321 !di->chg_info.ac_chg_ok) { 1322 if (di->charge_state != STATE_OVV_PROTECT) 1323 ab8500_chargalg_state_to(di, STATE_OVV_PROTECT_INIT); 1324 } 1325 /* USB Thermal, stop charging */ 1326 else if (di->events.main_thermal_prot || 1327 di->events.usb_thermal_prot) { 1328 if (di->charge_state != STATE_HW_TEMP_PROTECT) 1329 ab8500_chargalg_state_to(di, 1330 STATE_HW_TEMP_PROTECT_INIT); 1331 } 1332 /* Battery temp over/under */ 1333 else if (di->events.btemp_underover) { 1334 if (di->charge_state != STATE_TEMP_UNDEROVER) 1335 ab8500_chargalg_state_to(di, 1336 STATE_TEMP_UNDEROVER_INIT); 1337 } 1338 /* Watchdog expired */ 1339 else if (di->events.ac_wd_expired || 1340 di->events.usb_wd_expired) { 1341 if (di->charge_state != STATE_WD_EXPIRED) 1342 ab8500_chargalg_state_to(di, STATE_WD_EXPIRED_INIT); 1343 } 1344 /* Battery temp high/low */ 1345 else if (di->events.btemp_lowhigh) { 1346 if (di->charge_state != STATE_TEMP_LOWHIGH) 1347 ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH_INIT); 1348 } 1349 1350 dev_dbg(di->dev, 1351 "[CHARGALG] Vb %d Ib_avg %d Ib_inst %d Tb %d Cap %d Maint %d " 1352 "State %s Active_chg %d Chg_status %d AC %d USB %d " 1353 "AC_online %d USB_online %d AC_CV %d USB_CV %d AC_I %d " 1354 "USB_I %d AC_Vset %d AC_Iset %d USB_Vset %d USB_Iset %d\n", 1355 di->batt_data.volt_uv, 1356 di->batt_data.avg_curr_ua, 1357 di->batt_data.inst_curr_ua, 1358 di->batt_data.temp, 1359 di->batt_data.percent, 1360 di->maintenance_chg, 1361 states[di->charge_state], 1362 di->chg_info.charger_type, 1363 di->charge_status, 1364 di->chg_info.conn_chg & AC_CHG, 1365 di->chg_info.conn_chg & USB_CHG, 1366 di->chg_info.online_chg & AC_CHG, 1367 di->chg_info.online_chg & USB_CHG, 1368 di->events.ac_cv_active, 1369 di->events.usb_cv_active, 1370 di->chg_info.ac_curr_ua, 1371 di->chg_info.usb_curr_ua, 1372 di->chg_info.ac_vset_uv, 1373 di->chg_info.ac_iset_ua, 1374 di->chg_info.usb_vset_uv, 1375 di->chg_info.usb_iset_ua); 1376 1377 switch (di->charge_state) { 1378 case STATE_HANDHELD_INIT: 1379 ab8500_chargalg_stop_charging(di); 1380 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING; 1381 ab8500_chargalg_state_to(di, STATE_HANDHELD); 1382 fallthrough; 1383 1384 case STATE_HANDHELD: 1385 break; 1386 1387 case STATE_SUSPENDED_INIT: 1388 if (di->susp_status.ac_suspended) 1389 ab8500_chargalg_ac_en(di, false, 0, 0); 1390 if (di->susp_status.usb_suspended) 1391 ab8500_chargalg_usb_en(di, false, 0, 0); 1392 ab8500_chargalg_stop_safety_timer(di); 1393 ab8500_chargalg_stop_maintenance_timer(di); 1394 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING; 1395 di->maintenance_chg = false; 1396 ab8500_chargalg_state_to(di, STATE_SUSPENDED); 1397 power_supply_changed(di->chargalg_psy); 1398 fallthrough; 1399 1400 case STATE_SUSPENDED: 1401 /* CHARGING is suspended */ 1402 break; 1403 1404 case STATE_BATT_REMOVED_INIT: 1405 ab8500_chargalg_stop_charging(di); 1406 ab8500_chargalg_state_to(di, STATE_BATT_REMOVED); 1407 fallthrough; 1408 1409 case STATE_BATT_REMOVED: 1410 if (!di->events.batt_rem) 1411 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1412 break; 1413 1414 case STATE_HW_TEMP_PROTECT_INIT: 1415 ab8500_chargalg_stop_charging(di); 1416 ab8500_chargalg_state_to(di, STATE_HW_TEMP_PROTECT); 1417 fallthrough; 1418 1419 case STATE_HW_TEMP_PROTECT: 1420 if (!di->events.main_thermal_prot && 1421 !di->events.usb_thermal_prot) 1422 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1423 break; 1424 1425 case STATE_OVV_PROTECT_INIT: 1426 ab8500_chargalg_stop_charging(di); 1427 ab8500_chargalg_state_to(di, STATE_OVV_PROTECT); 1428 fallthrough; 1429 1430 case STATE_OVV_PROTECT: 1431 if (!di->events.vbus_ovv && 1432 !di->events.main_ovv && 1433 !di->events.batt_ovv && 1434 di->chg_info.usb_chg_ok && 1435 di->chg_info.ac_chg_ok) 1436 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1437 break; 1438 1439 case STATE_CHG_NOT_OK_INIT: 1440 ab8500_chargalg_stop_charging(di); 1441 ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK); 1442 fallthrough; 1443 1444 case STATE_CHG_NOT_OK: 1445 if (!di->events.mainextchnotok && 1446 !di->events.usbchargernotok) 1447 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1448 break; 1449 1450 case STATE_SAFETY_TIMER_EXPIRED_INIT: 1451 ab8500_chargalg_stop_charging(di); 1452 ab8500_chargalg_state_to(di, STATE_SAFETY_TIMER_EXPIRED); 1453 fallthrough; 1454 1455 case STATE_SAFETY_TIMER_EXPIRED: 1456 /* We exit this state when charger is removed */ 1457 break; 1458 1459 case STATE_NORMAL_INIT: 1460 if (bi->constant_charge_current_max_ua == 0) 1461 /* "charging" with 0 uA */ 1462 ab8500_chargalg_stop_charging(di); 1463 else { 1464 ab8500_chargalg_start_charging(di, 1465 bi->constant_charge_voltage_max_uv, 1466 bi->constant_charge_current_max_ua); 1467 } 1468 1469 ab8500_chargalg_state_to(di, STATE_NORMAL); 1470 ab8500_chargalg_start_safety_timer(di); 1471 ab8500_chargalg_stop_maintenance_timer(di); 1472 init_maxim_chg_curr(di); 1473 di->charge_status = POWER_SUPPLY_STATUS_CHARGING; 1474 di->eoc_cnt = 0; 1475 di->maintenance_chg = false; 1476 power_supply_changed(di->chargalg_psy); 1477 1478 break; 1479 1480 case STATE_NORMAL: 1481 handle_maxim_chg_curr(di); 1482 if (di->charge_status == POWER_SUPPLY_STATUS_FULL && 1483 di->maintenance_chg) { 1484 if (di->bm->no_maintenance) 1485 ab8500_chargalg_state_to(di, 1486 STATE_WAIT_FOR_RECHARGE_INIT); 1487 else 1488 ab8500_chargalg_state_to(di, 1489 STATE_MAINTENANCE_A_INIT); 1490 } 1491 break; 1492 1493 /* This state will be used when the maintenance state is disabled */ 1494 case STATE_WAIT_FOR_RECHARGE_INIT: 1495 ab8500_chargalg_hold_charging(di); 1496 ab8500_chargalg_state_to(di, STATE_WAIT_FOR_RECHARGE); 1497 fallthrough; 1498 1499 case STATE_WAIT_FOR_RECHARGE: 1500 if (di->batt_data.percent <= AB8500_RECHARGE_CAP) 1501 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1502 break; 1503 1504 case STATE_MAINTENANCE_A_INIT: 1505 ab8500_chargalg_stop_safety_timer(di); 1506 ab8500_chargalg_start_maintenance_timer(di, 1507 di->bm->bat_type->maint_a_chg_timer_h); 1508 ab8500_chargalg_start_charging(di, 1509 di->bm->bat_type->maint_a_vol_lvl, 1510 di->bm->bat_type->maint_a_cur_lvl); 1511 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_A); 1512 power_supply_changed(di->chargalg_psy); 1513 fallthrough; 1514 1515 case STATE_MAINTENANCE_A: 1516 if (di->events.maintenance_timer_expired) { 1517 ab8500_chargalg_stop_maintenance_timer(di); 1518 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B_INIT); 1519 } 1520 break; 1521 1522 case STATE_MAINTENANCE_B_INIT: 1523 ab8500_chargalg_start_maintenance_timer(di, 1524 di->bm->bat_type->maint_b_chg_timer_h); 1525 ab8500_chargalg_start_charging(di, 1526 di->bm->bat_type->maint_b_vol_lvl, 1527 di->bm->bat_type->maint_b_cur_lvl); 1528 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B); 1529 power_supply_changed(di->chargalg_psy); 1530 fallthrough; 1531 1532 case STATE_MAINTENANCE_B: 1533 if (di->events.maintenance_timer_expired) { 1534 ab8500_chargalg_stop_maintenance_timer(di); 1535 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1536 } 1537 break; 1538 1539 case STATE_TEMP_LOWHIGH_INIT: 1540 ab8500_chargalg_start_charging(di, 1541 di->bm->bat_type->low_high_vol_lvl, 1542 di->bm->bat_type->low_high_cur_lvl); 1543 ab8500_chargalg_stop_maintenance_timer(di); 1544 di->charge_status = POWER_SUPPLY_STATUS_CHARGING; 1545 ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH); 1546 power_supply_changed(di->chargalg_psy); 1547 fallthrough; 1548 1549 case STATE_TEMP_LOWHIGH: 1550 if (!di->events.btemp_lowhigh) 1551 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1552 break; 1553 1554 case STATE_WD_EXPIRED_INIT: 1555 ab8500_chargalg_stop_charging(di); 1556 ab8500_chargalg_state_to(di, STATE_WD_EXPIRED); 1557 fallthrough; 1558 1559 case STATE_WD_EXPIRED: 1560 if (!di->events.ac_wd_expired && 1561 !di->events.usb_wd_expired) 1562 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1563 break; 1564 1565 case STATE_TEMP_UNDEROVER_INIT: 1566 ab8500_chargalg_stop_charging(di); 1567 ab8500_chargalg_state_to(di, STATE_TEMP_UNDEROVER); 1568 fallthrough; 1569 1570 case STATE_TEMP_UNDEROVER: 1571 if (!di->events.btemp_underover) 1572 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT); 1573 break; 1574 } 1575 1576 /* Start charging directly if the new state is a charge state */ 1577 if (di->charge_state == STATE_NORMAL_INIT || 1578 di->charge_state == STATE_MAINTENANCE_A_INIT || 1579 di->charge_state == STATE_MAINTENANCE_B_INIT) 1580 queue_work(di->chargalg_wq, &di->chargalg_work); 1581 } 1582 1583 /** 1584 * ab8500_chargalg_periodic_work() - Periodic work for the algorithm 1585 * @work: pointer to the work_struct structure 1586 * 1587 * Work queue function for the charging algorithm 1588 */ 1589 static void ab8500_chargalg_periodic_work(struct work_struct *work) 1590 { 1591 struct ab8500_chargalg *di = container_of(work, 1592 struct ab8500_chargalg, chargalg_periodic_work.work); 1593 1594 ab8500_chargalg_algorithm(di); 1595 1596 /* 1597 * If a charger is connected then the battery has to be monitored 1598 * frequently, else the work can be delayed. 1599 */ 1600 if (di->chg_info.conn_chg) 1601 queue_delayed_work(di->chargalg_wq, 1602 &di->chargalg_periodic_work, 1603 di->bm->interval_charging * HZ); 1604 else 1605 queue_delayed_work(di->chargalg_wq, 1606 &di->chargalg_periodic_work, 1607 di->bm->interval_not_charging * HZ); 1608 } 1609 1610 /** 1611 * ab8500_chargalg_wd_work() - periodic work to kick the charger watchdog 1612 * @work: pointer to the work_struct structure 1613 * 1614 * Work queue function for kicking the charger watchdog 1615 */ 1616 static void ab8500_chargalg_wd_work(struct work_struct *work) 1617 { 1618 int ret; 1619 struct ab8500_chargalg *di = container_of(work, 1620 struct ab8500_chargalg, chargalg_wd_work.work); 1621 1622 ret = ab8500_chargalg_kick_watchdog(di); 1623 if (ret < 0) 1624 dev_err(di->dev, "failed to kick watchdog\n"); 1625 1626 queue_delayed_work(di->chargalg_wq, 1627 &di->chargalg_wd_work, CHG_WD_INTERVAL); 1628 } 1629 1630 /** 1631 * ab8500_chargalg_work() - Work to run the charging algorithm instantly 1632 * @work: pointer to the work_struct structure 1633 * 1634 * Work queue function for calling the charging algorithm 1635 */ 1636 static void ab8500_chargalg_work(struct work_struct *work) 1637 { 1638 struct ab8500_chargalg *di = container_of(work, 1639 struct ab8500_chargalg, chargalg_work); 1640 1641 ab8500_chargalg_algorithm(di); 1642 } 1643 1644 /** 1645 * ab8500_chargalg_get_property() - get the chargalg properties 1646 * @psy: pointer to the power_supply structure 1647 * @psp: pointer to the power_supply_property structure 1648 * @val: pointer to the power_supply_propval union 1649 * 1650 * This function gets called when an application tries to get the 1651 * chargalg properties by reading the sysfs files. 1652 * status: charging/discharging/full/unknown 1653 * health: health of the battery 1654 * Returns error code in case of failure else 0 on success 1655 */ 1656 static int ab8500_chargalg_get_property(struct power_supply *psy, 1657 enum power_supply_property psp, 1658 union power_supply_propval *val) 1659 { 1660 struct ab8500_chargalg *di = power_supply_get_drvdata(psy); 1661 1662 switch (psp) { 1663 case POWER_SUPPLY_PROP_STATUS: 1664 val->intval = di->charge_status; 1665 break; 1666 case POWER_SUPPLY_PROP_HEALTH: 1667 if (di->events.batt_ovv) { 1668 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 1669 } else if (di->events.btemp_underover) { 1670 if (di->batt_data.temp <= di->bm->bi->temp_min) 1671 val->intval = POWER_SUPPLY_HEALTH_COLD; 1672 else 1673 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 1674 } else if (di->charge_state == STATE_SAFETY_TIMER_EXPIRED || 1675 di->charge_state == STATE_SAFETY_TIMER_EXPIRED_INIT) { 1676 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 1677 } else { 1678 val->intval = POWER_SUPPLY_HEALTH_GOOD; 1679 } 1680 break; 1681 default: 1682 return -EINVAL; 1683 } 1684 return 0; 1685 } 1686 1687 /* Exposure to the sysfs interface */ 1688 1689 static ssize_t ab8500_chargalg_en_show(struct ab8500_chargalg *di, 1690 char *buf) 1691 { 1692 return sprintf(buf, "%d\n", 1693 di->susp_status.ac_suspended && 1694 di->susp_status.usb_suspended); 1695 } 1696 1697 static ssize_t ab8500_chargalg_en_store(struct ab8500_chargalg *di, 1698 const char *buf, size_t length) 1699 { 1700 long param; 1701 int ac_usb; 1702 int ret; 1703 1704 ret = kstrtol(buf, 10, ¶m); 1705 if (ret < 0) 1706 return ret; 1707 1708 ac_usb = param; 1709 switch (ac_usb) { 1710 case 0: 1711 /* Disable charging */ 1712 di->susp_status.ac_suspended = true; 1713 di->susp_status.usb_suspended = true; 1714 di->susp_status.suspended_change = true; 1715 /* Trigger a state change */ 1716 queue_work(di->chargalg_wq, 1717 &di->chargalg_work); 1718 break; 1719 case 1: 1720 /* Enable AC Charging */ 1721 di->susp_status.ac_suspended = false; 1722 di->susp_status.suspended_change = true; 1723 /* Trigger a state change */ 1724 queue_work(di->chargalg_wq, 1725 &di->chargalg_work); 1726 break; 1727 case 2: 1728 /* Enable USB charging */ 1729 di->susp_status.usb_suspended = false; 1730 di->susp_status.suspended_change = true; 1731 /* Trigger a state change */ 1732 queue_work(di->chargalg_wq, 1733 &di->chargalg_work); 1734 break; 1735 default: 1736 dev_info(di->dev, "Wrong input\n" 1737 "Enter 0. Disable AC/USB Charging\n" 1738 "1. Enable AC charging\n" 1739 "2. Enable USB Charging\n"); 1740 } 1741 return strlen(buf); 1742 } 1743 1744 static struct ab8500_chargalg_sysfs_entry ab8500_chargalg_en_charger = 1745 __ATTR(chargalg, 0644, ab8500_chargalg_en_show, 1746 ab8500_chargalg_en_store); 1747 1748 static ssize_t ab8500_chargalg_sysfs_show(struct kobject *kobj, 1749 struct attribute *attr, char *buf) 1750 { 1751 struct ab8500_chargalg_sysfs_entry *entry = container_of(attr, 1752 struct ab8500_chargalg_sysfs_entry, attr); 1753 1754 struct ab8500_chargalg *di = container_of(kobj, 1755 struct ab8500_chargalg, chargalg_kobject); 1756 1757 if (!entry->show) 1758 return -EIO; 1759 1760 return entry->show(di, buf); 1761 } 1762 1763 static ssize_t ab8500_chargalg_sysfs_charger(struct kobject *kobj, 1764 struct attribute *attr, const char *buf, size_t length) 1765 { 1766 struct ab8500_chargalg_sysfs_entry *entry = container_of(attr, 1767 struct ab8500_chargalg_sysfs_entry, attr); 1768 1769 struct ab8500_chargalg *di = container_of(kobj, 1770 struct ab8500_chargalg, chargalg_kobject); 1771 1772 if (!entry->store) 1773 return -EIO; 1774 1775 return entry->store(di, buf, length); 1776 } 1777 1778 static struct attribute *ab8500_chargalg_chg[] = { 1779 &ab8500_chargalg_en_charger.attr, 1780 NULL, 1781 }; 1782 1783 static const struct sysfs_ops ab8500_chargalg_sysfs_ops = { 1784 .show = ab8500_chargalg_sysfs_show, 1785 .store = ab8500_chargalg_sysfs_charger, 1786 }; 1787 1788 static struct kobj_type ab8500_chargalg_ktype = { 1789 .sysfs_ops = &ab8500_chargalg_sysfs_ops, 1790 .default_attrs = ab8500_chargalg_chg, 1791 }; 1792 1793 /** 1794 * ab8500_chargalg_sysfs_exit() - de-init of sysfs entry 1795 * @di: pointer to the struct ab8500_chargalg 1796 * 1797 * This function removes the entry in sysfs. 1798 */ 1799 static void ab8500_chargalg_sysfs_exit(struct ab8500_chargalg *di) 1800 { 1801 kobject_del(&di->chargalg_kobject); 1802 } 1803 1804 /** 1805 * ab8500_chargalg_sysfs_init() - init of sysfs entry 1806 * @di: pointer to the struct ab8500_chargalg 1807 * 1808 * This function adds an entry in sysfs. 1809 * Returns error code in case of failure else 0(on success) 1810 */ 1811 static int ab8500_chargalg_sysfs_init(struct ab8500_chargalg *di) 1812 { 1813 int ret = 0; 1814 1815 ret = kobject_init_and_add(&di->chargalg_kobject, 1816 &ab8500_chargalg_ktype, 1817 NULL, "ab8500_chargalg"); 1818 if (ret < 0) 1819 dev_err(di->dev, "failed to create sysfs entry\n"); 1820 1821 return ret; 1822 } 1823 /* Exposure to the sysfs interface <<END>> */ 1824 1825 static int __maybe_unused ab8500_chargalg_resume(struct device *dev) 1826 { 1827 struct ab8500_chargalg *di = dev_get_drvdata(dev); 1828 1829 /* Kick charger watchdog if charging (any charger online) */ 1830 if (di->chg_info.online_chg) 1831 queue_delayed_work(di->chargalg_wq, &di->chargalg_wd_work, 0); 1832 1833 /* 1834 * Run the charging algorithm directly to be sure we don't 1835 * do it too seldom 1836 */ 1837 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0); 1838 1839 return 0; 1840 } 1841 1842 static int __maybe_unused ab8500_chargalg_suspend(struct device *dev) 1843 { 1844 struct ab8500_chargalg *di = dev_get_drvdata(dev); 1845 1846 if (di->chg_info.online_chg) 1847 cancel_delayed_work_sync(&di->chargalg_wd_work); 1848 1849 cancel_delayed_work_sync(&di->chargalg_periodic_work); 1850 1851 return 0; 1852 } 1853 1854 static char *supply_interface[] = { 1855 "ab8500_fg", 1856 }; 1857 1858 static const struct power_supply_desc ab8500_chargalg_desc = { 1859 .name = "ab8500_chargalg", 1860 .type = POWER_SUPPLY_TYPE_BATTERY, 1861 .properties = ab8500_chargalg_props, 1862 .num_properties = ARRAY_SIZE(ab8500_chargalg_props), 1863 .get_property = ab8500_chargalg_get_property, 1864 .external_power_changed = ab8500_chargalg_external_power_changed, 1865 }; 1866 1867 static int ab8500_chargalg_bind(struct device *dev, struct device *master, 1868 void *data) 1869 { 1870 struct ab8500_chargalg *di = dev_get_drvdata(dev); 1871 1872 /* Create a work queue for the chargalg */ 1873 di->chargalg_wq = alloc_ordered_workqueue("ab8500_chargalg_wq", 1874 WQ_MEM_RECLAIM); 1875 if (di->chargalg_wq == NULL) { 1876 dev_err(di->dev, "failed to create work queue\n"); 1877 return -ENOMEM; 1878 } 1879 1880 /* Run the charging algorithm */ 1881 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0); 1882 1883 return 0; 1884 } 1885 1886 static void ab8500_chargalg_unbind(struct device *dev, struct device *master, 1887 void *data) 1888 { 1889 struct ab8500_chargalg *di = dev_get_drvdata(dev); 1890 1891 /* Stop all timers and work */ 1892 hrtimer_cancel(&di->safety_timer); 1893 hrtimer_cancel(&di->maintenance_timer); 1894 1895 cancel_delayed_work_sync(&di->chargalg_periodic_work); 1896 cancel_delayed_work_sync(&di->chargalg_wd_work); 1897 cancel_work_sync(&di->chargalg_work); 1898 1899 /* Delete the work queue */ 1900 destroy_workqueue(di->chargalg_wq); 1901 flush_scheduled_work(); 1902 } 1903 1904 static const struct component_ops ab8500_chargalg_component_ops = { 1905 .bind = ab8500_chargalg_bind, 1906 .unbind = ab8500_chargalg_unbind, 1907 }; 1908 1909 static int ab8500_chargalg_probe(struct platform_device *pdev) 1910 { 1911 struct device *dev = &pdev->dev; 1912 struct power_supply_config psy_cfg = {}; 1913 struct ab8500_chargalg *di; 1914 int ret = 0; 1915 1916 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL); 1917 if (!di) 1918 return -ENOMEM; 1919 1920 di->bm = &ab8500_bm_data; 1921 1922 /* get device struct and parent */ 1923 di->dev = dev; 1924 di->parent = dev_get_drvdata(pdev->dev.parent); 1925 1926 psy_cfg.supplied_to = supply_interface; 1927 psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface); 1928 psy_cfg.drv_data = di; 1929 1930 /* Initilialize safety timer */ 1931 hrtimer_init(&di->safety_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 1932 di->safety_timer.function = ab8500_chargalg_safety_timer_expired; 1933 1934 /* Initilialize maintenance timer */ 1935 hrtimer_init(&di->maintenance_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS); 1936 di->maintenance_timer.function = 1937 ab8500_chargalg_maintenance_timer_expired; 1938 1939 /* Init work for chargalg */ 1940 INIT_DEFERRABLE_WORK(&di->chargalg_periodic_work, 1941 ab8500_chargalg_periodic_work); 1942 INIT_DEFERRABLE_WORK(&di->chargalg_wd_work, 1943 ab8500_chargalg_wd_work); 1944 1945 /* Init work for chargalg */ 1946 INIT_WORK(&di->chargalg_work, ab8500_chargalg_work); 1947 1948 /* To detect charger at startup */ 1949 di->chg_info.prev_conn_chg = -1; 1950 1951 /* Register chargalg power supply class */ 1952 di->chargalg_psy = devm_power_supply_register(di->dev, 1953 &ab8500_chargalg_desc, 1954 &psy_cfg); 1955 if (IS_ERR(di->chargalg_psy)) { 1956 dev_err(di->dev, "failed to register chargalg psy\n"); 1957 return PTR_ERR(di->chargalg_psy); 1958 } 1959 1960 platform_set_drvdata(pdev, di); 1961 1962 /* sysfs interface to enable/disable charging from user space */ 1963 ret = ab8500_chargalg_sysfs_init(di); 1964 if (ret) { 1965 dev_err(di->dev, "failed to create sysfs entry\n"); 1966 return ret; 1967 } 1968 1969 dev_info(di->dev, "probe success\n"); 1970 return component_add(dev, &ab8500_chargalg_component_ops); 1971 } 1972 1973 static int ab8500_chargalg_remove(struct platform_device *pdev) 1974 { 1975 struct ab8500_chargalg *di = platform_get_drvdata(pdev); 1976 1977 component_del(&pdev->dev, &ab8500_chargalg_component_ops); 1978 1979 /* sysfs interface to enable/disable charging from user space */ 1980 ab8500_chargalg_sysfs_exit(di); 1981 1982 return 0; 1983 } 1984 1985 static SIMPLE_DEV_PM_OPS(ab8500_chargalg_pm_ops, ab8500_chargalg_suspend, ab8500_chargalg_resume); 1986 1987 static const struct of_device_id ab8500_chargalg_match[] = { 1988 { .compatible = "stericsson,ab8500-chargalg", }, 1989 { }, 1990 }; 1991 1992 struct platform_driver ab8500_chargalg_driver = { 1993 .probe = ab8500_chargalg_probe, 1994 .remove = ab8500_chargalg_remove, 1995 .driver = { 1996 .name = "ab8500_chargalg", 1997 .of_match_table = ab8500_chargalg_match, 1998 .pm = &ab8500_chargalg_pm_ops, 1999 }, 2000 }; 2001 MODULE_LICENSE("GPL v2"); 2002 MODULE_AUTHOR("Johan Palsson, Karl Komierowski"); 2003 MODULE_ALIAS("platform:ab8500-chargalg"); 2004 MODULE_DESCRIPTION("ab8500 battery charging algorithm"); 2005