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