1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) ST-Ericsson SA 2012 4 * 5 * Charger driver for AB8500 6 * 7 * Author: 8 * Johan Palsson <johan.palsson@stericsson.com> 9 * Karl Komierowski <karl.komierowski@stericsson.com> 10 * Arun R Murthy <arun.murthy@stericsson.com> 11 */ 12 13 #include <linux/init.h> 14 #include <linux/module.h> 15 #include <linux/device.h> 16 #include <linux/interrupt.h> 17 #include <linux/delay.h> 18 #include <linux/notifier.h> 19 #include <linux/slab.h> 20 #include <linux/platform_device.h> 21 #include <linux/power_supply.h> 22 #include <linux/completion.h> 23 #include <linux/regulator/consumer.h> 24 #include <linux/err.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/ab8500.h> 30 #include <linux/mfd/abx500.h> 31 #include <linux/mfd/abx500/ab8500-bm.h> 32 #include <linux/mfd/abx500/ab8500-gpadc.h> 33 #include <linux/mfd/abx500/ux500_chargalg.h> 34 #include <linux/usb/otg.h> 35 #include <linux/mutex.h> 36 37 /* Charger constants */ 38 #define NO_PW_CONN 0 39 #define AC_PW_CONN 1 40 #define USB_PW_CONN 2 41 42 #define MAIN_WDOG_ENA 0x01 43 #define MAIN_WDOG_KICK 0x02 44 #define MAIN_WDOG_DIS 0x00 45 #define CHARG_WD_KICK 0x01 46 #define MAIN_CH_ENA 0x01 47 #define MAIN_CH_NO_OVERSHOOT_ENA_N 0x02 48 #define USB_CH_ENA 0x01 49 #define USB_CHG_NO_OVERSHOOT_ENA_N 0x02 50 #define MAIN_CH_DET 0x01 51 #define MAIN_CH_CV_ON 0x04 52 #define USB_CH_CV_ON 0x08 53 #define VBUS_DET_DBNC100 0x02 54 #define VBUS_DET_DBNC1 0x01 55 #define OTP_ENABLE_WD 0x01 56 #define DROP_COUNT_RESET 0x01 57 #define USB_CH_DET 0x01 58 59 #define MAIN_CH_INPUT_CURR_SHIFT 4 60 #define VBUS_IN_CURR_LIM_SHIFT 4 61 #define AUTO_VBUS_IN_CURR_LIM_SHIFT 4 62 #define VBUS_IN_CURR_LIM_RETRY_SET_TIME 30 /* seconds */ 63 64 #define LED_INDICATOR_PWM_ENA 0x01 65 #define LED_INDICATOR_PWM_DIS 0x00 66 #define LED_IND_CUR_5MA 0x04 67 #define LED_INDICATOR_PWM_DUTY_252_256 0xBF 68 69 /* HW failure constants */ 70 #define MAIN_CH_TH_PROT 0x02 71 #define VBUS_CH_NOK 0x08 72 #define USB_CH_TH_PROT 0x02 73 #define VBUS_OVV_TH 0x01 74 #define MAIN_CH_NOK 0x01 75 #define VBUS_DET 0x80 76 77 #define MAIN_CH_STATUS2_MAINCHGDROP 0x80 78 #define MAIN_CH_STATUS2_MAINCHARGERDETDBNC 0x40 79 #define USB_CH_VBUSDROP 0x40 80 #define USB_CH_VBUSDETDBNC 0x01 81 82 /* UsbLineStatus register bit masks */ 83 #define AB8500_USB_LINK_STATUS 0x78 84 #define AB8505_USB_LINK_STATUS 0xF8 85 #define AB8500_STD_HOST_SUSP 0x18 86 #define USB_LINK_STATUS_SHIFT 3 87 88 /* Watchdog timeout constant */ 89 #define WD_TIMER 0x30 /* 4min */ 90 #define WD_KICK_INTERVAL (60 * HZ) 91 92 /* Lowest charger voltage is 3.39V -> 0x4E */ 93 #define LOW_VOLT_REG 0x4E 94 95 /* Step up/down delay in us */ 96 #define STEP_UDELAY 1000 97 98 #define CHARGER_STATUS_POLL 10 /* in ms */ 99 100 #define CHG_WD_INTERVAL (60 * HZ) 101 102 #define AB8500_SW_CONTROL_FALLBACK 0x03 103 /* Wait for enumeration before charing in us */ 104 #define WAIT_ACA_RID_ENUMERATION (5 * 1000) 105 /*External charger control*/ 106 #define AB8500_SYS_CHARGER_CONTROL_REG 0x52 107 #define EXTERNAL_CHARGER_DISABLE_REG_VAL 0x03 108 #define EXTERNAL_CHARGER_ENABLE_REG_VAL 0x07 109 110 /* UsbLineStatus register - usb types */ 111 enum ab8500_charger_link_status { 112 USB_STAT_NOT_CONFIGURED, 113 USB_STAT_STD_HOST_NC, 114 USB_STAT_STD_HOST_C_NS, 115 USB_STAT_STD_HOST_C_S, 116 USB_STAT_HOST_CHG_NM, 117 USB_STAT_HOST_CHG_HS, 118 USB_STAT_HOST_CHG_HS_CHIRP, 119 USB_STAT_DEDICATED_CHG, 120 USB_STAT_ACA_RID_A, 121 USB_STAT_ACA_RID_B, 122 USB_STAT_ACA_RID_C_NM, 123 USB_STAT_ACA_RID_C_HS, 124 USB_STAT_ACA_RID_C_HS_CHIRP, 125 USB_STAT_HM_IDGND, 126 USB_STAT_RESERVED, 127 USB_STAT_NOT_VALID_LINK, 128 USB_STAT_PHY_EN, 129 USB_STAT_SUP_NO_IDGND_VBUS, 130 USB_STAT_SUP_IDGND_VBUS, 131 USB_STAT_CHARGER_LINE_1, 132 USB_STAT_CARKIT_1, 133 USB_STAT_CARKIT_2, 134 USB_STAT_ACA_DOCK_CHARGER, 135 }; 136 137 enum ab8500_usb_state { 138 AB8500_BM_USB_STATE_RESET_HS, /* HighSpeed Reset */ 139 AB8500_BM_USB_STATE_RESET_FS, /* FullSpeed/LowSpeed Reset */ 140 AB8500_BM_USB_STATE_CONFIGURED, 141 AB8500_BM_USB_STATE_SUSPEND, 142 AB8500_BM_USB_STATE_RESUME, 143 AB8500_BM_USB_STATE_MAX, 144 }; 145 146 /* VBUS input current limits supported in AB8500 in mA */ 147 #define USB_CH_IP_CUR_LVL_0P05 50 148 #define USB_CH_IP_CUR_LVL_0P09 98 149 #define USB_CH_IP_CUR_LVL_0P19 193 150 #define USB_CH_IP_CUR_LVL_0P29 290 151 #define USB_CH_IP_CUR_LVL_0P38 380 152 #define USB_CH_IP_CUR_LVL_0P45 450 153 #define USB_CH_IP_CUR_LVL_0P5 500 154 #define USB_CH_IP_CUR_LVL_0P6 600 155 #define USB_CH_IP_CUR_LVL_0P7 700 156 #define USB_CH_IP_CUR_LVL_0P8 800 157 #define USB_CH_IP_CUR_LVL_0P9 900 158 #define USB_CH_IP_CUR_LVL_1P0 1000 159 #define USB_CH_IP_CUR_LVL_1P1 1100 160 #define USB_CH_IP_CUR_LVL_1P3 1300 161 #define USB_CH_IP_CUR_LVL_1P4 1400 162 #define USB_CH_IP_CUR_LVL_1P5 1500 163 164 #define VBAT_TRESH_IP_CUR_RED 3800 165 166 #define to_ab8500_charger_usb_device_info(x) container_of((x), \ 167 struct ab8500_charger, usb_chg) 168 #define to_ab8500_charger_ac_device_info(x) container_of((x), \ 169 struct ab8500_charger, ac_chg) 170 171 /** 172 * struct ab8500_charger_interrupts - ab8500 interupts 173 * @name: name of the interrupt 174 * @isr function pointer to the isr 175 */ 176 struct ab8500_charger_interrupts { 177 char *name; 178 irqreturn_t (*isr)(int irq, void *data); 179 }; 180 181 struct ab8500_charger_info { 182 int charger_connected; 183 int charger_online; 184 int charger_voltage; 185 int cv_active; 186 bool wd_expired; 187 int charger_current; 188 }; 189 190 struct ab8500_charger_event_flags { 191 bool mainextchnotok; 192 bool main_thermal_prot; 193 bool usb_thermal_prot; 194 bool vbus_ovv; 195 bool usbchargernotok; 196 bool chgwdexp; 197 bool vbus_collapse; 198 bool vbus_drop_end; 199 }; 200 201 struct ab8500_charger_usb_state { 202 int usb_current; 203 int usb_current_tmp; 204 enum ab8500_usb_state state; 205 enum ab8500_usb_state state_tmp; 206 spinlock_t usb_lock; 207 }; 208 209 struct ab8500_charger_max_usb_in_curr { 210 int usb_type_max; 211 int set_max; 212 int calculated_max; 213 }; 214 215 /** 216 * struct ab8500_charger - ab8500 Charger device information 217 * @dev: Pointer to the structure device 218 * @vbus_detected: VBUS detected 219 * @vbus_detected_start: 220 * VBUS detected during startup 221 * @ac_conn: This will be true when the AC charger has been plugged 222 * @vddadc_en_ac: Indicate if VDD ADC supply is enabled because AC 223 * charger is enabled 224 * @vddadc_en_usb: Indicate if VDD ADC supply is enabled because USB 225 * charger is enabled 226 * @vbat Battery voltage 227 * @old_vbat Previously measured battery voltage 228 * @usb_device_is_unrecognised USB device is unrecognised by the hardware 229 * @autopower Indicate if we should have automatic pwron after pwrloss 230 * @autopower_cfg platform specific power config support for "pwron after pwrloss" 231 * @invalid_charger_detect_state State when forcing AB to use invalid charger 232 * @is_aca_rid: Incicate if accessory is ACA type 233 * @current_stepping_sessions: 234 * Counter for current stepping sessions 235 * @parent: Pointer to the struct ab8500 236 * @gpadc: Pointer to the struct gpadc 237 * @bm: Platform specific battery management information 238 * @flags: Structure for information about events triggered 239 * @usb_state: Structure for usb stack information 240 * @max_usb_in_curr: Max USB charger input current 241 * @ac_chg: AC charger power supply 242 * @usb_chg: USB charger power supply 243 * @ac: Structure that holds the AC charger properties 244 * @usb: Structure that holds the USB charger properties 245 * @regu: Pointer to the struct regulator 246 * @charger_wq: Work queue for the IRQs and checking HW state 247 * @usb_ipt_crnt_lock: Lock to protect VBUS input current setting from mutuals 248 * @pm_lock: Lock to prevent system to suspend 249 * @check_vbat_work Work for checking vbat threshold to adjust vbus current 250 * @check_hw_failure_work: Work for checking HW state 251 * @check_usbchgnotok_work: Work for checking USB charger not ok status 252 * @kick_wd_work: Work for kicking the charger watchdog in case 253 * of ABB rev 1.* due to the watchog logic bug 254 * @ac_charger_attached_work: Work for checking if AC charger is still 255 * connected 256 * @usb_charger_attached_work: Work for checking if USB charger is still 257 * connected 258 * @ac_work: Work for checking AC charger connection 259 * @detect_usb_type_work: Work for detecting the USB type connected 260 * @usb_link_status_work: Work for checking the new USB link status 261 * @usb_state_changed_work: Work for checking USB state 262 * @attach_work: Work for detecting USB type 263 * @vbus_drop_end_work: Work for detecting VBUS drop end 264 * @check_main_thermal_prot_work: 265 * Work for checking Main thermal status 266 * @check_usb_thermal_prot_work: 267 * Work for checking USB thermal status 268 * @charger_attached_mutex: For controlling the wakelock 269 */ 270 struct ab8500_charger { 271 struct device *dev; 272 bool vbus_detected; 273 bool vbus_detected_start; 274 bool ac_conn; 275 bool vddadc_en_ac; 276 bool vddadc_en_usb; 277 int vbat; 278 int old_vbat; 279 bool usb_device_is_unrecognised; 280 bool autopower; 281 bool autopower_cfg; 282 int invalid_charger_detect_state; 283 int is_aca_rid; 284 atomic_t current_stepping_sessions; 285 struct ab8500 *parent; 286 struct ab8500_gpadc *gpadc; 287 struct abx500_bm_data *bm; 288 struct ab8500_charger_event_flags flags; 289 struct ab8500_charger_usb_state usb_state; 290 struct ab8500_charger_max_usb_in_curr max_usb_in_curr; 291 struct ux500_charger ac_chg; 292 struct ux500_charger usb_chg; 293 struct ab8500_charger_info ac; 294 struct ab8500_charger_info usb; 295 struct regulator *regu; 296 struct workqueue_struct *charger_wq; 297 struct mutex usb_ipt_crnt_lock; 298 struct delayed_work check_vbat_work; 299 struct delayed_work check_hw_failure_work; 300 struct delayed_work check_usbchgnotok_work; 301 struct delayed_work kick_wd_work; 302 struct delayed_work usb_state_changed_work; 303 struct delayed_work attach_work; 304 struct delayed_work ac_charger_attached_work; 305 struct delayed_work usb_charger_attached_work; 306 struct delayed_work vbus_drop_end_work; 307 struct work_struct ac_work; 308 struct work_struct detect_usb_type_work; 309 struct work_struct usb_link_status_work; 310 struct work_struct check_main_thermal_prot_work; 311 struct work_struct check_usb_thermal_prot_work; 312 struct usb_phy *usb_phy; 313 struct notifier_block nb; 314 struct mutex charger_attached_mutex; 315 }; 316 317 /* AC properties */ 318 static enum power_supply_property ab8500_charger_ac_props[] = { 319 POWER_SUPPLY_PROP_HEALTH, 320 POWER_SUPPLY_PROP_PRESENT, 321 POWER_SUPPLY_PROP_ONLINE, 322 POWER_SUPPLY_PROP_VOLTAGE_NOW, 323 POWER_SUPPLY_PROP_VOLTAGE_AVG, 324 POWER_SUPPLY_PROP_CURRENT_NOW, 325 }; 326 327 /* USB properties */ 328 static enum power_supply_property ab8500_charger_usb_props[] = { 329 POWER_SUPPLY_PROP_HEALTH, 330 POWER_SUPPLY_PROP_CURRENT_AVG, 331 POWER_SUPPLY_PROP_PRESENT, 332 POWER_SUPPLY_PROP_ONLINE, 333 POWER_SUPPLY_PROP_VOLTAGE_NOW, 334 POWER_SUPPLY_PROP_VOLTAGE_AVG, 335 POWER_SUPPLY_PROP_CURRENT_NOW, 336 }; 337 338 /* 339 * Function for enabling and disabling sw fallback mode 340 * should always be disabled when no charger is connected. 341 */ 342 static void ab8500_enable_disable_sw_fallback(struct ab8500_charger *di, 343 bool fallback) 344 { 345 u8 val; 346 u8 reg; 347 u8 bank; 348 u8 bit; 349 int ret; 350 351 dev_dbg(di->dev, "SW Fallback: %d\n", fallback); 352 353 if (is_ab8500(di->parent)) { 354 bank = 0x15; 355 reg = 0x0; 356 bit = 3; 357 } else { 358 bank = AB8500_SYS_CTRL1_BLOCK; 359 reg = AB8500_SW_CONTROL_FALLBACK; 360 bit = 0; 361 } 362 363 /* read the register containing fallback bit */ 364 ret = abx500_get_register_interruptible(di->dev, bank, reg, &val); 365 if (ret < 0) { 366 dev_err(di->dev, "%d read failed\n", __LINE__); 367 return; 368 } 369 370 if (is_ab8500(di->parent)) { 371 /* enable the OPT emulation registers */ 372 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2); 373 if (ret) { 374 dev_err(di->dev, "%d write failed\n", __LINE__); 375 goto disable_otp; 376 } 377 } 378 379 if (fallback) 380 val |= (1 << bit); 381 else 382 val &= ~(1 << bit); 383 384 /* write back the changed fallback bit value to register */ 385 ret = abx500_set_register_interruptible(di->dev, bank, reg, val); 386 if (ret) { 387 dev_err(di->dev, "%d write failed\n", __LINE__); 388 } 389 390 disable_otp: 391 if (is_ab8500(di->parent)) { 392 /* disable the set OTP registers again */ 393 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0); 394 if (ret) { 395 dev_err(di->dev, "%d write failed\n", __LINE__); 396 } 397 } 398 } 399 400 /** 401 * ab8500_power_supply_changed - a wrapper with local extentions for 402 * power_supply_changed 403 * @di: pointer to the ab8500_charger structure 404 * @psy: pointer to power_supply_that have changed. 405 * 406 */ 407 static void ab8500_power_supply_changed(struct ab8500_charger *di, 408 struct power_supply *psy) 409 { 410 if (di->autopower_cfg) { 411 if (!di->usb.charger_connected && 412 !di->ac.charger_connected && 413 di->autopower) { 414 di->autopower = false; 415 ab8500_enable_disable_sw_fallback(di, false); 416 } else if (!di->autopower && 417 (di->ac.charger_connected || 418 di->usb.charger_connected)) { 419 di->autopower = true; 420 ab8500_enable_disable_sw_fallback(di, true); 421 } 422 } 423 power_supply_changed(psy); 424 } 425 426 static void ab8500_charger_set_usb_connected(struct ab8500_charger *di, 427 bool connected) 428 { 429 if (connected != di->usb.charger_connected) { 430 dev_dbg(di->dev, "USB connected:%i\n", connected); 431 di->usb.charger_connected = connected; 432 433 if (!connected) 434 di->flags.vbus_drop_end = false; 435 436 sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL, "present"); 437 438 if (connected) { 439 mutex_lock(&di->charger_attached_mutex); 440 mutex_unlock(&di->charger_attached_mutex); 441 442 if (is_ab8500(di->parent)) 443 queue_delayed_work(di->charger_wq, 444 &di->usb_charger_attached_work, 445 HZ); 446 } else { 447 cancel_delayed_work_sync(&di->usb_charger_attached_work); 448 mutex_lock(&di->charger_attached_mutex); 449 mutex_unlock(&di->charger_attached_mutex); 450 } 451 } 452 } 453 454 /** 455 * ab8500_charger_get_ac_voltage() - get ac charger voltage 456 * @di: pointer to the ab8500_charger structure 457 * 458 * Returns ac charger voltage (on success) 459 */ 460 static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di) 461 { 462 int vch; 463 464 /* Only measure voltage if the charger is connected */ 465 if (di->ac.charger_connected) { 466 vch = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_V); 467 if (vch < 0) 468 dev_err(di->dev, "%s gpadc conv failed,\n", __func__); 469 } else { 470 vch = 0; 471 } 472 return vch; 473 } 474 475 /** 476 * ab8500_charger_ac_cv() - check if the main charger is in CV mode 477 * @di: pointer to the ab8500_charger structure 478 * 479 * Returns ac charger CV mode (on success) else error code 480 */ 481 static int ab8500_charger_ac_cv(struct ab8500_charger *di) 482 { 483 u8 val; 484 int ret = 0; 485 486 /* Only check CV mode if the charger is online */ 487 if (di->ac.charger_online) { 488 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 489 AB8500_CH_STATUS1_REG, &val); 490 if (ret < 0) { 491 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 492 return 0; 493 } 494 495 if (val & MAIN_CH_CV_ON) 496 ret = 1; 497 else 498 ret = 0; 499 } 500 501 return ret; 502 } 503 504 /** 505 * ab8500_charger_get_vbus_voltage() - get vbus voltage 506 * @di: pointer to the ab8500_charger structure 507 * 508 * This function returns the vbus voltage. 509 * Returns vbus voltage (on success) 510 */ 511 static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di) 512 { 513 int vch; 514 515 /* Only measure voltage if the charger is connected */ 516 if (di->usb.charger_connected) { 517 vch = ab8500_gpadc_convert(di->gpadc, VBUS_V); 518 if (vch < 0) 519 dev_err(di->dev, "%s gpadc conv failed\n", __func__); 520 } else { 521 vch = 0; 522 } 523 return vch; 524 } 525 526 /** 527 * ab8500_charger_get_usb_current() - get usb charger current 528 * @di: pointer to the ab8500_charger structure 529 * 530 * This function returns the usb charger current. 531 * Returns usb current (on success) and error code on failure 532 */ 533 static int ab8500_charger_get_usb_current(struct ab8500_charger *di) 534 { 535 int ich; 536 537 /* Only measure current if the charger is online */ 538 if (di->usb.charger_online) { 539 ich = ab8500_gpadc_convert(di->gpadc, USB_CHARGER_C); 540 if (ich < 0) 541 dev_err(di->dev, "%s gpadc conv failed\n", __func__); 542 } else { 543 ich = 0; 544 } 545 return ich; 546 } 547 548 /** 549 * ab8500_charger_get_ac_current() - get ac charger current 550 * @di: pointer to the ab8500_charger structure 551 * 552 * This function returns the ac charger current. 553 * Returns ac current (on success) and error code on failure. 554 */ 555 static int ab8500_charger_get_ac_current(struct ab8500_charger *di) 556 { 557 int ich; 558 559 /* Only measure current if the charger is online */ 560 if (di->ac.charger_online) { 561 ich = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_C); 562 if (ich < 0) 563 dev_err(di->dev, "%s gpadc conv failed\n", __func__); 564 } else { 565 ich = 0; 566 } 567 return ich; 568 } 569 570 /** 571 * ab8500_charger_usb_cv() - check if the usb charger is in CV mode 572 * @di: pointer to the ab8500_charger structure 573 * 574 * Returns ac charger CV mode (on success) else error code 575 */ 576 static int ab8500_charger_usb_cv(struct ab8500_charger *di) 577 { 578 int ret; 579 u8 val; 580 581 /* Only check CV mode if the charger is online */ 582 if (di->usb.charger_online) { 583 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 584 AB8500_CH_USBCH_STAT1_REG, &val); 585 if (ret < 0) { 586 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 587 return 0; 588 } 589 590 if (val & USB_CH_CV_ON) 591 ret = 1; 592 else 593 ret = 0; 594 } else { 595 ret = 0; 596 } 597 598 return ret; 599 } 600 601 /** 602 * ab8500_charger_detect_chargers() - Detect the connected chargers 603 * @di: pointer to the ab8500_charger structure 604 * @probe: if probe, don't delay and wait for HW 605 * 606 * Returns the type of charger connected. 607 * For USB it will not mean we can actually charge from it 608 * but that there is a USB cable connected that we have to 609 * identify. This is used during startup when we don't get 610 * interrupts of the charger detection 611 * 612 * Returns an integer value, that means, 613 * NO_PW_CONN no power supply is connected 614 * AC_PW_CONN if the AC power supply is connected 615 * USB_PW_CONN if the USB power supply is connected 616 * AC_PW_CONN + USB_PW_CONN if USB and AC power supplies are both connected 617 */ 618 static int ab8500_charger_detect_chargers(struct ab8500_charger *di, bool probe) 619 { 620 int result = NO_PW_CONN; 621 int ret; 622 u8 val; 623 624 /* Check for AC charger */ 625 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 626 AB8500_CH_STATUS1_REG, &val); 627 if (ret < 0) { 628 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 629 return ret; 630 } 631 632 if (val & MAIN_CH_DET) 633 result = AC_PW_CONN; 634 635 /* Check for USB charger */ 636 637 if (!probe) { 638 /* 639 * AB8500 says VBUS_DET_DBNC1 & VBUS_DET_DBNC100 640 * when disconnecting ACA even though no 641 * charger was connected. Try waiting a little 642 * longer than the 100 ms of VBUS_DET_DBNC100... 643 */ 644 msleep(110); 645 } 646 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 647 AB8500_CH_USBCH_STAT1_REG, &val); 648 if (ret < 0) { 649 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 650 return ret; 651 } 652 dev_dbg(di->dev, 653 "%s AB8500_CH_USBCH_STAT1_REG %x\n", __func__, 654 val); 655 if ((val & VBUS_DET_DBNC1) && (val & VBUS_DET_DBNC100)) 656 result |= USB_PW_CONN; 657 658 return result; 659 } 660 661 /** 662 * ab8500_charger_max_usb_curr() - get the max curr for the USB type 663 * @di: pointer to the ab8500_charger structure 664 * @link_status: the identified USB type 665 * 666 * Get the maximum current that is allowed to be drawn from the host 667 * based on the USB type. 668 * Returns error code in case of failure else 0 on success 669 */ 670 static int ab8500_charger_max_usb_curr(struct ab8500_charger *di, 671 enum ab8500_charger_link_status link_status) 672 { 673 int ret = 0; 674 675 di->usb_device_is_unrecognised = false; 676 677 /* 678 * Platform only supports USB 2.0. 679 * This means that charging current from USB source 680 * is maximum 500 mA. Every occurence of USB_STAT_*_HOST_* 681 * should set USB_CH_IP_CUR_LVL_0P5. 682 */ 683 684 switch (link_status) { 685 case USB_STAT_STD_HOST_NC: 686 case USB_STAT_STD_HOST_C_NS: 687 case USB_STAT_STD_HOST_C_S: 688 dev_dbg(di->dev, "USB Type - Standard host is " 689 "detected through USB driver\n"); 690 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 691 di->is_aca_rid = 0; 692 break; 693 case USB_STAT_HOST_CHG_HS_CHIRP: 694 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 695 di->is_aca_rid = 0; 696 break; 697 case USB_STAT_HOST_CHG_HS: 698 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 699 di->is_aca_rid = 0; 700 break; 701 case USB_STAT_ACA_RID_C_HS: 702 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P9; 703 di->is_aca_rid = 0; 704 break; 705 case USB_STAT_ACA_RID_A: 706 /* 707 * Dedicated charger level minus maximum current accessory 708 * can consume (900mA). Closest level is 500mA 709 */ 710 dev_dbg(di->dev, "USB_STAT_ACA_RID_A detected\n"); 711 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 712 di->is_aca_rid = 1; 713 break; 714 case USB_STAT_ACA_RID_B: 715 /* 716 * Dedicated charger level minus 120mA (20mA for ACA and 717 * 100mA for potential accessory). Closest level is 1300mA 718 */ 719 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P3; 720 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status, 721 di->max_usb_in_curr.usb_type_max); 722 di->is_aca_rid = 1; 723 break; 724 case USB_STAT_HOST_CHG_NM: 725 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 726 di->is_aca_rid = 0; 727 break; 728 case USB_STAT_DEDICATED_CHG: 729 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P5; 730 di->is_aca_rid = 0; 731 break; 732 case USB_STAT_ACA_RID_C_HS_CHIRP: 733 case USB_STAT_ACA_RID_C_NM: 734 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P5; 735 di->is_aca_rid = 1; 736 break; 737 case USB_STAT_NOT_CONFIGURED: 738 if (di->vbus_detected) { 739 di->usb_device_is_unrecognised = true; 740 dev_dbg(di->dev, "USB Type - Legacy charger.\n"); 741 di->max_usb_in_curr.usb_type_max = 742 USB_CH_IP_CUR_LVL_1P5; 743 break; 744 } 745 case USB_STAT_HM_IDGND: 746 dev_err(di->dev, "USB Type - Charging not allowed\n"); 747 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05; 748 ret = -ENXIO; 749 break; 750 case USB_STAT_RESERVED: 751 if (is_ab8500(di->parent)) { 752 di->flags.vbus_collapse = true; 753 dev_err(di->dev, "USB Type - USB_STAT_RESERVED " 754 "VBUS has collapsed\n"); 755 ret = -ENXIO; 756 break; 757 } else { 758 dev_dbg(di->dev, "USB Type - Charging not allowed\n"); 759 di->max_usb_in_curr.usb_type_max = 760 USB_CH_IP_CUR_LVL_0P05; 761 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", 762 link_status, 763 di->max_usb_in_curr.usb_type_max); 764 ret = -ENXIO; 765 break; 766 } 767 case USB_STAT_CARKIT_1: 768 case USB_STAT_CARKIT_2: 769 case USB_STAT_ACA_DOCK_CHARGER: 770 case USB_STAT_CHARGER_LINE_1: 771 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 772 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status, 773 di->max_usb_in_curr.usb_type_max); 774 break; 775 case USB_STAT_NOT_VALID_LINK: 776 dev_err(di->dev, "USB Type invalid - try charging anyway\n"); 777 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 778 break; 779 780 default: 781 dev_err(di->dev, "USB Type - Unknown\n"); 782 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05; 783 ret = -ENXIO; 784 break; 785 }; 786 787 di->max_usb_in_curr.set_max = di->max_usb_in_curr.usb_type_max; 788 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", 789 link_status, di->max_usb_in_curr.set_max); 790 791 return ret; 792 } 793 794 /** 795 * ab8500_charger_read_usb_type() - read the type of usb connected 796 * @di: pointer to the ab8500_charger structure 797 * 798 * Detect the type of the plugged USB 799 * Returns error code in case of failure else 0 on success 800 */ 801 static int ab8500_charger_read_usb_type(struct ab8500_charger *di) 802 { 803 int ret; 804 u8 val; 805 806 ret = abx500_get_register_interruptible(di->dev, 807 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, &val); 808 if (ret < 0) { 809 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 810 return ret; 811 } 812 if (is_ab8500(di->parent)) 813 ret = abx500_get_register_interruptible(di->dev, AB8500_USB, 814 AB8500_USB_LINE_STAT_REG, &val); 815 else 816 ret = abx500_get_register_interruptible(di->dev, 817 AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val); 818 if (ret < 0) { 819 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 820 return ret; 821 } 822 823 /* get the USB type */ 824 if (is_ab8500(di->parent)) 825 val = (val & AB8500_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT; 826 else 827 val = (val & AB8505_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT; 828 ret = ab8500_charger_max_usb_curr(di, 829 (enum ab8500_charger_link_status) val); 830 831 return ret; 832 } 833 834 /** 835 * ab8500_charger_detect_usb_type() - get the type of usb connected 836 * @di: pointer to the ab8500_charger structure 837 * 838 * Detect the type of the plugged USB 839 * Returns error code in case of failure else 0 on success 840 */ 841 static int ab8500_charger_detect_usb_type(struct ab8500_charger *di) 842 { 843 int i, ret; 844 u8 val; 845 846 /* 847 * On getting the VBUS rising edge detect interrupt there 848 * is a 250ms delay after which the register UsbLineStatus 849 * is filled with valid data. 850 */ 851 for (i = 0; i < 10; i++) { 852 msleep(250); 853 ret = abx500_get_register_interruptible(di->dev, 854 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, 855 &val); 856 dev_dbg(di->dev, "%s AB8500_IT_SOURCE21_REG %x\n", 857 __func__, val); 858 if (ret < 0) { 859 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 860 return ret; 861 } 862 863 if (is_ab8500(di->parent)) 864 ret = abx500_get_register_interruptible(di->dev, 865 AB8500_USB, AB8500_USB_LINE_STAT_REG, &val); 866 else 867 ret = abx500_get_register_interruptible(di->dev, 868 AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val); 869 if (ret < 0) { 870 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 871 return ret; 872 } 873 dev_dbg(di->dev, "%s AB8500_USB_LINE_STAT_REG %x\n", __func__, 874 val); 875 /* 876 * Until the IT source register is read the UsbLineStatus 877 * register is not updated, hence doing the same 878 * Revisit this: 879 */ 880 881 /* get the USB type */ 882 if (is_ab8500(di->parent)) 883 val = (val & AB8500_USB_LINK_STATUS) >> 884 USB_LINK_STATUS_SHIFT; 885 else 886 val = (val & AB8505_USB_LINK_STATUS) >> 887 USB_LINK_STATUS_SHIFT; 888 if (val) 889 break; 890 } 891 ret = ab8500_charger_max_usb_curr(di, 892 (enum ab8500_charger_link_status) val); 893 894 return ret; 895 } 896 897 /* 898 * This array maps the raw hex value to charger voltage used by the AB8500 899 * Values taken from the UM0836 900 */ 901 static int ab8500_charger_voltage_map[] = { 902 3500 , 903 3525 , 904 3550 , 905 3575 , 906 3600 , 907 3625 , 908 3650 , 909 3675 , 910 3700 , 911 3725 , 912 3750 , 913 3775 , 914 3800 , 915 3825 , 916 3850 , 917 3875 , 918 3900 , 919 3925 , 920 3950 , 921 3975 , 922 4000 , 923 4025 , 924 4050 , 925 4060 , 926 4070 , 927 4080 , 928 4090 , 929 4100 , 930 4110 , 931 4120 , 932 4130 , 933 4140 , 934 4150 , 935 4160 , 936 4170 , 937 4180 , 938 4190 , 939 4200 , 940 4210 , 941 4220 , 942 4230 , 943 4240 , 944 4250 , 945 4260 , 946 4270 , 947 4280 , 948 4290 , 949 4300 , 950 4310 , 951 4320 , 952 4330 , 953 4340 , 954 4350 , 955 4360 , 956 4370 , 957 4380 , 958 4390 , 959 4400 , 960 4410 , 961 4420 , 962 4430 , 963 4440 , 964 4450 , 965 4460 , 966 4470 , 967 4480 , 968 4490 , 969 4500 , 970 4510 , 971 4520 , 972 4530 , 973 4540 , 974 4550 , 975 4560 , 976 4570 , 977 4580 , 978 4590 , 979 4600 , 980 }; 981 982 static int ab8500_voltage_to_regval(int voltage) 983 { 984 int i; 985 986 /* Special case for voltage below 3.5V */ 987 if (voltage < ab8500_charger_voltage_map[0]) 988 return LOW_VOLT_REG; 989 990 for (i = 1; i < ARRAY_SIZE(ab8500_charger_voltage_map); i++) { 991 if (voltage < ab8500_charger_voltage_map[i]) 992 return i - 1; 993 } 994 995 /* If not last element, return error */ 996 i = ARRAY_SIZE(ab8500_charger_voltage_map) - 1; 997 if (voltage == ab8500_charger_voltage_map[i]) 998 return i; 999 else 1000 return -1; 1001 } 1002 1003 static int ab8500_current_to_regval(struct ab8500_charger *di, int curr) 1004 { 1005 int i; 1006 1007 if (curr < di->bm->chg_output_curr[0]) 1008 return 0; 1009 1010 for (i = 0; i < di->bm->n_chg_out_curr; i++) { 1011 if (curr < di->bm->chg_output_curr[i]) 1012 return i - 1; 1013 } 1014 1015 /* If not last element, return error */ 1016 i = di->bm->n_chg_out_curr - 1; 1017 if (curr == di->bm->chg_output_curr[i]) 1018 return i; 1019 else 1020 return -1; 1021 } 1022 1023 static int ab8500_vbus_in_curr_to_regval(struct ab8500_charger *di, int curr) 1024 { 1025 int i; 1026 1027 if (curr < di->bm->chg_input_curr[0]) 1028 return 0; 1029 1030 for (i = 0; i < di->bm->n_chg_in_curr; i++) { 1031 if (curr < di->bm->chg_input_curr[i]) 1032 return i - 1; 1033 } 1034 1035 /* If not last element, return error */ 1036 i = di->bm->n_chg_in_curr - 1; 1037 if (curr == di->bm->chg_input_curr[i]) 1038 return i; 1039 else 1040 return -1; 1041 } 1042 1043 /** 1044 * ab8500_charger_get_usb_cur() - get usb current 1045 * @di: pointer to the ab8500_charger structre 1046 * 1047 * The usb stack provides the maximum current that can be drawn from 1048 * the standard usb host. This will be in mA. 1049 * This function converts current in mA to a value that can be written 1050 * to the register. Returns -1 if charging is not allowed 1051 */ 1052 static int ab8500_charger_get_usb_cur(struct ab8500_charger *di) 1053 { 1054 int ret = 0; 1055 switch (di->usb_state.usb_current) { 1056 case 100: 1057 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P09; 1058 break; 1059 case 200: 1060 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P19; 1061 break; 1062 case 300: 1063 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P29; 1064 break; 1065 case 400: 1066 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P38; 1067 break; 1068 case 500: 1069 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5; 1070 break; 1071 default: 1072 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05; 1073 ret = -EPERM; 1074 break; 1075 }; 1076 di->max_usb_in_curr.set_max = di->max_usb_in_curr.usb_type_max; 1077 return ret; 1078 } 1079 1080 /** 1081 * ab8500_charger_check_continue_stepping() - Check to allow stepping 1082 * @di: pointer to the ab8500_charger structure 1083 * @reg: select what charger register to check 1084 * 1085 * Check if current stepping should be allowed to continue. 1086 * Checks if charger source has not collapsed. If it has, further stepping 1087 * is not allowed. 1088 */ 1089 static bool ab8500_charger_check_continue_stepping(struct ab8500_charger *di, 1090 int reg) 1091 { 1092 if (reg == AB8500_USBCH_IPT_CRNTLVL_REG) 1093 return !di->flags.vbus_drop_end; 1094 else 1095 return true; 1096 } 1097 1098 /** 1099 * ab8500_charger_set_current() - set charger current 1100 * @di: pointer to the ab8500_charger structure 1101 * @ich: charger current, in mA 1102 * @reg: select what charger register to set 1103 * 1104 * Set charger current. 1105 * There is no state machine in the AB to step up/down the charger 1106 * current to avoid dips and spikes on MAIN, VBUS and VBAT when 1107 * charging is started. Instead we need to implement 1108 * this charger current step-up/down here. 1109 * Returns error code in case of failure else 0(on success) 1110 */ 1111 static int ab8500_charger_set_current(struct ab8500_charger *di, 1112 int ich, int reg) 1113 { 1114 int ret = 0; 1115 int curr_index, prev_curr_index, shift_value, i; 1116 u8 reg_value; 1117 u32 step_udelay; 1118 bool no_stepping = false; 1119 1120 atomic_inc(&di->current_stepping_sessions); 1121 1122 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 1123 reg, ®_value); 1124 if (ret < 0) { 1125 dev_err(di->dev, "%s read failed\n", __func__); 1126 goto exit_set_current; 1127 } 1128 1129 switch (reg) { 1130 case AB8500_MCH_IPT_CURLVL_REG: 1131 shift_value = MAIN_CH_INPUT_CURR_SHIFT; 1132 prev_curr_index = (reg_value >> shift_value); 1133 curr_index = ab8500_current_to_regval(di, ich); 1134 step_udelay = STEP_UDELAY; 1135 if (!di->ac.charger_connected) 1136 no_stepping = true; 1137 break; 1138 case AB8500_USBCH_IPT_CRNTLVL_REG: 1139 shift_value = VBUS_IN_CURR_LIM_SHIFT; 1140 prev_curr_index = (reg_value >> shift_value); 1141 curr_index = ab8500_vbus_in_curr_to_regval(di, ich); 1142 step_udelay = STEP_UDELAY * 100; 1143 1144 if (!di->usb.charger_connected) 1145 no_stepping = true; 1146 break; 1147 case AB8500_CH_OPT_CRNTLVL_REG: 1148 shift_value = 0; 1149 prev_curr_index = (reg_value >> shift_value); 1150 curr_index = ab8500_current_to_regval(di, ich); 1151 step_udelay = STEP_UDELAY; 1152 if (curr_index && (curr_index - prev_curr_index) > 1) 1153 step_udelay *= 100; 1154 1155 if (!di->usb.charger_connected && !di->ac.charger_connected) 1156 no_stepping = true; 1157 1158 break; 1159 default: 1160 dev_err(di->dev, "%s current register not valid\n", __func__); 1161 ret = -ENXIO; 1162 goto exit_set_current; 1163 } 1164 1165 if (curr_index < 0) { 1166 dev_err(di->dev, "requested current limit out-of-range\n"); 1167 ret = -ENXIO; 1168 goto exit_set_current; 1169 } 1170 1171 /* only update current if it's been changed */ 1172 if (prev_curr_index == curr_index) { 1173 dev_dbg(di->dev, "%s current not changed for reg: 0x%02x\n", 1174 __func__, reg); 1175 ret = 0; 1176 goto exit_set_current; 1177 } 1178 1179 dev_dbg(di->dev, "%s set charger current: %d mA for reg: 0x%02x\n", 1180 __func__, ich, reg); 1181 1182 if (no_stepping) { 1183 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1184 reg, (u8)curr_index << shift_value); 1185 if (ret) 1186 dev_err(di->dev, "%s write failed\n", __func__); 1187 } else if (prev_curr_index > curr_index) { 1188 for (i = prev_curr_index - 1; i >= curr_index; i--) { 1189 dev_dbg(di->dev, "curr change_1 to: %x for 0x%02x\n", 1190 (u8) i << shift_value, reg); 1191 ret = abx500_set_register_interruptible(di->dev, 1192 AB8500_CHARGER, reg, (u8)i << shift_value); 1193 if (ret) { 1194 dev_err(di->dev, "%s write failed\n", __func__); 1195 goto exit_set_current; 1196 } 1197 if (i != curr_index) 1198 usleep_range(step_udelay, step_udelay * 2); 1199 } 1200 } else { 1201 bool allow = true; 1202 for (i = prev_curr_index + 1; i <= curr_index && allow; i++) { 1203 dev_dbg(di->dev, "curr change_2 to: %x for 0x%02x\n", 1204 (u8)i << shift_value, reg); 1205 ret = abx500_set_register_interruptible(di->dev, 1206 AB8500_CHARGER, reg, (u8)i << shift_value); 1207 if (ret) { 1208 dev_err(di->dev, "%s write failed\n", __func__); 1209 goto exit_set_current; 1210 } 1211 if (i != curr_index) 1212 usleep_range(step_udelay, step_udelay * 2); 1213 1214 allow = ab8500_charger_check_continue_stepping(di, reg); 1215 } 1216 } 1217 1218 exit_set_current: 1219 atomic_dec(&di->current_stepping_sessions); 1220 1221 return ret; 1222 } 1223 1224 /** 1225 * ab8500_charger_set_vbus_in_curr() - set VBUS input current limit 1226 * @di: pointer to the ab8500_charger structure 1227 * @ich_in: charger input current limit 1228 * 1229 * Sets the current that can be drawn from the USB host 1230 * Returns error code in case of failure else 0(on success) 1231 */ 1232 static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di, 1233 int ich_in) 1234 { 1235 int min_value; 1236 int ret; 1237 1238 /* We should always use to lowest current limit */ 1239 min_value = min(di->bm->chg_params->usb_curr_max, ich_in); 1240 if (di->max_usb_in_curr.set_max > 0) 1241 min_value = min(di->max_usb_in_curr.set_max, min_value); 1242 1243 if (di->usb_state.usb_current >= 0) 1244 min_value = min(di->usb_state.usb_current, min_value); 1245 1246 switch (min_value) { 1247 case 100: 1248 if (di->vbat < VBAT_TRESH_IP_CUR_RED) 1249 min_value = USB_CH_IP_CUR_LVL_0P05; 1250 break; 1251 case 500: 1252 if (di->vbat < VBAT_TRESH_IP_CUR_RED) 1253 min_value = USB_CH_IP_CUR_LVL_0P45; 1254 break; 1255 default: 1256 break; 1257 } 1258 1259 dev_info(di->dev, "VBUS input current limit set to %d mA\n", min_value); 1260 1261 mutex_lock(&di->usb_ipt_crnt_lock); 1262 ret = ab8500_charger_set_current(di, min_value, 1263 AB8500_USBCH_IPT_CRNTLVL_REG); 1264 mutex_unlock(&di->usb_ipt_crnt_lock); 1265 1266 return ret; 1267 } 1268 1269 /** 1270 * ab8500_charger_set_main_in_curr() - set main charger input current 1271 * @di: pointer to the ab8500_charger structure 1272 * @ich_in: input charger current, in mA 1273 * 1274 * Set main charger input current. 1275 * Returns error code in case of failure else 0(on success) 1276 */ 1277 static int ab8500_charger_set_main_in_curr(struct ab8500_charger *di, 1278 int ich_in) 1279 { 1280 return ab8500_charger_set_current(di, ich_in, 1281 AB8500_MCH_IPT_CURLVL_REG); 1282 } 1283 1284 /** 1285 * ab8500_charger_set_output_curr() - set charger output current 1286 * @di: pointer to the ab8500_charger structure 1287 * @ich_out: output charger current, in mA 1288 * 1289 * Set charger output current. 1290 * Returns error code in case of failure else 0(on success) 1291 */ 1292 static int ab8500_charger_set_output_curr(struct ab8500_charger *di, 1293 int ich_out) 1294 { 1295 return ab8500_charger_set_current(di, ich_out, 1296 AB8500_CH_OPT_CRNTLVL_REG); 1297 } 1298 1299 /** 1300 * ab8500_charger_led_en() - turn on/off chargign led 1301 * @di: pointer to the ab8500_charger structure 1302 * @on: flag to turn on/off the chargign led 1303 * 1304 * Power ON/OFF charging LED indication 1305 * Returns error code in case of failure else 0(on success) 1306 */ 1307 static int ab8500_charger_led_en(struct ab8500_charger *di, int on) 1308 { 1309 int ret; 1310 1311 if (on) { 1312 /* Power ON charging LED indicator, set LED current to 5mA */ 1313 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1314 AB8500_LED_INDICATOR_PWM_CTRL, 1315 (LED_IND_CUR_5MA | LED_INDICATOR_PWM_ENA)); 1316 if (ret) { 1317 dev_err(di->dev, "Power ON LED failed\n"); 1318 return ret; 1319 } 1320 /* LED indicator PWM duty cycle 252/256 */ 1321 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1322 AB8500_LED_INDICATOR_PWM_DUTY, 1323 LED_INDICATOR_PWM_DUTY_252_256); 1324 if (ret) { 1325 dev_err(di->dev, "Set LED PWM duty cycle failed\n"); 1326 return ret; 1327 } 1328 } else { 1329 /* Power off charging LED indicator */ 1330 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1331 AB8500_LED_INDICATOR_PWM_CTRL, 1332 LED_INDICATOR_PWM_DIS); 1333 if (ret) { 1334 dev_err(di->dev, "Power-off LED failed\n"); 1335 return ret; 1336 } 1337 } 1338 1339 return ret; 1340 } 1341 1342 /** 1343 * ab8500_charger_ac_en() - enable or disable ac charging 1344 * @di: pointer to the ab8500_charger structure 1345 * @enable: enable/disable flag 1346 * @vset: charging voltage 1347 * @iset: charging current 1348 * 1349 * Enable/Disable AC/Mains charging and turns on/off the charging led 1350 * respectively. 1351 **/ 1352 static int ab8500_charger_ac_en(struct ux500_charger *charger, 1353 int enable, int vset, int iset) 1354 { 1355 int ret; 1356 int volt_index; 1357 int curr_index; 1358 int input_curr_index; 1359 u8 overshoot = 0; 1360 1361 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger); 1362 1363 if (enable) { 1364 /* Check if AC is connected */ 1365 if (!di->ac.charger_connected) { 1366 dev_err(di->dev, "AC charger not connected\n"); 1367 return -ENXIO; 1368 } 1369 1370 /* Enable AC charging */ 1371 dev_dbg(di->dev, "Enable AC: %dmV %dmA\n", vset, iset); 1372 1373 /* 1374 * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts 1375 * will be triggered everytime we enable the VDD ADC supply. 1376 * This will turn off charging for a short while. 1377 * It can be avoided by having the supply on when 1378 * there is a charger enabled. Normally the VDD ADC supply 1379 * is enabled everytime a GPADC conversion is triggered. We will 1380 * force it to be enabled from this driver to have 1381 * the GPADC module independant of the AB8500 chargers 1382 */ 1383 if (!di->vddadc_en_ac) { 1384 ret = regulator_enable(di->regu); 1385 if (ret) 1386 dev_warn(di->dev, 1387 "Failed to enable regulator\n"); 1388 else 1389 di->vddadc_en_ac = true; 1390 } 1391 1392 /* Check if the requested voltage or current is valid */ 1393 volt_index = ab8500_voltage_to_regval(vset); 1394 curr_index = ab8500_current_to_regval(di, iset); 1395 input_curr_index = ab8500_current_to_regval(di, 1396 di->bm->chg_params->ac_curr_max); 1397 if (volt_index < 0 || curr_index < 0 || input_curr_index < 0) { 1398 dev_err(di->dev, 1399 "Charger voltage or current too high, " 1400 "charging not started\n"); 1401 return -ENXIO; 1402 } 1403 1404 /* ChVoltLevel: maximum battery charging voltage */ 1405 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1406 AB8500_CH_VOLT_LVL_REG, (u8) volt_index); 1407 if (ret) { 1408 dev_err(di->dev, "%s write failed\n", __func__); 1409 return ret; 1410 } 1411 /* MainChInputCurr: current that can be drawn from the charger*/ 1412 ret = ab8500_charger_set_main_in_curr(di, 1413 di->bm->chg_params->ac_curr_max); 1414 if (ret) { 1415 dev_err(di->dev, "%s Failed to set MainChInputCurr\n", 1416 __func__); 1417 return ret; 1418 } 1419 /* ChOutputCurentLevel: protected output current */ 1420 ret = ab8500_charger_set_output_curr(di, iset); 1421 if (ret) { 1422 dev_err(di->dev, "%s " 1423 "Failed to set ChOutputCurentLevel\n", 1424 __func__); 1425 return ret; 1426 } 1427 1428 /* Check if VBAT overshoot control should be enabled */ 1429 if (!di->bm->enable_overshoot) 1430 overshoot = MAIN_CH_NO_OVERSHOOT_ENA_N; 1431 1432 /* Enable Main Charger */ 1433 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1434 AB8500_MCH_CTRL1, MAIN_CH_ENA | overshoot); 1435 if (ret) { 1436 dev_err(di->dev, "%s write failed\n", __func__); 1437 return ret; 1438 } 1439 1440 /* Power on charging LED indication */ 1441 ret = ab8500_charger_led_en(di, true); 1442 if (ret < 0) 1443 dev_err(di->dev, "failed to enable LED\n"); 1444 1445 di->ac.charger_online = 1; 1446 } else { 1447 /* Disable AC charging */ 1448 if (is_ab8500_1p1_or_earlier(di->parent)) { 1449 /* 1450 * For ABB revision 1.0 and 1.1 there is a bug in the 1451 * watchdog logic. That means we have to continously 1452 * kick the charger watchdog even when no charger is 1453 * connected. This is only valid once the AC charger 1454 * has been enabled. This is a bug that is not handled 1455 * by the algorithm and the watchdog have to be kicked 1456 * by the charger driver when the AC charger 1457 * is disabled 1458 */ 1459 if (di->ac_conn) { 1460 queue_delayed_work(di->charger_wq, 1461 &di->kick_wd_work, 1462 round_jiffies(WD_KICK_INTERVAL)); 1463 } 1464 1465 /* 1466 * We can't turn off charging completely 1467 * due to a bug in AB8500 cut1. 1468 * If we do, charging will not start again. 1469 * That is why we set the lowest voltage 1470 * and current possible 1471 */ 1472 ret = abx500_set_register_interruptible(di->dev, 1473 AB8500_CHARGER, 1474 AB8500_CH_VOLT_LVL_REG, CH_VOL_LVL_3P5); 1475 if (ret) { 1476 dev_err(di->dev, 1477 "%s write failed\n", __func__); 1478 return ret; 1479 } 1480 1481 ret = ab8500_charger_set_output_curr(di, 0); 1482 if (ret) { 1483 dev_err(di->dev, "%s " 1484 "Failed to set ChOutputCurentLevel\n", 1485 __func__); 1486 return ret; 1487 } 1488 } else { 1489 ret = abx500_set_register_interruptible(di->dev, 1490 AB8500_CHARGER, 1491 AB8500_MCH_CTRL1, 0); 1492 if (ret) { 1493 dev_err(di->dev, 1494 "%s write failed\n", __func__); 1495 return ret; 1496 } 1497 } 1498 1499 ret = ab8500_charger_led_en(di, false); 1500 if (ret < 0) 1501 dev_err(di->dev, "failed to disable LED\n"); 1502 1503 di->ac.charger_online = 0; 1504 di->ac.wd_expired = false; 1505 1506 /* Disable regulator if enabled */ 1507 if (di->vddadc_en_ac) { 1508 regulator_disable(di->regu); 1509 di->vddadc_en_ac = false; 1510 } 1511 1512 dev_dbg(di->dev, "%s Disabled AC charging\n", __func__); 1513 } 1514 ab8500_power_supply_changed(di, di->ac_chg.psy); 1515 1516 return ret; 1517 } 1518 1519 /** 1520 * ab8500_charger_usb_en() - enable usb charging 1521 * @di: pointer to the ab8500_charger structure 1522 * @enable: enable/disable flag 1523 * @vset: charging voltage 1524 * @ich_out: charger output current 1525 * 1526 * Enable/Disable USB charging and turns on/off the charging led respectively. 1527 * Returns error code in case of failure else 0(on success) 1528 */ 1529 static int ab8500_charger_usb_en(struct ux500_charger *charger, 1530 int enable, int vset, int ich_out) 1531 { 1532 int ret; 1533 int volt_index; 1534 int curr_index; 1535 u8 overshoot = 0; 1536 1537 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger); 1538 1539 if (enable) { 1540 /* Check if USB is connected */ 1541 if (!di->usb.charger_connected) { 1542 dev_err(di->dev, "USB charger not connected\n"); 1543 return -ENXIO; 1544 } 1545 1546 /* 1547 * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts 1548 * will be triggered everytime we enable the VDD ADC supply. 1549 * This will turn off charging for a short while. 1550 * It can be avoided by having the supply on when 1551 * there is a charger enabled. Normally the VDD ADC supply 1552 * is enabled everytime a GPADC conversion is triggered. We will 1553 * force it to be enabled from this driver to have 1554 * the GPADC module independant of the AB8500 chargers 1555 */ 1556 if (!di->vddadc_en_usb) { 1557 ret = regulator_enable(di->regu); 1558 if (ret) 1559 dev_warn(di->dev, 1560 "Failed to enable regulator\n"); 1561 else 1562 di->vddadc_en_usb = true; 1563 } 1564 1565 /* Enable USB charging */ 1566 dev_dbg(di->dev, "Enable USB: %dmV %dmA\n", vset, ich_out); 1567 1568 /* Check if the requested voltage or current is valid */ 1569 volt_index = ab8500_voltage_to_regval(vset); 1570 curr_index = ab8500_current_to_regval(di, ich_out); 1571 if (volt_index < 0 || curr_index < 0) { 1572 dev_err(di->dev, 1573 "Charger voltage or current too high, " 1574 "charging not started\n"); 1575 return -ENXIO; 1576 } 1577 1578 /* ChVoltLevel: max voltage upto which battery can be charged */ 1579 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1580 AB8500_CH_VOLT_LVL_REG, (u8) volt_index); 1581 if (ret) { 1582 dev_err(di->dev, "%s write failed\n", __func__); 1583 return ret; 1584 } 1585 /* Check if VBAT overshoot control should be enabled */ 1586 if (!di->bm->enable_overshoot) 1587 overshoot = USB_CHG_NO_OVERSHOOT_ENA_N; 1588 1589 /* Enable USB Charger */ 1590 dev_dbg(di->dev, 1591 "Enabling USB with write to AB8500_USBCH_CTRL1_REG\n"); 1592 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1593 AB8500_USBCH_CTRL1_REG, USB_CH_ENA | overshoot); 1594 if (ret) { 1595 dev_err(di->dev, "%s write failed\n", __func__); 1596 return ret; 1597 } 1598 1599 /* If success power on charging LED indication */ 1600 ret = ab8500_charger_led_en(di, true); 1601 if (ret < 0) 1602 dev_err(di->dev, "failed to enable LED\n"); 1603 1604 di->usb.charger_online = 1; 1605 1606 /* USBChInputCurr: current that can be drawn from the usb */ 1607 ret = ab8500_charger_set_vbus_in_curr(di, 1608 di->max_usb_in_curr.usb_type_max); 1609 if (ret) { 1610 dev_err(di->dev, "setting USBChInputCurr failed\n"); 1611 return ret; 1612 } 1613 1614 /* ChOutputCurentLevel: protected output current */ 1615 ret = ab8500_charger_set_output_curr(di, ich_out); 1616 if (ret) { 1617 dev_err(di->dev, "%s " 1618 "Failed to set ChOutputCurentLevel\n", 1619 __func__); 1620 return ret; 1621 } 1622 1623 queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ); 1624 1625 } else { 1626 /* Disable USB charging */ 1627 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__); 1628 ret = abx500_set_register_interruptible(di->dev, 1629 AB8500_CHARGER, 1630 AB8500_USBCH_CTRL1_REG, 0); 1631 if (ret) { 1632 dev_err(di->dev, 1633 "%s write failed\n", __func__); 1634 return ret; 1635 } 1636 1637 ret = ab8500_charger_led_en(di, false); 1638 if (ret < 0) 1639 dev_err(di->dev, "failed to disable LED\n"); 1640 /* USBChInputCurr: current that can be drawn from the usb */ 1641 ret = ab8500_charger_set_vbus_in_curr(di, 0); 1642 if (ret) { 1643 dev_err(di->dev, "setting USBChInputCurr failed\n"); 1644 return ret; 1645 } 1646 1647 /* ChOutputCurentLevel: protected output current */ 1648 ret = ab8500_charger_set_output_curr(di, 0); 1649 if (ret) { 1650 dev_err(di->dev, "%s " 1651 "Failed to reset ChOutputCurentLevel\n", 1652 __func__); 1653 return ret; 1654 } 1655 di->usb.charger_online = 0; 1656 di->usb.wd_expired = false; 1657 1658 /* Disable regulator if enabled */ 1659 if (di->vddadc_en_usb) { 1660 regulator_disable(di->regu); 1661 di->vddadc_en_usb = false; 1662 } 1663 1664 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__); 1665 1666 /* Cancel any pending Vbat check work */ 1667 cancel_delayed_work(&di->check_vbat_work); 1668 1669 } 1670 ab8500_power_supply_changed(di, di->usb_chg.psy); 1671 1672 return ret; 1673 } 1674 1675 static int ab8500_external_charger_prepare(struct notifier_block *charger_nb, 1676 unsigned long event, void *data) 1677 { 1678 int ret; 1679 struct device *dev = data; 1680 /*Toggle External charger control pin*/ 1681 ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK, 1682 AB8500_SYS_CHARGER_CONTROL_REG, 1683 EXTERNAL_CHARGER_DISABLE_REG_VAL); 1684 if (ret < 0) { 1685 dev_err(dev, "write reg failed %d\n", ret); 1686 goto out; 1687 } 1688 ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK, 1689 AB8500_SYS_CHARGER_CONTROL_REG, 1690 EXTERNAL_CHARGER_ENABLE_REG_VAL); 1691 if (ret < 0) 1692 dev_err(dev, "Write reg failed %d\n", ret); 1693 1694 out: 1695 return ret; 1696 } 1697 1698 /** 1699 * ab8500_charger_usb_check_enable() - enable usb charging 1700 * @charger: pointer to the ux500_charger structure 1701 * @vset: charging voltage 1702 * @iset: charger output current 1703 * 1704 * Check if the VBUS charger has been disconnected and reconnected without 1705 * AB8500 rising an interrupt. Returns 0 on success. 1706 */ 1707 static int ab8500_charger_usb_check_enable(struct ux500_charger *charger, 1708 int vset, int iset) 1709 { 1710 u8 usbch_ctrl1 = 0; 1711 int ret = 0; 1712 1713 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger); 1714 1715 if (!di->usb.charger_connected) 1716 return ret; 1717 1718 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 1719 AB8500_USBCH_CTRL1_REG, &usbch_ctrl1); 1720 if (ret < 0) { 1721 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__); 1722 return ret; 1723 } 1724 dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1); 1725 1726 if (!(usbch_ctrl1 & USB_CH_ENA)) { 1727 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n"); 1728 1729 ret = abx500_mask_and_set_register_interruptible(di->dev, 1730 AB8500_CHARGER, AB8500_CHARGER_CTRL, 1731 DROP_COUNT_RESET, DROP_COUNT_RESET); 1732 if (ret < 0) { 1733 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__); 1734 return ret; 1735 } 1736 1737 ret = ab8500_charger_usb_en(&di->usb_chg, true, vset, iset); 1738 if (ret < 0) { 1739 dev_err(di->dev, "Failed to enable VBUS charger %d\n", 1740 __LINE__); 1741 return ret; 1742 } 1743 } 1744 return ret; 1745 } 1746 1747 /** 1748 * ab8500_charger_ac_check_enable() - enable usb charging 1749 * @charger: pointer to the ux500_charger structure 1750 * @vset: charging voltage 1751 * @iset: charger output current 1752 * 1753 * Check if the AC charger has been disconnected and reconnected without 1754 * AB8500 rising an interrupt. Returns 0 on success. 1755 */ 1756 static int ab8500_charger_ac_check_enable(struct ux500_charger *charger, 1757 int vset, int iset) 1758 { 1759 u8 mainch_ctrl1 = 0; 1760 int ret = 0; 1761 1762 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger); 1763 1764 if (!di->ac.charger_connected) 1765 return ret; 1766 1767 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 1768 AB8500_MCH_CTRL1, &mainch_ctrl1); 1769 if (ret < 0) { 1770 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__); 1771 return ret; 1772 } 1773 dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1); 1774 1775 if (!(mainch_ctrl1 & MAIN_CH_ENA)) { 1776 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n"); 1777 1778 ret = abx500_mask_and_set_register_interruptible(di->dev, 1779 AB8500_CHARGER, AB8500_CHARGER_CTRL, 1780 DROP_COUNT_RESET, DROP_COUNT_RESET); 1781 1782 if (ret < 0) { 1783 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__); 1784 return ret; 1785 } 1786 1787 ret = ab8500_charger_ac_en(&di->usb_chg, true, vset, iset); 1788 if (ret < 0) { 1789 dev_err(di->dev, "failed to enable AC charger %d\n", 1790 __LINE__); 1791 return ret; 1792 } 1793 } 1794 return ret; 1795 } 1796 1797 /** 1798 * ab8500_charger_watchdog_kick() - kick charger watchdog 1799 * @di: pointer to the ab8500_charger structure 1800 * 1801 * Kick charger watchdog 1802 * Returns error code in case of failure else 0(on success) 1803 */ 1804 static int ab8500_charger_watchdog_kick(struct ux500_charger *charger) 1805 { 1806 int ret; 1807 struct ab8500_charger *di; 1808 1809 if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS) 1810 di = to_ab8500_charger_ac_device_info(charger); 1811 else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB) 1812 di = to_ab8500_charger_usb_device_info(charger); 1813 else 1814 return -ENXIO; 1815 1816 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1817 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK); 1818 if (ret) 1819 dev_err(di->dev, "Failed to kick WD!\n"); 1820 1821 return ret; 1822 } 1823 1824 /** 1825 * ab8500_charger_update_charger_current() - update charger current 1826 * @di: pointer to the ab8500_charger structure 1827 * 1828 * Update the charger output current for the specified charger 1829 * Returns error code in case of failure else 0(on success) 1830 */ 1831 static int ab8500_charger_update_charger_current(struct ux500_charger *charger, 1832 int ich_out) 1833 { 1834 int ret; 1835 struct ab8500_charger *di; 1836 1837 if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS) 1838 di = to_ab8500_charger_ac_device_info(charger); 1839 else if (charger->psy->desc->type == POWER_SUPPLY_TYPE_USB) 1840 di = to_ab8500_charger_usb_device_info(charger); 1841 else 1842 return -ENXIO; 1843 1844 ret = ab8500_charger_set_output_curr(di, ich_out); 1845 if (ret) { 1846 dev_err(di->dev, "%s " 1847 "Failed to set ChOutputCurentLevel\n", 1848 __func__); 1849 return ret; 1850 } 1851 1852 /* Reset the main and usb drop input current measurement counter */ 1853 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 1854 AB8500_CHARGER_CTRL, DROP_COUNT_RESET); 1855 if (ret) { 1856 dev_err(di->dev, "%s write failed\n", __func__); 1857 return ret; 1858 } 1859 1860 return ret; 1861 } 1862 1863 static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data) 1864 { 1865 struct power_supply *psy; 1866 struct power_supply *ext = dev_get_drvdata(dev); 1867 const char **supplicants = (const char **)ext->supplied_to; 1868 struct ab8500_charger *di; 1869 union power_supply_propval ret; 1870 int j; 1871 struct ux500_charger *usb_chg; 1872 1873 usb_chg = (struct ux500_charger *)data; 1874 psy = usb_chg->psy; 1875 1876 di = to_ab8500_charger_usb_device_info(usb_chg); 1877 1878 /* For all psy where the driver name appears in any supplied_to */ 1879 j = match_string(supplicants, ext->num_supplicants, psy->desc->name); 1880 if (j < 0) 1881 return 0; 1882 1883 /* Go through all properties for the psy */ 1884 for (j = 0; j < ext->desc->num_properties; j++) { 1885 enum power_supply_property prop; 1886 prop = ext->desc->properties[j]; 1887 1888 if (power_supply_get_property(ext, prop, &ret)) 1889 continue; 1890 1891 switch (prop) { 1892 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 1893 switch (ext->desc->type) { 1894 case POWER_SUPPLY_TYPE_BATTERY: 1895 di->vbat = ret.intval / 1000; 1896 break; 1897 default: 1898 break; 1899 } 1900 break; 1901 default: 1902 break; 1903 } 1904 } 1905 return 0; 1906 } 1907 1908 /** 1909 * ab8500_charger_check_vbat_work() - keep vbus current within spec 1910 * @work pointer to the work_struct structure 1911 * 1912 * Due to a asic bug it is necessary to lower the input current to the vbus 1913 * charger when charging with at some specific levels. This issue is only valid 1914 * for below a certain battery voltage. This function makes sure that the 1915 * the allowed current limit isn't exceeded. 1916 */ 1917 static void ab8500_charger_check_vbat_work(struct work_struct *work) 1918 { 1919 int t = 10; 1920 struct ab8500_charger *di = container_of(work, 1921 struct ab8500_charger, check_vbat_work.work); 1922 1923 class_for_each_device(power_supply_class, NULL, 1924 di->usb_chg.psy, ab8500_charger_get_ext_psy_data); 1925 1926 /* First run old_vbat is 0. */ 1927 if (di->old_vbat == 0) 1928 di->old_vbat = di->vbat; 1929 1930 if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED && 1931 di->vbat <= VBAT_TRESH_IP_CUR_RED) || 1932 (di->old_vbat > VBAT_TRESH_IP_CUR_RED && 1933 di->vbat > VBAT_TRESH_IP_CUR_RED))) { 1934 1935 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d," 1936 " old: %d\n", di->max_usb_in_curr.usb_type_max, 1937 di->vbat, di->old_vbat); 1938 ab8500_charger_set_vbus_in_curr(di, 1939 di->max_usb_in_curr.usb_type_max); 1940 power_supply_changed(di->usb_chg.psy); 1941 } 1942 1943 di->old_vbat = di->vbat; 1944 1945 /* 1946 * No need to check the battery voltage every second when not close to 1947 * the threshold. 1948 */ 1949 if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100) && 1950 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100))) 1951 t = 1; 1952 1953 queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ); 1954 } 1955 1956 /** 1957 * ab8500_charger_check_hw_failure_work() - check main charger failure 1958 * @work: pointer to the work_struct structure 1959 * 1960 * Work queue function for checking the main charger status 1961 */ 1962 static void ab8500_charger_check_hw_failure_work(struct work_struct *work) 1963 { 1964 int ret; 1965 u8 reg_value; 1966 1967 struct ab8500_charger *di = container_of(work, 1968 struct ab8500_charger, check_hw_failure_work.work); 1969 1970 /* Check if the status bits for HW failure is still active */ 1971 if (di->flags.mainextchnotok) { 1972 ret = abx500_get_register_interruptible(di->dev, 1973 AB8500_CHARGER, AB8500_CH_STATUS2_REG, ®_value); 1974 if (ret < 0) { 1975 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 1976 return; 1977 } 1978 if (!(reg_value & MAIN_CH_NOK)) { 1979 di->flags.mainextchnotok = false; 1980 ab8500_power_supply_changed(di, di->ac_chg.psy); 1981 } 1982 } 1983 if (di->flags.vbus_ovv) { 1984 ret = abx500_get_register_interruptible(di->dev, 1985 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, 1986 ®_value); 1987 if (ret < 0) { 1988 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 1989 return; 1990 } 1991 if (!(reg_value & VBUS_OVV_TH)) { 1992 di->flags.vbus_ovv = false; 1993 ab8500_power_supply_changed(di, di->usb_chg.psy); 1994 } 1995 } 1996 /* If we still have a failure, schedule a new check */ 1997 if (di->flags.mainextchnotok || di->flags.vbus_ovv) { 1998 queue_delayed_work(di->charger_wq, 1999 &di->check_hw_failure_work, round_jiffies(HZ)); 2000 } 2001 } 2002 2003 /** 2004 * ab8500_charger_kick_watchdog_work() - kick the watchdog 2005 * @work: pointer to the work_struct structure 2006 * 2007 * Work queue function for kicking the charger watchdog. 2008 * 2009 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog 2010 * logic. That means we have to continously kick the charger 2011 * watchdog even when no charger is connected. This is only 2012 * valid once the AC charger has been enabled. This is 2013 * a bug that is not handled by the algorithm and the 2014 * watchdog have to be kicked by the charger driver 2015 * when the AC charger is disabled 2016 */ 2017 static void ab8500_charger_kick_watchdog_work(struct work_struct *work) 2018 { 2019 int ret; 2020 2021 struct ab8500_charger *di = container_of(work, 2022 struct ab8500_charger, kick_wd_work.work); 2023 2024 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 2025 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK); 2026 if (ret) 2027 dev_err(di->dev, "Failed to kick WD!\n"); 2028 2029 /* Schedule a new watchdog kick */ 2030 queue_delayed_work(di->charger_wq, 2031 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL)); 2032 } 2033 2034 /** 2035 * ab8500_charger_ac_work() - work to get and set main charger status 2036 * @work: pointer to the work_struct structure 2037 * 2038 * Work queue function for checking the main charger status 2039 */ 2040 static void ab8500_charger_ac_work(struct work_struct *work) 2041 { 2042 int ret; 2043 2044 struct ab8500_charger *di = container_of(work, 2045 struct ab8500_charger, ac_work); 2046 2047 /* 2048 * Since we can't be sure that the events are received 2049 * synchronously, we have the check if the main charger is 2050 * connected by reading the status register 2051 */ 2052 ret = ab8500_charger_detect_chargers(di, false); 2053 if (ret < 0) 2054 return; 2055 2056 if (ret & AC_PW_CONN) { 2057 di->ac.charger_connected = 1; 2058 di->ac_conn = true; 2059 } else { 2060 di->ac.charger_connected = 0; 2061 } 2062 2063 ab8500_power_supply_changed(di, di->ac_chg.psy); 2064 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present"); 2065 } 2066 2067 static void ab8500_charger_usb_attached_work(struct work_struct *work) 2068 { 2069 struct ab8500_charger *di = container_of(work, 2070 struct ab8500_charger, 2071 usb_charger_attached_work.work); 2072 int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC); 2073 int ret, i; 2074 u8 statval; 2075 2076 for (i = 0; i < 10; i++) { 2077 ret = abx500_get_register_interruptible(di->dev, 2078 AB8500_CHARGER, 2079 AB8500_CH_USBCH_STAT1_REG, 2080 &statval); 2081 if (ret < 0) { 2082 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__); 2083 goto reschedule; 2084 } 2085 if ((statval & usbch) != usbch) 2086 goto reschedule; 2087 2088 msleep(CHARGER_STATUS_POLL); 2089 } 2090 2091 ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0); 2092 2093 mutex_lock(&di->charger_attached_mutex); 2094 mutex_unlock(&di->charger_attached_mutex); 2095 2096 return; 2097 2098 reschedule: 2099 queue_delayed_work(di->charger_wq, 2100 &di->usb_charger_attached_work, 2101 HZ); 2102 } 2103 2104 static void ab8500_charger_ac_attached_work(struct work_struct *work) 2105 { 2106 2107 struct ab8500_charger *di = container_of(work, 2108 struct ab8500_charger, 2109 ac_charger_attached_work.work); 2110 int mainch = (MAIN_CH_STATUS2_MAINCHGDROP | 2111 MAIN_CH_STATUS2_MAINCHARGERDETDBNC); 2112 int ret, i; 2113 u8 statval; 2114 2115 for (i = 0; i < 10; i++) { 2116 ret = abx500_get_register_interruptible(di->dev, 2117 AB8500_CHARGER, 2118 AB8500_CH_STATUS2_REG, 2119 &statval); 2120 if (ret < 0) { 2121 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__); 2122 goto reschedule; 2123 } 2124 2125 if ((statval & mainch) != mainch) 2126 goto reschedule; 2127 2128 msleep(CHARGER_STATUS_POLL); 2129 } 2130 2131 ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0); 2132 queue_work(di->charger_wq, &di->ac_work); 2133 2134 mutex_lock(&di->charger_attached_mutex); 2135 mutex_unlock(&di->charger_attached_mutex); 2136 2137 return; 2138 2139 reschedule: 2140 queue_delayed_work(di->charger_wq, 2141 &di->ac_charger_attached_work, 2142 HZ); 2143 } 2144 2145 /** 2146 * ab8500_charger_detect_usb_type_work() - work to detect USB type 2147 * @work: Pointer to the work_struct structure 2148 * 2149 * Detect the type of USB plugged 2150 */ 2151 static void ab8500_charger_detect_usb_type_work(struct work_struct *work) 2152 { 2153 int ret; 2154 2155 struct ab8500_charger *di = container_of(work, 2156 struct ab8500_charger, detect_usb_type_work); 2157 2158 /* 2159 * Since we can't be sure that the events are received 2160 * synchronously, we have the check if is 2161 * connected by reading the status register 2162 */ 2163 ret = ab8500_charger_detect_chargers(di, false); 2164 if (ret < 0) 2165 return; 2166 2167 if (!(ret & USB_PW_CONN)) { 2168 dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__); 2169 di->vbus_detected = false; 2170 ab8500_charger_set_usb_connected(di, false); 2171 ab8500_power_supply_changed(di, di->usb_chg.psy); 2172 } else { 2173 dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__); 2174 di->vbus_detected = true; 2175 2176 if (is_ab8500_1p1_or_earlier(di->parent)) { 2177 ret = ab8500_charger_detect_usb_type(di); 2178 if (!ret) { 2179 ab8500_charger_set_usb_connected(di, true); 2180 ab8500_power_supply_changed(di, 2181 di->usb_chg.psy); 2182 } 2183 } else { 2184 /* 2185 * For ABB cut2.0 and onwards we have an IRQ, 2186 * USB_LINK_STATUS that will be triggered when the USB 2187 * link status changes. The exception is USB connected 2188 * during startup. Then we don't get a 2189 * USB_LINK_STATUS IRQ 2190 */ 2191 if (di->vbus_detected_start) { 2192 di->vbus_detected_start = false; 2193 ret = ab8500_charger_detect_usb_type(di); 2194 if (!ret) { 2195 ab8500_charger_set_usb_connected(di, 2196 true); 2197 ab8500_power_supply_changed(di, 2198 di->usb_chg.psy); 2199 } 2200 } 2201 } 2202 } 2203 } 2204 2205 /** 2206 * ab8500_charger_usb_link_attach_work() - work to detect USB type 2207 * @work: pointer to the work_struct structure 2208 * 2209 * Detect the type of USB plugged 2210 */ 2211 static void ab8500_charger_usb_link_attach_work(struct work_struct *work) 2212 { 2213 struct ab8500_charger *di = 2214 container_of(work, struct ab8500_charger, attach_work.work); 2215 int ret; 2216 2217 /* Update maximum input current if USB enumeration is not detected */ 2218 if (!di->usb.charger_online) { 2219 ret = ab8500_charger_set_vbus_in_curr(di, 2220 di->max_usb_in_curr.usb_type_max); 2221 if (ret) 2222 return; 2223 } 2224 2225 ab8500_charger_set_usb_connected(di, true); 2226 ab8500_power_supply_changed(di, di->usb_chg.psy); 2227 } 2228 2229 /** 2230 * ab8500_charger_usb_link_status_work() - work to detect USB type 2231 * @work: pointer to the work_struct structure 2232 * 2233 * Detect the type of USB plugged 2234 */ 2235 static void ab8500_charger_usb_link_status_work(struct work_struct *work) 2236 { 2237 int detected_chargers; 2238 int ret; 2239 u8 val; 2240 u8 link_status; 2241 2242 struct ab8500_charger *di = container_of(work, 2243 struct ab8500_charger, usb_link_status_work); 2244 2245 /* 2246 * Since we can't be sure that the events are received 2247 * synchronously, we have the check if is 2248 * connected by reading the status register 2249 */ 2250 detected_chargers = ab8500_charger_detect_chargers(di, false); 2251 if (detected_chargers < 0) 2252 return; 2253 2254 /* 2255 * Some chargers that breaks the USB spec is 2256 * identified as invalid by AB8500 and it refuse 2257 * to start the charging process. but by jumping 2258 * thru a few hoops it can be forced to start. 2259 */ 2260 if (is_ab8500(di->parent)) 2261 ret = abx500_get_register_interruptible(di->dev, AB8500_USB, 2262 AB8500_USB_LINE_STAT_REG, &val); 2263 else 2264 ret = abx500_get_register_interruptible(di->dev, AB8500_USB, 2265 AB8500_USB_LINK1_STAT_REG, &val); 2266 2267 if (ret >= 0) 2268 dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val); 2269 else 2270 dev_dbg(di->dev, "Error reading USB link status\n"); 2271 2272 if (is_ab8500(di->parent)) 2273 link_status = AB8500_USB_LINK_STATUS; 2274 else 2275 link_status = AB8505_USB_LINK_STATUS; 2276 2277 if (detected_chargers & USB_PW_CONN) { 2278 if (((val & link_status) >> USB_LINK_STATUS_SHIFT) == 2279 USB_STAT_NOT_VALID_LINK && 2280 di->invalid_charger_detect_state == 0) { 2281 dev_dbg(di->dev, 2282 "Invalid charger detected, state= 0\n"); 2283 /*Enable charger*/ 2284 abx500_mask_and_set_register_interruptible(di->dev, 2285 AB8500_CHARGER, AB8500_USBCH_CTRL1_REG, 2286 USB_CH_ENA, USB_CH_ENA); 2287 /*Enable charger detection*/ 2288 abx500_mask_and_set_register_interruptible(di->dev, 2289 AB8500_USB, AB8500_USB_LINE_CTRL2_REG, 2290 USB_CH_DET, USB_CH_DET); 2291 di->invalid_charger_detect_state = 1; 2292 /*exit and wait for new link status interrupt.*/ 2293 return; 2294 2295 } 2296 if (di->invalid_charger_detect_state == 1) { 2297 dev_dbg(di->dev, 2298 "Invalid charger detected, state= 1\n"); 2299 /*Stop charger detection*/ 2300 abx500_mask_and_set_register_interruptible(di->dev, 2301 AB8500_USB, AB8500_USB_LINE_CTRL2_REG, 2302 USB_CH_DET, 0x00); 2303 /*Check link status*/ 2304 if (is_ab8500(di->parent)) 2305 ret = abx500_get_register_interruptible(di->dev, 2306 AB8500_USB, AB8500_USB_LINE_STAT_REG, 2307 &val); 2308 else 2309 ret = abx500_get_register_interruptible(di->dev, 2310 AB8500_USB, AB8500_USB_LINK1_STAT_REG, 2311 &val); 2312 2313 dev_dbg(di->dev, "USB link status= 0x%02x\n", 2314 (val & link_status) >> USB_LINK_STATUS_SHIFT); 2315 di->invalid_charger_detect_state = 2; 2316 } 2317 } else { 2318 di->invalid_charger_detect_state = 0; 2319 } 2320 2321 if (!(detected_chargers & USB_PW_CONN)) { 2322 di->vbus_detected = false; 2323 ab8500_charger_set_usb_connected(di, false); 2324 ab8500_power_supply_changed(di, di->usb_chg.psy); 2325 return; 2326 } 2327 2328 dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__); 2329 di->vbus_detected = true; 2330 ret = ab8500_charger_read_usb_type(di); 2331 if (ret) { 2332 if (ret == -ENXIO) { 2333 /* No valid charger type detected */ 2334 ab8500_charger_set_usb_connected(di, false); 2335 ab8500_power_supply_changed(di, di->usb_chg.psy); 2336 } 2337 return; 2338 } 2339 2340 if (di->usb_device_is_unrecognised) { 2341 dev_dbg(di->dev, 2342 "Potential Legacy Charger device. " 2343 "Delay work for %d msec for USB enum " 2344 "to finish", 2345 WAIT_ACA_RID_ENUMERATION); 2346 queue_delayed_work(di->charger_wq, 2347 &di->attach_work, 2348 msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION)); 2349 } else if (di->is_aca_rid == 1) { 2350 /* Only wait once */ 2351 di->is_aca_rid++; 2352 dev_dbg(di->dev, 2353 "%s Wait %d msec for USB enum to finish", 2354 __func__, WAIT_ACA_RID_ENUMERATION); 2355 queue_delayed_work(di->charger_wq, 2356 &di->attach_work, 2357 msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION)); 2358 } else { 2359 queue_delayed_work(di->charger_wq, 2360 &di->attach_work, 2361 0); 2362 } 2363 } 2364 2365 static void ab8500_charger_usb_state_changed_work(struct work_struct *work) 2366 { 2367 int ret; 2368 unsigned long flags; 2369 2370 struct ab8500_charger *di = container_of(work, 2371 struct ab8500_charger, usb_state_changed_work.work); 2372 2373 if (!di->vbus_detected) { 2374 dev_dbg(di->dev, 2375 "%s !di->vbus_detected\n", 2376 __func__); 2377 return; 2378 } 2379 2380 spin_lock_irqsave(&di->usb_state.usb_lock, flags); 2381 di->usb_state.state = di->usb_state.state_tmp; 2382 di->usb_state.usb_current = di->usb_state.usb_current_tmp; 2383 spin_unlock_irqrestore(&di->usb_state.usb_lock, flags); 2384 2385 dev_dbg(di->dev, "%s USB state: 0x%02x mA: %d\n", 2386 __func__, di->usb_state.state, di->usb_state.usb_current); 2387 2388 switch (di->usb_state.state) { 2389 case AB8500_BM_USB_STATE_RESET_HS: 2390 case AB8500_BM_USB_STATE_RESET_FS: 2391 case AB8500_BM_USB_STATE_SUSPEND: 2392 case AB8500_BM_USB_STATE_MAX: 2393 ab8500_charger_set_usb_connected(di, false); 2394 ab8500_power_supply_changed(di, di->usb_chg.psy); 2395 break; 2396 2397 case AB8500_BM_USB_STATE_RESUME: 2398 /* 2399 * when suspend->resume there should be delay 2400 * of 1sec for enabling charging 2401 */ 2402 msleep(1000); 2403 /* Intentional fall through */ 2404 case AB8500_BM_USB_STATE_CONFIGURED: 2405 /* 2406 * USB is configured, enable charging with the charging 2407 * input current obtained from USB driver 2408 */ 2409 if (!ab8500_charger_get_usb_cur(di)) { 2410 /* Update maximum input current */ 2411 ret = ab8500_charger_set_vbus_in_curr(di, 2412 di->max_usb_in_curr.usb_type_max); 2413 if (ret) 2414 return; 2415 2416 ab8500_charger_set_usb_connected(di, true); 2417 ab8500_power_supply_changed(di, di->usb_chg.psy); 2418 } 2419 break; 2420 2421 default: 2422 break; 2423 }; 2424 } 2425 2426 /** 2427 * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status 2428 * @work: pointer to the work_struct structure 2429 * 2430 * Work queue function for checking the USB charger Not OK status 2431 */ 2432 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work) 2433 { 2434 int ret; 2435 u8 reg_value; 2436 bool prev_status; 2437 2438 struct ab8500_charger *di = container_of(work, 2439 struct ab8500_charger, check_usbchgnotok_work.work); 2440 2441 /* Check if the status bit for usbchargernotok is still active */ 2442 ret = abx500_get_register_interruptible(di->dev, 2443 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, ®_value); 2444 if (ret < 0) { 2445 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2446 return; 2447 } 2448 prev_status = di->flags.usbchargernotok; 2449 2450 if (reg_value & VBUS_CH_NOK) { 2451 di->flags.usbchargernotok = true; 2452 /* Check again in 1sec */ 2453 queue_delayed_work(di->charger_wq, 2454 &di->check_usbchgnotok_work, HZ); 2455 } else { 2456 di->flags.usbchargernotok = false; 2457 di->flags.vbus_collapse = false; 2458 } 2459 2460 if (prev_status != di->flags.usbchargernotok) 2461 ab8500_power_supply_changed(di, di->usb_chg.psy); 2462 } 2463 2464 /** 2465 * ab8500_charger_check_main_thermal_prot_work() - check main thermal status 2466 * @work: pointer to the work_struct structure 2467 * 2468 * Work queue function for checking the Main thermal prot status 2469 */ 2470 static void ab8500_charger_check_main_thermal_prot_work( 2471 struct work_struct *work) 2472 { 2473 int ret; 2474 u8 reg_value; 2475 2476 struct ab8500_charger *di = container_of(work, 2477 struct ab8500_charger, check_main_thermal_prot_work); 2478 2479 /* Check if the status bit for main_thermal_prot is still active */ 2480 ret = abx500_get_register_interruptible(di->dev, 2481 AB8500_CHARGER, AB8500_CH_STATUS2_REG, ®_value); 2482 if (ret < 0) { 2483 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2484 return; 2485 } 2486 if (reg_value & MAIN_CH_TH_PROT) 2487 di->flags.main_thermal_prot = true; 2488 else 2489 di->flags.main_thermal_prot = false; 2490 2491 ab8500_power_supply_changed(di, di->ac_chg.psy); 2492 } 2493 2494 /** 2495 * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status 2496 * @work: pointer to the work_struct structure 2497 * 2498 * Work queue function for checking the USB thermal prot status 2499 */ 2500 static void ab8500_charger_check_usb_thermal_prot_work( 2501 struct work_struct *work) 2502 { 2503 int ret; 2504 u8 reg_value; 2505 2506 struct ab8500_charger *di = container_of(work, 2507 struct ab8500_charger, check_usb_thermal_prot_work); 2508 2509 /* Check if the status bit for usb_thermal_prot is still active */ 2510 ret = abx500_get_register_interruptible(di->dev, 2511 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, ®_value); 2512 if (ret < 0) { 2513 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2514 return; 2515 } 2516 if (reg_value & USB_CH_TH_PROT) 2517 di->flags.usb_thermal_prot = true; 2518 else 2519 di->flags.usb_thermal_prot = false; 2520 2521 ab8500_power_supply_changed(di, di->usb_chg.psy); 2522 } 2523 2524 /** 2525 * ab8500_charger_mainchunplugdet_handler() - main charger unplugged 2526 * @irq: interrupt number 2527 * @_di: pointer to the ab8500_charger structure 2528 * 2529 * Returns IRQ status(IRQ_HANDLED) 2530 */ 2531 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di) 2532 { 2533 struct ab8500_charger *di = _di; 2534 2535 dev_dbg(di->dev, "Main charger unplugged\n"); 2536 queue_work(di->charger_wq, &di->ac_work); 2537 2538 cancel_delayed_work_sync(&di->ac_charger_attached_work); 2539 mutex_lock(&di->charger_attached_mutex); 2540 mutex_unlock(&di->charger_attached_mutex); 2541 2542 return IRQ_HANDLED; 2543 } 2544 2545 /** 2546 * ab8500_charger_mainchplugdet_handler() - main charger plugged 2547 * @irq: interrupt number 2548 * @_di: pointer to the ab8500_charger structure 2549 * 2550 * Returns IRQ status(IRQ_HANDLED) 2551 */ 2552 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di) 2553 { 2554 struct ab8500_charger *di = _di; 2555 2556 dev_dbg(di->dev, "Main charger plugged\n"); 2557 queue_work(di->charger_wq, &di->ac_work); 2558 2559 mutex_lock(&di->charger_attached_mutex); 2560 mutex_unlock(&di->charger_attached_mutex); 2561 2562 if (is_ab8500(di->parent)) 2563 queue_delayed_work(di->charger_wq, 2564 &di->ac_charger_attached_work, 2565 HZ); 2566 return IRQ_HANDLED; 2567 } 2568 2569 /** 2570 * ab8500_charger_mainextchnotok_handler() - main charger not ok 2571 * @irq: interrupt number 2572 * @_di: pointer to the ab8500_charger structure 2573 * 2574 * Returns IRQ status(IRQ_HANDLED) 2575 */ 2576 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di) 2577 { 2578 struct ab8500_charger *di = _di; 2579 2580 dev_dbg(di->dev, "Main charger not ok\n"); 2581 di->flags.mainextchnotok = true; 2582 ab8500_power_supply_changed(di, di->ac_chg.psy); 2583 2584 /* Schedule a new HW failure check */ 2585 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0); 2586 2587 return IRQ_HANDLED; 2588 } 2589 2590 /** 2591 * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger 2592 * thermal protection threshold 2593 * @irq: interrupt number 2594 * @_di: pointer to the ab8500_charger structure 2595 * 2596 * Returns IRQ status(IRQ_HANDLED) 2597 */ 2598 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di) 2599 { 2600 struct ab8500_charger *di = _di; 2601 2602 dev_dbg(di->dev, 2603 "Die temp above Main charger thermal protection threshold\n"); 2604 queue_work(di->charger_wq, &di->check_main_thermal_prot_work); 2605 2606 return IRQ_HANDLED; 2607 } 2608 2609 /** 2610 * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger 2611 * thermal protection threshold 2612 * @irq: interrupt number 2613 * @_di: pointer to the ab8500_charger structure 2614 * 2615 * Returns IRQ status(IRQ_HANDLED) 2616 */ 2617 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di) 2618 { 2619 struct ab8500_charger *di = _di; 2620 2621 dev_dbg(di->dev, 2622 "Die temp ok for Main charger thermal protection threshold\n"); 2623 queue_work(di->charger_wq, &di->check_main_thermal_prot_work); 2624 2625 return IRQ_HANDLED; 2626 } 2627 2628 static void ab8500_charger_vbus_drop_end_work(struct work_struct *work) 2629 { 2630 struct ab8500_charger *di = container_of(work, 2631 struct ab8500_charger, vbus_drop_end_work.work); 2632 int ret, curr; 2633 u8 reg_value; 2634 2635 di->flags.vbus_drop_end = false; 2636 2637 /* Reset the drop counter */ 2638 abx500_set_register_interruptible(di->dev, 2639 AB8500_CHARGER, AB8500_CHARGER_CTRL, 0x01); 2640 2641 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 2642 AB8500_CH_USBCH_STAT2_REG, ®_value); 2643 if (ret < 0) { 2644 dev_err(di->dev, "%s read failed\n", __func__); 2645 return; 2646 } 2647 2648 curr = di->bm->chg_input_curr[ 2649 reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT]; 2650 2651 if (di->max_usb_in_curr.calculated_max != curr) { 2652 /* USB source is collapsing */ 2653 di->max_usb_in_curr.calculated_max = curr; 2654 dev_dbg(di->dev, 2655 "VBUS input current limiting to %d mA\n", 2656 di->max_usb_in_curr.calculated_max); 2657 } else { 2658 /* 2659 * USB source can not give more than this amount. 2660 * Taking more will collapse the source. 2661 */ 2662 di->max_usb_in_curr.set_max = 2663 di->max_usb_in_curr.calculated_max; 2664 dev_dbg(di->dev, 2665 "VBUS input current limited to %d mA\n", 2666 di->max_usb_in_curr.set_max); 2667 } 2668 2669 if (di->usb.charger_connected) 2670 ab8500_charger_set_vbus_in_curr(di, 2671 di->max_usb_in_curr.usb_type_max); 2672 } 2673 2674 /** 2675 * ab8500_charger_vbusdetf_handler() - VBUS falling detected 2676 * @irq: interrupt number 2677 * @_di: pointer to the ab8500_charger structure 2678 * 2679 * Returns IRQ status(IRQ_HANDLED) 2680 */ 2681 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di) 2682 { 2683 struct ab8500_charger *di = _di; 2684 2685 di->vbus_detected = false; 2686 dev_dbg(di->dev, "VBUS falling detected\n"); 2687 queue_work(di->charger_wq, &di->detect_usb_type_work); 2688 2689 return IRQ_HANDLED; 2690 } 2691 2692 /** 2693 * ab8500_charger_vbusdetr_handler() - VBUS rising detected 2694 * @irq: interrupt number 2695 * @_di: pointer to the ab8500_charger structure 2696 * 2697 * Returns IRQ status(IRQ_HANDLED) 2698 */ 2699 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di) 2700 { 2701 struct ab8500_charger *di = _di; 2702 2703 di->vbus_detected = true; 2704 dev_dbg(di->dev, "VBUS rising detected\n"); 2705 2706 queue_work(di->charger_wq, &di->detect_usb_type_work); 2707 2708 return IRQ_HANDLED; 2709 } 2710 2711 /** 2712 * ab8500_charger_usblinkstatus_handler() - USB link status has changed 2713 * @irq: interrupt number 2714 * @_di: pointer to the ab8500_charger structure 2715 * 2716 * Returns IRQ status(IRQ_HANDLED) 2717 */ 2718 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di) 2719 { 2720 struct ab8500_charger *di = _di; 2721 2722 dev_dbg(di->dev, "USB link status changed\n"); 2723 2724 queue_work(di->charger_wq, &di->usb_link_status_work); 2725 2726 return IRQ_HANDLED; 2727 } 2728 2729 /** 2730 * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger 2731 * thermal protection threshold 2732 * @irq: interrupt number 2733 * @_di: pointer to the ab8500_charger structure 2734 * 2735 * Returns IRQ status(IRQ_HANDLED) 2736 */ 2737 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di) 2738 { 2739 struct ab8500_charger *di = _di; 2740 2741 dev_dbg(di->dev, 2742 "Die temp above USB charger thermal protection threshold\n"); 2743 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work); 2744 2745 return IRQ_HANDLED; 2746 } 2747 2748 /** 2749 * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger 2750 * thermal protection threshold 2751 * @irq: interrupt number 2752 * @_di: pointer to the ab8500_charger structure 2753 * 2754 * Returns IRQ status(IRQ_HANDLED) 2755 */ 2756 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di) 2757 { 2758 struct ab8500_charger *di = _di; 2759 2760 dev_dbg(di->dev, 2761 "Die temp ok for USB charger thermal protection threshold\n"); 2762 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work); 2763 2764 return IRQ_HANDLED; 2765 } 2766 2767 /** 2768 * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected 2769 * @irq: interrupt number 2770 * @_di: pointer to the ab8500_charger structure 2771 * 2772 * Returns IRQ status(IRQ_HANDLED) 2773 */ 2774 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di) 2775 { 2776 struct ab8500_charger *di = _di; 2777 2778 dev_dbg(di->dev, "Not allowed USB charger detected\n"); 2779 queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0); 2780 2781 return IRQ_HANDLED; 2782 } 2783 2784 /** 2785 * ab8500_charger_chwdexp_handler() - Charger watchdog expired 2786 * @irq: interrupt number 2787 * @_di: pointer to the ab8500_charger structure 2788 * 2789 * Returns IRQ status(IRQ_HANDLED) 2790 */ 2791 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di) 2792 { 2793 struct ab8500_charger *di = _di; 2794 2795 dev_dbg(di->dev, "Charger watchdog expired\n"); 2796 2797 /* 2798 * The charger that was online when the watchdog expired 2799 * needs to be restarted for charging to start again 2800 */ 2801 if (di->ac.charger_online) { 2802 di->ac.wd_expired = true; 2803 ab8500_power_supply_changed(di, di->ac_chg.psy); 2804 } 2805 if (di->usb.charger_online) { 2806 di->usb.wd_expired = true; 2807 ab8500_power_supply_changed(di, di->usb_chg.psy); 2808 } 2809 2810 return IRQ_HANDLED; 2811 } 2812 2813 /** 2814 * ab8500_charger_vbuschdropend_handler() - VBUS drop removed 2815 * @irq: interrupt number 2816 * @_di: pointer to the ab8500_charger structure 2817 * 2818 * Returns IRQ status(IRQ_HANDLED) 2819 */ 2820 static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di) 2821 { 2822 struct ab8500_charger *di = _di; 2823 2824 dev_dbg(di->dev, "VBUS charger drop ended\n"); 2825 di->flags.vbus_drop_end = true; 2826 2827 /* 2828 * VBUS might have dropped due to bad connection. 2829 * Schedule a new input limit set to the value SW requests. 2830 */ 2831 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 2832 round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ)); 2833 2834 return IRQ_HANDLED; 2835 } 2836 2837 /** 2838 * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected 2839 * @irq: interrupt number 2840 * @_di: pointer to the ab8500_charger structure 2841 * 2842 * Returns IRQ status(IRQ_HANDLED) 2843 */ 2844 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di) 2845 { 2846 struct ab8500_charger *di = _di; 2847 2848 dev_dbg(di->dev, "VBUS overvoltage detected\n"); 2849 di->flags.vbus_ovv = true; 2850 ab8500_power_supply_changed(di, di->usb_chg.psy); 2851 2852 /* Schedule a new HW failure check */ 2853 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0); 2854 2855 return IRQ_HANDLED; 2856 } 2857 2858 /** 2859 * ab8500_charger_ac_get_property() - get the ac/mains properties 2860 * @psy: pointer to the power_supply structure 2861 * @psp: pointer to the power_supply_property structure 2862 * @val: pointer to the power_supply_propval union 2863 * 2864 * This function gets called when an application tries to get the ac/mains 2865 * properties by reading the sysfs files. 2866 * AC/Mains properties are online, present and voltage. 2867 * online: ac/mains charging is in progress or not 2868 * present: presence of the ac/mains 2869 * voltage: AC/Mains voltage 2870 * Returns error code in case of failure else 0(on success) 2871 */ 2872 static int ab8500_charger_ac_get_property(struct power_supply *psy, 2873 enum power_supply_property psp, 2874 union power_supply_propval *val) 2875 { 2876 struct ab8500_charger *di; 2877 int ret; 2878 2879 di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy)); 2880 2881 switch (psp) { 2882 case POWER_SUPPLY_PROP_HEALTH: 2883 if (di->flags.mainextchnotok) 2884 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 2885 else if (di->ac.wd_expired || di->usb.wd_expired) 2886 val->intval = POWER_SUPPLY_HEALTH_DEAD; 2887 else if (di->flags.main_thermal_prot) 2888 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 2889 else 2890 val->intval = POWER_SUPPLY_HEALTH_GOOD; 2891 break; 2892 case POWER_SUPPLY_PROP_ONLINE: 2893 val->intval = di->ac.charger_online; 2894 break; 2895 case POWER_SUPPLY_PROP_PRESENT: 2896 val->intval = di->ac.charger_connected; 2897 break; 2898 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 2899 ret = ab8500_charger_get_ac_voltage(di); 2900 if (ret >= 0) 2901 di->ac.charger_voltage = ret; 2902 /* On error, use previous value */ 2903 val->intval = di->ac.charger_voltage * 1000; 2904 break; 2905 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 2906 /* 2907 * This property is used to indicate when CV mode is entered 2908 * for the AC charger 2909 */ 2910 di->ac.cv_active = ab8500_charger_ac_cv(di); 2911 val->intval = di->ac.cv_active; 2912 break; 2913 case POWER_SUPPLY_PROP_CURRENT_NOW: 2914 ret = ab8500_charger_get_ac_current(di); 2915 if (ret >= 0) 2916 di->ac.charger_current = ret; 2917 val->intval = di->ac.charger_current * 1000; 2918 break; 2919 default: 2920 return -EINVAL; 2921 } 2922 return 0; 2923 } 2924 2925 /** 2926 * ab8500_charger_usb_get_property() - get the usb properties 2927 * @psy: pointer to the power_supply structure 2928 * @psp: pointer to the power_supply_property structure 2929 * @val: pointer to the power_supply_propval union 2930 * 2931 * This function gets called when an application tries to get the usb 2932 * properties by reading the sysfs files. 2933 * USB properties are online, present and voltage. 2934 * online: usb charging is in progress or not 2935 * present: presence of the usb 2936 * voltage: vbus voltage 2937 * Returns error code in case of failure else 0(on success) 2938 */ 2939 static int ab8500_charger_usb_get_property(struct power_supply *psy, 2940 enum power_supply_property psp, 2941 union power_supply_propval *val) 2942 { 2943 struct ab8500_charger *di; 2944 int ret; 2945 2946 di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy)); 2947 2948 switch (psp) { 2949 case POWER_SUPPLY_PROP_HEALTH: 2950 if (di->flags.usbchargernotok) 2951 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 2952 else if (di->ac.wd_expired || di->usb.wd_expired) 2953 val->intval = POWER_SUPPLY_HEALTH_DEAD; 2954 else if (di->flags.usb_thermal_prot) 2955 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 2956 else if (di->flags.vbus_ovv) 2957 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 2958 else 2959 val->intval = POWER_SUPPLY_HEALTH_GOOD; 2960 break; 2961 case POWER_SUPPLY_PROP_ONLINE: 2962 val->intval = di->usb.charger_online; 2963 break; 2964 case POWER_SUPPLY_PROP_PRESENT: 2965 val->intval = di->usb.charger_connected; 2966 break; 2967 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 2968 ret = ab8500_charger_get_vbus_voltage(di); 2969 if (ret >= 0) 2970 di->usb.charger_voltage = ret; 2971 val->intval = di->usb.charger_voltage * 1000; 2972 break; 2973 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 2974 /* 2975 * This property is used to indicate when CV mode is entered 2976 * for the USB charger 2977 */ 2978 di->usb.cv_active = ab8500_charger_usb_cv(di); 2979 val->intval = di->usb.cv_active; 2980 break; 2981 case POWER_SUPPLY_PROP_CURRENT_NOW: 2982 ret = ab8500_charger_get_usb_current(di); 2983 if (ret >= 0) 2984 di->usb.charger_current = ret; 2985 val->intval = di->usb.charger_current * 1000; 2986 break; 2987 case POWER_SUPPLY_PROP_CURRENT_AVG: 2988 /* 2989 * This property is used to indicate when VBUS has collapsed 2990 * due to too high output current from the USB charger 2991 */ 2992 if (di->flags.vbus_collapse) 2993 val->intval = 1; 2994 else 2995 val->intval = 0; 2996 break; 2997 default: 2998 return -EINVAL; 2999 } 3000 return 0; 3001 } 3002 3003 /** 3004 * ab8500_charger_init_hw_registers() - Set up charger related registers 3005 * @di: pointer to the ab8500_charger structure 3006 * 3007 * Set up charger OVV, watchdog and maximum voltage registers as well as 3008 * charging of the backup battery 3009 */ 3010 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di) 3011 { 3012 int ret = 0; 3013 u8 bup_vch_range = 0, vbup33_vrtcn = 0; 3014 3015 /* Setup maximum charger current and voltage for ABB cut2.0 */ 3016 if (!is_ab8500_1p1_or_earlier(di->parent)) { 3017 ret = abx500_set_register_interruptible(di->dev, 3018 AB8500_CHARGER, 3019 AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6); 3020 if (ret) { 3021 dev_err(di->dev, 3022 "failed to set CH_VOLT_LVL_MAX_REG\n"); 3023 goto out; 3024 } 3025 3026 ret = abx500_set_register_interruptible(di->dev, 3027 AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG, 3028 CH_OP_CUR_LVL_1P6); 3029 if (ret) { 3030 dev_err(di->dev, 3031 "failed to set CH_OPT_CRNTLVL_MAX_REG\n"); 3032 goto out; 3033 } 3034 } 3035 3036 if (is_ab8505_2p0(di->parent)) 3037 ret = abx500_mask_and_set_register_interruptible(di->dev, 3038 AB8500_CHARGER, 3039 AB8500_USBCH_CTRL2_REG, 3040 VBUS_AUTO_IN_CURR_LIM_ENA, 3041 VBUS_AUTO_IN_CURR_LIM_ENA); 3042 else 3043 /* 3044 * VBUS OVV set to 6.3V and enable automatic current limitation 3045 */ 3046 ret = abx500_set_register_interruptible(di->dev, 3047 AB8500_CHARGER, 3048 AB8500_USBCH_CTRL2_REG, 3049 VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA); 3050 if (ret) { 3051 dev_err(di->dev, 3052 "failed to set automatic current limitation\n"); 3053 goto out; 3054 } 3055 3056 /* Enable main watchdog in OTP */ 3057 ret = abx500_set_register_interruptible(di->dev, 3058 AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD); 3059 if (ret) { 3060 dev_err(di->dev, "failed to enable main WD in OTP\n"); 3061 goto out; 3062 } 3063 3064 /* Enable main watchdog */ 3065 ret = abx500_set_register_interruptible(di->dev, 3066 AB8500_SYS_CTRL2_BLOCK, 3067 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA); 3068 if (ret) { 3069 dev_err(di->dev, "failed to enable main watchdog\n"); 3070 goto out; 3071 } 3072 3073 /* 3074 * Due to internal synchronisation, Enable and Kick watchdog bits 3075 * cannot be enabled in a single write. 3076 * A minimum delay of 2*32 kHz period (62.5µs) must be inserted 3077 * between writing Enable then Kick bits. 3078 */ 3079 udelay(63); 3080 3081 /* Kick main watchdog */ 3082 ret = abx500_set_register_interruptible(di->dev, 3083 AB8500_SYS_CTRL2_BLOCK, 3084 AB8500_MAIN_WDOG_CTRL_REG, 3085 (MAIN_WDOG_ENA | MAIN_WDOG_KICK)); 3086 if (ret) { 3087 dev_err(di->dev, "failed to kick main watchdog\n"); 3088 goto out; 3089 } 3090 3091 /* Disable main watchdog */ 3092 ret = abx500_set_register_interruptible(di->dev, 3093 AB8500_SYS_CTRL2_BLOCK, 3094 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS); 3095 if (ret) { 3096 dev_err(di->dev, "failed to disable main watchdog\n"); 3097 goto out; 3098 } 3099 3100 /* Set watchdog timeout */ 3101 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 3102 AB8500_CH_WD_TIMER_REG, WD_TIMER); 3103 if (ret) { 3104 dev_err(di->dev, "failed to set charger watchdog timeout\n"); 3105 goto out; 3106 } 3107 3108 ret = ab8500_charger_led_en(di, false); 3109 if (ret < 0) { 3110 dev_err(di->dev, "failed to disable LED\n"); 3111 goto out; 3112 } 3113 3114 /* Backup battery voltage and current */ 3115 if (di->bm->bkup_bat_v > BUP_VCH_SEL_3P1V) 3116 bup_vch_range = BUP_VCH_RANGE; 3117 if (di->bm->bkup_bat_v == BUP_VCH_SEL_3P3V) 3118 vbup33_vrtcn = VBUP33_VRTCN; 3119 3120 ret = abx500_set_register_interruptible(di->dev, 3121 AB8500_RTC, 3122 AB8500_RTC_BACKUP_CHG_REG, 3123 (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i); 3124 if (ret) { 3125 dev_err(di->dev, "failed to setup backup battery charging\n"); 3126 goto out; 3127 } 3128 3129 /* Enable backup battery charging */ 3130 ret = abx500_mask_and_set_register_interruptible(di->dev, 3131 AB8500_RTC, AB8500_RTC_CTRL_REG, 3132 RTC_BUP_CH_ENA, RTC_BUP_CH_ENA); 3133 if (ret < 0) { 3134 dev_err(di->dev, "%s mask and set failed\n", __func__); 3135 goto out; 3136 } 3137 3138 out: 3139 return ret; 3140 } 3141 3142 /* 3143 * ab8500 charger driver interrupts and their respective isr 3144 */ 3145 static struct ab8500_charger_interrupts ab8500_charger_irq[] = { 3146 {"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler}, 3147 {"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler}, 3148 {"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler}, 3149 {"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler}, 3150 {"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler}, 3151 {"VBUS_DET_F", ab8500_charger_vbusdetf_handler}, 3152 {"VBUS_DET_R", ab8500_charger_vbusdetr_handler}, 3153 {"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler}, 3154 {"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler}, 3155 {"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler}, 3156 {"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler}, 3157 {"VBUS_OVV", ab8500_charger_vbusovv_handler}, 3158 {"CH_WD_EXP", ab8500_charger_chwdexp_handler}, 3159 {"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler}, 3160 }; 3161 3162 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb, 3163 unsigned long event, void *power) 3164 { 3165 struct ab8500_charger *di = 3166 container_of(nb, struct ab8500_charger, nb); 3167 enum ab8500_usb_state bm_usb_state; 3168 unsigned mA = *((unsigned *)power); 3169 3170 if (!di) 3171 return NOTIFY_DONE; 3172 3173 if (event != USB_EVENT_VBUS) { 3174 dev_dbg(di->dev, "not a standard host, returning\n"); 3175 return NOTIFY_DONE; 3176 } 3177 3178 /* TODO: State is fabricate here. See if charger really needs USB 3179 * state or if mA is enough 3180 */ 3181 if ((di->usb_state.usb_current == 2) && (mA > 2)) 3182 bm_usb_state = AB8500_BM_USB_STATE_RESUME; 3183 else if (mA == 0) 3184 bm_usb_state = AB8500_BM_USB_STATE_RESET_HS; 3185 else if (mA == 2) 3186 bm_usb_state = AB8500_BM_USB_STATE_SUSPEND; 3187 else if (mA >= 8) /* 8, 100, 500 */ 3188 bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED; 3189 else /* Should never occur */ 3190 bm_usb_state = AB8500_BM_USB_STATE_RESET_FS; 3191 3192 dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n", 3193 __func__, bm_usb_state, mA); 3194 3195 spin_lock(&di->usb_state.usb_lock); 3196 di->usb_state.state_tmp = bm_usb_state; 3197 di->usb_state.usb_current_tmp = mA; 3198 spin_unlock(&di->usb_state.usb_lock); 3199 3200 /* 3201 * wait for some time until you get updates from the usb stack 3202 * and negotiations are completed 3203 */ 3204 queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2); 3205 3206 return NOTIFY_OK; 3207 } 3208 3209 #if defined(CONFIG_PM) 3210 static int ab8500_charger_resume(struct platform_device *pdev) 3211 { 3212 int ret; 3213 struct ab8500_charger *di = platform_get_drvdata(pdev); 3214 3215 /* 3216 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog 3217 * logic. That means we have to continously kick the charger 3218 * watchdog even when no charger is connected. This is only 3219 * valid once the AC charger has been enabled. This is 3220 * a bug that is not handled by the algorithm and the 3221 * watchdog have to be kicked by the charger driver 3222 * when the AC charger is disabled 3223 */ 3224 if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) { 3225 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 3226 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK); 3227 if (ret) 3228 dev_err(di->dev, "Failed to kick WD!\n"); 3229 3230 /* If not already pending start a new timer */ 3231 queue_delayed_work(di->charger_wq, &di->kick_wd_work, 3232 round_jiffies(WD_KICK_INTERVAL)); 3233 } 3234 3235 /* If we still have a HW failure, schedule a new check */ 3236 if (di->flags.mainextchnotok || di->flags.vbus_ovv) { 3237 queue_delayed_work(di->charger_wq, 3238 &di->check_hw_failure_work, 0); 3239 } 3240 3241 if (di->flags.vbus_drop_end) 3242 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0); 3243 3244 return 0; 3245 } 3246 3247 static int ab8500_charger_suspend(struct platform_device *pdev, 3248 pm_message_t state) 3249 { 3250 struct ab8500_charger *di = platform_get_drvdata(pdev); 3251 3252 /* Cancel any pending jobs */ 3253 cancel_delayed_work(&di->check_hw_failure_work); 3254 cancel_delayed_work(&di->vbus_drop_end_work); 3255 3256 flush_delayed_work(&di->attach_work); 3257 flush_delayed_work(&di->usb_charger_attached_work); 3258 flush_delayed_work(&di->ac_charger_attached_work); 3259 flush_delayed_work(&di->check_usbchgnotok_work); 3260 flush_delayed_work(&di->check_vbat_work); 3261 flush_delayed_work(&di->kick_wd_work); 3262 3263 flush_work(&di->usb_link_status_work); 3264 flush_work(&di->ac_work); 3265 flush_work(&di->detect_usb_type_work); 3266 3267 if (atomic_read(&di->current_stepping_sessions)) 3268 return -EAGAIN; 3269 3270 return 0; 3271 } 3272 #else 3273 #define ab8500_charger_suspend NULL 3274 #define ab8500_charger_resume NULL 3275 #endif 3276 3277 static struct notifier_block charger_nb = { 3278 .notifier_call = ab8500_external_charger_prepare, 3279 }; 3280 3281 static int ab8500_charger_remove(struct platform_device *pdev) 3282 { 3283 struct ab8500_charger *di = platform_get_drvdata(pdev); 3284 int i, irq, ret; 3285 3286 /* Disable AC charging */ 3287 ab8500_charger_ac_en(&di->ac_chg, false, 0, 0); 3288 3289 /* Disable USB charging */ 3290 ab8500_charger_usb_en(&di->usb_chg, false, 0, 0); 3291 3292 /* Disable interrupts */ 3293 for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) { 3294 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name); 3295 free_irq(irq, di); 3296 } 3297 3298 /* Backup battery voltage and current disable */ 3299 ret = abx500_mask_and_set_register_interruptible(di->dev, 3300 AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0); 3301 if (ret < 0) 3302 dev_err(di->dev, "%s mask and set failed\n", __func__); 3303 3304 usb_unregister_notifier(di->usb_phy, &di->nb); 3305 usb_put_phy(di->usb_phy); 3306 3307 /* Delete the work queue */ 3308 destroy_workqueue(di->charger_wq); 3309 3310 /* Unregister external charger enable notifier */ 3311 if (!di->ac_chg.enabled) 3312 blocking_notifier_chain_unregister( 3313 &charger_notifier_list, &charger_nb); 3314 3315 flush_scheduled_work(); 3316 if (di->usb_chg.enabled) 3317 power_supply_unregister(di->usb_chg.psy); 3318 3319 if (di->ac_chg.enabled && !di->ac_chg.external) 3320 power_supply_unregister(di->ac_chg.psy); 3321 3322 return 0; 3323 } 3324 3325 static char *supply_interface[] = { 3326 "ab8500_chargalg", 3327 "ab8500_fg", 3328 "ab8500_btemp", 3329 }; 3330 3331 static const struct power_supply_desc ab8500_ac_chg_desc = { 3332 .name = "ab8500_ac", 3333 .type = POWER_SUPPLY_TYPE_MAINS, 3334 .properties = ab8500_charger_ac_props, 3335 .num_properties = ARRAY_SIZE(ab8500_charger_ac_props), 3336 .get_property = ab8500_charger_ac_get_property, 3337 }; 3338 3339 static const struct power_supply_desc ab8500_usb_chg_desc = { 3340 .name = "ab8500_usb", 3341 .type = POWER_SUPPLY_TYPE_USB, 3342 .properties = ab8500_charger_usb_props, 3343 .num_properties = ARRAY_SIZE(ab8500_charger_usb_props), 3344 .get_property = ab8500_charger_usb_get_property, 3345 }; 3346 3347 static int ab8500_charger_probe(struct platform_device *pdev) 3348 { 3349 struct device_node *np = pdev->dev.of_node; 3350 struct abx500_bm_data *plat = pdev->dev.platform_data; 3351 struct power_supply_config ac_psy_cfg = {}, usb_psy_cfg = {}; 3352 struct ab8500_charger *di; 3353 int irq, i, charger_status, ret = 0, ch_stat; 3354 3355 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL); 3356 if (!di) { 3357 dev_err(&pdev->dev, "%s no mem for ab8500_charger\n", __func__); 3358 return -ENOMEM; 3359 } 3360 3361 if (!plat) { 3362 dev_err(&pdev->dev, "no battery management data supplied\n"); 3363 return -EINVAL; 3364 } 3365 di->bm = plat; 3366 3367 if (np) { 3368 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm); 3369 if (ret) { 3370 dev_err(&pdev->dev, "failed to get battery information\n"); 3371 return ret; 3372 } 3373 di->autopower_cfg = of_property_read_bool(np, "autopower_cfg"); 3374 } else 3375 di->autopower_cfg = false; 3376 3377 /* get parent data */ 3378 di->dev = &pdev->dev; 3379 di->parent = dev_get_drvdata(pdev->dev.parent); 3380 di->gpadc = ab8500_gpadc_get("ab8500-gpadc.0"); 3381 3382 /* initialize lock */ 3383 spin_lock_init(&di->usb_state.usb_lock); 3384 mutex_init(&di->usb_ipt_crnt_lock); 3385 3386 di->autopower = false; 3387 di->invalid_charger_detect_state = 0; 3388 3389 /* AC and USB supply config */ 3390 ac_psy_cfg.supplied_to = supply_interface; 3391 ac_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface); 3392 ac_psy_cfg.drv_data = &di->ac_chg; 3393 usb_psy_cfg.supplied_to = supply_interface; 3394 usb_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface); 3395 usb_psy_cfg.drv_data = &di->usb_chg; 3396 3397 /* AC supply */ 3398 /* ux500_charger sub-class */ 3399 di->ac_chg.ops.enable = &ab8500_charger_ac_en; 3400 di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable; 3401 di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick; 3402 di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current; 3403 di->ac_chg.max_out_volt = ab8500_charger_voltage_map[ 3404 ARRAY_SIZE(ab8500_charger_voltage_map) - 1]; 3405 di->ac_chg.max_out_curr = 3406 di->bm->chg_output_curr[di->bm->n_chg_out_curr - 1]; 3407 di->ac_chg.wdt_refresh = CHG_WD_INTERVAL; 3408 di->ac_chg.enabled = di->bm->ac_enabled; 3409 di->ac_chg.external = false; 3410 3411 /*notifier for external charger enabling*/ 3412 if (!di->ac_chg.enabled) 3413 blocking_notifier_chain_register( 3414 &charger_notifier_list, &charger_nb); 3415 3416 /* USB supply */ 3417 /* ux500_charger sub-class */ 3418 di->usb_chg.ops.enable = &ab8500_charger_usb_en; 3419 di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable; 3420 di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick; 3421 di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current; 3422 di->usb_chg.max_out_volt = ab8500_charger_voltage_map[ 3423 ARRAY_SIZE(ab8500_charger_voltage_map) - 1]; 3424 di->usb_chg.max_out_curr = 3425 di->bm->chg_output_curr[di->bm->n_chg_out_curr - 1]; 3426 di->usb_chg.wdt_refresh = CHG_WD_INTERVAL; 3427 di->usb_chg.enabled = di->bm->usb_enabled; 3428 di->usb_chg.external = false; 3429 di->usb_state.usb_current = -1; 3430 3431 /* Create a work queue for the charger */ 3432 di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq", 3433 WQ_MEM_RECLAIM); 3434 if (di->charger_wq == NULL) { 3435 dev_err(di->dev, "failed to create work queue\n"); 3436 return -ENOMEM; 3437 } 3438 3439 mutex_init(&di->charger_attached_mutex); 3440 3441 /* Init work for HW failure check */ 3442 INIT_DEFERRABLE_WORK(&di->check_hw_failure_work, 3443 ab8500_charger_check_hw_failure_work); 3444 INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work, 3445 ab8500_charger_check_usbchargernotok_work); 3446 3447 INIT_DELAYED_WORK(&di->ac_charger_attached_work, 3448 ab8500_charger_ac_attached_work); 3449 INIT_DELAYED_WORK(&di->usb_charger_attached_work, 3450 ab8500_charger_usb_attached_work); 3451 3452 /* 3453 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog 3454 * logic. That means we have to continously kick the charger 3455 * watchdog even when no charger is connected. This is only 3456 * valid once the AC charger has been enabled. This is 3457 * a bug that is not handled by the algorithm and the 3458 * watchdog have to be kicked by the charger driver 3459 * when the AC charger is disabled 3460 */ 3461 INIT_DEFERRABLE_WORK(&di->kick_wd_work, 3462 ab8500_charger_kick_watchdog_work); 3463 3464 INIT_DEFERRABLE_WORK(&di->check_vbat_work, 3465 ab8500_charger_check_vbat_work); 3466 3467 INIT_DELAYED_WORK(&di->attach_work, 3468 ab8500_charger_usb_link_attach_work); 3469 3470 INIT_DELAYED_WORK(&di->usb_state_changed_work, 3471 ab8500_charger_usb_state_changed_work); 3472 3473 INIT_DELAYED_WORK(&di->vbus_drop_end_work, 3474 ab8500_charger_vbus_drop_end_work); 3475 3476 /* Init work for charger detection */ 3477 INIT_WORK(&di->usb_link_status_work, 3478 ab8500_charger_usb_link_status_work); 3479 INIT_WORK(&di->ac_work, ab8500_charger_ac_work); 3480 INIT_WORK(&di->detect_usb_type_work, 3481 ab8500_charger_detect_usb_type_work); 3482 3483 /* Init work for checking HW status */ 3484 INIT_WORK(&di->check_main_thermal_prot_work, 3485 ab8500_charger_check_main_thermal_prot_work); 3486 INIT_WORK(&di->check_usb_thermal_prot_work, 3487 ab8500_charger_check_usb_thermal_prot_work); 3488 3489 /* 3490 * VDD ADC supply needs to be enabled from this driver when there 3491 * is a charger connected to avoid erroneous BTEMP_HIGH/LOW 3492 * interrupts during charging 3493 */ 3494 di->regu = devm_regulator_get(di->dev, "vddadc"); 3495 if (IS_ERR(di->regu)) { 3496 ret = PTR_ERR(di->regu); 3497 dev_err(di->dev, "failed to get vddadc regulator\n"); 3498 goto free_charger_wq; 3499 } 3500 3501 3502 /* Initialize OVV, and other registers */ 3503 ret = ab8500_charger_init_hw_registers(di); 3504 if (ret) { 3505 dev_err(di->dev, "failed to initialize ABB registers\n"); 3506 goto free_charger_wq; 3507 } 3508 3509 /* Register AC charger class */ 3510 if (di->ac_chg.enabled) { 3511 di->ac_chg.psy = power_supply_register(di->dev, 3512 &ab8500_ac_chg_desc, 3513 &ac_psy_cfg); 3514 if (IS_ERR(di->ac_chg.psy)) { 3515 dev_err(di->dev, "failed to register AC charger\n"); 3516 ret = PTR_ERR(di->ac_chg.psy); 3517 goto free_charger_wq; 3518 } 3519 } 3520 3521 /* Register USB charger class */ 3522 if (di->usb_chg.enabled) { 3523 di->usb_chg.psy = power_supply_register(di->dev, 3524 &ab8500_usb_chg_desc, 3525 &usb_psy_cfg); 3526 if (IS_ERR(di->usb_chg.psy)) { 3527 dev_err(di->dev, "failed to register USB charger\n"); 3528 ret = PTR_ERR(di->usb_chg.psy); 3529 goto free_ac; 3530 } 3531 } 3532 3533 di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2); 3534 if (IS_ERR_OR_NULL(di->usb_phy)) { 3535 dev_err(di->dev, "failed to get usb transceiver\n"); 3536 ret = -EINVAL; 3537 goto free_usb; 3538 } 3539 di->nb.notifier_call = ab8500_charger_usb_notifier_call; 3540 ret = usb_register_notifier(di->usb_phy, &di->nb); 3541 if (ret) { 3542 dev_err(di->dev, "failed to register usb notifier\n"); 3543 goto put_usb_phy; 3544 } 3545 3546 /* Identify the connected charger types during startup */ 3547 charger_status = ab8500_charger_detect_chargers(di, true); 3548 if (charger_status & AC_PW_CONN) { 3549 di->ac.charger_connected = 1; 3550 di->ac_conn = true; 3551 ab8500_power_supply_changed(di, di->ac_chg.psy); 3552 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present"); 3553 } 3554 3555 if (charger_status & USB_PW_CONN) { 3556 di->vbus_detected = true; 3557 di->vbus_detected_start = true; 3558 queue_work(di->charger_wq, 3559 &di->detect_usb_type_work); 3560 } 3561 3562 /* Register interrupts */ 3563 for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) { 3564 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name); 3565 ret = request_threaded_irq(irq, NULL, ab8500_charger_irq[i].isr, 3566 IRQF_SHARED | IRQF_NO_SUSPEND, 3567 ab8500_charger_irq[i].name, di); 3568 3569 if (ret != 0) { 3570 dev_err(di->dev, "failed to request %s IRQ %d: %d\n" 3571 , ab8500_charger_irq[i].name, irq, ret); 3572 goto free_irq; 3573 } 3574 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n", 3575 ab8500_charger_irq[i].name, irq, ret); 3576 } 3577 3578 platform_set_drvdata(pdev, di); 3579 3580 mutex_lock(&di->charger_attached_mutex); 3581 3582 ch_stat = ab8500_charger_detect_chargers(di, false); 3583 3584 if ((ch_stat & AC_PW_CONN) == AC_PW_CONN) { 3585 if (is_ab8500(di->parent)) 3586 queue_delayed_work(di->charger_wq, 3587 &di->ac_charger_attached_work, 3588 HZ); 3589 } 3590 if ((ch_stat & USB_PW_CONN) == USB_PW_CONN) { 3591 if (is_ab8500(di->parent)) 3592 queue_delayed_work(di->charger_wq, 3593 &di->usb_charger_attached_work, 3594 HZ); 3595 } 3596 3597 mutex_unlock(&di->charger_attached_mutex); 3598 3599 return ret; 3600 3601 free_irq: 3602 usb_unregister_notifier(di->usb_phy, &di->nb); 3603 3604 /* We also have to free all successfully registered irqs */ 3605 for (i = i - 1; i >= 0; i--) { 3606 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name); 3607 free_irq(irq, di); 3608 } 3609 put_usb_phy: 3610 usb_put_phy(di->usb_phy); 3611 free_usb: 3612 if (di->usb_chg.enabled) 3613 power_supply_unregister(di->usb_chg.psy); 3614 free_ac: 3615 if (di->ac_chg.enabled) 3616 power_supply_unregister(di->ac_chg.psy); 3617 free_charger_wq: 3618 destroy_workqueue(di->charger_wq); 3619 return ret; 3620 } 3621 3622 static const struct of_device_id ab8500_charger_match[] = { 3623 { .compatible = "stericsson,ab8500-charger", }, 3624 { }, 3625 }; 3626 3627 static struct platform_driver ab8500_charger_driver = { 3628 .probe = ab8500_charger_probe, 3629 .remove = ab8500_charger_remove, 3630 .suspend = ab8500_charger_suspend, 3631 .resume = ab8500_charger_resume, 3632 .driver = { 3633 .name = "ab8500-charger", 3634 .of_match_table = ab8500_charger_match, 3635 }, 3636 }; 3637 3638 static int __init ab8500_charger_init(void) 3639 { 3640 return platform_driver_register(&ab8500_charger_driver); 3641 } 3642 3643 static void __exit ab8500_charger_exit(void) 3644 { 3645 platform_driver_unregister(&ab8500_charger_driver); 3646 } 3647 3648 subsys_initcall_sync(ab8500_charger_init); 3649 module_exit(ab8500_charger_exit); 3650 3651 MODULE_LICENSE("GPL v2"); 3652 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy"); 3653 MODULE_ALIAS("platform:ab8500-charger"); 3654 MODULE_DESCRIPTION("AB8500 charger management driver"); 3655