drivers/power/rk818_charger.c

   1 /*
   2  * rk818 charger driver
   3  *
   4  * Copyright (C) 2016 Rockchip Electronics Co., Ltd
   5  * chenjh <chenjh@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/irq.h>
  22 #include <linux/irqdomain.h>
  23 #include <linux/jiffies.h>
  24 #include <linux/kernel.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
  37 static int dbg_enable = 0;
  38 module_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 CG_INFO(fmt, args...) pr_info("rk818-charger: "fmt, ##args)
  48
  49 #define DEFAULT_CHRG_CURRENT    1400
  50 #define DEFAULT_INPUT_CURRENT   2000
  51 #define DEFAULT_CHRG_VOLTAGE    4200
  52 #define SAMPLE_RES_10MR         10
  53 #define SAMPLE_RES_20MR         20
  54 #define SAMPLE_RES_DIV1         1
  55 #define SAMPLE_RES_DIV2         2
  56
  57 /* RK818_USB_CTRL_REG */
  58 #define INPUT_CUR450MA          (0x00)
  59 #define INPUT_CUR1500MA         (0x05)
  60 #define INPUT_CUR_MSK           (0x0f)
  61 /* RK818_CHRG_CTRL_REG3 */
  62 #define CHRG_FINISH_MODE_MSK    BIT(5)
  63 #define CHRG_FINISH_ANA_SIGNAL  (0)
  64 #define CHRG_FINISH_DIG_SIGNAL  BIT(5)
  65 /* RK818_SUP_STS_REG */
  66 #define BAT_EXS                 BIT(7)
  67 #define USB_VLIMIT_EN           BIT(3)
  68 #define USB_CLIMIT_EN           BIT(2)
  69 /* RK818_CHRG_CTRL_REG1 */
  70 #define CHRG_EN                 BIT(7)
  71 /* RK818_INT_STS_MSK_REG2 */
  72 #define CHRG_CVTLMT_INT_MSK     BIT(6)
  73 #define PLUG_OUT_MSK            BIT(1)
  74 #define PLUG_IN_MSK             BIT(0)
  75 /* RK818_VB_MON_REG */
  76 #define PLUG_IN_STS             BIT(6)
  77 /* RK818_TS_CTRL_REG */
  78 #define GG_EN                   BIT(7)
  79
  80 #define DRIVER_VERSION          "1.0"
  81
  82 extern void rk_send_wakeup_key(void);
  83
  84 static const u16 chrg_vol_sel_array[] = {
  85         4050, 4100, 4150, 4200, 4250, 4300, 4350
  86 };
  87
  88 static const u16 chrg_cur_sel_array[] = {
  89         1000, 1200, 1400, 1600, 1800, 2000, 2250, 2400, 2600, 2800, 3000
  90 };
  91
  92 static const u16 chrg_cur_input_array[] = {
  93         450, 800, 850, 1000, 1250, 1500, 1750, 2000, 2250, 2500, 2750, 3000
  94 };
  95
  96 enum charger_t {
  97         USB_TYPE_UNKNOWN_CHARGER,
  98         USB_TYPE_NONE_CHARGER,
  99         USB_TYPE_USB_CHARGER,
 100         USB_TYPE_AC_CHARGER,
 101         USB_TYPE_CDP_CHARGER,
 102         DC_TYPE_DC_CHARGER,
 103         DC_TYPE_NONE_CHARGER,
 104 };
 105
 106 struct charger_platform_data {
 107         u32 max_input_current;
 108         u32 max_chrg_current;
 109         u32 max_chrg_voltage;
 110         u32 pwroff_vol;
 111         u32 power_dc2otg;
 112         u32 dc_det_level;
 113         int dc_det_pin;
 114         bool support_dc_det;
 115         int virtual_power;
 116         int sample_res;
 117         bool extcon;
 118 };
 119
 120 struct rk818_charger {
 121         struct platform_device *pdev;
 122         struct device *dev;
 123         struct rk808 *rk818;
 124         struct regmap *regmap;
 125         struct power_supply *ac_psy;
 126         struct power_supply *usb_psy;
 127         struct extcon_dev *cable_edev;
 128         struct charger_platform_data *pdata;
 129         struct workqueue_struct *usb_charger_wq;
 130         struct workqueue_struct *dc_charger_wq;
 131         struct workqueue_struct *finish_sig_wq;
 132         struct delayed_work dc_work;
 133         struct delayed_work usb_work;
 134         struct delayed_work host_work;
 135         struct delayed_work discnt_work;
 136         struct delayed_work finish_sig_work;
 137         struct delayed_work irq_work;
 138         struct notifier_block bc_nb;
 139         struct notifier_block cable_cg_nb;
 140         struct notifier_block cable_host_nb;
 141         struct notifier_block cable_discnt_nb;
 142         unsigned int bc_event;
 143         enum charger_t usb_charger;
 144         enum charger_t dc_charger;
 145         u8 ac_in;
 146         u8 usb_in;
 147         u8 otg_in;
 148         u8 dc_in;
 149         u8 prop_status;
 150         u8 chrg_voltage;
 151         u8 chrg_input;
 152         u8 chrg_current;
 153         u8 res_div;
 154         u8 plugin_trigger;
 155         u8 plugout_trigger;
 156         int plugin_irq;
 157         int plugout_irq;
 158 };
 159
 160 static int rk818_reg_read(struct rk818_charger *cg, u8 reg)
 161 {
 162         int ret, val;
 163
 164         ret = regmap_read(cg->regmap, reg, &val);
 165         if (ret)
 166                 dev_err(cg->dev, "i2c read reg: 0x%2x failed\n", reg);
 167
 168         return val;
 169 }
 170
 171 static int rk818_reg_write(struct rk818_charger *cg, u8 reg, u8 buf)
 172 {
 173         int ret;
 174
 175         ret = regmap_write(cg->regmap, reg, buf);
 176         if (ret)
 177                 dev_err(cg->dev, "i2c write reg: 0x%2x failed\n", reg);
 178
 179         return ret;
 180 }
 181
 182 static int rk818_reg_set_bits(struct rk818_charger *cg, u8 reg, u8 mask, u8 buf)
 183 {
 184         int ret;
 185
 186         ret = regmap_update_bits(cg->regmap, reg, mask, buf);
 187         if (ret)
 188                 dev_err(cg->dev, "i2c set reg: 0x%2x failed\n", reg);
 189
 190         return ret;
 191 }
 192
 193 static int rk818_reg_clear_bits(struct rk818_charger *cg, u8 reg, u8 mask)
 194 {
 195         int ret;
 196
 197         ret = regmap_update_bits(cg->regmap, reg, mask, 0);
 198         if (ret)
 199                 dev_err(cg->dev, "i2c clr reg: 0x%02x failed\n", reg);
 200
 201         return ret;
 202 }
 203
 204 static int rk818_cg_online(struct rk818_charger *cg)
 205 {
 206         return (cg->ac_in | cg->usb_in | cg->dc_in);
 207 }
 208
 209 static int rk818_cg_get_dsoc(struct rk818_charger *cg)
 210 {
 211         return rk818_reg_read(cg, RK818_SOC_REG);
 212 }
 213
 214 static int rk818_cg_get_avg_current(struct rk818_charger *cg)
 215 {
 216         int cur, val = 0;
 217
 218         val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGL) << 0;
 219         val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGH) << 8;
 220
 221         if (val & 0x800)
 222                 val -= 4096;
 223         cur = val * cg->res_div * 1506 / 1000;
 224
 225         return cur;
 226 }
 227
 228 static u64 get_boot_sec(void)
 229 {
 230         struct timespec ts;
 231
 232         get_monotonic_boottime(&ts);
 233
 234         return ts.tv_sec;
 235 }
 236
 237 static int rk818_cg_lowpwr_check(struct rk818_charger *cg)
 238 {
 239         u8 buf;
 240         static u64 time;
 241         int current_avg, dsoc, fake_offline = 0;
 242
 243         buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
 244         if (!(buf & GG_EN))
 245                 return fake_offline;
 246
 247         dsoc = rk818_cg_get_dsoc(cg);
 248         current_avg = rk818_cg_get_avg_current(cg);
 249         if ((current_avg < 0) && (dsoc == 0)) {
 250                 if (!time)
 251                         time = get_boot_sec();
 252                 if ((get_boot_sec() - time) >= 30) {
 253                         fake_offline = 1;
 254                         CG_INFO("low power....soc=%d, current=%d\n",
 255                                 dsoc, current_avg);
 256                 }
 257         } else {
 258                 time = 0;
 259                 fake_offline = 0;
 260         }
 261
 262         DBG("<%s>. t=%lld, dsoc=%d, current=%d, fake_offline=%d\n",
 263             __func__, get_boot_sec() - time, dsoc, current_avg, fake_offline);
 264
 265         return fake_offline;
 266 }
 267
 268 static enum power_supply_property rk818_ac_props[] = {
 269         POWER_SUPPLY_PROP_ONLINE,
 270         POWER_SUPPLY_PROP_STATUS,
 271 };
 272
 273 static enum power_supply_property rk818_usb_props[] = {
 274         POWER_SUPPLY_PROP_ONLINE,
 275         POWER_SUPPLY_PROP_STATUS,
 276 };
 277
 278 static int rk818_cg_ac_get_property(struct power_supply *psy,
 279                                     enum power_supply_property psp,
 280                                     union power_supply_propval *val)
 281 {
 282         struct rk818_charger *cg = power_supply_get_drvdata(psy);
 283         int fake_offline = 0, ret = 0;
 284
 285         if (rk818_cg_online(cg))
 286                 fake_offline = rk818_cg_lowpwr_check(cg);
 287
 288         switch (psp) {
 289         case POWER_SUPPLY_PROP_ONLINE:
 290                 if (cg->pdata->virtual_power)
 291                         val->intval = 1;
 292                 else if (fake_offline)
 293                         val->intval = 0;
 294                 else
 295                         val->intval = (cg->ac_in | cg->dc_in);
 296
 297                 DBG("report online: %d\n", val->intval);
 298                 break;
 299         case POWER_SUPPLY_PROP_STATUS:
 300                 if (cg->pdata->virtual_power)
 301                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 302                 else if (fake_offline)
 303                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 304                 else
 305                         val->intval = cg->prop_status;
 306
 307                 DBG("report prop: %d\n", val->intval);
 308                 break;
 309         default:
 310                 ret = -EINVAL;
 311                 break;
 312         }
 313
 314         return ret;
 315 }
 316
 317 static int rk818_cg_usb_get_property(struct power_supply *psy,
 318                                      enum power_supply_property psp,
 319                                      union power_supply_propval *val)
 320 {
 321         struct rk818_charger *cg = power_supply_get_drvdata(psy);
 322         int fake_offline, ret = 0;
 323
 324         if (rk818_cg_online(cg))
 325                 fake_offline = rk818_cg_lowpwr_check(cg);
 326
 327         switch (psp) {
 328         case POWER_SUPPLY_PROP_ONLINE:
 329                 if (cg->pdata->virtual_power)
 330                         val->intval = 1;
 331                 else if (fake_offline)
 332                         val->intval = 0;
 333                 else
 334                         val->intval = cg->usb_in;
 335
 336                 DBG("report online: %d\n", val->intval);
 337                 break;
 338         case POWER_SUPPLY_PROP_STATUS:
 339                 if (cg->pdata->virtual_power)
 340                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 341                 else if (fake_offline)
 342                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 343                 else
 344                         val->intval = cg->prop_status;
 345
 346                 DBG("report prop: %d\n", val->intval);
 347                 break;
 348         default:
 349                 ret = -EINVAL;
 350                 break;
 351         }
 352
 353         return ret;
 354 }
 355
 356 static const struct power_supply_desc rk818_ac_desc = {
 357         .name           = "ac",
 358         .type           = POWER_SUPPLY_TYPE_MAINS,
 359         .properties     = rk818_ac_props,
 360         .num_properties = ARRAY_SIZE(rk818_ac_props),
 361         .get_property   = rk818_cg_ac_get_property,
 362 };
 363
 364 static const struct power_supply_desc rk818_usb_desc = {
 365         .name           = "usb",
 366         .type           = POWER_SUPPLY_TYPE_USB,
 367         .properties     = rk818_usb_props,
 368         .num_properties = ARRAY_SIZE(rk818_usb_props),
 369         .get_property   = rk818_cg_usb_get_property,
 370 };
 371
 372 static int rk818_cg_init_power_supply(struct rk818_charger *cg)
 373 {
 374         struct power_supply_config psy_cfg = { .drv_data = cg, };
 375
 376         cg->usb_psy = devm_power_supply_register(cg->dev, &rk818_usb_desc,
 377                                                  &psy_cfg);
 378         if (IS_ERR(cg->usb_psy)) {
 379                 dev_err(cg->dev, "register usb power supply fail\n");
 380                 return PTR_ERR(cg->usb_psy);
 381         }
 382
 383         cg->ac_psy = devm_power_supply_register(cg->dev, &rk818_ac_desc,
 384                                                 &psy_cfg);
 385         if (IS_ERR(cg->ac_psy)) {
 386                 dev_err(cg->dev, "register ac power supply fail\n");
 387                 return PTR_ERR(cg->ac_psy);
 388         }
 389
 390         return 0;
 391 }
 392
 393 static void rk818_cg_pr_info(struct rk818_charger *cg)
 394 {
 395         u8 usb_ctrl, chrg_ctrl1;
 396
 397         usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
 398         chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
 399         CG_INFO("ac=%d usb=%d dc=%d otg=%d v=%d chrg=%d input=%d virt=%d\n",
 400                 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in,
 401                 chrg_vol_sel_array[(chrg_ctrl1 & 0x70) >> 4],
 402                 chrg_cur_sel_array[chrg_ctrl1 & 0x0f] * cg->res_div,
 403                 chrg_cur_input_array[usb_ctrl & 0x0f],
 404                 cg->pdata->virtual_power);
 405 }
 406
 407 static bool is_battery_exist(struct rk818_charger *cg)
 408 {
 409         return (rk818_reg_read(cg, RK818_SUP_STS_REG) & BAT_EXS) ? true : false;
 410 }
 411
 412 static void rk818_cg_set_input_current(struct rk818_charger *cg,
 413                                        int input_current)
 414 {
 415         u8 usb_ctrl;
 416
 417         if (cg->pdata->virtual_power) {
 418                 CG_INFO("warning: virtual power mode...\n");
 419                 input_current = cg->chrg_input;
 420         }
 421
 422         usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
 423         usb_ctrl &= ~INPUT_CUR_MSK;
 424         usb_ctrl |= (input_current);
 425         rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
 426 }
 427
 428 static void rk818_cg_set_finish_sig(struct rk818_charger *cg, int mode)
 429 {
 430         u8 buf;
 431
 432         buf = rk818_reg_read(cg, RK818_CHRG_CTRL_REG3);
 433         buf &= ~CHRG_FINISH_MODE_MSK;
 434         buf |= mode;
 435         rk818_reg_write(cg, RK818_CHRG_CTRL_REG3, buf);
 436 }
 437
 438 static void rk818_cg_finish_sig_work(struct work_struct *work)
 439 {
 440         struct rk818_charger *cg;
 441
 442         cg = container_of(work, struct rk818_charger, finish_sig_work.work);
 443         if (rk818_cg_online(cg))
 444                 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
 445         else
 446                 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
 447 }
 448
 449 static void rk818_cg_set_chrg_param(struct rk818_charger *cg,
 450                                     enum charger_t charger)
 451 {
 452         u8 buf;
 453
 454         switch (charger) {
 455         case USB_TYPE_NONE_CHARGER:
 456                 cg->usb_in = 0;
 457                 cg->ac_in = 0;
 458                 if (cg->dc_in == 0) {
 459                         cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
 460                         rk818_cg_set_input_current(cg, INPUT_CUR450MA);
 461                 }
 462                 power_supply_changed(cg->usb_psy);
 463                 power_supply_changed(cg->ac_psy);
 464                 break;
 465         case USB_TYPE_USB_CHARGER:
 466                 cg->usb_in = 1;
 467                 cg->ac_in = 0;
 468                 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
 469                 if (cg->dc_in == 0)
 470                         rk818_cg_set_input_current(cg, INPUT_CUR450MA);
 471                 power_supply_changed(cg->usb_psy);
 472                 power_supply_changed(cg->ac_psy);
 473                 break;
 474         case USB_TYPE_AC_CHARGER:
 475         case USB_TYPE_CDP_CHARGER:
 476                 cg->ac_in = 1;
 477                 cg->usb_in = 0;
 478                 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
 479                 if (charger == USB_TYPE_AC_CHARGER)
 480                         rk818_cg_set_input_current(cg, cg->chrg_input);
 481                 else
 482                         rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
 483                 power_supply_changed(cg->usb_psy);
 484                 power_supply_changed(cg->ac_psy);
 485                 break;
 486         case DC_TYPE_DC_CHARGER:
 487                 cg->dc_in = 1;
 488                 cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
 489                 rk818_cg_set_input_current(cg, cg->chrg_input);
 490                 power_supply_changed(cg->usb_psy);
 491                 power_supply_changed(cg->ac_psy);
 492                 break;
 493         case DC_TYPE_NONE_CHARGER:
 494                 cg->dc_in = 0;
 495                 buf = rk818_reg_read(cg, RK818_VB_MON_REG);
 496                 if ((buf & PLUG_IN_STS) == 0) {
 497                         cg->ac_in = 0;
 498                         cg->usb_in = 0;
 499                         cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
 500                         rk818_cg_set_input_current(cg, INPUT_CUR450MA);
 501                 } else if (cg->usb_in) {
 502                         rk818_cg_set_input_current(cg, INPUT_CUR450MA);
 503                         cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
 504                 }
 505                 power_supply_changed(cg->usb_psy);
 506                 power_supply_changed(cg->ac_psy);
 507                 break;
 508         default:
 509                 cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
 510                 break;
 511         }
 512
 513         if (rk818_cg_online(cg) && rk818_cg_get_dsoc(cg) == 100)
 514                 cg->prop_status = POWER_SUPPLY_STATUS_FULL;
 515
 516         if (cg->finish_sig_wq)
 517                 queue_delayed_work(cg->finish_sig_wq, &cg->finish_sig_work,
 518                                    msecs_to_jiffies(1000));
 519 }
 520
 521 static void rk818_cg_set_otg_state(struct rk818_charger *cg, int state)
 522 {
 523         switch (state) {
 524         case USB_OTG_POWER_ON:
 525                 if (cg->otg_in) {
 526                         CG_INFO("otg5v is on yet, ignore..\n");
 527                 } else {
 528                         cg->otg_in = 1;
 529                         disable_irq(cg->plugin_irq);
 530                         disable_irq(cg->plugout_irq);
 531                         rk818_reg_set_bits(cg, RK818_DCDC_EN_REG,
 532                                            OTG_EN_MASK, OTG_EN_MASK);
 533                         CG_INFO("enable otg5v\n");
 534                 }
 535                 break;
 536         case USB_OTG_POWER_OFF:
 537                 if (!cg->otg_in) {
 538                         CG_INFO("otg5v is off yet, ignore..\n");
 539                 } else {
 540                         cg->otg_in = 0;
 541                         enable_irq(cg->plugin_irq);
 542                         enable_irq(cg->plugout_irq);
 543                         rk818_reg_clear_bits(cg, RK818_DCDC_EN_REG,
 544                                              OTG_EN_MASK);
 545                         CG_INFO("disable otg5v\n");
 546                 }
 547                 break;
 548         default:
 549                 dev_err(cg->dev, "error otg type\n");
 550                 break;
 551         }
 552 }
 553
 554 static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
 555 {
 556         int level;
 557
 558         if (!gpio_is_valid(cg->pdata->dc_det_pin))
 559                 return DC_TYPE_NONE_CHARGER;
 560
 561         level = gpio_get_value(cg->pdata->dc_det_pin);
 562
 563         return (level == cg->pdata->dc_det_level) ?
 564                 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
 565 }
 566
 567 static void rk818_cg_dc_det_worker(struct work_struct *work)
 568 {
 569         enum charger_t charger;
 570         struct rk818_charger *cg = container_of(work,
 571                         struct rk818_charger, dc_work.work);
 572
 573         charger = rk818_cg_get_dc_state(cg);
 574         if (charger == DC_TYPE_DC_CHARGER) {
 575                 CG_INFO("detect dc charger in..\n");
 576                 rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
 577                 /* check otg supply */
 578                 if (cg->otg_in && cg->pdata->power_dc2otg) {
 579                         CG_INFO("otg power from dc adapter\n");
 580                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
 581                 }
 582         } else {
 583                 CG_INFO("detect dc charger out..\n");
 584                 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
 585                 /* check otg supply, power on anyway */
 586                 if (cg->otg_in)
 587                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
 588         }
 589
 590         rk_send_wakeup_key();
 591         rk818_cg_pr_info(cg);
 592 }
 593
 594 static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg)
 595 {
 596         u8 val, index;
 597         u32 chrg_vol;
 598
 599         chrg_vol = cg->pdata->max_chrg_voltage;
 600         for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
 601                 if (chrg_vol < chrg_vol_sel_array[index])
 602                         break;
 603                 val = index << 4;
 604         }
 605
 606         DBG("<%s>. vol=0x%x\n", __func__, val);
 607         return val;
 608 }
 609
 610 static u8 rk818_cg_decode_input_current(struct rk818_charger *cg)
 611 {
 612         u8 val, index;
 613         u32 input_current;
 614
 615         input_current = cg->pdata->max_input_current;
 616         for (index = 0; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
 617                 if (input_current < chrg_cur_input_array[index])
 618                         break;
 619                 val = index <<  0;
 620         }
 621
 622         DBG("<%s>. input=0x%x\n", __func__, val);
 623         return val;
 624 }
 625
 626 static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg)
 627 {
 628         u8 val, index;
 629         u32 chrg_current;
 630
 631         chrg_current = cg->pdata->max_chrg_current;
 632         if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
 633                 if (chrg_current > 2000)
 634                         chrg_current /= cg->res_div;
 635                 else
 636                         chrg_current = 1000;
 637         }
 638
 639         for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
 640                 if (chrg_current < chrg_cur_sel_array[index])
 641                         break;
 642                 val = index << 0;
 643         }
 644
 645         DBG("<%s>. sel=0x%x\n", __func__, val);
 646         return val;
 647 }
 648
 649 static void rk818_cg_init_config(struct rk818_charger *cg)
 650 {
 651         u8 usb_ctrl, sup_sts, chrg_ctrl1;
 652
 653         cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg);
 654         cg->chrg_current = rk818_cg_decode_chrg_current(cg);
 655         cg->chrg_input = rk818_cg_decode_input_current(cg);
 656
 657         sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
 658         usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
 659
 660         /* set charge current and voltage */
 661         usb_ctrl &= ~INPUT_CUR_MSK;
 662         usb_ctrl |= cg->chrg_input;
 663         chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
 664
 665         /* disable voltage limit and enable input current limit */
 666         sup_sts &= ~USB_VLIMIT_EN;
 667         sup_sts |= USB_CLIMIT_EN;
 668
 669         rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
 670         rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
 671         rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
 672 }
 673
 674 static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
 675                                          unsigned long event, void *ptr)
 676 {
 677         struct rk818_charger *cg =
 678                 container_of(nb, struct rk818_charger, cable_cg_nb);
 679
 680         queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
 681                            msecs_to_jiffies(10));
 682
 683         return NOTIFY_DONE;
 684 }
 685
 686 static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
 687                                        unsigned long event, void *ptr)
 688 {
 689         struct rk818_charger *cg =
 690                 container_of(nb, struct rk818_charger, cable_discnt_nb);
 691
 692         queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
 693                            msecs_to_jiffies(10));
 694
 695         return NOTIFY_DONE;
 696 }
 697
 698 static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
 699                                       unsigned long event, void *ptr)
 700 {
 701         struct rk818_charger *cg =
 702                 container_of(nb, struct rk818_charger, cable_host_nb);
 703
 704         queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
 705                            msecs_to_jiffies(10));
 706
 707         return NOTIFY_DONE;
 708 }
 709
 710 static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
 711                                     unsigned long event, void *ptr)
 712 {
 713         struct rk818_charger *cg =
 714                 container_of(nb, struct rk818_charger, bc_nb);
 715
 716         cg->bc_event = event;
 717         queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
 718                            msecs_to_jiffies(10));
 719
 720         return NOTIFY_DONE;
 721 }
 722
 723 static void rk818_cg_bc_evt_worker(struct work_struct *work)
 724 {
 725         struct rk818_charger *cg = container_of(work,
 726                                         struct rk818_charger, usb_work.work);
 727         const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
 728                                     "UNKNOWN", "OTG ON", "OTG OFF"};
 729
 730         switch (cg->bc_event) {
 731         case USB_BC_TYPE_DISCNT:
 732                 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
 733                 break;
 734         case USB_BC_TYPE_SDP:
 735                 rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
 736                 break;
 737         case USB_BC_TYPE_DCP:
 738                 rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
 739                 break;
 740         case USB_BC_TYPE_CDP:
 741                 rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
 742                 break;
 743         case USB_OTG_POWER_ON:
 744                 if (cg->pdata->power_dc2otg && cg->dc_in)
 745                         CG_INFO("otg power from dc adapter\n");
 746                 else
 747                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
 748                 break;
 749         case USB_OTG_POWER_OFF:
 750                 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
 751                 break;
 752         default:
 753                 break;
 754         }
 755
 756         CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
 757
 758         rk818_cg_pr_info(cg);
 759 }
 760
 761 static void rk818_cg_irq_delay_work(struct work_struct *work)
 762 {
 763         struct rk818_charger *cg = container_of(work,
 764                         struct rk818_charger, irq_work.work);
 765
 766         if (cg->plugin_trigger) {
 767                 CG_INFO("pmic: plug in\n");
 768                 cg->plugin_trigger = 0;
 769                 rk_send_wakeup_key();
 770         } else if (cg->plugout_trigger) {
 771                 CG_INFO("pmic: plug out\n");
 772                 cg->plugout_trigger = 0;
 773                 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
 774                 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
 775                 rk_send_wakeup_key();
 776                 rk818_cg_pr_info(cg);
 777         } else {
 778                 CG_INFO("pmic: unknown irq\n");
 779         }
 780 }
 781
 782 static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
 783 {
 784         struct rk818_charger *icg;
 785
 786         icg = (struct rk818_charger *)cg;
 787         icg->plugin_trigger = 1;
 788         queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
 789                            msecs_to_jiffies(10));
 790
 791         return IRQ_HANDLED;
 792 }
 793
 794 static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
 795 {
 796         struct rk818_charger *icg;
 797
 798         icg = (struct rk818_charger *)cg;
 799         icg->plugout_trigger = 1;
 800         queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
 801                            msecs_to_jiffies(10));
 802
 803         return IRQ_HANDLED;
 804 }
 805
 806 static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
 807 {
 808         struct rk818_charger *cg = (struct rk818_charger *)charger;
 809
 810         if (gpio_get_value(cg->pdata->dc_det_pin))
 811                 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
 812         else
 813                 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
 814
 815         queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
 816                            msecs_to_jiffies(10));
 817
 818         return IRQ_HANDLED;
 819 }
 820
 821 static int rk818_cg_init_irqs(struct rk818_charger *cg)
 822 {
 823         struct rk808 *rk818 = cg->rk818;
 824         struct platform_device *pdev = cg->pdev;
 825         int ret, plug_in_irq, plug_out_irq;
 826
 827         plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
 828         if (plug_in_irq < 0) {
 829                 dev_err(cg->dev, "plug_in_irq request failed!\n");
 830                 return plug_in_irq;
 831         }
 832
 833         plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
 834         if (plug_out_irq < 0) {
 835                 dev_err(cg->dev, "plug_out_irq request failed!\n");
 836                 return plug_out_irq;
 837         }
 838
 839         ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
 840                                         rk818_plug_in_isr,
 841                                         IRQF_TRIGGER_RISING,
 842                                         "rk818_plug_in", cg);
 843         if (ret) {
 844                 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
 845                 return ret;
 846         }
 847
 848         ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
 849                                         rk818_plug_out_isr,
 850                                         IRQF_TRIGGER_FALLING,
 851                                         "rk818_plug_out", cg);
 852         if (ret) {
 853                 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
 854                 return ret;
 855         }
 856
 857         cg->plugin_irq = plug_in_irq;
 858         cg->plugout_irq = plug_out_irq;
 859
 860         INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
 861
 862         return 0;
 863 }
 864
 865 static int rk818_cg_init_dc(struct rk818_charger *cg)
 866 {
 867         int ret, level;
 868         unsigned long irq_flags;
 869         unsigned int dc_det_irq;
 870
 871         cg->dc_charger_wq = alloc_ordered_workqueue("%s",
 872                                 WQ_MEM_RECLAIM | WQ_FREEZABLE,
 873                                 "rk818-dc-wq");
 874         INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
 875         cg->dc_charger = DC_TYPE_NONE_CHARGER;
 876
 877         if (!cg->pdata->support_dc_det)
 878                 return 0;
 879
 880         ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
 881         if (ret < 0) {
 882                 dev_err(cg->dev, "failed to request gpio %d\n",
 883                         cg->pdata->dc_det_pin);
 884                 return ret;
 885         }
 886
 887         ret = gpio_direction_input(cg->pdata->dc_det_pin);
 888         if (ret) {
 889                 dev_err(cg->dev, "failed to set gpio input\n");
 890                 return ret;
 891         }
 892
 893         level = gpio_get_value(cg->pdata->dc_det_pin);
 894         if (level == cg->pdata->dc_det_level)
 895                 cg->dc_charger = DC_TYPE_DC_CHARGER;
 896         else
 897                 cg->dc_charger = DC_TYPE_NONE_CHARGER;
 898
 899         if (level)
 900                 irq_flags = IRQF_TRIGGER_LOW;
 901         else
 902                 irq_flags = IRQF_TRIGGER_HIGH;
 903
 904         dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
 905         ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
 906                                irq_flags, "rk818_dc_det", cg);
 907         if (ret != 0) {
 908                 dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
 909                 return ret;
 910         }
 911
 912         enable_irq_wake(dc_det_irq);
 913
 914         return 0;
 915 }
 916
 917 static void rk818_cg_discnt_evt_worker(struct work_struct *work)
 918 {
 919         struct rk818_charger *cg = container_of(work,
 920                         struct rk818_charger, discnt_work.work);
 921
 922         if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
 923                 CG_INFO("receive type-c notifier event: DISCNT...\n");
 924                 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
 925                 rk818_cg_pr_info(cg);
 926         }
 927 }
 928
 929 static void rk818_cg_host_evt_worker(struct work_struct *work)
 930 {
 931         struct rk818_charger *cg = container_of(work,
 932                         struct rk818_charger, host_work.work);
 933         struct extcon_dev *edev = cg->cable_edev;
 934
 935         /* Determine cable/charger type */
 936         if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
 937                 CG_INFO("receive type-c notifier event: OTG ON...\n");
 938                 if (cg->dc_in && cg->pdata->power_dc2otg)
 939                         CG_INFO("otg power from dc adapter\n");
 940                 else
 941                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
 942         } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
 943                 CG_INFO("receive type-c notifier event: OTG OFF...\n");
 944                 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
 945         }
 946
 947         rk818_cg_pr_info(cg);
 948 }
 949
 950 static void rk818_cg_charger_evt_worker(struct work_struct *work)
 951 {
 952         struct rk818_charger *cg = container_of(work,
 953                                 struct rk818_charger, usb_work.work);
 954         struct extcon_dev *edev = cg->cable_edev;
 955         enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
 956         const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
 957
 958         /* Determine cable/charger type */
 959         if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
 960                 charger = USB_TYPE_USB_CHARGER;
 961         else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
 962                 charger = USB_TYPE_AC_CHARGER;
 963         else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
 964                 charger = USB_TYPE_CDP_CHARGER;
 965
 966         if (charger != USB_TYPE_UNKNOWN_CHARGER) {
 967                 CG_INFO("receive type-c notifier event: %s...\n",
 968                         event[charger]);
 969                 rk818_cg_set_chrg_param(cg, charger);
 970                 rk818_cg_pr_info(cg);
 971         }
 972 }
 973
 974 static long rk818_cg_init_usb(struct rk818_charger *cg)
 975 {
 976         enum charger_t charger;
 977         enum bc_port_type bc_type;
 978         struct extcon_dev *edev;
 979         struct device *dev = cg->dev;
 980         int ret;
 981
 982         cg->usb_charger_wq = alloc_ordered_workqueue("%s",
 983                                 WQ_MEM_RECLAIM | WQ_FREEZABLE,
 984                                 "rk818-usb-wq");
 985         cg->usb_charger = USB_TYPE_NONE_CHARGER;
 986
 987         /* type-C */
 988         if (cg->pdata->extcon) {
 989                 edev = extcon_get_edev_by_phandle(dev->parent, 0);
 990                 if (IS_ERR(edev)) {
 991                         if (PTR_ERR(edev) != -EPROBE_DEFER)
 992                                 dev_err(dev, "Invalid or missing extcon\n");
 993                         return PTR_ERR(edev);
 994                 }
 995
 996                 /* Register chargers  */
 997                 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
 998                 cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
 999                 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
1000                                                &cg->cable_cg_nb);
1001                 if (ret < 0) {
1002                         dev_err(dev, "failed to register notifier for SDP\n");
1003                         return ret;
1004                 }
1005
1006                 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1007                                                &cg->cable_cg_nb);
1008                 if (ret < 0) {
1009                         dev_err(dev, "failed to register notifier for DCP\n");
1010                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1011                                                    &cg->cable_cg_nb);
1012                         return ret;
1013                 }
1014
1015                 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1016                                                &cg->cable_cg_nb);
1017                 if (ret < 0) {
1018                         dev_err(dev, "failed to register notifier for CDP\n");
1019                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1020                                                    &cg->cable_cg_nb);
1021                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1022                                                    &cg->cable_cg_nb);
1023                         return ret;
1024                 }
1025
1026                 /* Register host */
1027                 INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
1028                 cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
1029                 ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
1030                                                &cg->cable_host_nb);
1031                 if (ret < 0) {
1032                         dev_err(dev, "failed to register notifier for HOST\n");
1033                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1034                                                    &cg->cable_cg_nb);
1035                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1036                                                    &cg->cable_cg_nb);
1037                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1038                                                    &cg->cable_cg_nb);
1039
1040                         return ret;
1041                 }
1042
1043                 /* Register discnt usb */
1044                 INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
1045                 cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
1046                 ret = extcon_register_notifier(edev, EXTCON_USB,
1047                                                &cg->cable_discnt_nb);
1048                 if (ret < 0) {
1049                         dev_err(dev, "failed to register notifier for HOST\n");
1050                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1051                                                    &cg->cable_cg_nb);
1052                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1053                                                    &cg->cable_cg_nb);
1054                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1055                                                    &cg->cable_cg_nb);
1056                         extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
1057                                                    &cg->cable_host_nb);
1058                         return ret;
1059                 }
1060
1061                 cg->cable_edev = edev;
1062
1063                 schedule_delayed_work(&cg->host_work, 0);
1064
1065                 CG_INFO("register typec extcon evt notifier\n");
1066         } else {
1067                 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
1068                 cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
1069                 ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
1070                 if (ret) {
1071                         dev_err(dev, "failed to register notifier for bc\n");
1072                         return -EINVAL;
1073                 }
1074
1075                 switch (bc_type) {
1076                 case USB_BC_TYPE_DISCNT:
1077                         charger = USB_TYPE_NONE_CHARGER;
1078                         break;
1079                 case USB_BC_TYPE_SDP:
1080                 case USB_BC_TYPE_CDP:
1081                         charger = USB_TYPE_USB_CHARGER;
1082                         break;
1083                 case USB_BC_TYPE_DCP:
1084                         charger = USB_TYPE_AC_CHARGER;
1085                         break;
1086                 default:
1087                         charger = USB_TYPE_NONE_CHARGER;
1088                         break;
1089                 }
1090
1091                 cg->usb_charger = charger;
1092                 CG_INFO("register bc evt notifier\n");
1093         }
1094
1095         return 0;
1096 }
1097
1098 static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
1099 {
1100         if (rk818_cg_online(cg))
1101                 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
1102         else
1103                 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1104
1105         cg->finish_sig_wq = alloc_ordered_workqueue("%s",
1106                                 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1107                                 "rk818-finish-sig-wq");
1108         INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
1109 }
1110
1111 static void rk818_cg_init_charger_state(struct rk818_charger *cg)
1112 {
1113         rk818_cg_init_config(cg);
1114         rk818_cg_init_finish_sig(cg);
1115         rk818_cg_set_chrg_param(cg, cg->dc_charger);
1116         rk818_cg_set_chrg_param(cg, cg->usb_charger);
1117         CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d\n",
1118                 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1119 }
1120
1121 #ifdef CONFIG_OF
1122 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1123 {
1124         struct device_node *np;
1125         struct charger_platform_data *pdata;
1126         enum of_gpio_flags flags;
1127         struct device *dev = cg->dev;
1128         int ret;
1129
1130         np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
1131         if (!np) {
1132                 dev_err(dev, "battery node not found!\n");
1133                 return -ENODEV;
1134         }
1135
1136         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1137         if (!pdata)
1138                 return -ENOMEM;
1139
1140         cg->pdata = pdata;
1141         pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1142         pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1143         pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1144
1145         pdata->extcon = device_property_read_bool(dev->parent, "extcon");
1146
1147         ret = of_property_read_u32(np, "max_chrg_current",
1148                                    &pdata->max_chrg_current);
1149         if (ret < 0)
1150                 dev_err(dev, "max_chrg_current missing!\n");
1151
1152         ret = of_property_read_u32(np, "max_input_current",
1153                                    &pdata->max_input_current);
1154         if (ret < 0)
1155                 dev_err(dev, "max_input_current missing!\n");
1156
1157         ret = of_property_read_u32(np, "max_chrg_voltage",
1158                                    &pdata->max_chrg_voltage);
1159         if (ret < 0)
1160                 dev_err(dev, "max_chrg_voltage missing!\n");
1161
1162         ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1163         if (ret < 0)
1164                 dev_err(dev, "virtual_power missing!\n");
1165
1166         ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1167         if (ret < 0)
1168                 dev_err(dev, "power_dc2otg missing!\n");
1169
1170         ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1171         if (ret < 0) {
1172                 pdata->sample_res = SAMPLE_RES_20MR;
1173                 dev_err(dev, "sample_res missing!\n");
1174         }
1175
1176         if (!is_battery_exist(cg))
1177                 pdata->virtual_power = 1;
1178
1179         cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
1180                        SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1181
1182         if (!of_find_property(np, "dc_det_gpio", &ret)) {
1183                 pdata->support_dc_det = false;
1184                 CG_INFO("not support dc\n");
1185         } else {
1186                 pdata->support_dc_det = true;
1187                 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1188                                                             0, &flags);
1189                 if (gpio_is_valid(pdata->dc_det_pin)) {
1190                         CG_INFO("support dc\n");
1191                         pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1192                                                0 : 1;
1193                 } else {
1194                         dev_err(dev, "invalid dc det gpio!\n");
1195                         return -EINVAL;
1196                 }
1197         }
1198
1199         DBG("input_current:%d\n"
1200             "chrg_current:%d\n"
1201             "chrg_voltage:%d\n"
1202             "sample_res:%d\n"
1203             "extcon:%d\n"
1204             "virtual_power:%d\n"
1205             "power_dc2otg:%d\n",
1206             pdata->max_input_current, pdata->max_chrg_current,
1207             pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
1208             pdata->virtual_power, pdata->power_dc2otg);
1209
1210         return 0;
1211 }
1212 #else
1213 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1214 {
1215         return -ENODEV;
1216 }
1217 #endif
1218
1219 static int rk818_charger_probe(struct platform_device *pdev)
1220 {
1221         struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
1222         struct rk818_charger *cg;
1223         int ret;
1224
1225         cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
1226         if (!cg)
1227                 return -ENOMEM;
1228
1229         cg->rk818 = rk818;
1230         cg->pdev = pdev;
1231         cg->dev = &pdev->dev;
1232         cg->regmap = rk818->regmap;
1233         platform_set_drvdata(pdev, cg);
1234
1235         ret = rk818_cg_parse_dt(cg);
1236         if (ret < 0) {
1237                 dev_err(cg->dev, "parse dt failed!\n");
1238                 return ret;
1239         }
1240
1241         ret = rk818_cg_init_irqs(cg);
1242         if (ret != 0) {
1243                 dev_err(cg->dev, "init irqs failed!\n");
1244                 return ret;
1245         }
1246
1247         ret = rk818_cg_init_dc(cg);
1248         if (ret) {
1249                 dev_err(cg->dev, "init dc failed!\n");
1250                 return ret;
1251         }
1252
1253         ret = rk818_cg_init_usb(cg);
1254         if (ret) {
1255                 dev_err(cg->dev, "init usb failed!\n");
1256                 return ret;
1257         }
1258
1259         ret = rk818_cg_init_power_supply(cg);
1260         if (ret) {
1261                 dev_err(cg->dev, "init power supply fail!\n");
1262                 return ret;
1263         }
1264
1265         rk818_cg_init_charger_state(cg);
1266
1267         CG_INFO("driver version: %s\n", DRIVER_VERSION);
1268
1269         return ret;
1270 }
1271
1272 static void rk818_charger_shutdown(struct platform_device *pdev)
1273 {
1274         struct rk818_charger *cg = platform_get_drvdata(pdev);
1275
1276         cancel_delayed_work_sync(&cg->host_work);
1277         cancel_delayed_work_sync(&cg->usb_work);
1278         cancel_delayed_work_sync(&cg->discnt_work);
1279         cancel_delayed_work_sync(&cg->dc_work);
1280         cancel_delayed_work_sync(&cg->finish_sig_work);
1281         cancel_delayed_work_sync(&cg->irq_work);
1282         destroy_workqueue(cg->usb_charger_wq);
1283         destroy_workqueue(cg->dc_charger_wq);
1284         destroy_workqueue(cg->finish_sig_wq);
1285
1286         if (cg->pdata->extcon) {
1287                 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1288                                            &cg->cable_cg_nb);
1289                 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1290                                            &cg->cable_cg_nb);
1291                 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1292                                            &cg->cable_cg_nb);
1293                 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
1294                                            &cg->cable_host_nb);
1295                 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1296                                            &cg->cable_discnt_nb);
1297         } else {
1298                 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1299         }
1300
1301         rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
1302         rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1303
1304         CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d\n",
1305                 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1306 }
1307
1308 static struct platform_driver rk818_charger_driver = {
1309         .probe = rk818_charger_probe,
1310         .shutdown = rk818_charger_shutdown,
1311         .driver = {
1312                 .name   = "rk818-charger",
1313         },
1314 };
1315
1316 static int __init charger_init(void)
1317 {
1318         return platform_driver_register(&rk818_charger_driver);
1319 }
1320 module_init(charger_init);
1321
1322 static void __exit charger_exit(void)
1323 {
1324         platform_driver_unregister(&rk818_charger_driver);
1325 }
1326 module_exit(charger_exit);
1327
1328 MODULE_LICENSE("GPL");
1329 MODULE_ALIAS("platform:rk818-charger");
1330 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");