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