drivers/power/supply/axp288_charger.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * axp288_charger.c - X-power AXP288 PMIC Charger driver
   4  *
   5  * Copyright (C) 2016-2017 Hans de Goede <hdegoede@redhat.com>
   6  * Copyright (C) 2014 Intel Corporation
   7  * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
   8  */
   9
  10 #include <linux/acpi.h>
  11 #include <linux/bitops.h>
  12 #include <linux/module.h>
  13 #include <linux/device.h>
  14 #include <linux/regmap.h>
  15 #include <linux/workqueue.h>
  16 #include <linux/delay.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/usb/otg.h>
  19 #include <linux/notifier.h>
  20 #include <linux/power_supply.h>
  21 #include <linux/property.h>
  22 #include <linux/mfd/axp20x.h>
  23 #include <linux/extcon.h>
  24 #include <linux/dmi.h>
  25
  26 #define PS_STAT_VBUS_TRIGGER            BIT(0)
  27 #define PS_STAT_BAT_CHRG_DIR            BIT(2)
  28 #define PS_STAT_VBAT_ABOVE_VHOLD        BIT(3)
  29 #define PS_STAT_VBUS_VALID              BIT(4)
  30 #define PS_STAT_VBUS_PRESENT            BIT(5)
  31
  32 #define CHRG_STAT_BAT_SAFE_MODE         BIT(3)
  33 #define CHRG_STAT_BAT_VALID             BIT(4)
  34 #define CHRG_STAT_BAT_PRESENT           BIT(5)
  35 #define CHRG_STAT_CHARGING              BIT(6)
  36 #define CHRG_STAT_PMIC_OTP              BIT(7)
  37
  38 #define VBUS_ISPOUT_CUR_LIM_MASK        0x03
  39 #define VBUS_ISPOUT_CUR_LIM_BIT_POS     0
  40 #define VBUS_ISPOUT_CUR_LIM_900MA       0x0     /* 900mA */
  41 #define VBUS_ISPOUT_CUR_LIM_1500MA      0x1     /* 1500mA */
  42 #define VBUS_ISPOUT_CUR_LIM_2000MA      0x2     /* 2000mA */
  43 #define VBUS_ISPOUT_CUR_NO_LIM          0x3     /* 2500mA */
  44 #define VBUS_ISPOUT_VHOLD_SET_MASK      0x31
  45 #define VBUS_ISPOUT_VHOLD_SET_BIT_POS   0x3
  46 #define VBUS_ISPOUT_VHOLD_SET_OFFSET    4000    /* 4000mV */
  47 #define VBUS_ISPOUT_VHOLD_SET_LSB_RES   100     /* 100mV */
  48 #define VBUS_ISPOUT_VHOLD_SET_4300MV    0x3     /* 4300mV */
  49 #define VBUS_ISPOUT_VBUS_PATH_DIS       BIT(7)
  50
  51 #define CHRG_CCCV_CC_MASK               0xf             /* 4 bits */
  52 #define CHRG_CCCV_CC_BIT_POS            0
  53 #define CHRG_CCCV_CC_OFFSET             200             /* 200mA */
  54 #define CHRG_CCCV_CC_LSB_RES            200             /* 200mA */
  55 #define CHRG_CCCV_ITERM_20P             BIT(4)          /* 20% of CC */
  56 #define CHRG_CCCV_CV_MASK               0x60            /* 2 bits */
  57 #define CHRG_CCCV_CV_BIT_POS            5
  58 #define CHRG_CCCV_CV_4100MV             0x0             /* 4.10V */
  59 #define CHRG_CCCV_CV_4150MV             0x1             /* 4.15V */
  60 #define CHRG_CCCV_CV_4200MV             0x2             /* 4.20V */
  61 #define CHRG_CCCV_CV_4350MV             0x3             /* 4.35V */
  62 #define CHRG_CCCV_CHG_EN                BIT(7)
  63
  64 #define CNTL2_CC_TIMEOUT_MASK           0x3     /* 2 bits */
  65 #define CNTL2_CC_TIMEOUT_OFFSET         6       /* 6 Hrs */
  66 #define CNTL2_CC_TIMEOUT_LSB_RES        2       /* 2 Hrs */
  67 #define CNTL2_CC_TIMEOUT_12HRS          0x3     /* 12 Hrs */
  68 #define CNTL2_CHGLED_TYPEB              BIT(4)
  69 #define CNTL2_CHG_OUT_TURNON            BIT(5)
  70 #define CNTL2_PC_TIMEOUT_MASK           0xC0
  71 #define CNTL2_PC_TIMEOUT_OFFSET         40      /* 40 mins */
  72 #define CNTL2_PC_TIMEOUT_LSB_RES        10      /* 10 mins */
  73 #define CNTL2_PC_TIMEOUT_70MINS         0x3
  74
  75 #define CHRG_ILIM_TEMP_LOOP_EN          BIT(3)
  76 #define CHRG_VBUS_ILIM_MASK             0xf0
  77 #define CHRG_VBUS_ILIM_BIT_POS          4
  78 #define CHRG_VBUS_ILIM_100MA            0x0     /* 100mA */
  79 #define CHRG_VBUS_ILIM_500MA            0x1     /* 500mA */
  80 #define CHRG_VBUS_ILIM_900MA            0x2     /* 900mA */
  81 #define CHRG_VBUS_ILIM_1500MA           0x3     /* 1500mA */
  82 #define CHRG_VBUS_ILIM_2000MA           0x4     /* 2000mA */
  83 #define CHRG_VBUS_ILIM_2500MA           0x5     /* 2500mA */
  84 #define CHRG_VBUS_ILIM_3000MA           0x6     /* 3000mA */
  85 #define CHRG_VBUS_ILIM_3500MA           0x7     /* 3500mA */
  86 #define CHRG_VBUS_ILIM_4000MA           0x8     /* 4000mA */
  87
  88 #define CHRG_VLTFC_0C                   0xA5    /* 0 DegC */
  89 #define CHRG_VHTFC_45C                  0x1F    /* 45 DegC */
  90
  91 #define FG_CNTL_OCV_ADJ_EN              BIT(3)
  92
  93 #define CV_4100MV                       4100    /* 4100mV */
  94 #define CV_4150MV                       4150    /* 4150mV */
  95 #define CV_4200MV                       4200    /* 4200mV */
  96 #define CV_4350MV                       4350    /* 4350mV */
  97
  98 #define AXP288_EXTCON_DEV_NAME          "axp288_extcon"
  99 #define USB_HOST_EXTCON_HID             "INT3496"
 100 #define USB_HOST_EXTCON_NAME            "INT3496:00"
 101
 102 enum {
 103         VBUS_OV_IRQ = 0,
 104         CHARGE_DONE_IRQ,
 105         CHARGE_CHARGING_IRQ,
 106         BAT_SAFE_QUIT_IRQ,
 107         BAT_SAFE_ENTER_IRQ,
 108         QCBTU_IRQ,
 109         CBTU_IRQ,
 110         QCBTO_IRQ,
 111         CBTO_IRQ,
 112         CHRG_INTR_END,
 113 };
 114
 115 struct axp288_chrg_info {
 116         struct platform_device *pdev;
 117         struct regmap *regmap;
 118         struct regmap_irq_chip_data *regmap_irqc;
 119         int irq[CHRG_INTR_END];
 120         struct power_supply *psy_usb;
 121
 122         /* OTG/Host mode */
 123         struct {
 124                 struct work_struct work;
 125                 struct extcon_dev *cable;
 126                 struct notifier_block id_nb;
 127                 bool id_short;
 128         } otg;
 129
 130         /* SDP/CDP/DCP USB charging cable notifications */
 131         struct {
 132                 struct extcon_dev *edev;
 133                 struct notifier_block nb;
 134                 struct work_struct work;
 135         } cable;
 136
 137         int cc;
 138         int cv;
 139         int max_cc;
 140         int max_cv;
 141 };
 142
 143 static inline int axp288_charger_set_cc(struct axp288_chrg_info *info, int cc)
 144 {
 145         u8 reg_val;
 146         int ret;
 147
 148         if (cc < CHRG_CCCV_CC_OFFSET)
 149                 cc = CHRG_CCCV_CC_OFFSET;
 150         else if (cc > info->max_cc)
 151                 cc = info->max_cc;
 152
 153         reg_val = (cc - CHRG_CCCV_CC_OFFSET) / CHRG_CCCV_CC_LSB_RES;
 154         cc = (reg_val * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
 155         reg_val = reg_val << CHRG_CCCV_CC_BIT_POS;
 156
 157         ret = regmap_update_bits(info->regmap,
 158                                 AXP20X_CHRG_CTRL1,
 159                                 CHRG_CCCV_CC_MASK, reg_val);
 160         if (ret >= 0)
 161                 info->cc = cc;
 162
 163         return ret;
 164 }
 165
 166 static inline int axp288_charger_set_cv(struct axp288_chrg_info *info, int cv)
 167 {
 168         u8 reg_val;
 169         int ret;
 170
 171         if (cv <= CV_4100MV) {
 172                 reg_val = CHRG_CCCV_CV_4100MV;
 173                 cv = CV_4100MV;
 174         } else if (cv <= CV_4150MV) {
 175                 reg_val = CHRG_CCCV_CV_4150MV;
 176                 cv = CV_4150MV;
 177         } else if (cv <= CV_4200MV) {
 178                 reg_val = CHRG_CCCV_CV_4200MV;
 179                 cv = CV_4200MV;
 180         } else {
 181                 reg_val = CHRG_CCCV_CV_4350MV;
 182                 cv = CV_4350MV;
 183         }
 184
 185         reg_val = reg_val << CHRG_CCCV_CV_BIT_POS;
 186
 187         ret = regmap_update_bits(info->regmap,
 188                                 AXP20X_CHRG_CTRL1,
 189                                 CHRG_CCCV_CV_MASK, reg_val);
 190
 191         if (ret >= 0)
 192                 info->cv = cv;
 193
 194         return ret;
 195 }
 196
 197 static int axp288_charger_get_vbus_inlmt(struct axp288_chrg_info *info)
 198 {
 199         unsigned int val;
 200         int ret;
 201
 202         ret = regmap_read(info->regmap, AXP20X_CHRG_BAK_CTRL, &val);
 203         if (ret < 0)
 204                 return ret;
 205
 206         val >>= CHRG_VBUS_ILIM_BIT_POS;
 207         switch (val) {
 208         case CHRG_VBUS_ILIM_100MA:
 209                 return 100000;
 210         case CHRG_VBUS_ILIM_500MA:
 211                 return 500000;
 212         case CHRG_VBUS_ILIM_900MA:
 213                 return 900000;
 214         case CHRG_VBUS_ILIM_1500MA:
 215                 return 1500000;
 216         case CHRG_VBUS_ILIM_2000MA:
 217                 return 2000000;
 218         case CHRG_VBUS_ILIM_2500MA:
 219                 return 2500000;
 220         case CHRG_VBUS_ILIM_3000MA:
 221                 return 3000000;
 222         case CHRG_VBUS_ILIM_3500MA:
 223                 return 3500000;
 224         default:
 225                 /* All b1xxx values map to 4000 mA */
 226                 return 4000000;
 227         }
 228 }
 229
 230 static inline int axp288_charger_set_vbus_inlmt(struct axp288_chrg_info *info,
 231                                            int inlmt)
 232 {
 233         int ret;
 234         u8 reg_val;
 235
 236         if (inlmt >= 4000000)
 237                 reg_val = CHRG_VBUS_ILIM_4000MA << CHRG_VBUS_ILIM_BIT_POS;
 238         else if (inlmt >= 3500000)
 239                 reg_val = CHRG_VBUS_ILIM_3500MA << CHRG_VBUS_ILIM_BIT_POS;
 240         else if (inlmt >= 3000000)
 241                 reg_val = CHRG_VBUS_ILIM_3000MA << CHRG_VBUS_ILIM_BIT_POS;
 242         else if (inlmt >= 2500000)
 243                 reg_val = CHRG_VBUS_ILIM_2500MA << CHRG_VBUS_ILIM_BIT_POS;
 244         else if (inlmt >= 2000000)
 245                 reg_val = CHRG_VBUS_ILIM_2000MA << CHRG_VBUS_ILIM_BIT_POS;
 246         else if (inlmt >= 1500000)
 247                 reg_val = CHRG_VBUS_ILIM_1500MA << CHRG_VBUS_ILIM_BIT_POS;
 248         else if (inlmt >= 900000)
 249                 reg_val = CHRG_VBUS_ILIM_900MA << CHRG_VBUS_ILIM_BIT_POS;
 250         else if (inlmt >= 500000)
 251                 reg_val = CHRG_VBUS_ILIM_500MA << CHRG_VBUS_ILIM_BIT_POS;
 252         else
 253                 reg_val = CHRG_VBUS_ILIM_100MA << CHRG_VBUS_ILIM_BIT_POS;
 254
 255         ret = regmap_update_bits(info->regmap, AXP20X_CHRG_BAK_CTRL,
 256                                  CHRG_VBUS_ILIM_MASK, reg_val);
 257         if (ret < 0)
 258                 dev_err(&info->pdev->dev, "charger BAK control %d\n", ret);
 259
 260         return ret;
 261 }
 262
 263 static int axp288_charger_vbus_path_select(struct axp288_chrg_info *info,
 264                                                                 bool enable)
 265 {
 266         int ret;
 267
 268         if (enable)
 269                 ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
 270                                         VBUS_ISPOUT_VBUS_PATH_DIS, 0);
 271         else
 272                 ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
 273                         VBUS_ISPOUT_VBUS_PATH_DIS, VBUS_ISPOUT_VBUS_PATH_DIS);
 274
 275         if (ret < 0)
 276                 dev_err(&info->pdev->dev, "axp288 vbus path select %d\n", ret);
 277
 278         return ret;
 279 }
 280
 281 static int axp288_charger_enable_charger(struct axp288_chrg_info *info,
 282                                                                 bool enable)
 283 {
 284         int ret;
 285
 286         if (enable)
 287                 ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
 288                                 CHRG_CCCV_CHG_EN, CHRG_CCCV_CHG_EN);
 289         else
 290                 ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
 291                                 CHRG_CCCV_CHG_EN, 0);
 292         if (ret < 0)
 293                 dev_err(&info->pdev->dev, "axp288 enable charger %d\n", ret);
 294
 295         return ret;
 296 }
 297
 298 static int axp288_charger_is_present(struct axp288_chrg_info *info)
 299 {
 300         int ret, present = 0;
 301         unsigned int val;
 302
 303         ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
 304         if (ret < 0)
 305                 return ret;
 306
 307         if (val & PS_STAT_VBUS_PRESENT)
 308                 present = 1;
 309         return present;
 310 }
 311
 312 static int axp288_charger_is_online(struct axp288_chrg_info *info)
 313 {
 314         int ret, online = 0;
 315         unsigned int val;
 316
 317         ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
 318         if (ret < 0)
 319                 return ret;
 320
 321         if (val & PS_STAT_VBUS_VALID)
 322                 online = 1;
 323         return online;
 324 }
 325
 326 static int axp288_get_charger_health(struct axp288_chrg_info *info)
 327 {
 328         int ret, pwr_stat, chrg_stat;
 329         int health = POWER_SUPPLY_HEALTH_UNKNOWN;
 330         unsigned int val;
 331
 332         ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
 333         if ((ret < 0) || !(val & PS_STAT_VBUS_PRESENT))
 334                 goto health_read_fail;
 335         else
 336                 pwr_stat = val;
 337
 338         ret = regmap_read(info->regmap, AXP20X_PWR_OP_MODE, &val);
 339         if (ret < 0)
 340                 goto health_read_fail;
 341         else
 342                 chrg_stat = val;
 343
 344         if (!(pwr_stat & PS_STAT_VBUS_VALID))
 345                 health = POWER_SUPPLY_HEALTH_DEAD;
 346         else if (chrg_stat & CHRG_STAT_PMIC_OTP)
 347                 health = POWER_SUPPLY_HEALTH_OVERHEAT;
 348         else if (chrg_stat & CHRG_STAT_BAT_SAFE_MODE)
 349                 health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 350         else
 351                 health = POWER_SUPPLY_HEALTH_GOOD;
 352
 353 health_read_fail:
 354         return health;
 355 }
 356
 357 static int axp288_charger_usb_set_property(struct power_supply *psy,
 358                                     enum power_supply_property psp,
 359                                     const union power_supply_propval *val)
 360 {
 361         struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
 362         int ret = 0;
 363         int scaled_val;
 364
 365         switch (psp) {
 366         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 367                 scaled_val = min(val->intval, info->max_cc);
 368                 scaled_val = DIV_ROUND_CLOSEST(scaled_val, 1000);
 369                 ret = axp288_charger_set_cc(info, scaled_val);
 370                 if (ret < 0)
 371                         dev_warn(&info->pdev->dev, "set charge current failed\n");
 372                 break;
 373         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 374                 scaled_val = min(val->intval, info->max_cv);
 375                 scaled_val = DIV_ROUND_CLOSEST(scaled_val, 1000);
 376                 ret = axp288_charger_set_cv(info, scaled_val);
 377                 if (ret < 0)
 378                         dev_warn(&info->pdev->dev, "set charge voltage failed\n");
 379                 break;
 380         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 381                 ret = axp288_charger_set_vbus_inlmt(info, val->intval);
 382                 if (ret < 0)
 383                         dev_warn(&info->pdev->dev, "set input current limit failed\n");
 384                 break;
 385         default:
 386                 ret = -EINVAL;
 387         }
 388
 389         return ret;
 390 }
 391
 392 static int axp288_charger_usb_get_property(struct power_supply *psy,
 393                                     enum power_supply_property psp,
 394                                     union power_supply_propval *val)
 395 {
 396         struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
 397         int ret;
 398
 399         switch (psp) {
 400         case POWER_SUPPLY_PROP_PRESENT:
 401                 /* Check for OTG case first */
 402                 if (info->otg.id_short) {
 403                         val->intval = 0;
 404                         break;
 405                 }
 406                 ret = axp288_charger_is_present(info);
 407                 if (ret < 0)
 408                         return ret;
 409                 val->intval = ret;
 410                 break;
 411         case POWER_SUPPLY_PROP_ONLINE:
 412                 /* Check for OTG case first */
 413                 if (info->otg.id_short) {
 414                         val->intval = 0;
 415                         break;
 416                 }
 417                 ret = axp288_charger_is_online(info);
 418                 if (ret < 0)
 419                         return ret;
 420                 val->intval = ret;
 421                 break;
 422         case POWER_SUPPLY_PROP_HEALTH:
 423                 val->intval = axp288_get_charger_health(info);
 424                 break;
 425         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 426                 val->intval = info->cc * 1000;
 427                 break;
 428         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 429                 val->intval = info->max_cc * 1000;
 430                 break;
 431         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 432                 val->intval = info->cv * 1000;
 433                 break;
 434         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 435                 val->intval = info->max_cv * 1000;
 436                 break;
 437         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 438                 ret = axp288_charger_get_vbus_inlmt(info);
 439                 if (ret < 0)
 440                         return ret;
 441                 val->intval = ret;
 442                 break;
 443         default:
 444                 return -EINVAL;
 445         }
 446
 447         return 0;
 448 }
 449
 450 static int axp288_charger_property_is_writeable(struct power_supply *psy,
 451                 enum power_supply_property psp)
 452 {
 453         int ret;
 454
 455         switch (psp) {
 456         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 457         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 458         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 459                 ret = 1;
 460                 break;
 461         default:
 462                 ret = 0;
 463         }
 464
 465         return ret;
 466 }
 467
 468 static enum power_supply_property axp288_usb_props[] = {
 469         POWER_SUPPLY_PROP_PRESENT,
 470         POWER_SUPPLY_PROP_ONLINE,
 471         POWER_SUPPLY_PROP_TYPE,
 472         POWER_SUPPLY_PROP_HEALTH,
 473         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 474         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 475         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 476         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 477         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 478 };
 479
 480 static const struct power_supply_desc axp288_charger_desc = {
 481         .name                   = "axp288_charger",
 482         .type                   = POWER_SUPPLY_TYPE_USB,
 483         .properties             = axp288_usb_props,
 484         .num_properties         = ARRAY_SIZE(axp288_usb_props),
 485         .get_property           = axp288_charger_usb_get_property,
 486         .set_property           = axp288_charger_usb_set_property,
 487         .property_is_writeable  = axp288_charger_property_is_writeable,
 488 };
 489
 490 static irqreturn_t axp288_charger_irq_thread_handler(int irq, void *dev)
 491 {
 492         struct axp288_chrg_info *info = dev;
 493         int i;
 494
 495         for (i = 0; i < CHRG_INTR_END; i++) {
 496                 if (info->irq[i] == irq)
 497                         break;
 498         }
 499
 500         if (i >= CHRG_INTR_END) {
 501                 dev_warn(&info->pdev->dev, "spurious interrupt!!\n");
 502                 return IRQ_NONE;
 503         }
 504
 505         switch (i) {
 506         case VBUS_OV_IRQ:
 507                 dev_dbg(&info->pdev->dev, "VBUS Over Voltage INTR\n");
 508                 break;
 509         case CHARGE_DONE_IRQ:
 510                 dev_dbg(&info->pdev->dev, "Charging Done INTR\n");
 511                 break;
 512         case CHARGE_CHARGING_IRQ:
 513                 dev_dbg(&info->pdev->dev, "Start Charging IRQ\n");
 514                 break;
 515         case BAT_SAFE_QUIT_IRQ:
 516                 dev_dbg(&info->pdev->dev,
 517                         "Quit Safe Mode(restart timer) Charging IRQ\n");
 518                 break;
 519         case BAT_SAFE_ENTER_IRQ:
 520                 dev_dbg(&info->pdev->dev,
 521                         "Enter Safe Mode(timer expire) Charging IRQ\n");
 522                 break;
 523         case QCBTU_IRQ:
 524                 dev_dbg(&info->pdev->dev,
 525                         "Quit Battery Under Temperature(CHRG) INTR\n");
 526                 break;
 527         case CBTU_IRQ:
 528                 dev_dbg(&info->pdev->dev,
 529                         "Hit Battery Under Temperature(CHRG) INTR\n");
 530                 break;
 531         case QCBTO_IRQ:
 532                 dev_dbg(&info->pdev->dev,
 533                         "Quit Battery Over Temperature(CHRG) INTR\n");
 534                 break;
 535         case CBTO_IRQ:
 536                 dev_dbg(&info->pdev->dev,
 537                         "Hit Battery Over Temperature(CHRG) INTR\n");
 538                 break;
 539         default:
 540                 dev_warn(&info->pdev->dev, "Spurious Interrupt!!!\n");
 541                 goto out;
 542         }
 543
 544         power_supply_changed(info->psy_usb);
 545 out:
 546         return IRQ_HANDLED;
 547 }
 548
 549 /*
 550  * The HP Pavilion x2 10 series comes in a number of variants:
 551  * Bay Trail SoC    + AXP288 PMIC, Micro-USB, DMI_BOARD_NAME: "8021"
 552  * Bay Trail SoC    + AXP288 PMIC, Type-C,    DMI_BOARD_NAME: "815D"
 553  * Cherry Trail SoC + AXP288 PMIC, Type-C,    DMI_BOARD_NAME: "813E"
 554  * Cherry Trail SoC + TI PMIC,     Type-C,    DMI_BOARD_NAME: "827C" or "82F4"
 555  *
 556  * The variants with the AXP288 + Type-C connector are all kinds of special:
 557  *
 558  * 1. They use a Type-C connector which the AXP288 does not support, so when
 559  * using a Type-C charger it is not recognized. Unlike most AXP288 devices,
 560  * this model actually has mostly working ACPI AC / Battery code, the ACPI code
 561  * "solves" this by simply setting the input_current_limit to 3A.
 562  * There are still some issues with the ACPI code, so we use this native driver,
 563  * and to solve the charging not working (500mA is not enough) issue we hardcode
 564  * the 3A input_current_limit like the ACPI code does.
 565  *
 566  * 2. If no charger is connected the machine boots with the vbus-path disabled.
 567  * Normally this is done when a 5V boost converter is active to avoid the PMIC
 568  * trying to charge from the 5V boost converter's output. This is done when
 569  * an OTG host cable is inserted and the ID pin on the micro-B receptacle is
 570  * pulled low and the ID pin has an ACPI event handler associated with it
 571  * which re-enables the vbus-path when the ID pin is pulled high when the
 572  * OTG host cable is removed. The Type-C connector has no ID pin, there is
 573  * no ID pin handler and there appears to be no 5V boost converter, so we
 574  * end up not charging because the vbus-path is disabled, until we unplug
 575  * the charger which automatically clears the vbus-path disable bit and then
 576  * on the second plug-in of the adapter we start charging. To solve the not
 577  * charging on first charger plugin we unconditionally enable the vbus-path at
 578  * probe on this model, which is safe since there is no 5V boost converter.
 579  */
 580 static const struct dmi_system_id axp288_hp_x2_dmi_ids[] = {
 581         {
 582                 .matches = {
 583                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 584                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
 585                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "815D"),
 586                 },
 587         },
 588         {
 589                 .matches = {
 590                         DMI_EXACT_MATCH(DMI_SYS_VENDOR, "HP"),
 591                         DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
 592                         DMI_EXACT_MATCH(DMI_BOARD_NAME, "813E"),
 593                 },
 594         },
 595         {} /* Terminating entry */
 596 };
 597
 598 static void axp288_charger_extcon_evt_worker(struct work_struct *work)
 599 {
 600         struct axp288_chrg_info *info =
 601             container_of(work, struct axp288_chrg_info, cable.work);
 602         int ret, current_limit;
 603         struct extcon_dev *edev = info->cable.edev;
 604         unsigned int val;
 605
 606         ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
 607         if (ret < 0) {
 608                 dev_err(&info->pdev->dev, "Error reading status (%d)\n", ret);
 609                 return;
 610         }
 611
 612         /* Offline? Disable charging and bail */
 613         if (!(val & PS_STAT_VBUS_VALID)) {
 614                 dev_dbg(&info->pdev->dev, "USB charger disconnected\n");
 615                 axp288_charger_enable_charger(info, false);
 616                 power_supply_changed(info->psy_usb);
 617                 return;
 618         }
 619
 620         /* Determine cable/charger type */
 621         if (dmi_check_system(axp288_hp_x2_dmi_ids)) {
 622                 /* See comment above axp288_hp_x2_dmi_ids declaration */
 623                 dev_dbg(&info->pdev->dev, "HP X2 with Type-C, setting inlmt to 3A\n");
 624                 current_limit = 3000000;
 625         } else if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0) {
 626                 dev_dbg(&info->pdev->dev, "USB SDP charger is connected\n");
 627                 current_limit = 500000;
 628         } else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0) {
 629                 dev_dbg(&info->pdev->dev, "USB CDP charger is connected\n");
 630                 current_limit = 1500000;
 631         } else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0) {
 632                 dev_dbg(&info->pdev->dev, "USB DCP charger is connected\n");
 633                 current_limit = 2000000;
 634         } else {
 635                 /* Charger type detection still in progress, bail. */
 636                 return;
 637         }
 638
 639         /* Set vbus current limit first, then enable charger */
 640         ret = axp288_charger_set_vbus_inlmt(info, current_limit);
 641         if (ret == 0)
 642                 axp288_charger_enable_charger(info, true);
 643         else
 644                 dev_err(&info->pdev->dev,
 645                         "error setting current limit (%d)\n", ret);
 646
 647         power_supply_changed(info->psy_usb);
 648 }
 649
 650 static int axp288_charger_handle_cable_evt(struct notifier_block *nb,
 651                                            unsigned long event, void *param)
 652 {
 653         struct axp288_chrg_info *info =
 654                 container_of(nb, struct axp288_chrg_info, cable.nb);
 655         schedule_work(&info->cable.work);
 656         return NOTIFY_OK;
 657 }
 658
 659 static void axp288_charger_otg_evt_worker(struct work_struct *work)
 660 {
 661         struct axp288_chrg_info *info =
 662             container_of(work, struct axp288_chrg_info, otg.work);
 663         struct extcon_dev *edev = info->otg.cable;
 664         int ret, usb_host = extcon_get_state(edev, EXTCON_USB_HOST);
 665
 666         dev_dbg(&info->pdev->dev, "external connector USB-Host is %s\n",
 667                                 usb_host ? "attached" : "detached");
 668
 669         /*
 670          * Set usb_id_short flag to avoid running charger detection logic
 671          * in case usb host.
 672          */
 673         info->otg.id_short = usb_host;
 674
 675         /* Disable VBUS path before enabling the 5V boost */
 676         ret = axp288_charger_vbus_path_select(info, !info->otg.id_short);
 677         if (ret < 0)
 678                 dev_warn(&info->pdev->dev, "vbus path disable failed\n");
 679 }
 680
 681 static int axp288_charger_handle_otg_evt(struct notifier_block *nb,
 682                                    unsigned long event, void *param)
 683 {
 684         struct axp288_chrg_info *info =
 685             container_of(nb, struct axp288_chrg_info, otg.id_nb);
 686
 687         schedule_work(&info->otg.work);
 688
 689         return NOTIFY_OK;
 690 }
 691
 692 static int charger_init_hw_regs(struct axp288_chrg_info *info)
 693 {
 694         int ret, cc, cv;
 695         unsigned int val;
 696
 697         /* Program temperature thresholds */
 698         ret = regmap_write(info->regmap, AXP20X_V_LTF_CHRG, CHRG_VLTFC_0C);
 699         if (ret < 0) {
 700                 dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
 701                                                         AXP20X_V_LTF_CHRG, ret);
 702                 return ret;
 703         }
 704
 705         ret = regmap_write(info->regmap, AXP20X_V_HTF_CHRG, CHRG_VHTFC_45C);
 706         if (ret < 0) {
 707                 dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
 708                                                         AXP20X_V_HTF_CHRG, ret);
 709                 return ret;
 710         }
 711
 712         /* Do not turn-off charger o/p after charge cycle ends */
 713         ret = regmap_update_bits(info->regmap,
 714                                 AXP20X_CHRG_CTRL2,
 715                                 CNTL2_CHG_OUT_TURNON, CNTL2_CHG_OUT_TURNON);
 716         if (ret < 0) {
 717                 dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
 718                                                 AXP20X_CHRG_CTRL2, ret);
 719                 return ret;
 720         }
 721
 722         /* Setup ending condition for charging to be 10% of I(chrg) */
 723         ret = regmap_update_bits(info->regmap,
 724                                 AXP20X_CHRG_CTRL1,
 725                                 CHRG_CCCV_ITERM_20P, 0);
 726         if (ret < 0) {
 727                 dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
 728                                                 AXP20X_CHRG_CTRL1, ret);
 729                 return ret;
 730         }
 731
 732         /* Disable OCV-SOC curve calibration */
 733         ret = regmap_update_bits(info->regmap,
 734                                 AXP20X_CC_CTRL,
 735                                 FG_CNTL_OCV_ADJ_EN, 0);
 736         if (ret < 0) {
 737                 dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
 738                                                 AXP20X_CC_CTRL, ret);
 739                 return ret;
 740         }
 741
 742         if (dmi_check_system(axp288_hp_x2_dmi_ids)) {
 743                 /* See comment above axp288_hp_x2_dmi_ids declaration */
 744                 ret = axp288_charger_vbus_path_select(info, true);
 745                 if (ret < 0)
 746                         return ret;
 747         }
 748
 749         /* Read current charge voltage and current limit */
 750         ret = regmap_read(info->regmap, AXP20X_CHRG_CTRL1, &val);
 751         if (ret < 0) {
 752                 dev_err(&info->pdev->dev, "register(%x) read error(%d)\n",
 753                         AXP20X_CHRG_CTRL1, ret);
 754                 return ret;
 755         }
 756
 757         /* Determine charge voltage */
 758         cv = (val & CHRG_CCCV_CV_MASK) >> CHRG_CCCV_CV_BIT_POS;
 759         switch (cv) {
 760         case CHRG_CCCV_CV_4100MV:
 761                 info->cv = CV_4100MV;
 762                 break;
 763         case CHRG_CCCV_CV_4150MV:
 764                 info->cv = CV_4150MV;
 765                 break;
 766         case CHRG_CCCV_CV_4200MV:
 767                 info->cv = CV_4200MV;
 768                 break;
 769         case CHRG_CCCV_CV_4350MV:
 770                 info->cv = CV_4350MV;
 771                 break;
 772         }
 773
 774         /* Determine charge current limit */
 775         cc = (val & CHRG_CCCV_CC_MASK) >> CHRG_CCCV_CC_BIT_POS;
 776         cc = (cc * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
 777         info->cc = cc;
 778
 779         /*
 780          * Do not allow the user to configure higher settings then those
 781          * set by the firmware
 782          */
 783         info->max_cv = info->cv;
 784         info->max_cc = info->cc;
 785
 786         return 0;
 787 }
 788
 789 static void axp288_charger_cancel_work(void *data)
 790 {
 791         struct axp288_chrg_info *info = data;
 792
 793         cancel_work_sync(&info->otg.work);
 794         cancel_work_sync(&info->cable.work);
 795 }
 796
 797 static int axp288_charger_probe(struct platform_device *pdev)
 798 {
 799         int ret, i, pirq;
 800         struct axp288_chrg_info *info;
 801         struct device *dev = &pdev->dev;
 802         struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
 803         struct power_supply_config charger_cfg = {};
 804         unsigned int val;
 805
 806         /*
 807          * On some devices the fuelgauge and charger parts of the axp288 are
 808          * not used, check that the fuelgauge is enabled (CC_CTRL != 0).
 809          */
 810         ret = regmap_read(axp20x->regmap, AXP20X_CC_CTRL, &val);
 811         if (ret < 0)
 812                 return ret;
 813         if (val == 0)
 814                 return -ENODEV;
 815
 816         info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
 817         if (!info)
 818                 return -ENOMEM;
 819
 820         info->pdev = pdev;
 821         info->regmap = axp20x->regmap;
 822         info->regmap_irqc = axp20x->regmap_irqc;
 823
 824         info->cable.edev = extcon_get_extcon_dev(AXP288_EXTCON_DEV_NAME);
 825         if (info->cable.edev == NULL) {
 826                 dev_dbg(&pdev->dev, "%s is not ready, probe deferred\n",
 827                         AXP288_EXTCON_DEV_NAME);
 828                 return -EPROBE_DEFER;
 829         }
 830
 831         if (acpi_dev_present(USB_HOST_EXTCON_HID, NULL, -1)) {
 832                 info->otg.cable = extcon_get_extcon_dev(USB_HOST_EXTCON_NAME);
 833                 if (info->otg.cable == NULL) {
 834                         dev_dbg(dev, "EXTCON_USB_HOST is not ready, probe deferred\n");
 835                         return -EPROBE_DEFER;
 836                 }
 837                 dev_info(&pdev->dev,
 838                          "Using " USB_HOST_EXTCON_HID " extcon for usb-id\n");
 839         }
 840
 841         platform_set_drvdata(pdev, info);
 842
 843         ret = charger_init_hw_regs(info);
 844         if (ret)
 845                 return ret;
 846
 847         /* Register with power supply class */
 848         charger_cfg.drv_data = info;
 849         info->psy_usb = devm_power_supply_register(dev, &axp288_charger_desc,
 850                                                    &charger_cfg);
 851         if (IS_ERR(info->psy_usb)) {
 852                 ret = PTR_ERR(info->psy_usb);
 853                 dev_err(dev, "failed to register power supply: %d\n", ret);
 854                 return ret;
 855         }
 856
 857         /* Cancel our work on cleanup, register this before the notifiers */
 858         ret = devm_add_action(dev, axp288_charger_cancel_work, info);
 859         if (ret)
 860                 return ret;
 861
 862         /* Register for extcon notification */
 863         INIT_WORK(&info->cable.work, axp288_charger_extcon_evt_worker);
 864         info->cable.nb.notifier_call = axp288_charger_handle_cable_evt;
 865         ret = devm_extcon_register_notifier_all(dev, info->cable.edev,
 866                                                 &info->cable.nb);
 867         if (ret) {
 868                 dev_err(dev, "failed to register cable extcon notifier\n");
 869                 return ret;
 870         }
 871         schedule_work(&info->cable.work);
 872
 873         /* Register for OTG notification */
 874         INIT_WORK(&info->otg.work, axp288_charger_otg_evt_worker);
 875         info->otg.id_nb.notifier_call = axp288_charger_handle_otg_evt;
 876         if (info->otg.cable) {
 877                 ret = devm_extcon_register_notifier(&pdev->dev, info->otg.cable,
 878                                         EXTCON_USB_HOST, &info->otg.id_nb);
 879                 if (ret) {
 880                         dev_err(dev, "failed to register EXTCON_USB_HOST notifier\n");
 881                         return ret;
 882                 }
 883                 schedule_work(&info->otg.work);
 884         }
 885
 886         /* Register charger interrupts */
 887         for (i = 0; i < CHRG_INTR_END; i++) {
 888                 pirq = platform_get_irq(info->pdev, i);
 889                 if (pirq < 0)
 890                         return pirq;
 891
 892                 info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
 893                 if (info->irq[i] < 0) {
 894                         dev_warn(&info->pdev->dev,
 895                                 "failed to get virtual interrupt=%d\n", pirq);
 896                         return info->irq[i];
 897                 }
 898                 ret = devm_request_threaded_irq(&info->pdev->dev, info->irq[i],
 899                                         NULL, axp288_charger_irq_thread_handler,
 900                                         IRQF_ONESHOT, info->pdev->name, info);
 901                 if (ret) {
 902                         dev_err(&pdev->dev, "failed to request interrupt=%d\n",
 903                                                                 info->irq[i]);
 904                         return ret;
 905                 }
 906         }
 907
 908         return 0;
 909 }
 910
 911 static const struct platform_device_id axp288_charger_id_table[] = {
 912         { .name = "axp288_charger" },
 913         {},
 914 };
 915 MODULE_DEVICE_TABLE(platform, axp288_charger_id_table);
 916
 917 static struct platform_driver axp288_charger_driver = {
 918         .probe = axp288_charger_probe,
 919         .id_table = axp288_charger_id_table,
 920         .driver = {
 921                 .name = "axp288_charger",
 922         },
 923 };
 924
 925 module_platform_driver(axp288_charger_driver);
 926
 927 MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
 928 MODULE_DESCRIPTION("X-power AXP288 Charger Driver");
 929 MODULE_LICENSE("GPL v2");