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