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