1/* 2 * rk817 charger driver 3 * 4 * Copyright (C) 2018 Rockchip Electronics Co., Ltd 5 * xsf <xsf@rock-chips.com> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms and conditions of the GNU General Public License, 9 * version 2, as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 */ 17 18#include <linux/delay.h> 19#include <linux/extcon.h> 20#include <linux/gpio.h> 21#include <linux/iio/consumer.h> 22#include <linux/iio/iio.h> 23#include <linux/irq.h> 24#include <linux/jiffies.h> 25#include <linux/mfd/rk808.h> 26#include <linux/module.h> 27#include <linux/of_device.h> 28#include <linux/of_gpio.h> 29#include <linux/platform_device.h> 30#include <linux/power_supply.h> 31#include <linux/power/rk_usbbc.h> 32#include <linux/regmap.h> 33#include <linux/rtc.h> 34#include <linux/timer.h> 35#include <linux/workqueue.h> 36 37static int dbg_enable; 38module_param_named(dbg_level, dbg_enable, int, 0644); 39 40#define DBG(args...) \ 41 do { \ 42 if (dbg_enable) { \ 43 pr_info(args); \ 44 } \ 45 } while (0) 46 47#define CHARGE_DRIVER_VERSION "1.0" 48 49#define DISABLE 0x00 50#define ENABLE 0x01 51#define OTG_SLP_ENABLE 0x01 52#define OTG_SLP_DISABLE 0x00 53#define OTG_ENABLE 0x11 54#define OTG_DISABLE 0x10 55#define RK817_BOOST_ENABLE 0x11 56#define RK817_BOOST_DISABLE 0x10 57#define OTG_MODE 0x01 58#define OTG_MODE_ON 0x01 59#define DEFAULT_INPUT_VOLTAGE 4500 60#define DEFAULT_INPUT_CURRENT 2000 61#define DEFAULT_CHRG_VOLTAGE 4200 62#define DEFAULT_CHRG_CURRENT 1400 63#define DEFAULT_CHRG_TERM_MODE 1 64#define DEFAULT_CHRG_TERM_CUR 150 65#define SAMPLE_RES_10MR 10 66#define SAMPLE_RES_20MR 20 67#define SAMPLE_RES_DIV1 1 68#define SAMPLE_RES_DIV2 2 69 70#define INPUT_450MA 450 71#define INPUT_1500MA 1500 72 73#define CURRENT_TO_ADC(current, samp_res) \ 74 (current * 1000 * samp_res / 172) 75 76enum charge_current { 77 CHRG_CUR_1000MA, 78 CHRG_CUR_1500MA, 79 CHRG_CUR_2000MA, 80 CHRG_CUR_2500MA, 81 CHRG_CUR_2750MA, 82 CHRG_CUR_3000MA, 83 CHRG_CUR_3500MA, 84 CHRG_CUR_500MA, 85}; 86 87enum charge_voltage { 88 CHRG_VOL_4100MV, 89 CHRG_VOL_4150MV, 90 CHRG_VOL_4200MV, 91 CHRG_VOL_4250MV, 92 CHRG_VOL_4300MV, 93 CHRG_VOL_4350MV, 94 CHRG_VOL_4400MV, 95 CHRG_VOL_4450MV, 96}; 97 98enum input_voltage { 99 INPUT_VOL_4000MV, 100 INPUT_VOL_4100MV, 101 INPUT_VOL_4200MV, 102 INPUT_VOL_4300MV, 103 INPUT_VOL_4400MV, 104 INPUT_VOL_4500MV, 105 INPUT_VOL_4600MV, 106 INPUT_VOL_4700MV, 107}; 108 109enum input_current { 110 INPUT_CUR_450MA, 111 INPUT_CUR_80MA, 112 INPUT_CUR_850MA, 113 INPUT_CUR_1500MA, 114 INPUT_CUR_1750MA, 115 INPUT_CUR_2000MA, 116 INPUT_CUR_2500MA, 117 INPUT_CUR_3000MA, 118}; 119 120enum charge_clk { 121 CHRG_CLK_1M, 122 CHRG_CLK_2M, 123}; 124 125enum charge_term_sel { 126 CHRG_TERM_150MA, 127 CHRG_TERM_200MA, 128 CHRG_TERM_300MA, 129 CHRG_TERM_400MA, 130}; 131 132enum charge_timer_trickle { 133 CHRG_TIMER_TRIKL_30MIN, 134 CHRG_TIMER_TRIKL_45MIN, 135 CHRG_TIMER_TRIKL_60MIN, 136 CHRG_TIMER_TRIKL_90MIN, 137 CHRG_TIMER_TRIKL_120MIN, 138 CHRG_TIMER_TRIKL_150MIN, 139 CHRG_TIMER_TRIKL_180MIN, 140 CHRG_TIMER_TRIKL_210MIN, 141}; 142 143enum charge_timer_cccv { 144 CHRG_TIMER_CCCV_4H, 145 CHRG_TIMER_CCCV_5H, 146 CHRG_TIMER_CCCV_6H, 147 CHRG_TIMER_CCCV_8H, 148 CHRG_TIMER_CCCV_10H, 149 CHRG_TIMER_CCCV_12H, 150 CHRG_TIMER_CCCV_14H, 151 CHRG_TIMER_CCCV_16H, 152}; 153 154enum charge_status { 155 CHRG_OFF, 156 DEAD_CHRG, 157 TRICKLE_CHRG, 158 CC_OR_CV_CHRG, 159 CHRG_TERM, 160 USB_OVER_VOL, 161 BAT_TMP_ERR, 162 BAT_TIM_ERR, 163}; 164 165enum discharge_ilimit { 166 DISCHRG_2000MA, 167 DISCHRG_2500MA, 168 DISCHRG_3000MA, 169 DISCHRG_3500MA, 170 DISCHRG_4000MA, 171}; 172 173enum bat_system_comp_time { 174 DLY_20US, 175 DLY_10US, 176 DLY_40US, 177 DLY_20US_AGAIN, 178}; 179 180enum charge_term_mode { 181 CHRG_ANALOG, 182 CHRG_DIGITAL, 183}; 184 185enum charger_t { 186 USB_TYPE_UNKNOWN_CHARGER, 187 USB_TYPE_NONE_CHARGER, 188 USB_TYPE_USB_CHARGER, 189 USB_TYPE_AC_CHARGER, 190 USB_TYPE_CDP_CHARGER, 191 DC_TYPE_DC_CHARGER, 192 DC_TYPE_NONE_CHARGER, 193}; 194 195enum charger_state { 196 OFFLINE = 0, 197 ONLINE 198}; 199 200enum rk817_charge_fields { 201 BOOST_EN, OTG_EN, OTG_SLP_EN, CHRG_CLK_SEL, 202 CHRG_EN, CHRG_VOL_SEL, CHRG_CT_EN, CHRG_CUR_SEL, 203 USB_VLIM_EN, USB_VLIM_SEL, USB_ILIM_EN, USB_ILIM_SEL, 204 SYS_CAN_SD, USB_SYS_EN, BAT_OVP_EN, CHRG_TERM_ANA_DIG, 205 CHRG_TERM_ANA_SEL, 206 CHRG_TERM_DIG, 207 BAT_HTS_TS, BAT_LTS_TS, 208 CHRG_TIMER_TRIKL_EN, CHRG_TIMER_TRIKL, 209 CHRG_TIMER_CCCV_EN, CHRG_TIMER_CCCV, 210 BAT_EXS, CHG_STS, BAT_OVP_STS, CHRG_IN_CLAMP, 211 USB_EXS, USB_EFF, 212 BAT_DIS_ILIM_STS, BAT_SYS_CMP_DLY, BAT_DIS_ILIM_EN, 213 BAT_DISCHRG_ILIM, 214 PLUG_IN_STS, SOC_REG0, SOC_REG1, SOC_REG2, 215 F_MAX_FIELDS 216}; 217 218static const struct reg_field rk817_charge_reg_fields[] = { 219 [SOC_REG0] = REG_FIELD(0x9A, 0, 7), 220 [SOC_REG1] = REG_FIELD(0x9B, 0, 7), 221 [SOC_REG2] = REG_FIELD(0x9C, 0, 7), 222 [BOOST_EN] = REG_FIELD(0xB4, 1, 5), 223 [OTG_EN] = REG_FIELD(0xB4, 2, 6), 224 [OTG_SLP_EN] = REG_FIELD(0xB5, 6, 6), 225 [CHRG_EN] = REG_FIELD(0xE4, 7, 7), 226 [CHRG_VOL_SEL] = REG_FIELD(0xE4, 4, 6), 227 [CHRG_CT_EN] = REG_FIELD(0xE4, 3, 3), 228 [CHRG_CUR_SEL] = REG_FIELD(0xE4, 0, 2), 229 230 [USB_VLIM_EN] = REG_FIELD(0xE5, 7, 7), 231 [USB_VLIM_SEL] = REG_FIELD(0xE5, 4, 6), 232 [USB_ILIM_EN] = REG_FIELD(0xE5, 3, 3), 233 [USB_ILIM_SEL] = REG_FIELD(0xE5, 0, 2), 234 235 [SYS_CAN_SD] = REG_FIELD(0xE6, 7, 7), 236 [USB_SYS_EN] = REG_FIELD(0xE6, 6, 6), 237 [BAT_OVP_EN] = REG_FIELD(0xE6, 3, 3), 238 [CHRG_TERM_ANA_DIG] = REG_FIELD(0xE6, 2, 2), 239 [CHRG_TERM_ANA_SEL] = REG_FIELD(0xE6, 0, 1), 240 241 [CHRG_TERM_DIG] = REG_FIELD(0xE7, 0, 7), 242 243 [BAT_HTS_TS] = REG_FIELD(0xE8, 0, 7), 244 245 [BAT_LTS_TS] = REG_FIELD(0xE9, 0, 7), 246 247 [CHRG_TIMER_TRIKL_EN] = REG_FIELD(0xEA, 7, 7), 248 [CHRG_TIMER_TRIKL] = REG_FIELD(0xEA, 4, 6), 249 [CHRG_TIMER_CCCV_EN] = REG_FIELD(0xEA, 3, 3), 250 [CHRG_TIMER_CCCV] = REG_FIELD(0xEA, 0, 2), 251 252 [BAT_EXS] = REG_FIELD(0xEB, 7, 7), 253 [CHG_STS] = REG_FIELD(0xEB, 4, 6), 254 [BAT_OVP_STS] = REG_FIELD(0xEB, 3, 3), 255 [CHRG_IN_CLAMP] = REG_FIELD(0xEB, 2, 2), 256 [USB_EXS] = REG_FIELD(0xEB, 1, 1), 257 [USB_EFF] = REG_FIELD(0xEB, 0, 0), 258 259 [BAT_DIS_ILIM_STS] = REG_FIELD(0xEC, 6, 6), 260 [BAT_SYS_CMP_DLY] = REG_FIELD(0xEC, 4, 5), 261 [BAT_DIS_ILIM_EN] = REG_FIELD(0xEC, 3, 3), 262 [BAT_DISCHRG_ILIM] = REG_FIELD(0xEC, 0, 2), 263 [PLUG_IN_STS] = REG_FIELD(0xf0, 6, 6), 264 [CHRG_CLK_SEL] = REG_FIELD(0xF3, 6, 6), 265}; 266 267struct charger_platform_data { 268 u32 max_input_current; 269 u32 min_input_voltage; 270 271 u32 max_chrg_current; 272 u32 max_chrg_voltage; 273 274 u32 chrg_finish_cur; 275 u32 chrg_term_mode; 276 277 u32 power_dc2otg; 278 u32 dc_det_level; 279 int dc_det_pin; 280 bool support_dc_det; 281 int virtual_power; 282 int sample_res; 283 int otg5v_suspend_enable; 284 bool extcon; 285 int gate_function_disable; 286}; 287 288struct rk817_charger { 289 struct i2c_client *client; 290 struct platform_device *pdev; 291 struct device *dev; 292 struct rk808 *rk817; 293 struct regmap *regmap; 294 struct regmap_field *rmap_fields[F_MAX_FIELDS]; 295 296 struct power_supply *ac_psy; 297 struct power_supply *usb_psy; 298 struct extcon_dev *cable_edev; 299 struct charger_platform_data *pdata; 300 struct workqueue_struct *usb_charger_wq; 301 struct workqueue_struct *dc_charger_wq; 302 struct delayed_work dc_work; 303 struct delayed_work usb_work; 304 struct delayed_work host_work; 305 struct delayed_work discnt_work; 306 struct delayed_work irq_work; 307 struct notifier_block bc_nb; 308 struct notifier_block cable_cg_nb; 309 struct notifier_block cable_host_nb; 310 struct notifier_block cable_discnt_nb; 311 unsigned int bc_event; 312 enum charger_t usb_charger; 313 enum charger_t dc_charger; 314 struct regulator *otg5v_rdev; 315 u8 ac_in; 316 u8 usb_in; 317 u8 otg_in; 318 u8 dc_in; 319 u8 prop_status; 320 321 u32 max_input_current; 322 u32 min_input_voltage; 323 324 u32 max_chrg_current; 325 u32 max_chrg_voltage; 326 327 u32 chrg_finish_cur; 328 u32 chrg_term_mode; 329 330 u8 res_div; 331 u8 otg_slp_state; 332 u8 plugin_trigger; 333 u8 plugout_trigger; 334 int plugin_irq; 335 int plugout_irq; 336}; 337 338static enum power_supply_property rk817_ac_props[] = { 339 POWER_SUPPLY_PROP_ONLINE, 340 POWER_SUPPLY_PROP_STATUS, 341 POWER_SUPPLY_PROP_VOLTAGE_MAX, 342 POWER_SUPPLY_PROP_CURRENT_MAX, 343}; 344 345static enum power_supply_property rk817_usb_props[] = { 346 POWER_SUPPLY_PROP_ONLINE, 347 POWER_SUPPLY_PROP_STATUS, 348 POWER_SUPPLY_PROP_VOLTAGE_MAX, 349 POWER_SUPPLY_PROP_CURRENT_MAX, 350}; 351 352static int rk817_charge_ac_get_property(struct power_supply *psy, 353 enum power_supply_property psp, 354 union power_supply_propval *val) 355{ 356 struct rk817_charger *charge = power_supply_get_drvdata(psy); 357 int ret = 0; 358 359 switch (psp) { 360 case POWER_SUPPLY_PROP_ONLINE: 361 if (charge->pdata->virtual_power) 362 val->intval = 1; 363 else 364 val->intval = (charge->ac_in | charge->dc_in); 365 366 DBG("ac report online: %d\n", val->intval); 367 break; 368 case POWER_SUPPLY_PROP_STATUS: 369 if (charge->pdata->virtual_power) 370 val->intval = POWER_SUPPLY_STATUS_CHARGING; 371 else 372 val->intval = charge->prop_status; 373 374 DBG("report prop: %d\n", val->intval); 375 break; 376 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 377 val->intval = charge->max_chrg_voltage * 1000; /* uV */ 378 break; 379 case POWER_SUPPLY_PROP_CURRENT_MAX: 380 val->intval = charge->max_chrg_current * 1000; /* uA */ 381 break; 382 default: 383 ret = -EINVAL; 384 break; 385 } 386 387 return ret; 388} 389 390static int rk817_charge_usb_get_property(struct power_supply *psy, 391 enum power_supply_property psp, 392 union power_supply_propval *val) 393{ 394 struct rk817_charger *charge = power_supply_get_drvdata(psy); 395 int ret = 0; 396 397 switch (psp) { 398 case POWER_SUPPLY_PROP_ONLINE: 399 if (charge->pdata->virtual_power) 400 val->intval = 1; 401 else 402 val->intval = charge->usb_in; 403 404 DBG("usb report online: %d\n", val->intval); 405 break; 406 case POWER_SUPPLY_PROP_STATUS: 407 if (charge->pdata->virtual_power) 408 val->intval = POWER_SUPPLY_STATUS_CHARGING; 409 else 410 val->intval = charge->prop_status; 411 412 DBG("report prop: %d\n", val->intval); 413 break; 414 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 415 val->intval = charge->max_chrg_voltage; 416 break; 417 case POWER_SUPPLY_PROP_CURRENT_MAX: 418 val->intval = charge->max_chrg_current; 419 break; 420 default: 421 ret = -EINVAL; 422 break; 423 } 424 425 return ret; 426} 427 428static const struct power_supply_desc rk817_ac_desc = { 429 .name = "ac", 430 .type = POWER_SUPPLY_TYPE_MAINS, 431 .properties = rk817_ac_props, 432 .num_properties = ARRAY_SIZE(rk817_ac_props), 433 .get_property = rk817_charge_ac_get_property, 434}; 435 436static const struct power_supply_desc rk817_usb_desc = { 437 .name = "usb", 438 .type = POWER_SUPPLY_TYPE_USB, 439 .properties = rk817_usb_props, 440 .num_properties = ARRAY_SIZE(rk817_usb_props), 441 .get_property = rk817_charge_usb_get_property, 442}; 443 444static int rk817_charge_init_power_supply(struct rk817_charger *charge) 445{ 446 struct power_supply_config psy_cfg = { .drv_data = charge, }; 447 448 charge->usb_psy = devm_power_supply_register(charge->dev, 449 &rk817_usb_desc, 450 &psy_cfg); 451 if (IS_ERR(charge->usb_psy)) { 452 dev_err(charge->dev, "register usb power supply fail\n"); 453 return PTR_ERR(charge->usb_psy); 454 } 455 456 charge->ac_psy = devm_power_supply_register(charge->dev, &rk817_ac_desc, 457 &psy_cfg); 458 if (IS_ERR(charge->ac_psy)) { 459 dev_err(charge->dev, "register ac power supply fail\n"); 460 return PTR_ERR(charge->ac_psy); 461 } 462 463 return 0; 464} 465 466static int rk817_charge_field_read(struct rk817_charger *charge, 467 enum rk817_charge_fields field_id) 468{ 469 int ret; 470 int val; 471 472 ret = regmap_field_read(charge->rmap_fields[field_id], &val); 473 if (ret < 0) 474 return ret; 475 476 return val; 477} 478 479static int rk817_charge_field_write(struct rk817_charger *charge, 480 enum rk817_charge_fields field_id, 481 unsigned int val) 482{ 483 return regmap_field_write(charge->rmap_fields[field_id], val); 484} 485 486static int rk817_charge_get_otg_state(struct rk817_charger *charge) 487{ 488 return regulator_is_enabled(charge->otg5v_rdev); 489} 490 491static void rk817_charge_boost_disable(struct rk817_charger *charge) 492{ 493 rk817_charge_field_write(charge, BOOST_EN, RK817_BOOST_DISABLE); 494} 495 496static void rk817_charge_boost_enable(struct rk817_charger *charge) 497{ 498 rk817_charge_field_write(charge, BOOST_EN, RK817_BOOST_ENABLE); 499} 500 501static void rk817_charge_otg_disable(struct rk817_charger *charge) 502{ 503 int ret; 504 505 ret = regulator_disable(charge->otg5v_rdev); 506 507 if (ret) { 508 DBG("disable otg5v failed:%d\n", ret); 509 return; 510 } 511 512 return; 513} 514 515static void rk817_charge_otg_enable(struct rk817_charger *charge) 516{ 517 int ret; 518 519 ret = regulator_enable(charge->otg5v_rdev); 520 521 if (ret) { 522 DBG("enable otg5v failed:%d\n", ret); 523 return; 524 } 525 526 return; 527} 528 529#ifdef CONFIG_PM_SLEEP 530static int rk817_charge_get_otg_slp_state(struct rk817_charger *charge) 531{ 532 return (rk817_charge_field_read(charge, OTG_SLP_EN) & OTG_SLP_ENABLE); 533} 534 535static void rk817_charge_otg_slp_disable(struct rk817_charger *charge) 536{ 537 rk817_charge_field_write(charge, OTG_SLP_EN, OTG_SLP_DISABLE); 538} 539 540static void rk817_charge_otg_slp_enable(struct rk817_charger *charge) 541{ 542 rk817_charge_field_write(charge, OTG_SLP_EN, OTG_SLP_ENABLE); 543} 544#endif 545 546static int rk817_charge_get_charge_state(struct rk817_charger *charge) 547{ 548 return rk817_charge_field_read(charge, CHRG_EN); 549} 550 551static void rk817_charge_enable_charge(struct rk817_charger *charge) 552{ 553 rk817_charge_field_write(charge, CHRG_EN, ENABLE); 554} 555 556static void rk817_charge_usb_to_sys_enable(struct rk817_charger *charge) 557{ 558 rk817_charge_field_write(charge, USB_SYS_EN, ENABLE); 559} 560 561static void rk817_charge_sys_can_sd_disable(struct rk817_charger *charge) 562{ 563 rk817_charge_field_write(charge, SYS_CAN_SD, DISABLE); 564} 565 566static int rk817_charge_get_charge_status(struct rk817_charger *charge) 567{ 568 int status; 569 570 status = rk817_charge_field_read(charge, CHG_STS); 571 572 switch (status) { 573 case CHRG_OFF: 574 DBG("charge off...\n"); 575 break; 576 case DEAD_CHRG: 577 DBG("dead charge...\n"); 578 break; 579 case TRICKLE_CHRG: 580 DBG("trickle charge...\n"); 581 break; 582 case CC_OR_CV_CHRG: 583 DBG("CC or CV charge...\n"); 584 break; 585 case CHRG_TERM: 586 DBG("charge TERM...\n"); 587 break; 588 case USB_OVER_VOL: 589 DBG("USB over voltage...\n"); 590 break; 591 case BAT_TMP_ERR: 592 DBG("battery temperature error...\n"); 593 break; 594 case BAT_TIM_ERR: 595 DBG("battery timer error..\n"); 596 break; 597 default: 598 break; 599 } 600 601 return status; 602} 603 604static int rk817_charge_get_plug_in_status(struct rk817_charger *charge) 605{ 606 return rk817_charge_field_read(charge, PLUG_IN_STS); 607} 608 609static void rk817_charge_set_charge_clock(struct rk817_charger *charge, 610 enum charge_clk clock) 611{ 612 rk817_charge_field_write(charge, CHRG_CLK_SEL, clock); 613} 614 615static int is_battery_exist(struct rk817_charger *charge) 616{ 617 return rk817_charge_field_read(charge, BAT_EXS); 618} 619 620static void rk817_charge_set_chrg_voltage(struct rk817_charger *charge, 621 int chrg_vol) 622{ 623 int voltage; 624 625 if (chrg_vol < 4100 || chrg_vol > 4500) { 626 dev_err(charge->dev, "the charge voltage is error!\n"); 627 } else { 628 voltage = (chrg_vol - 4100) / 50; 629 rk817_charge_field_write(charge, 630 CHRG_VOL_SEL, 631 CHRG_VOL_4100MV + voltage); 632 } 633} 634 635static void rk817_charge_set_chrg_current(struct rk817_charger *charge, 636 int chrg_current) 637{ 638 if (chrg_current < 500 || chrg_current > 3500) 639 dev_err(charge->dev, "the charge current is error!\n"); 640 641 if (chrg_current < 1000) 642 rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_500MA); 643 else if (chrg_current < 1500) 644 rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_1000MA); 645 else if (chrg_current < 2000) 646 rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_1500MA); 647 else if (chrg_current < 2500) 648 rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_2000MA); 649 else if (chrg_current < 3000) 650 rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_2500MA); 651 else if (chrg_current < 3500) 652 rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_3000MA); 653 else 654 rk817_charge_field_write(charge, CHRG_CUR_SEL, CHRG_CUR_3500MA); 655} 656 657static void rk817_charge_vlimit_enable(struct rk817_charger *charge) 658{ 659 rk817_charge_field_write(charge, USB_VLIM_EN, ENABLE); 660} 661 662static void rk817_charge_set_input_voltage(struct rk817_charger *charge, 663 int input_voltage) 664{ 665 int voltage; 666 667 if (input_voltage < 4000) 668 dev_err(charge->dev, "the input voltage is error.\n"); 669 670 voltage = INPUT_VOL_4000MV + (input_voltage - 4000) / 100; 671 672 rk817_charge_field_write(charge, USB_VLIM_SEL, voltage); 673 rk817_charge_vlimit_enable(charge); 674} 675 676static void rk817_charge_ilimit_enable(struct rk817_charger *charge) 677{ 678 rk817_charge_field_write(charge, USB_ILIM_EN, ENABLE); 679} 680 681static void rk817_charge_set_input_current(struct rk817_charger *charge, 682 int input_current) 683{ 684 if (input_current < 80 || input_current > 3000) 685 dev_err(charge->dev, "the input current is error.\n"); 686 687 if (input_current < 450) 688 rk817_charge_field_write(charge, USB_ILIM_SEL, 689 INPUT_CUR_80MA); 690 else if (input_current < 850) 691 rk817_charge_field_write(charge, USB_ILIM_SEL, 692 INPUT_CUR_450MA); 693 else if (input_current < 1500) 694 rk817_charge_field_write(charge, USB_ILIM_SEL, 695 INPUT_CUR_850MA); 696 else if (input_current < 1750) 697 rk817_charge_field_write(charge, USB_ILIM_SEL, 698 INPUT_CUR_1500MA); 699 else if (input_current < 2000) 700 rk817_charge_field_write(charge, USB_ILIM_SEL, 701 INPUT_CUR_1750MA); 702 else if (input_current < 2500) 703 rk817_charge_field_write(charge, USB_ILIM_SEL, 704 INPUT_CUR_2000MA); 705 else if (input_current < 3000) 706 rk817_charge_field_write(charge, USB_ILIM_SEL, 707 INPUT_CUR_2500MA); 708 else 709 rk817_charge_field_write(charge, USB_ILIM_SEL, 710 INPUT_CUR_3000MA); 711 712 rk817_charge_ilimit_enable(charge); 713} 714 715static void rk817_charge_set_chrg_term_mod(struct rk817_charger *charge, 716 int mode) 717{ 718 rk817_charge_field_write(charge, CHRG_TERM_ANA_DIG, mode); 719} 720 721static void rk817_charge_set_term_current_analog(struct rk817_charger *charge, 722 int chrg_current) 723{ 724 int value; 725 726 if (chrg_current < 200) 727 value = CHRG_TERM_150MA; 728 else if (chrg_current < 300) 729 value = CHRG_TERM_200MA; 730 else if (chrg_current < 400) 731 value = CHRG_TERM_300MA; 732 else 733 value = CHRG_TERM_400MA; 734 735 rk817_charge_field_write(charge, 736 CHRG_TERM_ANA_SEL, 737 value); 738} 739 740static void rk817_charge_set_term_current_digital(struct rk817_charger *charge, 741 int chrg_current) 742{ 743 int value; 744 u8 current_adc; 745 746 value = CURRENT_TO_ADC(chrg_current, charge->res_div); 747 748 value &= (0xff << 5); 749 current_adc = value >> 5; 750 rk817_charge_field_write(charge, CHRG_TERM_DIG, current_adc); 751} 752 753static void rk817_charge_set_chrg_finish_condition(struct rk817_charger *charge) 754{ 755 if (charge->chrg_term_mode == CHRG_ANALOG) 756 rk817_charge_set_term_current_analog(charge, 757 charge->chrg_finish_cur); 758 else 759 rk817_charge_set_term_current_digital(charge, 760 charge->chrg_finish_cur); 761 762 rk817_charge_set_chrg_term_mod(charge, charge->chrg_term_mode); 763} 764 765static int rk817_charge_online(struct rk817_charger *charge) 766{ 767 return (charge->ac_in | charge->usb_in | charge->dc_in); 768} 769 770static int rk817_charge_get_dsoc(struct rk817_charger *charge) 771{ 772 int soc_save; 773 774 soc_save = rk817_charge_field_read(charge, SOC_REG0); 775 soc_save |= (rk817_charge_field_read(charge, SOC_REG1) << 8); 776 soc_save |= (rk817_charge_field_read(charge, SOC_REG2) << 16); 777 778 return soc_save / 1000; 779} 780 781static void rk817_charge_set_otg_in(struct rk817_charger *charge, int online) 782{ 783 charge->otg_in = online; 784} 785 786static void rk817_charge_set_chrg_param(struct rk817_charger *charge, 787 enum charger_t charger) 788{ 789 switch (charger) { 790 case USB_TYPE_NONE_CHARGER: 791 charge->usb_in = 0; 792 charge->ac_in = 0; 793 if (charge->dc_in == 0) { 794 charge->prop_status = POWER_SUPPLY_STATUS_DISCHARGING; 795 rk817_charge_set_input_current(charge, INPUT_450MA); 796 } 797 power_supply_changed(charge->usb_psy); 798 power_supply_changed(charge->ac_psy); 799 break; 800 case USB_TYPE_USB_CHARGER: 801 charge->usb_in = 1; 802 charge->ac_in = 0; 803 charge->prop_status = POWER_SUPPLY_STATUS_CHARGING; 804 if (charge->dc_in == 0) 805 rk817_charge_set_input_current(charge, INPUT_450MA); 806 power_supply_changed(charge->usb_psy); 807 power_supply_changed(charge->ac_psy); 808 break; 809 case USB_TYPE_AC_CHARGER: 810 case USB_TYPE_CDP_CHARGER: 811 charge->ac_in = 1; 812 charge->usb_in = 0; 813 charge->prop_status = POWER_SUPPLY_STATUS_CHARGING; 814 if (charger == USB_TYPE_AC_CHARGER) 815 rk817_charge_set_input_current(charge, 816 charge->max_input_current); 817 else 818 rk817_charge_set_input_current(charge, 819 INPUT_1500MA); 820 power_supply_changed(charge->usb_psy); 821 power_supply_changed(charge->ac_psy); 822 break; 823 case DC_TYPE_DC_CHARGER: 824 charge->dc_in = 1; 825 charge->prop_status = POWER_SUPPLY_STATUS_CHARGING; 826 rk817_charge_set_input_current(charge, 827 charge->max_input_current); 828 power_supply_changed(charge->usb_psy); 829 power_supply_changed(charge->ac_psy); 830 break; 831 case DC_TYPE_NONE_CHARGER: 832 charge->dc_in = 0; 833 if (!rk817_charge_get_plug_in_status(charge)) { 834 charge->ac_in = 0; 835 charge->usb_in = 0; 836 charge->prop_status = POWER_SUPPLY_STATUS_DISCHARGING; 837 rk817_charge_set_input_current(charge, INPUT_450MA); 838 } else if (charge->usb_in) { 839 rk817_charge_set_input_current(charge, INPUT_450MA); 840 charge->prop_status = POWER_SUPPLY_STATUS_CHARGING; 841 } 842 power_supply_changed(charge->usb_psy); 843 power_supply_changed(charge->ac_psy); 844 break; 845 default: 846 charge->prop_status = POWER_SUPPLY_STATUS_DISCHARGING; 847 rk817_charge_set_input_current(charge, INPUT_450MA); 848 break; 849 } 850 851 if (rk817_charge_online(charge) && rk817_charge_get_dsoc(charge) == 100) 852 charge->prop_status = POWER_SUPPLY_STATUS_FULL; 853} 854 855static void rk817_charge_set_otg_state(struct rk817_charger *charge, int state) 856{ 857 switch (state) { 858 case USB_OTG_POWER_ON: 859 if (charge->otg_in) { 860 DBG("otg5v is on yet, ignore..\n"); 861 } else { 862 863 if (!rk817_charge_get_otg_state(charge)) { 864 rk817_charge_otg_enable(charge); 865 if (!rk817_charge_get_otg_state(charge)) { 866 DBG("enable otg5v failed\n"); 867 return; 868 } 869 } 870 disable_irq(charge->plugin_irq); 871 disable_irq(charge->plugout_irq); 872 DBG("enable otg5v\n"); 873 } 874 break; 875 876 case USB_OTG_POWER_OFF: 877 if (!charge->otg_in) { 878 DBG("otg5v is off yet, ignore..\n"); 879 } else { 880 881 if (rk817_charge_get_otg_state(charge)) { 882 rk817_charge_otg_disable(charge); 883 if (rk817_charge_get_otg_state(charge)) { 884 DBG("disable otg5v failed\n"); 885 return; 886 } 887 } 888 enable_irq(charge->plugin_irq); 889 enable_irq(charge->plugout_irq); 890 DBG("disable otg5v\n"); 891 } 892 break; 893 default: 894 dev_err(charge->dev, "error otg type\n"); 895 break; 896 } 897} 898 899static irqreturn_t rk817_charge_dc_det_isr(int irq, void *charger) 900{ 901 struct rk817_charger *charge = (struct rk817_charger *)charger; 902 903 if (gpio_get_value(charge->pdata->dc_det_pin)) 904 irq_set_irq_type(irq, IRQF_TRIGGER_LOW); 905 else 906 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH); 907 908 queue_delayed_work(charge->dc_charger_wq, &charge->dc_work, 909 msecs_to_jiffies(10)); 910 911 return IRQ_HANDLED; 912} 913 914static enum charger_t rk817_charge_get_dc_state(struct rk817_charger *charge) 915{ 916 int level; 917 918 if (!gpio_is_valid(charge->pdata->dc_det_pin)) 919 return DC_TYPE_NONE_CHARGER; 920 921 level = gpio_get_value(charge->pdata->dc_det_pin); 922 923 return (level == charge->pdata->dc_det_level) ? 924 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER; 925} 926 927static void rk817_charge_dc_det_worker(struct work_struct *work) 928{ 929 enum charger_t charger; 930 struct rk817_charger *charge = container_of(work, 931 struct rk817_charger, dc_work.work); 932 933 charger = rk817_charge_get_dc_state(charge); 934 if (charger == DC_TYPE_DC_CHARGER) { 935 DBG("detect dc charger in..\n"); 936 rk817_charge_set_chrg_param(charge, DC_TYPE_DC_CHARGER); 937 /* check otg supply */ 938 if (charge->otg_in && charge->pdata->power_dc2otg) { 939 DBG("otg power from dc adapter\n"); 940 rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF); 941 } 942 943 rk817_charge_boost_disable(charge); 944 } else { 945 DBG("detect dc charger out..\n"); 946 rk817_charge_set_chrg_param(charge, DC_TYPE_NONE_CHARGER); 947 rk817_charge_boost_enable(charge); 948 /* check otg supply, power on anyway */ 949 if (charge->otg_in) 950 rk817_charge_set_otg_state(charge, USB_OTG_POWER_ON); 951 } 952} 953 954static int rk817_charge_init_dc(struct rk817_charger *charge) 955{ 956 int ret, level; 957 unsigned long irq_flags; 958 unsigned int dc_det_irq; 959 960 charge->dc_charger_wq = alloc_ordered_workqueue("%s", 961 WQ_MEM_RECLAIM | WQ_FREEZABLE, 962 "rk817-dc-wq"); 963 INIT_DELAYED_WORK(&charge->dc_work, rk817_charge_dc_det_worker); 964 charge->dc_charger = DC_TYPE_NONE_CHARGER; 965 966 if (!charge->pdata->support_dc_det) 967 return 0; 968 969 ret = devm_gpio_request(charge->dev, 970 charge->pdata->dc_det_pin, 971 "rk817_dc_det"); 972 if (ret < 0) { 973 dev_err(charge->dev, "failed to request gpio %d\n", 974 charge->pdata->dc_det_pin); 975 return ret; 976 } 977 978 ret = gpio_direction_input(charge->pdata->dc_det_pin); 979 if (ret) { 980 dev_err(charge->dev, "failed to set gpio input\n"); 981 return ret; 982 } 983 984 level = gpio_get_value(charge->pdata->dc_det_pin); 985 if (level == charge->pdata->dc_det_level) 986 charge->dc_charger = DC_TYPE_DC_CHARGER; 987 else 988 charge->dc_charger = DC_TYPE_NONE_CHARGER; 989 990 if (level) 991 irq_flags = IRQF_TRIGGER_LOW; 992 else 993 irq_flags = IRQF_TRIGGER_HIGH; 994 995 dc_det_irq = gpio_to_irq(charge->pdata->dc_det_pin); 996 ret = devm_request_irq(charge->dev, dc_det_irq, rk817_charge_dc_det_isr, 997 irq_flags, "rk817_dc_det", charge); 998 if (ret != 0) { 999 dev_err(charge->dev, "rk817_dc_det_irq request failed!\n"); 1000 return ret; 1001 } 1002 1003 enable_irq_wake(dc_det_irq); 1004 1005 if (charge->dc_charger != DC_TYPE_NONE_CHARGER) 1006 rk817_charge_set_chrg_param(charge, charge->dc_charger); 1007 1008 return 0; 1009} 1010 1011static void rk817_charge_host_evt_worker(struct work_struct *work) 1012{ 1013 struct rk817_charger *charge = container_of(work, 1014 struct rk817_charger, host_work.work); 1015 struct extcon_dev *edev = charge->cable_edev; 1016 1017 /* Determine cable/charger type */ 1018 if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) > 0) { 1019 DBG("receive type-c notifier event: OTG ON...\n"); 1020 if (charge->dc_in && charge->pdata->power_dc2otg) { 1021 if (charge->otg_in) 1022 rk817_charge_set_otg_state(charge, 1023 USB_OTG_POWER_OFF); 1024 DBG("otg power from dc adapter\n"); 1025 } else { 1026 rk817_charge_set_otg_state(charge, USB_OTG_POWER_ON); 1027 } 1028 rk817_charge_set_otg_in(charge, ONLINE); 1029 } else if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) == 0) { 1030 DBG("receive type-c notifier event: OTG OFF...\n"); 1031 rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF); 1032 rk817_charge_set_otg_in(charge, OFFLINE); 1033 } 1034} 1035 1036static void rk817_charger_evt_worker(struct work_struct *work) 1037{ 1038 struct rk817_charger *charge = container_of(work, 1039 struct rk817_charger, usb_work.work); 1040 struct extcon_dev *edev = charge->cable_edev; 1041 enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER; 1042 static const char * const event[] = {"UN", "NONE", "USB", 1043 "AC", "CDP1.5A"}; 1044 1045 /* Determine cable/charger type */ 1046 if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0) 1047 charger = USB_TYPE_USB_CHARGER; 1048 else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0) 1049 charger = USB_TYPE_AC_CHARGER; 1050 else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0) 1051 charger = USB_TYPE_CDP_CHARGER; 1052 1053 if (charger != USB_TYPE_UNKNOWN_CHARGER) { 1054 DBG("receive type-c notifier event: %s...\n", 1055 event[charger]); 1056 charge->usb_charger = charger; 1057 rk817_charge_set_chrg_param(charge, charger); 1058 } 1059} 1060 1061static void rk817_charge_discnt_evt_worker(struct work_struct *work) 1062{ 1063 struct rk817_charger *charge = container_of(work, 1064 struct rk817_charger, discnt_work.work); 1065 1066 if (extcon_get_state(charge->cable_edev, EXTCON_USB) == 0) { 1067 DBG("receive type-c notifier event: DISCNT...\n"); 1068 1069 rk817_charge_set_chrg_param(charge, USB_TYPE_NONE_CHARGER); 1070 } 1071} 1072 1073static void rk817_charge_bc_evt_worker(struct work_struct *work) 1074{ 1075 struct rk817_charger *charge = container_of(work, 1076 struct rk817_charger, 1077 usb_work.work); 1078 static const char * const event_name[] = {"DISCNT", "USB", "AC", 1079 "CDP1.5A", "UNKNOWN", 1080 "OTG ON", "OTG OFF"}; 1081 1082 switch (charge->bc_event) { 1083 case USB_BC_TYPE_DISCNT: 1084 rk817_charge_set_chrg_param(charge, USB_TYPE_NONE_CHARGER); 1085 break; 1086 case USB_BC_TYPE_SDP: 1087 rk817_charge_set_chrg_param(charge, USB_TYPE_USB_CHARGER); 1088 break; 1089 case USB_BC_TYPE_DCP: 1090 rk817_charge_set_chrg_param(charge, USB_TYPE_AC_CHARGER); 1091 break; 1092 case USB_BC_TYPE_CDP: 1093 rk817_charge_set_chrg_param(charge, USB_TYPE_CDP_CHARGER); 1094 break; 1095 case USB_OTG_POWER_ON: 1096 if (charge->pdata->power_dc2otg && charge->dc_in) 1097 DBG("otg power from dc adapter\n"); 1098 else 1099 rk817_charge_set_otg_state(charge, USB_OTG_POWER_ON); 1100 break; 1101 case USB_OTG_POWER_OFF: 1102 rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF); 1103 break; 1104 default: 1105 break; 1106 } 1107 1108 DBG("receive bc notifier event: %s..\n", event_name[charge->bc_event]); 1109} 1110 1111static int rk817_charger_evt_notifier(struct notifier_block *nb, 1112 unsigned long event, void *ptr) 1113{ 1114 struct rk817_charger *charge = 1115 container_of(nb, struct rk817_charger, cable_cg_nb); 1116 1117 queue_delayed_work(charge->usb_charger_wq, &charge->usb_work, 1118 msecs_to_jiffies(10)); 1119 1120 return NOTIFY_DONE; 1121} 1122 1123static int rk817_charge_host_evt_notifier(struct notifier_block *nb, 1124 unsigned long event, void *ptr) 1125{ 1126 struct rk817_charger *charge = 1127 container_of(nb, struct rk817_charger, cable_host_nb); 1128 1129 queue_delayed_work(charge->usb_charger_wq, &charge->host_work, 1130 msecs_to_jiffies(10)); 1131 1132 return NOTIFY_DONE; 1133} 1134 1135static int rk817_charge_discnt_evt_notfier(struct notifier_block *nb, 1136 unsigned long event, void *ptr) 1137{ 1138 struct rk817_charger *charge = 1139 container_of(nb, struct rk817_charger, cable_discnt_nb); 1140 1141 queue_delayed_work(charge->usb_charger_wq, &charge->discnt_work, 1142 msecs_to_jiffies(10)); 1143 1144 return NOTIFY_DONE; 1145} 1146 1147static int rk817_charge_bc_evt_notifier(struct notifier_block *nb, 1148 unsigned long event, void *ptr) 1149{ 1150 struct rk817_charger *charge = 1151 container_of(nb, struct rk817_charger, bc_nb); 1152 1153 charge->bc_event = event; 1154 queue_delayed_work(charge->usb_charger_wq, &charge->usb_work, 1155 msecs_to_jiffies(10)); 1156 1157 return NOTIFY_DONE; 1158} 1159 1160static int rk817_charge_usb_init(struct rk817_charger *charge) 1161{ 1162 enum charger_t charger; 1163 enum bc_port_type bc_type; 1164 struct extcon_dev *edev; 1165 struct device *dev = charge->dev; 1166 int ret; 1167 1168 charge->usb_charger_wq = alloc_ordered_workqueue("%s", 1169 WQ_MEM_RECLAIM | WQ_FREEZABLE, 1170 "rk817-usb-wq"); 1171 1172 /* type-C */ 1173 if (charge->pdata->extcon) { 1174 edev = extcon_get_edev_by_phandle(dev, 0); 1175 if (IS_ERR(edev)) { 1176 if (PTR_ERR(edev) != -EPROBE_DEFER) 1177 dev_err(dev, "Invalid or missing extcon\n"); 1178 return PTR_ERR(edev); 1179 } 1180 1181 /* Register chargers */ 1182 INIT_DELAYED_WORK(&charge->usb_work, rk817_charger_evt_worker); 1183 charge->cable_cg_nb.notifier_call = rk817_charger_evt_notifier; 1184 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP, 1185 &charge->cable_cg_nb); 1186 if (ret < 0) { 1187 dev_err(dev, "failed to register notifier for SDP\n"); 1188 return ret; 1189 } 1190 1191 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP, 1192 &charge->cable_cg_nb); 1193 if (ret < 0) { 1194 dev_err(dev, "failed to register notifier for DCP\n"); 1195 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP, 1196 &charge->cable_cg_nb); 1197 return ret; 1198 } 1199 1200 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP, 1201 &charge->cable_cg_nb); 1202 if (ret < 0) { 1203 dev_err(dev, "failed to register notifier for CDP\n"); 1204 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP, 1205 &charge->cable_cg_nb); 1206 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP, 1207 &charge->cable_cg_nb); 1208 return ret; 1209 } 1210 1211 /* Register host */ 1212 INIT_DELAYED_WORK(&charge->host_work, 1213 rk817_charge_host_evt_worker); 1214 charge->cable_host_nb.notifier_call = 1215 rk817_charge_host_evt_notifier; 1216 ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN, 1217 &charge->cable_host_nb); 1218 if (ret < 0) { 1219 dev_err(dev, "failed to register notifier for HOST\n"); 1220 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP, 1221 &charge->cable_cg_nb); 1222 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP, 1223 &charge->cable_cg_nb); 1224 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP, 1225 &charge->cable_cg_nb); 1226 1227 return ret; 1228 } 1229 1230 /* Register discnt usb */ 1231 INIT_DELAYED_WORK(&charge->discnt_work, 1232 rk817_charge_discnt_evt_worker); 1233 charge->cable_discnt_nb.notifier_call = 1234 rk817_charge_discnt_evt_notfier; 1235 ret = extcon_register_notifier(edev, EXTCON_USB, 1236 &charge->cable_discnt_nb); 1237 if (ret < 0) { 1238 dev_err(dev, "failed to register notifier for HOST\n"); 1239 extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP, 1240 &charge->cable_cg_nb); 1241 extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP, 1242 &charge->cable_cg_nb); 1243 extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP, 1244 &charge->cable_cg_nb); 1245 extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN, 1246 &charge->cable_host_nb); 1247 return ret; 1248 } 1249 1250 charge->cable_edev = edev; 1251 1252 DBG("register typec extcon evt notifier\n"); 1253 } else { 1254 INIT_DELAYED_WORK(&charge->usb_work, 1255 rk817_charge_bc_evt_worker); 1256 charge->bc_nb.notifier_call = rk817_charge_bc_evt_notifier; 1257 ret = rk_bc_detect_notifier_register(&charge->bc_nb, &bc_type); 1258 if (ret) { 1259 dev_err(dev, "failed to register notifier for bc\n"); 1260 return -EINVAL; 1261 } 1262 1263 switch (bc_type) { 1264 case USB_BC_TYPE_DISCNT: 1265 charger = USB_TYPE_NONE_CHARGER; 1266 break; 1267 case USB_BC_TYPE_SDP: 1268 case USB_BC_TYPE_CDP: 1269 charger = USB_TYPE_USB_CHARGER; 1270 break; 1271 case USB_BC_TYPE_DCP: 1272 charger = USB_TYPE_AC_CHARGER; 1273 break; 1274 default: 1275 charger = USB_TYPE_NONE_CHARGER; 1276 break; 1277 } 1278 1279 charge->usb_charger = charger; 1280 if (charge->dc_charger != DC_TYPE_NONE_CHARGER) 1281 rk817_charge_set_chrg_param(charge, 1282 charge->usb_charger); 1283 1284 DBG("register bc evt notifier\n"); 1285 } 1286 1287 return 0; 1288} 1289 1290static void rk817_charge_pre_init(struct rk817_charger *charge) 1291{ 1292 charge->max_chrg_current = charge->pdata->max_chrg_current; 1293 charge->max_input_current = charge->pdata->max_input_current; 1294 charge->max_chrg_voltage = charge->pdata->max_chrg_voltage; 1295 charge->min_input_voltage = charge->pdata->min_input_voltage; 1296 charge->chrg_finish_cur = charge->pdata->chrg_finish_cur; 1297 charge->chrg_term_mode = charge->pdata->chrg_term_mode; 1298 1299 rk817_charge_set_input_voltage(charge, charge->min_input_voltage); 1300 1301 rk817_charge_set_chrg_voltage(charge, charge->max_chrg_voltage); 1302 rk817_charge_set_chrg_current(charge, charge->max_chrg_current); 1303 1304 rk817_charge_set_chrg_finish_condition(charge); 1305 1306 if (rk817_charge_get_otg_state(charge)) 1307 rk817_charge_otg_disable(charge); 1308 rk817_charge_field_write(charge, OTG_EN, OTG_DISABLE); 1309 rk817_charge_set_otg_in(charge, OFFLINE); 1310 1311 if (!charge->pdata->gate_function_disable) 1312 rk817_charge_sys_can_sd_disable(charge); 1313 rk817_charge_usb_to_sys_enable(charge); 1314 rk817_charge_enable_charge(charge); 1315 1316 rk817_charge_set_charge_clock(charge, CHRG_CLK_2M); 1317} 1318 1319static void rk817_chage_debug(struct rk817_charger *charge) 1320{ 1321 rk817_charge_get_charge_status(charge); 1322 DBG("OTG state : %d\n", rk817_charge_get_otg_state(charge)); 1323 DBG("charge state: %d\n", rk817_charge_get_charge_state(charge)); 1324 DBG("max_chrg_current: %d\n" 1325 "max_input_current: %d\n" 1326 "min_input_voltage: %d\n" 1327 "max_chrg_voltage: %d\n" 1328 "max_chrg_finish_cur: %d\n" 1329 "chrg_term_mode: %d\n", 1330 charge->max_chrg_current, 1331 charge->max_input_current, 1332 charge->min_input_voltage, 1333 charge->max_chrg_voltage, 1334 charge->chrg_finish_cur, 1335 charge->chrg_term_mode); 1336} 1337 1338static int rk817_charge_get_otg5v_regulator(struct rk817_charger *charge) 1339{ 1340 int ret; 1341 1342 charge->otg5v_rdev = devm_regulator_get(charge->dev, "otg_switch"); 1343 if (IS_ERR(charge->otg5v_rdev)) { 1344 ret = PTR_ERR(charge->otg5v_rdev); 1345 dev_warn(charge->dev, "failed to get otg regulator: %d\n", ret); 1346 } 1347 1348 return 0; 1349} 1350 1351#ifdef CONFIG_OF 1352static int rk817_charge_parse_dt(struct rk817_charger *charge) 1353{ 1354 struct charger_platform_data *pdata; 1355 enum of_gpio_flags flags; 1356 struct device *dev = charge->dev; 1357 struct device_node *np = charge->dev->of_node; 1358 int ret; 1359 1360 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 1361 if (!pdata) 1362 return -ENOMEM; 1363 1364 charge->pdata = pdata; 1365 pdata->max_chrg_current = DEFAULT_CHRG_CURRENT; 1366 pdata->max_input_current = DEFAULT_INPUT_CURRENT; 1367 pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE; 1368 pdata->min_input_voltage = DEFAULT_INPUT_VOLTAGE; 1369 pdata->chrg_finish_cur = DEFAULT_CHRG_TERM_CUR; 1370 pdata->chrg_term_mode = DEFAULT_CHRG_TERM_MODE; 1371 1372 pdata->extcon = of_property_read_bool(np, "extcon"); 1373 1374 ret = of_property_read_u32(np, "max_chrg_current", 1375 &pdata->max_chrg_current); 1376 if (ret < 0) 1377 dev_err(dev, "max_chrg_current missing!\n"); 1378 1379 ret = of_property_read_u32(np, "max_input_current", 1380 &pdata->max_input_current); 1381 if (ret < 0) 1382 dev_err(dev, "max_input_current missing!\n"); 1383 1384 ret = of_property_read_u32(np, "max_chrg_voltage", 1385 &pdata->max_chrg_voltage); 1386 if (ret < 0) 1387 dev_err(dev, "max_chrg_voltage missing!\n"); 1388 1389 ret = of_property_read_u32(np, "min_input_voltage", 1390 &pdata->min_input_voltage); 1391 if (ret < 0) 1392 dev_WARN(dev, "min_input_voltage missing!\n"); 1393 1394 ret = of_property_read_u32(np, "chrg_finish_cur", 1395 &pdata->chrg_finish_cur); 1396 1397 if (ret < 0) 1398 dev_WARN(dev, "chrg_term_mode missing!\n"); 1399 1400 ret = of_property_read_u32(np, "chrg_term_mode", 1401 &pdata->chrg_term_mode); 1402 if (ret < 0) 1403 dev_WARN(dev, "chrg_term_mode missing!\n"); 1404 1405 ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power); 1406 if (ret < 0) 1407 dev_err(dev, "virtual_power missing!\n"); 1408 1409 ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg); 1410 if (ret < 0) 1411 dev_err(dev, "power_dc2otg missing!\n"); 1412 1413 ret = of_property_read_u32(np, "sample_res", &pdata->sample_res); 1414 if (ret < 0) { 1415 pdata->sample_res = SAMPLE_RES_10MR; 1416 dev_err(dev, "sample_res missing!\n"); 1417 } 1418 1419 ret = of_property_read_u32(np, "otg5v_suspend_enable", 1420 &pdata->otg5v_suspend_enable); 1421 if (ret < 0) { 1422 pdata->otg5v_suspend_enable = 1; 1423 dev_err(dev, "otg5v_suspend_enable missing!\n"); 1424 } 1425 1426 ret = of_property_read_u32(np, "gate_function_disable", 1427 &pdata->gate_function_disable); 1428 if (ret < 0) 1429 dev_err(dev, "gate_function_disable missing!\n"); 1430 1431 if (!is_battery_exist(charge)) 1432 pdata->virtual_power = 1; 1433 1434 charge->res_div = (charge->pdata->sample_res == SAMPLE_RES_10MR) ? 1435 SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2; 1436 1437 if (!of_find_property(np, "dc_det_gpio", &ret)) { 1438 pdata->support_dc_det = false; 1439 DBG("not support dc\n"); 1440 } else { 1441 pdata->support_dc_det = true; 1442 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio", 1443 0, &flags); 1444 if (gpio_is_valid(pdata->dc_det_pin)) { 1445 DBG("support dc\n"); 1446 pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ? 1447 0 : 1; 1448 } else { 1449 dev_err(dev, "invalid dc det gpio!\n"); 1450 return -EINVAL; 1451 } 1452 } 1453 1454 DBG("input_current:%d\n" 1455 "input_min_voltage: %d\n" 1456 "chrg_current:%d\n" 1457 "chrg_voltage:%d\n" 1458 "sample_res:%d\n" 1459 "extcon:%d\n" 1460 "virtual_power:%d\n" 1461 "power_dc2otg:%d\n", 1462 pdata->max_input_current, pdata->min_input_voltage, 1463 pdata->max_chrg_current, pdata->max_chrg_voltage, 1464 pdata->sample_res, pdata->extcon, 1465 pdata->virtual_power, pdata->power_dc2otg); 1466 1467 return 0; 1468} 1469#else 1470static int rk817_charge_parse_dt(struct rk817_charger *charge) 1471{ 1472 return -ENODEV; 1473} 1474#endif 1475 1476static void rk817_charge_irq_delay_work(struct work_struct *work) 1477{ 1478 struct rk817_charger *charge = container_of(work, 1479 struct rk817_charger, irq_work.work); 1480 1481 if (charge->plugin_trigger) { 1482 DBG("pmic: plug in\n"); 1483 charge->plugin_trigger = 0; 1484 if (charge->pdata->extcon) 1485 queue_delayed_work(charge->usb_charger_wq, &charge->usb_work, 1486 msecs_to_jiffies(10)); 1487 } else if (charge->plugout_trigger) { 1488 DBG("pmic: plug out\n"); 1489 charge->plugout_trigger = 0; 1490 rk817_charge_set_chrg_param(charge, USB_TYPE_NONE_CHARGER); 1491 rk817_charge_set_chrg_param(charge, DC_TYPE_NONE_CHARGER); 1492 } else { 1493 DBG("pmic: unknown irq\n"); 1494 } 1495} 1496 1497static irqreturn_t rk817_plug_in_isr(int irq, void *cg) 1498{ 1499 struct rk817_charger *charge; 1500 1501 charge = (struct rk817_charger *)cg; 1502 charge->plugin_trigger = 1; 1503 queue_delayed_work(charge->usb_charger_wq, &charge->irq_work, 1504 msecs_to_jiffies(10)); 1505 1506 return IRQ_HANDLED; 1507} 1508 1509static irqreturn_t rk817_plug_out_isr(int irq, void *cg) 1510{ 1511 struct rk817_charger *charge; 1512 1513 charge = (struct rk817_charger *)cg; 1514 charge->plugout_trigger = 1; 1515 queue_delayed_work(charge->usb_charger_wq, &charge->irq_work, 1516 msecs_to_jiffies(10)); 1517 1518 return IRQ_HANDLED; 1519} 1520 1521static int rk817_charge_init_irqs(struct rk817_charger *charge) 1522{ 1523 struct rk808 *rk817 = charge->rk817; 1524 struct platform_device *pdev = charge->pdev; 1525 int ret, plug_in_irq, plug_out_irq; 1526 1527 plug_in_irq = regmap_irq_get_virq(rk817->irq_data, RK817_IRQ_PLUG_IN); 1528 if (plug_in_irq < 0) { 1529 dev_err(charge->dev, "plug_in_irq request failed!\n"); 1530 return plug_in_irq; 1531 } 1532 1533 plug_out_irq = regmap_irq_get_virq(rk817->irq_data, RK817_IRQ_PLUG_OUT); 1534 if (plug_out_irq < 0) { 1535 dev_err(charge->dev, "plug_out_irq request failed!\n"); 1536 return plug_out_irq; 1537 } 1538 1539 ret = devm_request_threaded_irq(charge->dev, plug_in_irq, NULL, 1540 rk817_plug_in_isr, 1541 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 1542 "rk817_plug_in", charge); 1543 if (ret) { 1544 dev_err(&pdev->dev, "plug_in_irq request failed!\n"); 1545 return ret; 1546 } 1547 1548 ret = devm_request_threaded_irq(charge->dev, plug_out_irq, NULL, 1549 rk817_plug_out_isr, 1550 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 1551 "rk817_plug_out", charge); 1552 if (ret) { 1553 dev_err(&pdev->dev, "plug_out_irq request failed!\n"); 1554 return ret; 1555 } 1556 1557 charge->plugin_irq = plug_in_irq; 1558 charge->plugout_irq = plug_out_irq; 1559 1560 INIT_DELAYED_WORK(&charge->irq_work, rk817_charge_irq_delay_work); 1561 1562 return 0; 1563} 1564 1565static const struct of_device_id rk817_charge_of_match[] = { 1566 { .compatible = "rk817,charger", }, 1567 { }, 1568}; 1569 1570static int rk817_charge_probe(struct platform_device *pdev) 1571{ 1572 struct rk808 *rk817 = dev_get_drvdata(pdev->dev.parent); 1573 const struct of_device_id *of_id = 1574 of_match_device(rk817_charge_of_match, &pdev->dev); 1575 struct i2c_client *client = rk817->i2c; 1576 struct rk817_charger *charge; 1577 int i; 1578 int ret; 1579 1580 if (!of_id) { 1581 dev_err(&pdev->dev, "Failed to find matching dt id\n"); 1582 return -ENODEV; 1583 } 1584 1585 charge = devm_kzalloc(&pdev->dev, sizeof(*charge), GFP_KERNEL); 1586 if (!charge) 1587 return -EINVAL; 1588 1589 charge->rk817 = rk817; 1590 charge->pdev = pdev; 1591 charge->dev = &pdev->dev; 1592 charge->client = client; 1593 platform_set_drvdata(pdev, charge); 1594 1595 charge->regmap = rk817->regmap; 1596 if (IS_ERR(charge->regmap)) { 1597 dev_err(charge->dev, "Failed to initialize regmap\n"); 1598 return -EINVAL; 1599 } 1600 1601 for (i = 0; i < ARRAY_SIZE(rk817_charge_reg_fields); i++) { 1602 const struct reg_field *reg_fields = rk817_charge_reg_fields; 1603 1604 charge->rmap_fields[i] = 1605 devm_regmap_field_alloc(charge->dev, 1606 charge->regmap, 1607 reg_fields[i]); 1608 if (IS_ERR(charge->rmap_fields[i])) { 1609 dev_err(charge->dev, "cannot allocate regmap field\n"); 1610 return PTR_ERR(charge->rmap_fields[i]); 1611 } 1612 } 1613 1614 ret = rk817_charge_parse_dt(charge); 1615 if (ret < 0) { 1616 dev_err(charge->dev, "charge parse dt failed!\n"); 1617 return ret; 1618 } 1619 rk817_charge_get_otg5v_regulator(charge); 1620 1621 rk817_charge_pre_init(charge); 1622 1623 ret = rk817_charge_init_power_supply(charge); 1624 if (ret) { 1625 dev_err(charge->dev, "init power supply fail!\n"); 1626 return ret; 1627 } 1628 1629 ret = rk817_charge_init_dc(charge); 1630 if (ret) { 1631 dev_err(charge->dev, "init dc failed!\n"); 1632 return ret; 1633 } 1634 1635 ret = rk817_charge_usb_init(charge); 1636 if (ret) { 1637 dev_err(charge->dev, "init usb failed!\n"); 1638 return ret; 1639 } 1640 1641 ret = rk817_charge_init_irqs(charge); 1642 if (ret) { 1643 dev_err(charge->dev, "init irqs failed!\n"); 1644 goto irq_fail; 1645 } 1646 1647 if (charge->pdata->extcon) { 1648 schedule_delayed_work(&charge->host_work, 0); 1649 schedule_delayed_work(&charge->usb_work, 0); 1650 } 1651 1652 rk817_chage_debug(charge); 1653 DBG("driver version: %s\n", CHARGE_DRIVER_VERSION); 1654 1655 return 0; 1656irq_fail: 1657 if (charge->pdata->extcon) { 1658 cancel_delayed_work_sync(&charge->host_work); 1659 cancel_delayed_work_sync(&charge->discnt_work); 1660 } 1661 1662 cancel_delayed_work_sync(&charge->usb_work); 1663 cancel_delayed_work_sync(&charge->dc_work); 1664 cancel_delayed_work_sync(&charge->irq_work); 1665 destroy_workqueue(charge->usb_charger_wq); 1666 destroy_workqueue(charge->dc_charger_wq); 1667 1668 if (charge->pdata->extcon) { 1669 extcon_unregister_notifier(charge->cable_edev, 1670 EXTCON_CHG_USB_SDP, 1671 &charge->cable_cg_nb); 1672 extcon_unregister_notifier(charge->cable_edev, 1673 EXTCON_CHG_USB_DCP, 1674 &charge->cable_cg_nb); 1675 extcon_unregister_notifier(charge->cable_edev, 1676 EXTCON_CHG_USB_CDP, 1677 &charge->cable_cg_nb); 1678 extcon_unregister_notifier(charge->cable_edev, 1679 EXTCON_USB_VBUS_EN, 1680 &charge->cable_host_nb); 1681 extcon_unregister_notifier(charge->cable_edev, 1682 EXTCON_USB, 1683 &charge->cable_discnt_nb); 1684 } else { 1685 rk_bc_detect_notifier_unregister(&charge->bc_nb); 1686 } 1687 1688 return ret; 1689} 1690 1691#ifdef CONFIG_PM_SLEEP 1692static int rk817_charge_pm_suspend(struct device *dev) 1693{ 1694 struct platform_device *pdev = to_platform_device(dev); 1695 struct rk817_charger *charge = dev_get_drvdata(&pdev->dev); 1696 1697 charge->otg_slp_state = rk817_charge_get_otg_slp_state(charge); 1698 1699 /* enable sleep boost5v and otg5v */ 1700 if (charge->pdata->otg5v_suspend_enable) { 1701 if ((charge->otg_in && !charge->dc_in) || 1702 (charge->otg_in && charge->dc_in && 1703 !charge->pdata->power_dc2otg)) { 1704 rk817_charge_otg_slp_enable(charge); 1705 DBG("suspend: otg 5v on\n"); 1706 return 0; 1707 } 1708 } 1709 1710 /* disable sleep otg5v */ 1711 rk817_charge_otg_slp_disable(charge); 1712 DBG("suspend: otg 5v off\n"); 1713 return 0; 1714} 1715 1716static int rk817_charge_pm_resume(struct device *dev) 1717{ 1718 struct platform_device *pdev = to_platform_device(dev); 1719 struct rk817_charger *charge = dev_get_drvdata(&pdev->dev); 1720 1721 /* resume sleep boost5v and otg5v */ 1722 if (charge->otg_slp_state) 1723 rk817_charge_otg_slp_enable(charge); 1724 1725 return 0; 1726} 1727#endif 1728static SIMPLE_DEV_PM_OPS(rk817_charge_pm_ops, 1729 rk817_charge_pm_suspend, rk817_charge_pm_resume); 1730 1731static void rk817_charger_shutdown(struct platform_device *dev) 1732{ 1733 struct rk817_charger *charge = platform_get_drvdata(dev); 1734 1735 /* type-c only */ 1736 if (charge->pdata->extcon) { 1737 cancel_delayed_work_sync(&charge->host_work); 1738 cancel_delayed_work_sync(&charge->discnt_work); 1739 } 1740 1741 rk817_charge_set_otg_state(charge, USB_OTG_POWER_OFF); 1742 rk817_charge_boost_disable(charge); 1743 disable_irq(charge->plugin_irq); 1744 disable_irq(charge->plugout_irq); 1745 1746 cancel_delayed_work_sync(&charge->usb_work); 1747 cancel_delayed_work_sync(&charge->dc_work); 1748 cancel_delayed_work_sync(&charge->irq_work); 1749 flush_workqueue(charge->usb_charger_wq); 1750 flush_workqueue(charge->dc_charger_wq); 1751 1752 if (charge->pdata->extcon) { 1753 extcon_unregister_notifier(charge->cable_edev, 1754 EXTCON_CHG_USB_SDP, 1755 &charge->cable_cg_nb); 1756 extcon_unregister_notifier(charge->cable_edev, 1757 EXTCON_CHG_USB_DCP, 1758 &charge->cable_cg_nb); 1759 extcon_unregister_notifier(charge->cable_edev, 1760 EXTCON_CHG_USB_CDP, 1761 &charge->cable_cg_nb); 1762 extcon_unregister_notifier(charge->cable_edev, 1763 EXTCON_USB_VBUS_EN, 1764 &charge->cable_host_nb); 1765 extcon_unregister_notifier(charge->cable_edev, EXTCON_USB, 1766 &charge->cable_discnt_nb); 1767 } else { 1768 rk_bc_detect_notifier_unregister(&charge->bc_nb); 1769 } 1770 1771 DBG("shutdown: ac=%d usb=%d dc=%d otg=%d\n", 1772 charge->ac_in, charge->usb_in, charge->dc_in, charge->otg_in); 1773} 1774 1775static struct platform_driver rk817_charge_driver = { 1776 .probe = rk817_charge_probe, 1777 .shutdown = rk817_charger_shutdown, 1778 .driver = { 1779 .name = "rk817-charger", 1780 .pm = &rk817_charge_pm_ops, 1781 .of_match_table = of_match_ptr(rk817_charge_of_match), 1782 }, 1783}; 1784 1785static int __init rk817_charge_init(void) 1786{ 1787 return platform_driver_register(&rk817_charge_driver); 1788} 1789fs_initcall_sync(rk817_charge_init); 1790 1791static void __exit rk817_charge_exit(void) 1792{ 1793 platform_driver_unregister(&rk817_charge_driver); 1794} 1795module_exit(rk817_charge_exit); 1796 1797MODULE_DESCRIPTION("RK817 Charge driver"); 1798MODULE_LICENSE("GPL"); 1799