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