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 class_for_each_device(power_supply_class, NULL, 1953 &di->usb_chg, ab8500_charger_get_ext_psy_data); 1954 1955 /* First run old_vbat is 0. */ 1956 if (di->old_vbat == 0) 1957 di->old_vbat = di->vbat; 1958 1959 if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED && 1960 di->vbat <= VBAT_TRESH_IP_CUR_RED) || 1961 (di->old_vbat > VBAT_TRESH_IP_CUR_RED && 1962 di->vbat > VBAT_TRESH_IP_CUR_RED))) { 1963 1964 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d," 1965 " old: %d\n", di->max_usb_in_curr.usb_type_max_ua, 1966 di->vbat, di->old_vbat); 1967 ab8500_charger_set_vbus_in_curr(di, 1968 di->max_usb_in_curr.usb_type_max_ua); 1969 power_supply_changed(di->usb_chg.psy); 1970 } 1971 1972 di->old_vbat = di->vbat; 1973 1974 /* 1975 * No need to check the battery voltage every second when not close to 1976 * the threshold. 1977 */ 1978 if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100000) && 1979 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100000))) 1980 t = 1; 1981 1982 queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ); 1983 } 1984 1985 /** 1986 * ab8500_charger_check_hw_failure_work() - check main charger failure 1987 * @work: pointer to the work_struct structure 1988 * 1989 * Work queue function for checking the main charger status 1990 */ 1991 static void ab8500_charger_check_hw_failure_work(struct work_struct *work) 1992 { 1993 int ret; 1994 u8 reg_value; 1995 1996 struct ab8500_charger *di = container_of(work, 1997 struct ab8500_charger, check_hw_failure_work.work); 1998 1999 /* Check if the status bits for HW failure is still active */ 2000 if (di->flags.mainextchnotok) { 2001 ret = abx500_get_register_interruptible(di->dev, 2002 AB8500_CHARGER, AB8500_CH_STATUS2_REG, ®_value); 2003 if (ret < 0) { 2004 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2005 return; 2006 } 2007 if (!(reg_value & MAIN_CH_NOK)) { 2008 di->flags.mainextchnotok = false; 2009 ab8500_power_supply_changed(di, di->ac_chg.psy); 2010 } 2011 } 2012 if (di->flags.vbus_ovv) { 2013 ret = abx500_get_register_interruptible(di->dev, 2014 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, 2015 ®_value); 2016 if (ret < 0) { 2017 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2018 return; 2019 } 2020 if (!(reg_value & VBUS_OVV_TH)) { 2021 di->flags.vbus_ovv = false; 2022 ab8500_power_supply_changed(di, di->usb_chg.psy); 2023 } 2024 } 2025 /* If we still have a failure, schedule a new check */ 2026 if (di->flags.mainextchnotok || di->flags.vbus_ovv) { 2027 queue_delayed_work(di->charger_wq, 2028 &di->check_hw_failure_work, round_jiffies(HZ)); 2029 } 2030 } 2031 2032 /** 2033 * ab8500_charger_kick_watchdog_work() - kick the watchdog 2034 * @work: pointer to the work_struct structure 2035 * 2036 * Work queue function for kicking the charger watchdog. 2037 * 2038 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog 2039 * logic. That means we have to continuously kick the charger 2040 * watchdog even when no charger is connected. This is only 2041 * valid once the AC charger has been enabled. This is 2042 * a bug that is not handled by the algorithm and the 2043 * watchdog have to be kicked by the charger driver 2044 * when the AC charger is disabled 2045 */ 2046 static void ab8500_charger_kick_watchdog_work(struct work_struct *work) 2047 { 2048 int ret; 2049 2050 struct ab8500_charger *di = container_of(work, 2051 struct ab8500_charger, kick_wd_work.work); 2052 2053 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 2054 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK); 2055 if (ret) 2056 dev_err(di->dev, "Failed to kick WD!\n"); 2057 2058 /* Schedule a new watchdog kick */ 2059 queue_delayed_work(di->charger_wq, 2060 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL)); 2061 } 2062 2063 /** 2064 * ab8500_charger_ac_work() - work to get and set main charger status 2065 * @work: pointer to the work_struct structure 2066 * 2067 * Work queue function for checking the main charger status 2068 */ 2069 static void ab8500_charger_ac_work(struct work_struct *work) 2070 { 2071 int ret; 2072 2073 struct ab8500_charger *di = container_of(work, 2074 struct ab8500_charger, ac_work); 2075 2076 /* 2077 * Since we can't be sure that the events are received 2078 * synchronously, we have the check if the main charger is 2079 * connected by reading the status register 2080 */ 2081 ret = ab8500_charger_detect_chargers(di, false); 2082 if (ret < 0) 2083 return; 2084 2085 if (ret & AC_PW_CONN) { 2086 di->ac.charger_connected = 1; 2087 di->ac_conn = true; 2088 } else { 2089 di->ac.charger_connected = 0; 2090 } 2091 2092 ab8500_power_supply_changed(di, di->ac_chg.psy); 2093 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present"); 2094 } 2095 2096 static void ab8500_charger_usb_attached_work(struct work_struct *work) 2097 { 2098 struct ab8500_charger *di = container_of(work, 2099 struct ab8500_charger, 2100 usb_charger_attached_work.work); 2101 int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC); 2102 int ret, i; 2103 u8 statval; 2104 2105 for (i = 0; i < 10; i++) { 2106 ret = abx500_get_register_interruptible(di->dev, 2107 AB8500_CHARGER, 2108 AB8500_CH_USBCH_STAT1_REG, 2109 &statval); 2110 if (ret < 0) { 2111 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__); 2112 goto reschedule; 2113 } 2114 if ((statval & usbch) != usbch) 2115 goto reschedule; 2116 2117 msleep(CHARGER_STATUS_POLL); 2118 } 2119 2120 ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0); 2121 2122 mutex_lock(&di->charger_attached_mutex); 2123 mutex_unlock(&di->charger_attached_mutex); 2124 2125 return; 2126 2127 reschedule: 2128 queue_delayed_work(di->charger_wq, 2129 &di->usb_charger_attached_work, 2130 HZ); 2131 } 2132 2133 static void ab8500_charger_ac_attached_work(struct work_struct *work) 2134 { 2135 2136 struct ab8500_charger *di = container_of(work, 2137 struct ab8500_charger, 2138 ac_charger_attached_work.work); 2139 int mainch = (MAIN_CH_STATUS2_MAINCHGDROP | 2140 MAIN_CH_STATUS2_MAINCHARGERDETDBNC); 2141 int ret, i; 2142 u8 statval; 2143 2144 for (i = 0; i < 10; i++) { 2145 ret = abx500_get_register_interruptible(di->dev, 2146 AB8500_CHARGER, 2147 AB8500_CH_STATUS2_REG, 2148 &statval); 2149 if (ret < 0) { 2150 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__); 2151 goto reschedule; 2152 } 2153 2154 if ((statval & mainch) != mainch) 2155 goto reschedule; 2156 2157 msleep(CHARGER_STATUS_POLL); 2158 } 2159 2160 ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0); 2161 queue_work(di->charger_wq, &di->ac_work); 2162 2163 mutex_lock(&di->charger_attached_mutex); 2164 mutex_unlock(&di->charger_attached_mutex); 2165 2166 return; 2167 2168 reschedule: 2169 queue_delayed_work(di->charger_wq, 2170 &di->ac_charger_attached_work, 2171 HZ); 2172 } 2173 2174 /** 2175 * ab8500_charger_detect_usb_type_work() - work to detect USB type 2176 * @work: Pointer to the work_struct structure 2177 * 2178 * Detect the type of USB plugged 2179 */ 2180 static void ab8500_charger_detect_usb_type_work(struct work_struct *work) 2181 { 2182 int ret; 2183 2184 struct ab8500_charger *di = container_of(work, 2185 struct ab8500_charger, detect_usb_type_work); 2186 2187 /* 2188 * Since we can't be sure that the events are received 2189 * synchronously, we have the check if is 2190 * connected by reading the status register 2191 */ 2192 ret = ab8500_charger_detect_chargers(di, false); 2193 if (ret < 0) 2194 return; 2195 2196 if (!(ret & USB_PW_CONN)) { 2197 dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__); 2198 di->vbus_detected = false; 2199 ab8500_charger_set_usb_connected(di, false); 2200 ab8500_power_supply_changed(di, di->usb_chg.psy); 2201 } else { 2202 dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__); 2203 di->vbus_detected = true; 2204 2205 if (is_ab8500_1p1_or_earlier(di->parent)) { 2206 ret = ab8500_charger_detect_usb_type(di); 2207 if (!ret) { 2208 ab8500_charger_set_usb_connected(di, true); 2209 ab8500_power_supply_changed(di, 2210 di->usb_chg.psy); 2211 } 2212 } else { 2213 /* 2214 * For ABB cut2.0 and onwards we have an IRQ, 2215 * USB_LINK_STATUS that will be triggered when the USB 2216 * link status changes. The exception is USB connected 2217 * during startup. Then we don't get a 2218 * USB_LINK_STATUS IRQ 2219 */ 2220 if (di->vbus_detected_start) { 2221 di->vbus_detected_start = false; 2222 ret = ab8500_charger_detect_usb_type(di); 2223 if (!ret) { 2224 ab8500_charger_set_usb_connected(di, 2225 true); 2226 ab8500_power_supply_changed(di, 2227 di->usb_chg.psy); 2228 } 2229 } 2230 } 2231 } 2232 } 2233 2234 /** 2235 * ab8500_charger_usb_link_attach_work() - work to detect USB type 2236 * @work: pointer to the work_struct structure 2237 * 2238 * Detect the type of USB plugged 2239 */ 2240 static void ab8500_charger_usb_link_attach_work(struct work_struct *work) 2241 { 2242 struct ab8500_charger *di = 2243 container_of(work, struct ab8500_charger, attach_work.work); 2244 int ret; 2245 2246 /* Update maximum input current if USB enumeration is not detected */ 2247 if (!di->usb.charger_online) { 2248 ret = ab8500_charger_set_vbus_in_curr(di, 2249 di->max_usb_in_curr.usb_type_max_ua); 2250 if (ret) 2251 return; 2252 } 2253 2254 ab8500_charger_set_usb_connected(di, true); 2255 ab8500_power_supply_changed(di, di->usb_chg.psy); 2256 } 2257 2258 /** 2259 * ab8500_charger_usb_link_status_work() - work to detect USB type 2260 * @work: pointer to the work_struct structure 2261 * 2262 * Detect the type of USB plugged 2263 */ 2264 static void ab8500_charger_usb_link_status_work(struct work_struct *work) 2265 { 2266 int detected_chargers; 2267 int ret; 2268 u8 val; 2269 u8 link_status; 2270 2271 struct ab8500_charger *di = container_of(work, 2272 struct ab8500_charger, usb_link_status_work); 2273 2274 /* 2275 * Since we can't be sure that the events are received 2276 * synchronously, we have the check if is 2277 * connected by reading the status register 2278 */ 2279 detected_chargers = ab8500_charger_detect_chargers(di, false); 2280 if (detected_chargers < 0) 2281 return; 2282 2283 /* 2284 * Some chargers that breaks the USB spec is 2285 * identified as invalid by AB8500 and it refuse 2286 * to start the charging process. but by jumping 2287 * through a few hoops it can be forced to start. 2288 */ 2289 if (is_ab8500(di->parent)) 2290 ret = abx500_get_register_interruptible(di->dev, AB8500_USB, 2291 AB8500_USB_LINE_STAT_REG, &val); 2292 else 2293 ret = abx500_get_register_interruptible(di->dev, AB8500_USB, 2294 AB8500_USB_LINK1_STAT_REG, &val); 2295 2296 if (ret >= 0) 2297 dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val); 2298 else 2299 dev_dbg(di->dev, "Error reading USB link status\n"); 2300 2301 if (is_ab8500(di->parent)) 2302 link_status = AB8500_USB_LINK_STATUS; 2303 else 2304 link_status = AB8505_USB_LINK_STATUS; 2305 2306 if (detected_chargers & USB_PW_CONN) { 2307 if (((val & link_status) >> USB_LINK_STATUS_SHIFT) == 2308 USB_STAT_NOT_VALID_LINK && 2309 di->invalid_charger_detect_state == 0) { 2310 dev_dbg(di->dev, 2311 "Invalid charger detected, state= 0\n"); 2312 /*Enable charger*/ 2313 abx500_mask_and_set_register_interruptible(di->dev, 2314 AB8500_CHARGER, AB8500_USBCH_CTRL1_REG, 2315 USB_CH_ENA, USB_CH_ENA); 2316 /*Enable charger detection*/ 2317 abx500_mask_and_set_register_interruptible(di->dev, 2318 AB8500_USB, AB8500_USB_LINE_CTRL2_REG, 2319 USB_CH_DET, USB_CH_DET); 2320 di->invalid_charger_detect_state = 1; 2321 /*exit and wait for new link status interrupt.*/ 2322 return; 2323 2324 } 2325 if (di->invalid_charger_detect_state == 1) { 2326 dev_dbg(di->dev, 2327 "Invalid charger detected, state= 1\n"); 2328 /*Stop charger detection*/ 2329 abx500_mask_and_set_register_interruptible(di->dev, 2330 AB8500_USB, AB8500_USB_LINE_CTRL2_REG, 2331 USB_CH_DET, 0x00); 2332 /*Check link status*/ 2333 if (is_ab8500(di->parent)) 2334 ret = abx500_get_register_interruptible(di->dev, 2335 AB8500_USB, AB8500_USB_LINE_STAT_REG, 2336 &val); 2337 else 2338 ret = abx500_get_register_interruptible(di->dev, 2339 AB8500_USB, AB8500_USB_LINK1_STAT_REG, 2340 &val); 2341 2342 dev_dbg(di->dev, "USB link status= 0x%02x\n", 2343 (val & link_status) >> USB_LINK_STATUS_SHIFT); 2344 di->invalid_charger_detect_state = 2; 2345 } 2346 } else { 2347 di->invalid_charger_detect_state = 0; 2348 } 2349 2350 if (!(detected_chargers & USB_PW_CONN)) { 2351 di->vbus_detected = false; 2352 ab8500_charger_set_usb_connected(di, false); 2353 ab8500_power_supply_changed(di, di->usb_chg.psy); 2354 return; 2355 } 2356 2357 dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__); 2358 di->vbus_detected = true; 2359 ret = ab8500_charger_read_usb_type(di); 2360 if (ret) { 2361 if (ret == -ENXIO) { 2362 /* No valid charger type detected */ 2363 ab8500_charger_set_usb_connected(di, false); 2364 ab8500_power_supply_changed(di, di->usb_chg.psy); 2365 } 2366 return; 2367 } 2368 2369 if (di->usb_device_is_unrecognised) { 2370 dev_dbg(di->dev, 2371 "Potential Legacy Charger device. " 2372 "Delay work for %d msec for USB enum " 2373 "to finish", 2374 WAIT_ACA_RID_ENUMERATION); 2375 queue_delayed_work(di->charger_wq, 2376 &di->attach_work, 2377 msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION)); 2378 } else if (di->is_aca_rid == 1) { 2379 /* Only wait once */ 2380 di->is_aca_rid++; 2381 dev_dbg(di->dev, 2382 "%s Wait %d msec for USB enum to finish", 2383 __func__, WAIT_ACA_RID_ENUMERATION); 2384 queue_delayed_work(di->charger_wq, 2385 &di->attach_work, 2386 msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION)); 2387 } else { 2388 queue_delayed_work(di->charger_wq, 2389 &di->attach_work, 2390 0); 2391 } 2392 } 2393 2394 static void ab8500_charger_usb_state_changed_work(struct work_struct *work) 2395 { 2396 int ret; 2397 unsigned long flags; 2398 2399 struct ab8500_charger *di = container_of(work, 2400 struct ab8500_charger, usb_state_changed_work.work); 2401 2402 if (!di->vbus_detected) { 2403 dev_dbg(di->dev, 2404 "%s !di->vbus_detected\n", 2405 __func__); 2406 return; 2407 } 2408 2409 spin_lock_irqsave(&di->usb_state.usb_lock, flags); 2410 di->usb_state.state = di->usb_state.state_tmp; 2411 di->usb_state.usb_current_ua = di->usb_state.usb_current_tmp_ua; 2412 spin_unlock_irqrestore(&di->usb_state.usb_lock, flags); 2413 2414 dev_dbg(di->dev, "%s USB state: 0x%02x uA: %d\n", 2415 __func__, di->usb_state.state, di->usb_state.usb_current_ua); 2416 2417 switch (di->usb_state.state) { 2418 case AB8500_BM_USB_STATE_RESET_HS: 2419 case AB8500_BM_USB_STATE_RESET_FS: 2420 case AB8500_BM_USB_STATE_SUSPEND: 2421 case AB8500_BM_USB_STATE_MAX: 2422 ab8500_charger_set_usb_connected(di, false); 2423 ab8500_power_supply_changed(di, di->usb_chg.psy); 2424 break; 2425 2426 case AB8500_BM_USB_STATE_RESUME: 2427 /* 2428 * when suspend->resume there should be delay 2429 * of 1sec for enabling charging 2430 */ 2431 msleep(1000); 2432 fallthrough; 2433 case AB8500_BM_USB_STATE_CONFIGURED: 2434 /* 2435 * USB is configured, enable charging with the charging 2436 * input current obtained from USB driver 2437 */ 2438 if (!ab8500_charger_get_usb_cur(di)) { 2439 /* Update maximum input current */ 2440 ret = ab8500_charger_set_vbus_in_curr(di, 2441 di->max_usb_in_curr.usb_type_max_ua); 2442 if (ret) 2443 return; 2444 2445 ab8500_charger_set_usb_connected(di, true); 2446 ab8500_power_supply_changed(di, di->usb_chg.psy); 2447 } 2448 break; 2449 2450 default: 2451 break; 2452 } 2453 } 2454 2455 /** 2456 * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status 2457 * @work: pointer to the work_struct structure 2458 * 2459 * Work queue function for checking the USB charger Not OK status 2460 */ 2461 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work) 2462 { 2463 int ret; 2464 u8 reg_value; 2465 bool prev_status; 2466 2467 struct ab8500_charger *di = container_of(work, 2468 struct ab8500_charger, check_usbchgnotok_work.work); 2469 2470 /* Check if the status bit for usbchargernotok is still active */ 2471 ret = abx500_get_register_interruptible(di->dev, 2472 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, ®_value); 2473 if (ret < 0) { 2474 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2475 return; 2476 } 2477 prev_status = di->flags.usbchargernotok; 2478 2479 if (reg_value & VBUS_CH_NOK) { 2480 di->flags.usbchargernotok = true; 2481 /* Check again in 1sec */ 2482 queue_delayed_work(di->charger_wq, 2483 &di->check_usbchgnotok_work, HZ); 2484 } else { 2485 di->flags.usbchargernotok = false; 2486 di->flags.vbus_collapse = false; 2487 } 2488 2489 if (prev_status != di->flags.usbchargernotok) 2490 ab8500_power_supply_changed(di, di->usb_chg.psy); 2491 } 2492 2493 /** 2494 * ab8500_charger_check_main_thermal_prot_work() - check main thermal status 2495 * @work: pointer to the work_struct structure 2496 * 2497 * Work queue function for checking the Main thermal prot status 2498 */ 2499 static void ab8500_charger_check_main_thermal_prot_work( 2500 struct work_struct *work) 2501 { 2502 int ret; 2503 u8 reg_value; 2504 2505 struct ab8500_charger *di = container_of(work, 2506 struct ab8500_charger, check_main_thermal_prot_work); 2507 2508 /* Check if the status bit for main_thermal_prot is still active */ 2509 ret = abx500_get_register_interruptible(di->dev, 2510 AB8500_CHARGER, AB8500_CH_STATUS2_REG, ®_value); 2511 if (ret < 0) { 2512 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2513 return; 2514 } 2515 if (reg_value & MAIN_CH_TH_PROT) 2516 di->flags.main_thermal_prot = true; 2517 else 2518 di->flags.main_thermal_prot = false; 2519 2520 ab8500_power_supply_changed(di, di->ac_chg.psy); 2521 } 2522 2523 /** 2524 * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status 2525 * @work: pointer to the work_struct structure 2526 * 2527 * Work queue function for checking the USB thermal prot status 2528 */ 2529 static void ab8500_charger_check_usb_thermal_prot_work( 2530 struct work_struct *work) 2531 { 2532 int ret; 2533 u8 reg_value; 2534 2535 struct ab8500_charger *di = container_of(work, 2536 struct ab8500_charger, check_usb_thermal_prot_work); 2537 2538 /* Check if the status bit for usb_thermal_prot is still active */ 2539 ret = abx500_get_register_interruptible(di->dev, 2540 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, ®_value); 2541 if (ret < 0) { 2542 dev_err(di->dev, "%s ab8500 read failed\n", __func__); 2543 return; 2544 } 2545 if (reg_value & USB_CH_TH_PROT) 2546 di->flags.usb_thermal_prot = true; 2547 else 2548 di->flags.usb_thermal_prot = false; 2549 2550 ab8500_power_supply_changed(di, di->usb_chg.psy); 2551 } 2552 2553 /** 2554 * ab8500_charger_mainchunplugdet_handler() - main charger unplugged 2555 * @irq: interrupt number 2556 * @_di: pointer to the ab8500_charger structure 2557 * 2558 * Returns IRQ status(IRQ_HANDLED) 2559 */ 2560 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di) 2561 { 2562 struct ab8500_charger *di = _di; 2563 2564 dev_dbg(di->dev, "Main charger unplugged\n"); 2565 queue_work(di->charger_wq, &di->ac_work); 2566 2567 cancel_delayed_work_sync(&di->ac_charger_attached_work); 2568 mutex_lock(&di->charger_attached_mutex); 2569 mutex_unlock(&di->charger_attached_mutex); 2570 2571 return IRQ_HANDLED; 2572 } 2573 2574 /** 2575 * ab8500_charger_mainchplugdet_handler() - main charger plugged 2576 * @irq: interrupt number 2577 * @_di: pointer to the ab8500_charger structure 2578 * 2579 * Returns IRQ status(IRQ_HANDLED) 2580 */ 2581 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di) 2582 { 2583 struct ab8500_charger *di = _di; 2584 2585 dev_dbg(di->dev, "Main charger plugged\n"); 2586 queue_work(di->charger_wq, &di->ac_work); 2587 2588 mutex_lock(&di->charger_attached_mutex); 2589 mutex_unlock(&di->charger_attached_mutex); 2590 2591 if (is_ab8500(di->parent)) 2592 queue_delayed_work(di->charger_wq, 2593 &di->ac_charger_attached_work, 2594 HZ); 2595 return IRQ_HANDLED; 2596 } 2597 2598 /** 2599 * ab8500_charger_mainextchnotok_handler() - main charger not ok 2600 * @irq: interrupt number 2601 * @_di: pointer to the ab8500_charger structure 2602 * 2603 * Returns IRQ status(IRQ_HANDLED) 2604 */ 2605 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di) 2606 { 2607 struct ab8500_charger *di = _di; 2608 2609 dev_dbg(di->dev, "Main charger not ok\n"); 2610 di->flags.mainextchnotok = true; 2611 ab8500_power_supply_changed(di, di->ac_chg.psy); 2612 2613 /* Schedule a new HW failure check */ 2614 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0); 2615 2616 return IRQ_HANDLED; 2617 } 2618 2619 /** 2620 * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger 2621 * thermal protection threshold 2622 * @irq: interrupt number 2623 * @_di: pointer to the ab8500_charger structure 2624 * 2625 * Returns IRQ status(IRQ_HANDLED) 2626 */ 2627 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di) 2628 { 2629 struct ab8500_charger *di = _di; 2630 2631 dev_dbg(di->dev, 2632 "Die temp above Main charger thermal protection threshold\n"); 2633 queue_work(di->charger_wq, &di->check_main_thermal_prot_work); 2634 2635 return IRQ_HANDLED; 2636 } 2637 2638 /** 2639 * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger 2640 * thermal protection threshold 2641 * @irq: interrupt number 2642 * @_di: pointer to the ab8500_charger structure 2643 * 2644 * Returns IRQ status(IRQ_HANDLED) 2645 */ 2646 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di) 2647 { 2648 struct ab8500_charger *di = _di; 2649 2650 dev_dbg(di->dev, 2651 "Die temp ok for Main charger thermal protection threshold\n"); 2652 queue_work(di->charger_wq, &di->check_main_thermal_prot_work); 2653 2654 return IRQ_HANDLED; 2655 } 2656 2657 static void ab8500_charger_vbus_drop_end_work(struct work_struct *work) 2658 { 2659 struct ab8500_charger *di = container_of(work, 2660 struct ab8500_charger, vbus_drop_end_work.work); 2661 int ret, curr_ua; 2662 u8 reg_value; 2663 2664 di->flags.vbus_drop_end = false; 2665 2666 /* Reset the drop counter */ 2667 abx500_set_register_interruptible(di->dev, 2668 AB8500_CHARGER, AB8500_CHARGER_CTRL, 0x01); 2669 2670 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER, 2671 AB8500_CH_USBCH_STAT2_REG, ®_value); 2672 if (ret < 0) { 2673 dev_err(di->dev, "%s read failed\n", __func__); 2674 return; 2675 } 2676 2677 curr_ua = ab8500_charge_input_curr_map[ 2678 reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT]; 2679 2680 if (di->max_usb_in_curr.calculated_max_ua != curr_ua) { 2681 /* USB source is collapsing */ 2682 di->max_usb_in_curr.calculated_max_ua = curr_ua; 2683 dev_dbg(di->dev, 2684 "VBUS input current limiting to %d uA\n", 2685 di->max_usb_in_curr.calculated_max_ua); 2686 } else { 2687 /* 2688 * USB source can not give more than this amount. 2689 * Taking more will collapse the source. 2690 */ 2691 di->max_usb_in_curr.set_max_ua = 2692 di->max_usb_in_curr.calculated_max_ua; 2693 dev_dbg(di->dev, 2694 "VBUS input current limited to %d uA\n", 2695 di->max_usb_in_curr.set_max_ua); 2696 } 2697 2698 if (di->usb.charger_connected) 2699 ab8500_charger_set_vbus_in_curr(di, 2700 di->max_usb_in_curr.usb_type_max_ua); 2701 } 2702 2703 /** 2704 * ab8500_charger_vbusdetf_handler() - VBUS falling detected 2705 * @irq: interrupt number 2706 * @_di: pointer to the ab8500_charger structure 2707 * 2708 * Returns IRQ status(IRQ_HANDLED) 2709 */ 2710 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di) 2711 { 2712 struct ab8500_charger *di = _di; 2713 2714 di->vbus_detected = false; 2715 dev_dbg(di->dev, "VBUS falling detected\n"); 2716 queue_work(di->charger_wq, &di->detect_usb_type_work); 2717 2718 return IRQ_HANDLED; 2719 } 2720 2721 /** 2722 * ab8500_charger_vbusdetr_handler() - VBUS rising detected 2723 * @irq: interrupt number 2724 * @_di: pointer to the ab8500_charger structure 2725 * 2726 * Returns IRQ status(IRQ_HANDLED) 2727 */ 2728 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di) 2729 { 2730 struct ab8500_charger *di = _di; 2731 2732 di->vbus_detected = true; 2733 dev_dbg(di->dev, "VBUS rising detected\n"); 2734 2735 queue_work(di->charger_wq, &di->detect_usb_type_work); 2736 2737 return IRQ_HANDLED; 2738 } 2739 2740 /** 2741 * ab8500_charger_usblinkstatus_handler() - USB link status has changed 2742 * @irq: interrupt number 2743 * @_di: pointer to the ab8500_charger structure 2744 * 2745 * Returns IRQ status(IRQ_HANDLED) 2746 */ 2747 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di) 2748 { 2749 struct ab8500_charger *di = _di; 2750 2751 dev_dbg(di->dev, "USB link status changed\n"); 2752 2753 queue_work(di->charger_wq, &di->usb_link_status_work); 2754 2755 return IRQ_HANDLED; 2756 } 2757 2758 /** 2759 * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger 2760 * thermal protection threshold 2761 * @irq: interrupt number 2762 * @_di: pointer to the ab8500_charger structure 2763 * 2764 * Returns IRQ status(IRQ_HANDLED) 2765 */ 2766 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di) 2767 { 2768 struct ab8500_charger *di = _di; 2769 2770 dev_dbg(di->dev, 2771 "Die temp above USB charger thermal protection threshold\n"); 2772 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work); 2773 2774 return IRQ_HANDLED; 2775 } 2776 2777 /** 2778 * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger 2779 * thermal protection threshold 2780 * @irq: interrupt number 2781 * @_di: pointer to the ab8500_charger structure 2782 * 2783 * Returns IRQ status(IRQ_HANDLED) 2784 */ 2785 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di) 2786 { 2787 struct ab8500_charger *di = _di; 2788 2789 dev_dbg(di->dev, 2790 "Die temp ok for USB charger thermal protection threshold\n"); 2791 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work); 2792 2793 return IRQ_HANDLED; 2794 } 2795 2796 /** 2797 * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected 2798 * @irq: interrupt number 2799 * @_di: pointer to the ab8500_charger structure 2800 * 2801 * Returns IRQ status(IRQ_HANDLED) 2802 */ 2803 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di) 2804 { 2805 struct ab8500_charger *di = _di; 2806 2807 dev_dbg(di->dev, "Not allowed USB charger detected\n"); 2808 queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0); 2809 2810 return IRQ_HANDLED; 2811 } 2812 2813 /** 2814 * ab8500_charger_chwdexp_handler() - Charger watchdog expired 2815 * @irq: interrupt number 2816 * @_di: pointer to the ab8500_charger structure 2817 * 2818 * Returns IRQ status(IRQ_HANDLED) 2819 */ 2820 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di) 2821 { 2822 struct ab8500_charger *di = _di; 2823 2824 dev_dbg(di->dev, "Charger watchdog expired\n"); 2825 2826 /* 2827 * The charger that was online when the watchdog expired 2828 * needs to be restarted for charging to start again 2829 */ 2830 if (di->ac.charger_online) { 2831 di->ac.wd_expired = true; 2832 ab8500_power_supply_changed(di, di->ac_chg.psy); 2833 } 2834 if (di->usb.charger_online) { 2835 di->usb.wd_expired = true; 2836 ab8500_power_supply_changed(di, di->usb_chg.psy); 2837 } 2838 2839 return IRQ_HANDLED; 2840 } 2841 2842 /** 2843 * ab8500_charger_vbuschdropend_handler() - VBUS drop removed 2844 * @irq: interrupt number 2845 * @_di: pointer to the ab8500_charger structure 2846 * 2847 * Returns IRQ status(IRQ_HANDLED) 2848 */ 2849 static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di) 2850 { 2851 struct ab8500_charger *di = _di; 2852 2853 dev_dbg(di->dev, "VBUS charger drop ended\n"); 2854 di->flags.vbus_drop_end = true; 2855 2856 /* 2857 * VBUS might have dropped due to bad connection. 2858 * Schedule a new input limit set to the value SW requests. 2859 */ 2860 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 2861 round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ)); 2862 2863 return IRQ_HANDLED; 2864 } 2865 2866 /** 2867 * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected 2868 * @irq: interrupt number 2869 * @_di: pointer to the ab8500_charger structure 2870 * 2871 * Returns IRQ status(IRQ_HANDLED) 2872 */ 2873 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di) 2874 { 2875 struct ab8500_charger *di = _di; 2876 2877 dev_dbg(di->dev, "VBUS overvoltage detected\n"); 2878 di->flags.vbus_ovv = true; 2879 ab8500_power_supply_changed(di, di->usb_chg.psy); 2880 2881 /* Schedule a new HW failure check */ 2882 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0); 2883 2884 return IRQ_HANDLED; 2885 } 2886 2887 /** 2888 * ab8500_charger_ac_get_property() - get the ac/mains properties 2889 * @psy: pointer to the power_supply structure 2890 * @psp: pointer to the power_supply_property structure 2891 * @val: pointer to the power_supply_propval union 2892 * 2893 * This function gets called when an application tries to get the ac/mains 2894 * properties by reading the sysfs files. 2895 * AC/Mains properties are online, present and voltage. 2896 * online: ac/mains charging is in progress or not 2897 * present: presence of the ac/mains 2898 * voltage: AC/Mains voltage 2899 * Returns error code in case of failure else 0(on success) 2900 */ 2901 static int ab8500_charger_ac_get_property(struct power_supply *psy, 2902 enum power_supply_property psp, 2903 union power_supply_propval *val) 2904 { 2905 struct ab8500_charger *di; 2906 int ret; 2907 2908 di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy)); 2909 2910 switch (psp) { 2911 case POWER_SUPPLY_PROP_HEALTH: 2912 if (di->flags.mainextchnotok) 2913 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 2914 else if (di->ac.wd_expired || di->usb.wd_expired) 2915 val->intval = POWER_SUPPLY_HEALTH_DEAD; 2916 else if (di->flags.main_thermal_prot) 2917 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 2918 else 2919 val->intval = POWER_SUPPLY_HEALTH_GOOD; 2920 break; 2921 case POWER_SUPPLY_PROP_ONLINE: 2922 val->intval = di->ac.charger_online; 2923 break; 2924 case POWER_SUPPLY_PROP_PRESENT: 2925 val->intval = di->ac.charger_connected; 2926 break; 2927 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 2928 ret = ab8500_charger_get_ac_voltage(di); 2929 if (ret >= 0) 2930 di->ac.charger_voltage_uv = ret; 2931 /* On error, use previous value */ 2932 val->intval = di->ac.charger_voltage_uv; 2933 break; 2934 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 2935 /* 2936 * This property is used to indicate when CV mode is entered 2937 * for the AC charger 2938 */ 2939 di->ac.cv_active = ab8500_charger_ac_cv(di); 2940 val->intval = di->ac.cv_active; 2941 break; 2942 case POWER_SUPPLY_PROP_CURRENT_NOW: 2943 ret = ab8500_charger_get_ac_current(di); 2944 if (ret >= 0) 2945 di->ac.charger_current_ua = ret; 2946 val->intval = di->ac.charger_current_ua; 2947 break; 2948 default: 2949 return -EINVAL; 2950 } 2951 return 0; 2952 } 2953 2954 /** 2955 * ab8500_charger_usb_get_property() - get the usb properties 2956 * @psy: pointer to the power_supply structure 2957 * @psp: pointer to the power_supply_property structure 2958 * @val: pointer to the power_supply_propval union 2959 * 2960 * This function gets called when an application tries to get the usb 2961 * properties by reading the sysfs files. 2962 * USB properties are online, present and voltage. 2963 * online: usb charging is in progress or not 2964 * present: presence of the usb 2965 * voltage: vbus voltage 2966 * Returns error code in case of failure else 0(on success) 2967 */ 2968 static int ab8500_charger_usb_get_property(struct power_supply *psy, 2969 enum power_supply_property psp, 2970 union power_supply_propval *val) 2971 { 2972 struct ab8500_charger *di; 2973 int ret; 2974 2975 di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy)); 2976 2977 switch (psp) { 2978 case POWER_SUPPLY_PROP_HEALTH: 2979 if (di->flags.usbchargernotok) 2980 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; 2981 else if (di->ac.wd_expired || di->usb.wd_expired) 2982 val->intval = POWER_SUPPLY_HEALTH_DEAD; 2983 else if (di->flags.usb_thermal_prot) 2984 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT; 2985 else if (di->flags.vbus_ovv) 2986 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 2987 else 2988 val->intval = POWER_SUPPLY_HEALTH_GOOD; 2989 break; 2990 case POWER_SUPPLY_PROP_ONLINE: 2991 val->intval = di->usb.charger_online; 2992 break; 2993 case POWER_SUPPLY_PROP_PRESENT: 2994 val->intval = di->usb.charger_connected; 2995 break; 2996 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 2997 ret = ab8500_charger_get_vbus_voltage(di); 2998 if (ret >= 0) 2999 di->usb.charger_voltage_uv = ret; 3000 val->intval = di->usb.charger_voltage_uv; 3001 break; 3002 case POWER_SUPPLY_PROP_VOLTAGE_AVG: 3003 /* 3004 * This property is used to indicate when CV mode is entered 3005 * for the USB charger 3006 */ 3007 di->usb.cv_active = ab8500_charger_usb_cv(di); 3008 val->intval = di->usb.cv_active; 3009 break; 3010 case POWER_SUPPLY_PROP_CURRENT_NOW: 3011 ret = ab8500_charger_get_usb_current(di); 3012 if (ret >= 0) 3013 di->usb.charger_current_ua = ret; 3014 val->intval = di->usb.charger_current_ua; 3015 break; 3016 case POWER_SUPPLY_PROP_CURRENT_AVG: 3017 /* 3018 * This property is used to indicate when VBUS has collapsed 3019 * due to too high output current from the USB charger 3020 */ 3021 if (di->flags.vbus_collapse) 3022 val->intval = 1; 3023 else 3024 val->intval = 0; 3025 break; 3026 default: 3027 return -EINVAL; 3028 } 3029 return 0; 3030 } 3031 3032 /** 3033 * ab8500_charger_init_hw_registers() - Set up charger related registers 3034 * @di: pointer to the ab8500_charger structure 3035 * 3036 * Set up charger OVV, watchdog and maximum voltage registers as well as 3037 * charging of the backup battery 3038 */ 3039 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di) 3040 { 3041 int ret = 0; 3042 3043 /* Setup maximum charger current and voltage for ABB cut2.0 */ 3044 if (!is_ab8500_1p1_or_earlier(di->parent)) { 3045 ret = abx500_set_register_interruptible(di->dev, 3046 AB8500_CHARGER, 3047 AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6); 3048 if (ret) { 3049 dev_err(di->dev, 3050 "failed to set CH_VOLT_LVL_MAX_REG\n"); 3051 goto out; 3052 } 3053 3054 ret = abx500_set_register_interruptible(di->dev, 3055 AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG, 3056 CH_OP_CUR_LVL_1P6); 3057 if (ret) { 3058 dev_err(di->dev, 3059 "failed to set CH_OPT_CRNTLVL_MAX_REG\n"); 3060 goto out; 3061 } 3062 } 3063 3064 if (is_ab8505_2p0(di->parent)) 3065 ret = abx500_mask_and_set_register_interruptible(di->dev, 3066 AB8500_CHARGER, 3067 AB8500_USBCH_CTRL2_REG, 3068 VBUS_AUTO_IN_CURR_LIM_ENA, 3069 VBUS_AUTO_IN_CURR_LIM_ENA); 3070 else 3071 /* 3072 * VBUS OVV set to 6.3V and enable automatic current limitation 3073 */ 3074 ret = abx500_set_register_interruptible(di->dev, 3075 AB8500_CHARGER, 3076 AB8500_USBCH_CTRL2_REG, 3077 VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA); 3078 if (ret) { 3079 dev_err(di->dev, 3080 "failed to set automatic current limitation\n"); 3081 goto out; 3082 } 3083 3084 /* Enable main watchdog in OTP */ 3085 ret = abx500_set_register_interruptible(di->dev, 3086 AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD); 3087 if (ret) { 3088 dev_err(di->dev, "failed to enable main WD in OTP\n"); 3089 goto out; 3090 } 3091 3092 /* Enable main watchdog */ 3093 ret = abx500_set_register_interruptible(di->dev, 3094 AB8500_SYS_CTRL2_BLOCK, 3095 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA); 3096 if (ret) { 3097 dev_err(di->dev, "failed to enable main watchdog\n"); 3098 goto out; 3099 } 3100 3101 /* 3102 * Due to internal synchronisation, Enable and Kick watchdog bits 3103 * cannot be enabled in a single write. 3104 * A minimum delay of 2*32 kHz period (62.5µs) must be inserted 3105 * between writing Enable then Kick bits. 3106 */ 3107 udelay(63); 3108 3109 /* Kick main watchdog */ 3110 ret = abx500_set_register_interruptible(di->dev, 3111 AB8500_SYS_CTRL2_BLOCK, 3112 AB8500_MAIN_WDOG_CTRL_REG, 3113 (MAIN_WDOG_ENA | MAIN_WDOG_KICK)); 3114 if (ret) { 3115 dev_err(di->dev, "failed to kick main watchdog\n"); 3116 goto out; 3117 } 3118 3119 /* Disable main watchdog */ 3120 ret = abx500_set_register_interruptible(di->dev, 3121 AB8500_SYS_CTRL2_BLOCK, 3122 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS); 3123 if (ret) { 3124 dev_err(di->dev, "failed to disable main watchdog\n"); 3125 goto out; 3126 } 3127 3128 /* Set watchdog timeout */ 3129 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 3130 AB8500_CH_WD_TIMER_REG, WD_TIMER); 3131 if (ret) { 3132 dev_err(di->dev, "failed to set charger watchdog timeout\n"); 3133 goto out; 3134 } 3135 3136 ret = ab8500_charger_led_en(di, false); 3137 if (ret < 0) { 3138 dev_err(di->dev, "failed to disable LED\n"); 3139 goto out; 3140 } 3141 3142 ret = abx500_set_register_interruptible(di->dev, 3143 AB8500_RTC, 3144 AB8500_RTC_BACKUP_CHG_REG, 3145 (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i); 3146 if (ret) { 3147 dev_err(di->dev, "failed to setup backup battery charging\n"); 3148 goto out; 3149 } 3150 3151 /* Enable backup battery charging */ 3152 ret = abx500_mask_and_set_register_interruptible(di->dev, 3153 AB8500_RTC, AB8500_RTC_CTRL_REG, 3154 RTC_BUP_CH_ENA, RTC_BUP_CH_ENA); 3155 if (ret < 0) { 3156 dev_err(di->dev, "%s mask and set failed\n", __func__); 3157 goto out; 3158 } 3159 3160 out: 3161 return ret; 3162 } 3163 3164 /* 3165 * ab8500 charger driver interrupts and their respective isr 3166 */ 3167 static struct ab8500_charger_interrupts ab8500_charger_irq[] = { 3168 {"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler}, 3169 {"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler}, 3170 {"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler}, 3171 {"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler}, 3172 {"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler}, 3173 {"VBUS_DET_F", ab8500_charger_vbusdetf_handler}, 3174 {"VBUS_DET_R", ab8500_charger_vbusdetr_handler}, 3175 {"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler}, 3176 {"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler}, 3177 {"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler}, 3178 {"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler}, 3179 {"VBUS_OVV", ab8500_charger_vbusovv_handler}, 3180 {"CH_WD_EXP", ab8500_charger_chwdexp_handler}, 3181 {"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler}, 3182 }; 3183 3184 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb, 3185 unsigned long event, void *power) 3186 { 3187 struct ab8500_charger *di = 3188 container_of(nb, struct ab8500_charger, nb); 3189 enum ab8500_usb_state bm_usb_state; 3190 /* 3191 * FIXME: it appears the AB8500 PHY never sends what it should here. 3192 * Fix the PHY driver to properly notify the desired current. 3193 * Also broadcast microampere and not milliampere. 3194 */ 3195 unsigned mA = *((unsigned *)power); 3196 3197 if (event != USB_EVENT_VBUS) { 3198 dev_dbg(di->dev, "not a standard host, returning\n"); 3199 return NOTIFY_DONE; 3200 } 3201 3202 /* TODO: State is fabricate here. See if charger really needs USB 3203 * state or if mA is enough 3204 */ 3205 if ((di->usb_state.usb_current_ua == 2000) && (mA > 2)) 3206 bm_usb_state = AB8500_BM_USB_STATE_RESUME; 3207 else if (mA == 0) 3208 bm_usb_state = AB8500_BM_USB_STATE_RESET_HS; 3209 else if (mA == 2) 3210 bm_usb_state = AB8500_BM_USB_STATE_SUSPEND; 3211 else if (mA >= 8) /* 8, 100, 500 */ 3212 bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED; 3213 else /* Should never occur */ 3214 bm_usb_state = AB8500_BM_USB_STATE_RESET_FS; 3215 3216 dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n", 3217 __func__, bm_usb_state, mA); 3218 3219 spin_lock(&di->usb_state.usb_lock); 3220 di->usb_state.state_tmp = bm_usb_state; 3221 /* FIXME: broadcast ua instead, see above */ 3222 di->usb_state.usb_current_tmp_ua = mA * 1000; 3223 spin_unlock(&di->usb_state.usb_lock); 3224 3225 /* 3226 * wait for some time until you get updates from the usb stack 3227 * and negotiations are completed 3228 */ 3229 queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2); 3230 3231 return NOTIFY_OK; 3232 } 3233 3234 static int __maybe_unused ab8500_charger_resume(struct device *dev) 3235 { 3236 int ret; 3237 struct ab8500_charger *di = dev_get_drvdata(dev); 3238 3239 /* 3240 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog 3241 * logic. That means we have to continuously kick the charger 3242 * watchdog even when no charger is connected. This is only 3243 * valid once the AC charger has been enabled. This is 3244 * a bug that is not handled by the algorithm and the 3245 * watchdog have to be kicked by the charger driver 3246 * when the AC charger is disabled 3247 */ 3248 if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) { 3249 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER, 3250 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK); 3251 if (ret) 3252 dev_err(di->dev, "Failed to kick WD!\n"); 3253 3254 /* If not already pending start a new timer */ 3255 queue_delayed_work(di->charger_wq, &di->kick_wd_work, 3256 round_jiffies(WD_KICK_INTERVAL)); 3257 } 3258 3259 /* If we still have a HW failure, schedule a new check */ 3260 if (di->flags.mainextchnotok || di->flags.vbus_ovv) { 3261 queue_delayed_work(di->charger_wq, 3262 &di->check_hw_failure_work, 0); 3263 } 3264 3265 if (di->flags.vbus_drop_end) 3266 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0); 3267 3268 return 0; 3269 } 3270 3271 static int __maybe_unused ab8500_charger_suspend(struct device *dev) 3272 { 3273 struct ab8500_charger *di = dev_get_drvdata(dev); 3274 3275 /* Cancel any pending jobs */ 3276 cancel_delayed_work(&di->check_hw_failure_work); 3277 cancel_delayed_work(&di->vbus_drop_end_work); 3278 3279 flush_delayed_work(&di->attach_work); 3280 flush_delayed_work(&di->usb_charger_attached_work); 3281 flush_delayed_work(&di->ac_charger_attached_work); 3282 flush_delayed_work(&di->check_usbchgnotok_work); 3283 flush_delayed_work(&di->check_vbat_work); 3284 flush_delayed_work(&di->kick_wd_work); 3285 3286 flush_work(&di->usb_link_status_work); 3287 flush_work(&di->ac_work); 3288 flush_work(&di->detect_usb_type_work); 3289 3290 if (atomic_read(&di->current_stepping_sessions)) 3291 return -EAGAIN; 3292 3293 return 0; 3294 } 3295 3296 static char *supply_interface[] = { 3297 "ab8500_chargalg", 3298 "ab8500_fg", 3299 "ab8500_btemp", 3300 }; 3301 3302 static const struct power_supply_desc ab8500_ac_chg_desc = { 3303 .name = "ab8500_ac", 3304 .type = POWER_SUPPLY_TYPE_MAINS, 3305 .properties = ab8500_charger_ac_props, 3306 .num_properties = ARRAY_SIZE(ab8500_charger_ac_props), 3307 .get_property = ab8500_charger_ac_get_property, 3308 }; 3309 3310 static const struct power_supply_desc ab8500_usb_chg_desc = { 3311 .name = "ab8500_usb", 3312 .type = POWER_SUPPLY_TYPE_USB, 3313 .properties = ab8500_charger_usb_props, 3314 .num_properties = ARRAY_SIZE(ab8500_charger_usb_props), 3315 .get_property = ab8500_charger_usb_get_property, 3316 }; 3317 3318 static int ab8500_charger_bind(struct device *dev) 3319 { 3320 struct ab8500_charger *di = dev_get_drvdata(dev); 3321 int ch_stat; 3322 int ret; 3323 3324 /* Create a work queue for the charger */ 3325 di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq", 3326 WQ_MEM_RECLAIM); 3327 if (di->charger_wq == NULL) { 3328 dev_err(dev, "failed to create work queue\n"); 3329 return -ENOMEM; 3330 } 3331 3332 ch_stat = ab8500_charger_detect_chargers(di, false); 3333 3334 if (ch_stat & AC_PW_CONN) { 3335 if (is_ab8500(di->parent)) 3336 queue_delayed_work(di->charger_wq, 3337 &di->ac_charger_attached_work, 3338 HZ); 3339 } 3340 if (ch_stat & USB_PW_CONN) { 3341 if (is_ab8500(di->parent)) 3342 queue_delayed_work(di->charger_wq, 3343 &di->usb_charger_attached_work, 3344 HZ); 3345 di->vbus_detected = true; 3346 di->vbus_detected_start = true; 3347 queue_work(di->charger_wq, 3348 &di->detect_usb_type_work); 3349 } 3350 3351 ret = component_bind_all(dev, di); 3352 if (ret) { 3353 dev_err(dev, "can't bind component devices\n"); 3354 destroy_workqueue(di->charger_wq); 3355 return ret; 3356 } 3357 3358 return 0; 3359 } 3360 3361 static void ab8500_charger_unbind(struct device *dev) 3362 { 3363 struct ab8500_charger *di = dev_get_drvdata(dev); 3364 int ret; 3365 3366 /* Disable AC charging */ 3367 ab8500_charger_ac_en(&di->ac_chg, false, 0, 0); 3368 3369 /* Disable USB charging */ 3370 ab8500_charger_usb_en(&di->usb_chg, false, 0, 0); 3371 3372 /* Backup battery voltage and current disable */ 3373 ret = abx500_mask_and_set_register_interruptible(di->dev, 3374 AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0); 3375 if (ret < 0) 3376 dev_err(di->dev, "%s mask and set failed\n", __func__); 3377 3378 /* Delete the work queue */ 3379 destroy_workqueue(di->charger_wq); 3380 3381 /* Unbind fg, btemp, algorithm */ 3382 component_unbind_all(dev, di); 3383 } 3384 3385 static const struct component_master_ops ab8500_charger_comp_ops = { 3386 .bind = ab8500_charger_bind, 3387 .unbind = ab8500_charger_unbind, 3388 }; 3389 3390 static struct platform_driver *const ab8500_charger_component_drivers[] = { 3391 &ab8500_fg_driver, 3392 &ab8500_btemp_driver, 3393 &ab8500_chargalg_driver, 3394 }; 3395 3396 static int ab8500_charger_probe(struct platform_device *pdev) 3397 { 3398 struct device *dev = &pdev->dev; 3399 struct device_node *np = dev->of_node; 3400 struct component_match *match = NULL; 3401 struct power_supply_config ac_psy_cfg = {}, usb_psy_cfg = {}; 3402 struct ab8500_charger *di; 3403 int charger_status; 3404 int i, irq; 3405 int ret; 3406 3407 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL); 3408 if (!di) 3409 return -ENOMEM; 3410 3411 di->bm = &ab8500_bm_data; 3412 3413 di->autopower_cfg = of_property_read_bool(np, "autopower_cfg"); 3414 3415 /* get parent data */ 3416 di->dev = dev; 3417 di->parent = dev_get_drvdata(pdev->dev.parent); 3418 3419 /* Get ADC channels */ 3420 if (!is_ab8505(di->parent)) { 3421 di->adc_main_charger_v = devm_iio_channel_get(dev, "main_charger_v"); 3422 if (IS_ERR(di->adc_main_charger_v)) { 3423 ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_v), 3424 "failed to get ADC main charger voltage\n"); 3425 return ret; 3426 } 3427 di->adc_main_charger_c = devm_iio_channel_get(dev, "main_charger_c"); 3428 if (IS_ERR(di->adc_main_charger_c)) { 3429 ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_c), 3430 "failed to get ADC main charger current\n"); 3431 return ret; 3432 } 3433 } 3434 di->adc_vbus_v = devm_iio_channel_get(dev, "vbus_v"); 3435 if (IS_ERR(di->adc_vbus_v)) { 3436 ret = dev_err_probe(dev, PTR_ERR(di->adc_vbus_v), 3437 "failed to get ADC USB charger voltage\n"); 3438 return ret; 3439 } 3440 di->adc_usb_charger_c = devm_iio_channel_get(dev, "usb_charger_c"); 3441 if (IS_ERR(di->adc_usb_charger_c)) { 3442 ret = dev_err_probe(dev, PTR_ERR(di->adc_usb_charger_c), 3443 "failed to get ADC USB charger current\n"); 3444 return ret; 3445 } 3446 3447 /* 3448 * VDD ADC supply needs to be enabled from this driver when there 3449 * is a charger connected to avoid erroneous BTEMP_HIGH/LOW 3450 * interrupts during charging 3451 */ 3452 di->regu = devm_regulator_get(dev, "vddadc"); 3453 if (IS_ERR(di->regu)) { 3454 ret = PTR_ERR(di->regu); 3455 dev_err(dev, "failed to get vddadc regulator\n"); 3456 return ret; 3457 } 3458 3459 /* Request interrupts */ 3460 for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) { 3461 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name); 3462 if (irq < 0) 3463 return irq; 3464 3465 ret = devm_request_threaded_irq(dev, 3466 irq, NULL, ab8500_charger_irq[i].isr, 3467 IRQF_SHARED | IRQF_NO_SUSPEND | IRQF_ONESHOT, 3468 ab8500_charger_irq[i].name, di); 3469 3470 if (ret != 0) { 3471 dev_err(dev, "failed to request %s IRQ %d: %d\n" 3472 , ab8500_charger_irq[i].name, irq, ret); 3473 return ret; 3474 } 3475 dev_dbg(dev, "Requested %s IRQ %d: %d\n", 3476 ab8500_charger_irq[i].name, irq, ret); 3477 } 3478 3479 /* initialize lock */ 3480 spin_lock_init(&di->usb_state.usb_lock); 3481 mutex_init(&di->usb_ipt_crnt_lock); 3482 3483 di->autopower = false; 3484 di->invalid_charger_detect_state = 0; 3485 3486 /* AC and USB supply config */ 3487 ac_psy_cfg.of_node = np; 3488 ac_psy_cfg.supplied_to = supply_interface; 3489 ac_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface); 3490 ac_psy_cfg.drv_data = &di->ac_chg; 3491 usb_psy_cfg.of_node = np; 3492 usb_psy_cfg.supplied_to = supply_interface; 3493 usb_psy_cfg.num_supplicants = ARRAY_SIZE(supply_interface); 3494 usb_psy_cfg.drv_data = &di->usb_chg; 3495 3496 /* AC supply */ 3497 /* ux500_charger sub-class */ 3498 di->ac_chg.ops.enable = &ab8500_charger_ac_en; 3499 di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable; 3500 di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick; 3501 di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current; 3502 di->ac_chg.max_out_volt_uv = ab8500_charger_voltage_map[ 3503 ARRAY_SIZE(ab8500_charger_voltage_map) - 1]; 3504 di->ac_chg.max_out_curr_ua = 3505 ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1]; 3506 di->ac_chg.wdt_refresh = CHG_WD_INTERVAL; 3507 /* 3508 * The AB8505 only supports USB charging. If we are not the 3509 * AB8505, register an AC charger. 3510 * 3511 * TODO: if this should be opt-in, add DT properties for this. 3512 */ 3513 if (!is_ab8505(di->parent)) 3514 di->ac_chg.enabled = true; 3515 3516 /* USB supply */ 3517 /* ux500_charger sub-class */ 3518 di->usb_chg.ops.enable = &ab8500_charger_usb_en; 3519 di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable; 3520 di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick; 3521 di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current; 3522 di->usb_chg.max_out_volt_uv = ab8500_charger_voltage_map[ 3523 ARRAY_SIZE(ab8500_charger_voltage_map) - 1]; 3524 di->usb_chg.max_out_curr_ua = 3525 ab8500_charge_output_curr_map[ARRAY_SIZE(ab8500_charge_output_curr_map) - 1]; 3526 di->usb_chg.wdt_refresh = CHG_WD_INTERVAL; 3527 di->usb_state.usb_current_ua = -1; 3528 3529 mutex_init(&di->charger_attached_mutex); 3530 3531 /* Init work for HW failure check */ 3532 INIT_DEFERRABLE_WORK(&di->check_hw_failure_work, 3533 ab8500_charger_check_hw_failure_work); 3534 INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work, 3535 ab8500_charger_check_usbchargernotok_work); 3536 3537 INIT_DELAYED_WORK(&di->ac_charger_attached_work, 3538 ab8500_charger_ac_attached_work); 3539 INIT_DELAYED_WORK(&di->usb_charger_attached_work, 3540 ab8500_charger_usb_attached_work); 3541 3542 /* 3543 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog 3544 * logic. That means we have to continuously kick the charger 3545 * watchdog even when no charger is connected. This is only 3546 * valid once the AC charger has been enabled. This is 3547 * a bug that is not handled by the algorithm and the 3548 * watchdog have to be kicked by the charger driver 3549 * when the AC charger is disabled 3550 */ 3551 INIT_DEFERRABLE_WORK(&di->kick_wd_work, 3552 ab8500_charger_kick_watchdog_work); 3553 3554 INIT_DEFERRABLE_WORK(&di->check_vbat_work, 3555 ab8500_charger_check_vbat_work); 3556 3557 INIT_DELAYED_WORK(&di->attach_work, 3558 ab8500_charger_usb_link_attach_work); 3559 3560 INIT_DELAYED_WORK(&di->usb_state_changed_work, 3561 ab8500_charger_usb_state_changed_work); 3562 3563 INIT_DELAYED_WORK(&di->vbus_drop_end_work, 3564 ab8500_charger_vbus_drop_end_work); 3565 3566 /* Init work for charger detection */ 3567 INIT_WORK(&di->usb_link_status_work, 3568 ab8500_charger_usb_link_status_work); 3569 INIT_WORK(&di->ac_work, ab8500_charger_ac_work); 3570 INIT_WORK(&di->detect_usb_type_work, 3571 ab8500_charger_detect_usb_type_work); 3572 3573 /* Init work for checking HW status */ 3574 INIT_WORK(&di->check_main_thermal_prot_work, 3575 ab8500_charger_check_main_thermal_prot_work); 3576 INIT_WORK(&di->check_usb_thermal_prot_work, 3577 ab8500_charger_check_usb_thermal_prot_work); 3578 3579 3580 /* Initialize OVV, and other registers */ 3581 ret = ab8500_charger_init_hw_registers(di); 3582 if (ret) { 3583 dev_err(dev, "failed to initialize ABB registers\n"); 3584 return ret; 3585 } 3586 3587 /* Register AC charger class */ 3588 if (di->ac_chg.enabled) { 3589 di->ac_chg.psy = devm_power_supply_register(dev, 3590 &ab8500_ac_chg_desc, 3591 &ac_psy_cfg); 3592 if (IS_ERR(di->ac_chg.psy)) { 3593 dev_err(dev, "failed to register AC charger\n"); 3594 return PTR_ERR(di->ac_chg.psy); 3595 } 3596 } 3597 3598 /* Register USB charger class */ 3599 di->usb_chg.psy = devm_power_supply_register(dev, 3600 &ab8500_usb_chg_desc, 3601 &usb_psy_cfg); 3602 if (IS_ERR(di->usb_chg.psy)) { 3603 dev_err(dev, "failed to register USB charger\n"); 3604 return PTR_ERR(di->usb_chg.psy); 3605 } 3606 3607 /* 3608 * Check what battery we have, since we always have the USB 3609 * psy, use that as a handle. 3610 */ 3611 ret = ab8500_bm_of_probe(di->usb_chg.psy, di->bm); 3612 if (ret) 3613 return dev_err_probe(dev, ret, 3614 "failed to get battery information\n"); 3615 3616 /* Identify the connected charger types during startup */ 3617 charger_status = ab8500_charger_detect_chargers(di, true); 3618 if (charger_status & AC_PW_CONN) { 3619 di->ac.charger_connected = 1; 3620 di->ac_conn = true; 3621 ab8500_power_supply_changed(di, di->ac_chg.psy); 3622 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present"); 3623 } 3624 3625 platform_set_drvdata(pdev, di); 3626 3627 /* Create something that will match the subdrivers when we bind */ 3628 for (i = 0; i < ARRAY_SIZE(ab8500_charger_component_drivers); i++) { 3629 struct device_driver *drv = &ab8500_charger_component_drivers[i]->driver; 3630 struct device *p = NULL, *d; 3631 3632 while ((d = platform_find_device_by_driver(p, drv))) { 3633 put_device(p); 3634 component_match_add(dev, &match, component_compare_dev, d); 3635 p = d; 3636 } 3637 put_device(p); 3638 } 3639 if (!match) { 3640 dev_err(dev, "no matching components\n"); 3641 ret = -ENODEV; 3642 goto remove_ab8500_bm; 3643 } 3644 if (IS_ERR(match)) { 3645 dev_err(dev, "could not create component match\n"); 3646 ret = PTR_ERR(match); 3647 goto remove_ab8500_bm; 3648 } 3649 3650 di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2); 3651 if (IS_ERR_OR_NULL(di->usb_phy)) { 3652 dev_err(dev, "failed to get usb transceiver\n"); 3653 ret = -EINVAL; 3654 goto remove_ab8500_bm; 3655 } 3656 di->nb.notifier_call = ab8500_charger_usb_notifier_call; 3657 ret = usb_register_notifier(di->usb_phy, &di->nb); 3658 if (ret) { 3659 dev_err(dev, "failed to register usb notifier\n"); 3660 goto put_usb_phy; 3661 } 3662 3663 ret = component_master_add_with_match(&pdev->dev, 3664 &ab8500_charger_comp_ops, 3665 match); 3666 if (ret) { 3667 dev_err(dev, "failed to add component master\n"); 3668 goto free_notifier; 3669 } 3670 3671 return 0; 3672 3673 free_notifier: 3674 usb_unregister_notifier(di->usb_phy, &di->nb); 3675 put_usb_phy: 3676 usb_put_phy(di->usb_phy); 3677 remove_ab8500_bm: 3678 ab8500_bm_of_remove(di->usb_chg.psy, di->bm); 3679 return ret; 3680 } 3681 3682 static int ab8500_charger_remove(struct platform_device *pdev) 3683 { 3684 struct ab8500_charger *di = platform_get_drvdata(pdev); 3685 3686 component_master_del(&pdev->dev, &ab8500_charger_comp_ops); 3687 3688 usb_unregister_notifier(di->usb_phy, &di->nb); 3689 ab8500_bm_of_remove(di->usb_chg.psy, di->bm); 3690 usb_put_phy(di->usb_phy); 3691 3692 return 0; 3693 } 3694 3695 static SIMPLE_DEV_PM_OPS(ab8500_charger_pm_ops, ab8500_charger_suspend, ab8500_charger_resume); 3696 3697 static const struct of_device_id ab8500_charger_match[] = { 3698 { .compatible = "stericsson,ab8500-charger", }, 3699 { }, 3700 }; 3701 MODULE_DEVICE_TABLE(of, ab8500_charger_match); 3702 3703 static struct platform_driver ab8500_charger_driver = { 3704 .probe = ab8500_charger_probe, 3705 .remove = ab8500_charger_remove, 3706 .driver = { 3707 .name = "ab8500-charger", 3708 .of_match_table = ab8500_charger_match, 3709 .pm = &ab8500_charger_pm_ops, 3710 }, 3711 }; 3712 3713 static int __init ab8500_charger_init(void) 3714 { 3715 int ret; 3716 3717 ret = platform_register_drivers(ab8500_charger_component_drivers, 3718 ARRAY_SIZE(ab8500_charger_component_drivers)); 3719 if (ret) 3720 return ret; 3721 3722 ret = platform_driver_register(&ab8500_charger_driver); 3723 if (ret) { 3724 platform_unregister_drivers(ab8500_charger_component_drivers, 3725 ARRAY_SIZE(ab8500_charger_component_drivers)); 3726 return ret; 3727 } 3728 3729 return 0; 3730 } 3731 3732 static void __exit ab8500_charger_exit(void) 3733 { 3734 platform_unregister_drivers(ab8500_charger_component_drivers, 3735 ARRAY_SIZE(ab8500_charger_component_drivers)); 3736 platform_driver_unregister(&ab8500_charger_driver); 3737 } 3738 3739 module_init(ab8500_charger_init); 3740 module_exit(ab8500_charger_exit); 3741 3742 MODULE_LICENSE("GPL v2"); 3743 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy"); 3744 MODULE_ALIAS("platform:ab8500-charger"); 3745 MODULE_DESCRIPTION("AB8500 charger management driver"); 3746