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 int_msk_reg2;
 155         u8 plug_in_irq;
 156         u8 plug_out_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                 rk818_reg_set_bits(cg, RK818_INT_STS_MSK_REG2,
 525                                    PLUG_IN_MSK, PLUG_IN_MSK);
 526                 rk818_reg_set_bits(cg, RK818_INT_STS_MSK_REG2,
 527                                    PLUG_OUT_MSK, PLUG_OUT_MSK);
 528                 rk818_reg_set_bits(cg, RK818_DCDC_EN_REG,
 529                                    OTG_EN_MASK, OTG_EN_MASK);
 530                 break;
 531         case USB_OTG_POWER_OFF:
 532                 rk818_reg_clear_bits(cg, RK818_INT_STS_MSK_REG2, PLUG_IN_MSK);
 533                 rk818_reg_clear_bits(cg, RK818_INT_STS_MSK_REG2, PLUG_OUT_MSK);
 534                 rk818_reg_clear_bits(cg, RK818_DCDC_EN_REG, OTG_EN_MASK);
 535                 break;
 536         default:
 537                 dev_err(cg->dev, "error otg type\n");
 538                 break;
 539         }
 540 }
 541
 542 static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
 543 {
 544         int level;
 545
 546         if (!gpio_is_valid(cg->pdata->dc_det_pin))
 547                 return DC_TYPE_NONE_CHARGER;
 548
 549         level = gpio_get_value(cg->pdata->dc_det_pin);
 550
 551         return (level == cg->pdata->dc_det_level) ?
 552                 DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
 553 }
 554
 555 static void rk818_cg_dc_det_worker(struct work_struct *work)
 556 {
 557         enum charger_t charger;
 558         struct rk818_charger *cg = container_of(work,
 559                         struct rk818_charger, dc_work.work);
 560
 561         charger = rk818_cg_get_dc_state(cg);
 562         if (charger == DC_TYPE_DC_CHARGER) {
 563                 CG_INFO("detect dc charger in..\n");
 564                 rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
 565                 /* check otg supply */
 566                 if (cg->otg_in && cg->pdata->power_dc2otg) {
 567                         CG_INFO("otg power from dc adapter\n");
 568                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
 569                 }
 570         } else {
 571                 CG_INFO("detect dc charger out..\n");
 572                 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
 573                 /* check otg supply, power on anyway */
 574                 if (cg->otg_in) {
 575                         CG_INFO("disable charge, enable otg\n");
 576                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
 577                 }
 578         }
 579
 580         rk_send_wakeup_key();
 581         rk818_cg_pr_info(cg);
 582 }
 583
 584 static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg)
 585 {
 586         u8 val, index;
 587         u32 chrg_vol;
 588
 589         chrg_vol = cg->pdata->max_chrg_voltage;
 590         for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
 591                 if (chrg_vol < chrg_vol_sel_array[index])
 592                         break;
 593                 val = index << 4;
 594         }
 595
 596         DBG("<%s>. vol=0x%x\n", __func__, val);
 597         return val;
 598 }
 599
 600 static u8 rk818_cg_decode_input_current(struct rk818_charger *cg)
 601 {
 602         u8 val, index;
 603         u32 input_current;
 604
 605         input_current = cg->pdata->max_input_current;
 606         for (index = 0; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
 607                 if (input_current < chrg_cur_input_array[index])
 608                         break;
 609                 val = index <<  0;
 610         }
 611
 612         DBG("<%s>. input=0x%x\n", __func__, val);
 613         return val;
 614 }
 615
 616 static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg)
 617 {
 618         u8 val, index;
 619         u32 chrg_current;
 620
 621         chrg_current = cg->pdata->max_chrg_current;
 622         if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
 623                 if (chrg_current > 2000)
 624                         chrg_current /= cg->res_div;
 625                 else
 626                         chrg_current = 1000;
 627         }
 628
 629         for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
 630                 if (chrg_current < chrg_cur_sel_array[index])
 631                         break;
 632                 val = index << 0;
 633         }
 634
 635         DBG("<%s>. sel=0x%x\n", __func__, val);
 636         return val;
 637 }
 638
 639 static void rk818_cg_init_config(struct rk818_charger *cg)
 640 {
 641         u8 usb_ctrl, sup_sts, chrg_ctrl1;
 642
 643         cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg);
 644         cg->chrg_current = rk818_cg_decode_chrg_current(cg);
 645         cg->chrg_input = rk818_cg_decode_input_current(cg);
 646
 647         sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
 648         usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
 649
 650         /* set charge current and voltage */
 651         usb_ctrl &= ~INPUT_CUR_MSK;
 652         usb_ctrl |= cg->chrg_input;
 653         chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
 654
 655         /* disable voltage limit and enable input current limit */
 656         sup_sts &= ~USB_VLIMIT_EN;
 657         sup_sts |= USB_CLIMIT_EN;
 658
 659         rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
 660         rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
 661         rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
 662 }
 663
 664 static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
 665                                          unsigned long event, void *ptr)
 666 {
 667         struct rk818_charger *cg =
 668                 container_of(nb, struct rk818_charger, cable_cg_nb);
 669
 670         queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
 671                            msecs_to_jiffies(10));
 672
 673         return NOTIFY_DONE;
 674 }
 675
 676 static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
 677                                        unsigned long event, void *ptr)
 678 {
 679         struct rk818_charger *cg =
 680                 container_of(nb, struct rk818_charger, cable_discnt_nb);
 681
 682         queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
 683                            msecs_to_jiffies(10));
 684
 685         return NOTIFY_DONE;
 686 }
 687
 688 static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
 689                                       unsigned long event, void *ptr)
 690 {
 691         struct rk818_charger *cg =
 692                 container_of(nb, struct rk818_charger, cable_host_nb);
 693
 694         queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
 695                            msecs_to_jiffies(10));
 696
 697         return NOTIFY_DONE;
 698 }
 699
 700 static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
 701                                     unsigned long event, void *ptr)
 702 {
 703         struct rk818_charger *cg =
 704                 container_of(nb, struct rk818_charger, bc_nb);
 705
 706         cg->bc_event = event;
 707         queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
 708                            msecs_to_jiffies(10));
 709
 710         return NOTIFY_DONE;
 711 }
 712
 713 static void rk818_cg_bc_evt_worker(struct work_struct *work)
 714 {
 715         struct rk818_charger *cg = container_of(work,
 716                                         struct rk818_charger, usb_work.work);
 717         const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
 718                                     "UNKNOWN", "OTG ON", "OTG OFF"};
 719
 720         switch (cg->bc_event) {
 721         case USB_BC_TYPE_DISCNT:
 722                 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
 723                 break;
 724         case USB_BC_TYPE_SDP:
 725                 rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
 726                 break;
 727         case USB_BC_TYPE_DCP:
 728                 rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
 729                 break;
 730         case USB_BC_TYPE_CDP:
 731                 rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
 732                 break;
 733         case USB_OTG_POWER_ON:
 734                 cg->otg_in = 1;
 735                 if (cg->pdata->power_dc2otg && cg->dc_in) {
 736                         CG_INFO("otg power from dc adapter\n");
 737                 } else {
 738                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
 739                         CG_INFO("disable charge, enable otg\n");
 740                 }
 741                 break;
 742         case USB_OTG_POWER_OFF:
 743                 cg->otg_in = 0;
 744                 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
 745                 CG_INFO("enable charge, disable otg\n");
 746                 break;
 747         default:
 748                 break;
 749         }
 750
 751         CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
 752
 753         rk818_cg_pr_info(cg);
 754 }
 755
 756 static void rk818_cg_irq_delay_work(struct work_struct *work)
 757 {
 758         struct rk818_charger *cg = container_of(work,
 759                         struct rk818_charger, irq_work.work);
 760
 761         if (cg->plug_in_irq) {
 762                 CG_INFO("pmic: plug in\n");
 763                 cg->plug_in_irq = 0;
 764                 rk_send_wakeup_key();
 765         } else if (cg->plug_out_irq) {
 766                 CG_INFO("pmic: plug out\n");
 767                 cg->plug_out_irq = 0;
 768                 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
 769                 rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
 770                 rk_send_wakeup_key();
 771                 rk818_cg_pr_info(cg);
 772         } else {
 773                 CG_INFO("pmic: unknown irq\n");
 774         }
 775 }
 776
 777 static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
 778 {
 779         struct rk818_charger *icg;
 780
 781         icg = (struct rk818_charger *)cg;
 782         icg->plug_in_irq = 1;
 783         queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
 784                            msecs_to_jiffies(10));
 785
 786         return IRQ_HANDLED;
 787 }
 788
 789 static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
 790 {
 791         struct rk818_charger *icg;
 792
 793         icg = (struct rk818_charger *)cg;
 794         icg->plug_out_irq = 1;
 795         queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
 796                            msecs_to_jiffies(10));
 797
 798         return IRQ_HANDLED;
 799 }
 800
 801 static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
 802 {
 803         struct rk818_charger *cg = (struct rk818_charger *)charger;
 804
 805         if (gpio_get_value(cg->pdata->dc_det_pin))
 806                 irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
 807         else
 808                 irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
 809
 810         queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
 811                            msecs_to_jiffies(10));
 812
 813         return IRQ_HANDLED;
 814 }
 815
 816 static int rk818_cg_init_irqs(struct rk818_charger *cg)
 817 {
 818         struct rk808 *rk818 = cg->rk818;
 819         struct platform_device *pdev = cg->pdev;
 820         int ret, plug_in_irq, plug_out_irq;
 821
 822         plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
 823         if (plug_in_irq < 0) {
 824                 dev_err(cg->dev, "plug_in_irq request failed!\n");
 825                 return plug_in_irq;
 826         }
 827
 828         plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
 829         if (plug_out_irq < 0) {
 830                 dev_err(cg->dev, "plug_out_irq request failed!\n");
 831                 return plug_out_irq;
 832         }
 833
 834         ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
 835                                         rk818_plug_in_isr,
 836                                         IRQF_TRIGGER_RISING,
 837                                         "rk818_plug_in", cg);
 838         if (ret) {
 839                 dev_err(&pdev->dev, "plug_in_irq request failed!\n");
 840                 return ret;
 841         }
 842
 843         ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
 844                                         rk818_plug_out_isr,
 845                                         IRQF_TRIGGER_FALLING,
 846                                         "rk818_plug_out", cg);
 847         if (ret) {
 848                 dev_err(&pdev->dev, "plug_out_irq request failed!\n");
 849                 return ret;
 850         }
 851
 852         INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
 853
 854         return 0;
 855 }
 856
 857 static int rk818_cg_init_dc(struct rk818_charger *cg)
 858 {
 859         int ret, level;
 860         unsigned long irq_flags;
 861         unsigned int dc_det_irq;
 862
 863         cg->dc_charger_wq = alloc_ordered_workqueue("%s",
 864                                 WQ_MEM_RECLAIM | WQ_FREEZABLE,
 865                                 "rk818-dc-wq");
 866         INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
 867         cg->dc_charger = DC_TYPE_NONE_CHARGER;
 868
 869         if (!cg->pdata->support_dc_det)
 870                 return 0;
 871
 872         ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
 873         if (ret < 0) {
 874                 dev_err(cg->dev, "failed to request gpio %d\n",
 875                         cg->pdata->dc_det_pin);
 876                 return ret;
 877         }
 878
 879         ret = gpio_direction_input(cg->pdata->dc_det_pin);
 880         if (ret) {
 881                 dev_err(cg->dev, "failed to set gpio input\n");
 882                 return ret;
 883         }
 884
 885         level = gpio_get_value(cg->pdata->dc_det_pin);
 886         if (level == cg->pdata->dc_det_level)
 887                 cg->dc_charger = DC_TYPE_DC_CHARGER;
 888         else
 889                 cg->dc_charger = DC_TYPE_NONE_CHARGER;
 890
 891         if (level)
 892                 irq_flags = IRQF_TRIGGER_LOW;
 893         else
 894                 irq_flags = IRQF_TRIGGER_HIGH;
 895
 896         dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
 897         ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
 898                                irq_flags, "rk818_dc_det", cg);
 899         if (ret != 0) {
 900                 dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
 901                 return ret;
 902         }
 903
 904         enable_irq_wake(dc_det_irq);
 905
 906         return 0;
 907 }
 908
 909 static void rk818_cg_discnt_evt_worker(struct work_struct *work)
 910 {
 911         struct rk818_charger *cg = container_of(work,
 912                         struct rk818_charger, discnt_work.work);
 913
 914         if (extcon_get_cable_state_(cg->cable_edev, EXTCON_USB) == 0) {
 915                 CG_INFO("receive type-c notifier event: DISCNT...\n");
 916                 rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
 917                 rk818_cg_pr_info(cg);
 918         }
 919 }
 920
 921 static void rk818_cg_host_evt_worker(struct work_struct *work)
 922 {
 923         struct rk818_charger *cg = container_of(work,
 924                         struct rk818_charger, host_work.work);
 925         struct extcon_dev *edev = cg->cable_edev;
 926
 927         /* Determine cable/charger type */
 928         if (extcon_get_cable_state_(edev, EXTCON_USB_HOST) > 0) {
 929                 CG_INFO("receive type-c notifier event: OTG ON...\n");
 930                 cg->otg_in = 1;
 931                 if (cg->dc_in && cg->pdata->power_dc2otg) {
 932                         CG_INFO("otg power from dc adapter\n");
 933                 } else {
 934                         rk818_cg_set_otg_state(cg, USB_OTG_POWER_ON);
 935                         CG_INFO("disable charge, enable otg\n");
 936                 }
 937         } else if (extcon_get_cable_state_(edev, EXTCON_USB_HOST) == 0) {
 938                 CG_INFO("receive type-c notifier event: OTG OFF...\n");
 939                 cg->otg_in = 0;
 940                 rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
 941                 CG_INFO("enble charge, disable otg\n");
 942         }
 943
 944         rk818_cg_pr_info(cg);
 945 }
 946
 947 static void rk818_cg_charger_evt_worker(struct work_struct *work)
 948 {
 949         struct rk818_charger *cg = container_of(work,
 950                                 struct rk818_charger, usb_work.work);
 951         struct extcon_dev *edev = cg->cable_edev;
 952         enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
 953         const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
 954
 955         /* Determine cable/charger type */
 956         if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0)
 957                 charger = USB_TYPE_USB_CHARGER;
 958         else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0)
 959                 charger = USB_TYPE_AC_CHARGER;
 960         else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0)
 961                 charger = USB_TYPE_CDP_CHARGER;
 962
 963         if (charger != USB_TYPE_UNKNOWN_CHARGER) {
 964                 CG_INFO("receive type-c notifier event: %s...\n",
 965                         event[charger]);
 966                 rk818_cg_set_chrg_param(cg, charger);
 967                 rk818_cg_pr_info(cg);
 968         }
 969 }
 970
 971 static long rk818_cg_init_usb(struct rk818_charger *cg)
 972 {
 973         enum charger_t charger;
 974         enum bc_port_type bc_type;
 975         struct extcon_dev *edev;
 976         struct device *dev = cg->dev;
 977         int ret;
 978
 979         cg->usb_charger_wq = alloc_ordered_workqueue("%s",
 980                                 WQ_MEM_RECLAIM | WQ_FREEZABLE,
 981                                 "rk818-usb-wq");
 982         cg->usb_charger = USB_TYPE_NONE_CHARGER;
 983
 984         /* type-C */
 985         if (cg->pdata->extcon) {
 986                 edev = extcon_get_edev_by_phandle(dev->parent, 0);
 987                 if (IS_ERR(edev)) {
 988                         if (PTR_ERR(edev) != -EPROBE_DEFER)
 989                                 dev_err(dev, "Invalid or missing extcon\n");
 990                         return PTR_ERR(edev);
 991                 }
 992
 993                 /* Register chargers  */
 994                 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
 995                 cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
 996                 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
 997                                                &cg->cable_cg_nb);
 998                 if (ret < 0) {
 999                         dev_err(dev, "failed to register notifier for SDP\n");
1000                         return ret;
1001                 }
1002
1003                 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
1004                                                &cg->cable_cg_nb);
1005                 if (ret < 0) {
1006                         dev_err(dev, "failed to register notifier for DCP\n");
1007                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1008                                                    &cg->cable_cg_nb);
1009                         return ret;
1010                 }
1011
1012                 ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
1013                                                &cg->cable_cg_nb);
1014                 if (ret < 0) {
1015                         dev_err(dev, "failed to register notifier for CDP\n");
1016                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1017                                                    &cg->cable_cg_nb);
1018                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1019                                                    &cg->cable_cg_nb);
1020                         return ret;
1021                 }
1022
1023                 /* Register host */
1024                 INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
1025                 cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
1026                 ret = extcon_register_notifier(edev, EXTCON_USB_HOST,
1027                                                &cg->cable_host_nb);
1028                 if (ret < 0) {
1029                         dev_err(dev, "failed to register notifier for HOST\n");
1030                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1031                                                    &cg->cable_cg_nb);
1032                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1033                                                    &cg->cable_cg_nb);
1034                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1035                                                    &cg->cable_cg_nb);
1036
1037                         return ret;
1038                 }
1039
1040                 /* Register discnt usb */
1041                 INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
1042                 cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
1043                 ret = extcon_register_notifier(edev, EXTCON_USB,
1044                                                &cg->cable_discnt_nb);
1045                 if (ret < 0) {
1046                         dev_err(dev, "failed to register notifier for HOST\n");
1047                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
1048                                                    &cg->cable_cg_nb);
1049                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
1050                                                    &cg->cable_cg_nb);
1051                         extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
1052                                                    &cg->cable_cg_nb);
1053                         extcon_unregister_notifier(edev, EXTCON_USB_HOST,
1054                                                    &cg->cable_host_nb);
1055                         return ret;
1056                 }
1057
1058                 cg->cable_edev = edev;
1059
1060                 CG_INFO("register typec extcon evt notifier\n");
1061         } else {
1062                 INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
1063                 cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
1064                 ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
1065                 if (ret) {
1066                         dev_err(dev, "failed to register notifier for bc\n");
1067                         return -EINVAL;
1068                 }
1069
1070                 switch (bc_type) {
1071                 case USB_BC_TYPE_DISCNT:
1072                         charger = USB_TYPE_NONE_CHARGER;
1073                         break;
1074                 case USB_BC_TYPE_SDP:
1075                 case USB_BC_TYPE_CDP:
1076                         charger = USB_TYPE_USB_CHARGER;
1077                         break;
1078                 case USB_BC_TYPE_DCP:
1079                         charger = USB_TYPE_AC_CHARGER;
1080                         break;
1081                 default:
1082                         charger = USB_TYPE_NONE_CHARGER;
1083                         break;
1084                 }
1085
1086                 cg->usb_charger = charger;
1087                 CG_INFO("register bc evt notifier\n");
1088         }
1089
1090         return 0;
1091 }
1092
1093 static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
1094 {
1095         if (rk818_cg_online(cg))
1096                 rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
1097         else
1098                 rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1099
1100         cg->finish_sig_wq = alloc_ordered_workqueue("%s",
1101                                 WQ_MEM_RECLAIM | WQ_FREEZABLE,
1102                                 "rk818-finish-sig-wq");
1103         INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
1104 }
1105
1106 static void rk818_cg_init_charger_state(struct rk818_charger *cg)
1107 {
1108         rk818_cg_init_config(cg);
1109         rk818_cg_init_finish_sig(cg);
1110         rk818_cg_set_chrg_param(cg, cg->dc_charger);
1111         rk818_cg_set_chrg_param(cg, cg->usb_charger);
1112         CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d\n",
1113                 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1114 }
1115
1116 #ifdef CONFIG_OF
1117 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1118 {
1119         struct device_node *np;
1120         struct charger_platform_data *pdata;
1121         enum of_gpio_flags flags;
1122         struct device *dev = cg->dev;
1123         int ret;
1124
1125         np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
1126         if (!np) {
1127                 dev_err(dev, "battery node not found!\n");
1128                 return -ENODEV;
1129         }
1130
1131         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1132         if (!pdata)
1133                 return -ENOMEM;
1134
1135         cg->pdata = pdata;
1136         pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
1137         pdata->max_input_current = DEFAULT_INPUT_CURRENT;
1138         pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
1139
1140         pdata->extcon = device_property_read_bool(dev->parent, "extcon");
1141
1142         ret = of_property_read_u32(np, "max_chrg_current",
1143                                    &pdata->max_chrg_current);
1144         if (ret < 0)
1145                 dev_err(dev, "max_chrg_current missing!\n");
1146
1147         ret = of_property_read_u32(np, "max_input_current",
1148                                    &pdata->max_input_current);
1149         if (ret < 0)
1150                 dev_err(dev, "max_input_current missing!\n");
1151
1152         ret = of_property_read_u32(np, "max_chrg_voltage",
1153                                    &pdata->max_chrg_voltage);
1154         if (ret < 0)
1155                 dev_err(dev, "max_chrg_voltage missing!\n");
1156
1157         ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
1158         if (ret < 0)
1159                 dev_err(dev, "virtual_power missing!\n");
1160
1161         ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
1162         if (ret < 0)
1163                 dev_err(dev, "power_dc2otg missing!\n");
1164
1165         ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
1166         if (ret < 0) {
1167                 pdata->sample_res = SAMPLE_RES_20MR;
1168                 dev_err(dev, "sample_res missing!\n");
1169         }
1170
1171         if (!is_battery_exist(cg))
1172                 pdata->virtual_power = 1;
1173
1174         cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
1175                        SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
1176
1177         if (!of_find_property(np, "dc_det_gpio", &ret)) {
1178                 pdata->support_dc_det = false;
1179                 CG_INFO("not support dc\n");
1180         } else {
1181                 pdata->support_dc_det = true;
1182                 pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
1183                                                             0, &flags);
1184                 if (gpio_is_valid(pdata->dc_det_pin)) {
1185                         CG_INFO("support dc\n");
1186                         pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
1187                                                0 : 1;
1188                 } else {
1189                         dev_err(dev, "invalid dc det gpio!\n");
1190                         return -EINVAL;
1191                 }
1192         }
1193
1194         DBG("input_current:%d\n"
1195             "chrg_current:%d\n"
1196             "chrg_voltage:%d\n"
1197             "sample_res:%d\n"
1198             "extcon:%d\n"
1199             "virtual_power:%d\n"
1200             "power_dc2otg:%d\n",
1201             pdata->max_input_current, pdata->max_chrg_current,
1202             pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
1203             pdata->virtual_power, pdata->power_dc2otg);
1204
1205         return 0;
1206 }
1207 #else
1208 static int rk818_cg_parse_dt(struct rk818_charger *cg)
1209 {
1210         return -ENODEV;
1211 }
1212 #endif
1213
1214 static int rk818_charger_probe(struct platform_device *pdev)
1215 {
1216         struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
1217         struct rk818_charger *cg;
1218         int ret;
1219
1220         cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
1221         if (!cg)
1222                 return -ENOMEM;
1223
1224         cg->rk818 = rk818;
1225         cg->pdev = pdev;
1226         cg->dev = &pdev->dev;
1227         cg->regmap = rk818->regmap;
1228         platform_set_drvdata(pdev, cg);
1229
1230         ret = rk818_cg_parse_dt(cg);
1231         if (ret < 0) {
1232                 dev_err(cg->dev, "parse dt failed!\n");
1233                 return ret;
1234         }
1235
1236         ret = rk818_cg_init_irqs(cg);
1237         if (ret != 0) {
1238                 dev_err(cg->dev, "init irqs failed!\n");
1239                 return ret;
1240         }
1241
1242         ret = rk818_cg_init_dc(cg);
1243         if (ret) {
1244                 dev_err(cg->dev, "init dc failed!\n");
1245                 return ret;
1246         }
1247
1248         ret = rk818_cg_init_usb(cg);
1249         if (ret) {
1250                 dev_err(cg->dev, "init usb failed!\n");
1251                 return ret;
1252         }
1253
1254         ret = rk818_cg_init_power_supply(cg);
1255         if (ret) {
1256                 dev_err(cg->dev, "init power supply fail!\n");
1257                 return ret;
1258         }
1259
1260         rk818_cg_init_charger_state(cg);
1261
1262         CG_INFO("driver version: %s\n", DRIVER_VERSION);
1263
1264         return ret;
1265 }
1266
1267 static int rk818_charger_suspend(struct platform_device *pdev,
1268                                  pm_message_t state)
1269 {
1270         struct rk818_charger *cg = platform_get_drvdata(pdev);
1271
1272         if (cg->otg_in && cg->dc_in) {
1273                 cg->int_msk_reg2 = rk818_reg_read(cg, RK818_INT_STS_MSK_REG2);
1274                 rk818_reg_set_bits(cg, RK818_INT_STS_MSK_REG2,
1275                                    CHRG_CVTLMT_INT_MSK, CHRG_CVTLMT_INT_MSK);
1276         }
1277
1278         return 0;
1279 }
1280
1281 static int rk818_charger_resume(struct platform_device *pdev)
1282 {
1283         struct rk818_charger *cg = platform_get_drvdata(pdev);
1284
1285         if (cg->otg_in && cg->dc_in)
1286                 rk818_reg_write(cg, RK818_INT_STS_MSK_REG2, cg->int_msk_reg2);
1287
1288         return 0;
1289 }
1290
1291 static void rk818_charger_shutdown(struct platform_device *pdev)
1292 {
1293         struct rk818_charger *cg = platform_get_drvdata(pdev);
1294
1295         cancel_delayed_work_sync(&cg->host_work);
1296         cancel_delayed_work_sync(&cg->usb_work);
1297         cancel_delayed_work_sync(&cg->discnt_work);
1298         cancel_delayed_work_sync(&cg->dc_work);
1299         cancel_delayed_work_sync(&cg->finish_sig_work);
1300         cancel_delayed_work_sync(&cg->irq_work);
1301         destroy_workqueue(cg->usb_charger_wq);
1302         destroy_workqueue(cg->dc_charger_wq);
1303         destroy_workqueue(cg->finish_sig_wq);
1304
1305         if (cg->pdata->extcon) {
1306                 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
1307                                            &cg->cable_cg_nb);
1308                 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
1309                                            &cg->cable_cg_nb);
1310                 extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
1311                                            &cg->cable_cg_nb);
1312                 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_HOST,
1313                                            &cg->cable_host_nb);
1314                 extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
1315                                            &cg->cable_discnt_nb);
1316         } else {
1317                 rk_bc_detect_notifier_unregister(&cg->bc_nb);
1318         }
1319
1320         rk818_cg_set_otg_state(cg, USB_OTG_POWER_OFF);
1321         rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
1322
1323         CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d\n",
1324                 cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in);
1325 }
1326
1327 static struct platform_driver rk818_charger_driver = {
1328         .probe = rk818_charger_probe,
1329         .suspend = rk818_charger_suspend,
1330         .resume = rk818_charger_resume,
1331         .shutdown = rk818_charger_shutdown,
1332         .driver = {
1333                 .name   = "rk818-charger",
1334         },
1335 };
1336
1337 static int __init charger_init(void)
1338 {
1339         return platform_driver_register(&rk818_charger_driver);
1340 }
1341 module_init(charger_init);
1342
1343 static void __exit charger_exit(void)
1344 {
1345         platform_driver_unregister(&rk818_charger_driver);
1346 }
1347 module_exit(charger_exit);
1348
1349 MODULE_LICENSE("GPL");
1350 MODULE_ALIAS("platform:rk818-charger");
1351 MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");