Quelle  axp288_charger.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * axp288_charger.c - X-power AXP288 PMIC Charger driver
 *
 * Copyright (C) 2016-2017 Hans de Goede <hdegoede@redhat.com>
 * Copyright (C) 2014 Intel Corporation
 * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
 */

#include <linux/acpi.h>
#include <linux/bitops.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/regmap.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/usb/otg.h>
#include <linux/notifier.h>
#include <linux/power_supply.h>
#include <linux/property.h>
#include <linux/mfd/axp20x.h>
#include <linux/extcon.h>
#include <linux/dmi.h>
#include <asm/iosf_mbi.h>

#define PS_STAT_VBUS_TRIGGER  BIT(0)
#define PS_STAT_BAT_CHRG_DIR  BIT(2)
#define PS_STAT_VBAT_ABOVE_VHOLD BIT(3)
#define PS_STAT_VBUS_VALID  BIT(4)
#define PS_STAT_VBUS_PRESENT  BIT(5)

#define CHRG_STAT_BAT_SAFE_MODE  BIT(3)
#define CHRG_STAT_BAT_VALID  BIT(4)
#define CHRG_STAT_BAT_PRESENT  BIT(5)
#define CHRG_STAT_CHARGING  BIT(6)
#define CHRG_STAT_PMIC_OTP  BIT(7)

#define VBUS_ISPOUT_CUR_LIM_MASK 0x03
#define VBUS_ISPOUT_CUR_LIM_BIT_POS 0
#define VBUS_ISPOUT_CUR_LIM_900MA 0x0 /* 900mA */
#define VBUS_ISPOUT_CUR_LIM_1500MA 0x1 /* 1500mA */
#define VBUS_ISPOUT_CUR_LIM_2000MA 0x2 /* 2000mA */
#define VBUS_ISPOUT_CUR_NO_LIM  0x3 /* 2500mA */
#define VBUS_ISPOUT_VHOLD_SET_MASK 0x38
#define VBUS_ISPOUT_VHOLD_SET_BIT_POS 0x3
#define VBUS_ISPOUT_VHOLD_SET_OFFSET 4000 /* 4000mV */
#define VBUS_ISPOUT_VHOLD_SET_LSB_RES 100 /* 100mV */
#define VBUS_ISPOUT_VHOLD_SET_4400MV 0x4 /* 4400mV */
#define VBUS_ISPOUT_VBUS_PATH_DIS BIT(7)

#define CHRG_CCCV_CC_MASK  0xf  /* 4 bits */
#define CHRG_CCCV_CC_BIT_POS  0
#define CHRG_CCCV_CC_OFFSET  200  /* 200mA */
#define CHRG_CCCV_CC_LSB_RES  200  /* 200mA */
#define CHRG_CCCV_ITERM_20P  BIT(4)  /* 20% of CC */
#define CHRG_CCCV_CV_MASK  0x60  /* 2 bits */
#define CHRG_CCCV_CV_BIT_POS  5
#define CHRG_CCCV_CV_4100MV  0x0  /* 4.10V */
#define CHRG_CCCV_CV_4150MV  0x1  /* 4.15V */
#define CHRG_CCCV_CV_4200MV  0x2  /* 4.20V */
#define CHRG_CCCV_CV_4350MV  0x3  /* 4.35V */
#define CHRG_CCCV_CHG_EN  BIT(7)

#define CNTL2_CC_TIMEOUT_MASK  0x3 /* 2 bits */
#define CNTL2_CC_TIMEOUT_OFFSET  6 /* 6 Hrs */
#define CNTL2_CC_TIMEOUT_LSB_RES 2 /* 2 Hrs */
#define CNTL2_CC_TIMEOUT_12HRS  0x3 /* 12 Hrs */
#define CNTL2_CHGLED_TYPEB  BIT(4)
#define CNTL2_CHG_OUT_TURNON  BIT(5)
#define CNTL2_PC_TIMEOUT_MASK  0xC0
#define CNTL2_PC_TIMEOUT_OFFSET  40 /* 40 mins */
#define CNTL2_PC_TIMEOUT_LSB_RES 10 /* 10 mins */
#define CNTL2_PC_TIMEOUT_70MINS  0x3

#define CHRG_ILIM_TEMP_LOOP_EN  BIT(3)
#define CHRG_VBUS_ILIM_MASK  0xf0
#define CHRG_VBUS_ILIM_BIT_POS  4
#define CHRG_VBUS_ILIM_100MA  0x0 /* 100mA */
#define CHRG_VBUS_ILIM_500MA  0x1 /* 500mA */
#define CHRG_VBUS_ILIM_900MA  0x2 /* 900mA */
#define CHRG_VBUS_ILIM_1500MA  0x3 /* 1500mA */
#define CHRG_VBUS_ILIM_2000MA  0x4 /* 2000mA */
#define CHRG_VBUS_ILIM_2500MA  0x5 /* 2500mA */
#define CHRG_VBUS_ILIM_3000MA  0x6 /* 3000mA */
#define CHRG_VBUS_ILIM_3500MA  0x7 /* 3500mA */
#define CHRG_VBUS_ILIM_4000MA  0x8 /* 4000mA */

#define CHRG_VLTFC_0C   0xA5 /* 0 DegC */
#define CHRG_VHTFC_45C   0x1F /* 45 DegC */

#define FG_CNTL_OCV_ADJ_EN  BIT(3)

#define CV_4100MV   4100 /* 4100mV */
#define CV_4150MV   4150 /* 4150mV */
#define CV_4200MV   4200 /* 4200mV */
#define CV_4350MV   4350 /* 4350mV */

#define AXP288_REG_UPDATE_INTERVAL (60 * HZ)

#define AXP288_EXTCON_DEV_NAME  "axp288_extcon"
#define USB_HOST_EXTCON_HID  "INT3496"
#define USB_HOST_EXTCON_NAME  "INT3496:00"

enum {
 VBUS_OV_IRQ = 0,
 CHARGE_DONE_IRQ,
 CHARGE_CHARGING_IRQ,
 BAT_SAFE_QUIT_IRQ,
 BAT_SAFE_ENTER_IRQ,
 QCBTU_IRQ,
 CBTU_IRQ,
 QCBTO_IRQ,
 CBTO_IRQ,
 CHRG_INTR_END,
};

struct axp288_chrg_info {
 struct platform_device *pdev;
 struct regmap *regmap;
 struct regmap_irq_chip_data *regmap_irqc;
 int irq[CHRG_INTR_END];
 struct power_supply *psy_usb;
 struct mutex lock;

 /* OTG/Host mode */
 struct {
  struct work_struct work;
  struct extcon_dev *cable;
  struct notifier_block id_nb;
  bool id_short;
 } otg;

 /* SDP/CDP/DCP USB charging cable notifications */
 struct {
  struct extcon_dev *edev;
  struct notifier_block nb;
  struct work_struct work;
 } cable;

 int cc;
 int cv;
 int max_cc;
 int max_cv;

 unsigned long last_updated;
 unsigned int input_status;
 unsigned int op_mode;
 unsigned int backend_control;
 bool valid;
};

static inline int axp288_charger_set_cc(struct axp288_chrg_info *info, int cc)
{
 u8 reg_val;
 int ret;

 if (cc < CHRG_CCCV_CC_OFFSET)
  cc = CHRG_CCCV_CC_OFFSET;
 else if (cc > info->max_cc)
  cc = info->max_cc;

 reg_val = (cc - CHRG_CCCV_CC_OFFSET) / CHRG_CCCV_CC_LSB_RES;
 cc = (reg_val * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
 reg_val = reg_val << CHRG_CCCV_CC_BIT_POS;

 ret = regmap_update_bits(info->regmap,
    AXP20X_CHRG_CTRL1,
    CHRG_CCCV_CC_MASK, reg_val);
 if (ret >= 0)
  info->cc = cc;

 return ret;
}

static inline int axp288_charger_set_cv(struct axp288_chrg_info *info, int cv)
{
 u8 reg_val;
 int ret;

 if (cv >= CV_4350MV) {
  reg_val = CHRG_CCCV_CV_4350MV;
  cv = CV_4350MV;
 } else if (cv >= CV_4200MV) {
  reg_val = CHRG_CCCV_CV_4200MV;
  cv = CV_4200MV;
 } else if (cv >= CV_4150MV) {
  reg_val = CHRG_CCCV_CV_4150MV;
  cv = CV_4150MV;
 } else {
  reg_val = CHRG_CCCV_CV_4100MV;
  cv = CV_4100MV;
 }

 reg_val = reg_val << CHRG_CCCV_CV_BIT_POS;

 ret = regmap_update_bits(info->regmap,
    AXP20X_CHRG_CTRL1,
    CHRG_CCCV_CV_MASK, reg_val);

 if (ret >= 0)
  info->cv = cv;

 return ret;
}

static int axp288_charger_get_vbus_inlmt(struct axp288_chrg_info *info)
{
 unsigned int val;

 val = info->backend_control;

 val >>= CHRG_VBUS_ILIM_BIT_POS;
 switch (val) {
 case CHRG_VBUS_ILIM_100MA:
  return 100000;
 case CHRG_VBUS_ILIM_500MA:
  return 500000;
 case CHRG_VBUS_ILIM_900MA:
  return 900000;
 case CHRG_VBUS_ILIM_1500MA:
  return 1500000;
 case CHRG_VBUS_ILIM_2000MA:
  return 2000000;
 case CHRG_VBUS_ILIM_2500MA:
  return 2500000;
 case CHRG_VBUS_ILIM_3000MA:
  return 3000000;
 case CHRG_VBUS_ILIM_3500MA:
  return 3500000;
 default:
  /* All b1xxx values map to 4000 mA */
  return 4000000;
 }
}

static inline int axp288_charger_set_vbus_inlmt(struct axp288_chrg_info *info,
        int inlmt)
{
 int ret;
 u8 reg_val;

 if (inlmt >= 4000000)
  reg_val = CHRG_VBUS_ILIM_4000MA << CHRG_VBUS_ILIM_BIT_POS;
 else if (inlmt >= 3500000)
  reg_val = CHRG_VBUS_ILIM_3500MA << CHRG_VBUS_ILIM_BIT_POS;
 else if (inlmt >= 3000000)
  reg_val = CHRG_VBUS_ILIM_3000MA << CHRG_VBUS_ILIM_BIT_POS;
 else if (inlmt >= 2500000)
  reg_val = CHRG_VBUS_ILIM_2500MA << CHRG_VBUS_ILIM_BIT_POS;
 else if (inlmt >= 2000000)
  reg_val = CHRG_VBUS_ILIM_2000MA << CHRG_VBUS_ILIM_BIT_POS;
 else if (inlmt >= 1500000)
  reg_val = CHRG_VBUS_ILIM_1500MA << CHRG_VBUS_ILIM_BIT_POS;
 else if (inlmt >= 900000)
  reg_val = CHRG_VBUS_ILIM_900MA << CHRG_VBUS_ILIM_BIT_POS;
 else if (inlmt >= 500000)
  reg_val = CHRG_VBUS_ILIM_500MA << CHRG_VBUS_ILIM_BIT_POS;
 else
  reg_val = CHRG_VBUS_ILIM_100MA << CHRG_VBUS_ILIM_BIT_POS;

 ret = regmap_update_bits(info->regmap, AXP20X_CHRG_BAK_CTRL,
     CHRG_VBUS_ILIM_MASK, reg_val);
 if (ret < 0)
  dev_err(&info->pdev->dev, "charger BAK control %d\n", ret);

 return ret;
}

static int axp288_charger_vbus_path_select(struct axp288_chrg_info *info,
        bool enable)
{
 int ret;

 if (enable)
  ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
     VBUS_ISPOUT_VBUS_PATH_DIS, 0);
 else
  ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
   VBUS_ISPOUT_VBUS_PATH_DIS, VBUS_ISPOUT_VBUS_PATH_DIS);

 if (ret < 0)
  dev_err(&info->pdev->dev, "axp288 vbus path select %d\n", ret);

 return ret;
}

static int axp288_charger_enable_charger(struct axp288_chrg_info *info,
        bool enable)
{
 int ret;

 if (enable)
  ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
    CHRG_CCCV_CHG_EN, CHRG_CCCV_CHG_EN);
 else
  ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
    CHRG_CCCV_CHG_EN, 0);
 if (ret < 0)
  dev_err(&info->pdev->dev, "axp288 enable charger %d\n", ret);

 return ret;
}

static int axp288_get_charger_health(struct axp288_chrg_info *info)
{
 if (!(info->input_status & PS_STAT_VBUS_PRESENT))
  return POWER_SUPPLY_HEALTH_UNKNOWN;

 if (!(info->input_status & PS_STAT_VBUS_VALID))
  return POWER_SUPPLY_HEALTH_DEAD;
 else if (info->op_mode & CHRG_STAT_PMIC_OTP)
  return POWER_SUPPLY_HEALTH_OVERHEAT;
 else if (info->op_mode & CHRG_STAT_BAT_SAFE_MODE)
  return POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 else
  return POWER_SUPPLY_HEALTH_GOOD;
}

static int axp288_charger_usb_set_property(struct power_supply *psy,
        enum power_supply_property psp,
        const union power_supply_propval *val)
{
 struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
 int ret = 0;
 int scaled_val;

 mutex_lock(&info->lock);
 switch (psp) {
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  scaled_val = min(val->intval, info->max_cc);
  scaled_val = DIV_ROUND_CLOSEST(scaled_val, 1000);
  ret = axp288_charger_set_cc(info, scaled_val);
  if (ret < 0) {
   dev_warn(&info->pdev->dev, "set charge current failed\n");
   goto out;
  }
  break;
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
  scaled_val = DIV_ROUND_CLOSEST(val->intval, 1000);
  scaled_val = min(scaled_val, info->max_cv);
  ret = axp288_charger_set_cv(info, scaled_val);
  if (ret < 0) {
   dev_warn(&info->pdev->dev, "set charge voltage failed\n");
   goto out;
  }
  break;
 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  ret = axp288_charger_set_vbus_inlmt(info, val->intval);
  if (ret < 0) {
   dev_warn(&info->pdev->dev, "set input current limit failed\n");
   goto out;
  }
  info->valid = false;
  break;
 default:
  ret = -EINVAL;
 }

out:
 mutex_unlock(&info->lock);
 return ret;
}

static int axp288_charger_reg_readb(struct axp288_chrg_info *info, int reg, unsigned int *ret_val)
{
 int ret;

 ret = regmap_read(info->regmap, reg, ret_val);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "Error %d on reading value from register 0x%04x\n",
   ret,
   reg);
  return ret;
 }
 return 0;
}

static int axp288_charger_usb_update_property(struct axp288_chrg_info *info)
{
 int ret = 0;

 if (info->valid && time_before(jiffies, info->last_updated + AXP288_REG_UPDATE_INTERVAL))
  return 0;

 dev_dbg(&info->pdev->dev, "Charger updating register values...\n");

 ret = iosf_mbi_block_punit_i2c_access();
 if (ret < 0)
  return ret;

 ret = axp288_charger_reg_readb(info, AXP20X_PWR_INPUT_STATUS, &info->input_status);
 if (ret < 0)
  goto out;

 ret = axp288_charger_reg_readb(info, AXP20X_PWR_OP_MODE, &info->op_mode);
 if (ret < 0)
  goto out;

 ret = axp288_charger_reg_readb(info, AXP20X_CHRG_BAK_CTRL, &info->backend_control);
 if (ret < 0)
  goto out;

 info->last_updated = jiffies;
 info->valid = true;
out:
 iosf_mbi_unblock_punit_i2c_access();
 return ret;
}

static int axp288_charger_usb_get_property(struct power_supply *psy,
        enum power_supply_property psp,
        union power_supply_propval *val)
{
 struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
 int ret;

 mutex_lock(&info->lock);
 ret = axp288_charger_usb_update_property(info);
 if (ret < 0)
  goto out;

 switch (psp) {
 case POWER_SUPPLY_PROP_PRESENT:
  /* Check for OTG case first */
  if (info->otg.id_short) {
   val->intval = 0;
   break;
  }
  val->intval = (info->input_status & PS_STAT_VBUS_PRESENT) ? 1 : 0;
  break;
 case POWER_SUPPLY_PROP_ONLINE:
  /* Check for OTG case first */
  if (info->otg.id_short) {
   val->intval = 0;
   break;
  }
  val->intval = (info->input_status & PS_STAT_VBUS_VALID) ? 1 : 0;
  break;
 case POWER_SUPPLY_PROP_HEALTH:
  val->intval = axp288_get_charger_health(info);
  break;
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  val->intval = info->cc * 1000;
  break;
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
  val->intval = info->max_cc * 1000;
  break;
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
  val->intval = info->cv * 1000;
  break;
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
  val->intval = info->max_cv * 1000;
  break;
 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  val->intval = axp288_charger_get_vbus_inlmt(info);
  break;
 default:
  ret = -EINVAL;
 }

out:
 mutex_unlock(&info->lock);
 return ret;
}

static int axp288_charger_property_is_writeable(struct power_supply *psy,
  enum power_supply_property psp)
{
 int ret;

 switch (psp) {
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  ret = 1;
  break;
 default:
  ret = 0;
 }

 return ret;
}

static enum power_supply_property axp288_usb_props[] = {
 POWER_SUPPLY_PROP_PRESENT,
 POWER_SUPPLY_PROP_ONLINE,
 POWER_SUPPLY_PROP_TYPE,
 POWER_SUPPLY_PROP_HEALTH,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
};

static const struct power_supply_desc axp288_charger_desc = {
 .name   = "axp288_charger",
 .type   = POWER_SUPPLY_TYPE_USB,
 .properties  = axp288_usb_props,
 .num_properties  = ARRAY_SIZE(axp288_usb_props),
 .get_property  = axp288_charger_usb_get_property,
 .set_property  = axp288_charger_usb_set_property,
 .property_is_writeable = axp288_charger_property_is_writeable,
};

static irqreturn_t axp288_charger_irq_thread_handler(int irq, void *dev)
{
 struct axp288_chrg_info *info = dev;
 int i;

 for (i = 0; i < CHRG_INTR_END; i++) {
  if (info->irq[i] == irq)
   break;
 }

 if (i >= CHRG_INTR_END) {
  dev_warn(&info->pdev->dev, "spurious interrupt!!\n");
  return IRQ_NONE;
 }

 switch (i) {
 case VBUS_OV_IRQ:
  dev_dbg(&info->pdev->dev, "VBUS Over Voltage INTR\n");
  break;
 case CHARGE_DONE_IRQ:
  dev_dbg(&info->pdev->dev, "Charging Done INTR\n");
  break;
 case CHARGE_CHARGING_IRQ:
  dev_dbg(&info->pdev->dev, "Start Charging IRQ\n");
  break;
 case BAT_SAFE_QUIT_IRQ:
  dev_dbg(&info->pdev->dev,
   "Quit Safe Mode(restart timer) Charging IRQ\n");
  break;
 case BAT_SAFE_ENTER_IRQ:
  dev_dbg(&info->pdev->dev,
   "Enter Safe Mode(timer expire) Charging IRQ\n");
  break;
 case QCBTU_IRQ:
  dev_dbg(&info->pdev->dev,
   "Quit Battery Under Temperature(CHRG) INTR\n");
  break;
 case CBTU_IRQ:
  dev_dbg(&info->pdev->dev,
   "Hit Battery Under Temperature(CHRG) INTR\n");
  break;
 case QCBTO_IRQ:
  dev_dbg(&info->pdev->dev,
   "Quit Battery Over Temperature(CHRG) INTR\n");
  break;
 case CBTO_IRQ:
  dev_dbg(&info->pdev->dev,
   "Hit Battery Over Temperature(CHRG) INTR\n");
  break;
 default:
  dev_warn(&info->pdev->dev, "Spurious Interrupt!!!\n");
  goto out;
 }
 mutex_lock(&info->lock);
 info->valid = false;
 mutex_unlock(&info->lock);
 power_supply_changed(info->psy_usb);
out:
 return IRQ_HANDLED;
}

/*
 * The HP Pavilion x2 10 series comes in a number of variants:
 * Bay Trail SoC    + AXP288 PMIC, Micro-USB, DMI_BOARD_NAME: "8021"
 * Bay Trail SoC    + AXP288 PMIC, Type-C,    DMI_BOARD_NAME: "815D"
 * Cherry Trail SoC + AXP288 PMIC, Type-C,    DMI_BOARD_NAME: "813E"
 * Cherry Trail SoC + TI PMIC,     Type-C,    DMI_BOARD_NAME: "827C" or "82F4"
 *
 * The variants with the AXP288 + Type-C connector are all kinds of special:
 *
 * 1. They use a Type-C connector which the AXP288 does not support, so when
 * using a Type-C charger it is not recognized. Unlike most AXP288 devices,
 * this model actually has mostly working ACPI AC / Battery code, the ACPI code
 * "solves" this by simply setting the input_current_limit to 3A.
 * There are still some issues with the ACPI code, so we use this native driver,
 * and to solve the charging not working (500mA is not enough) issue we hardcode
 * the 3A input_current_limit like the ACPI code does.
 *
 * 2. If no charger is connected the machine boots with the vbus-path disabled.
 * Normally this is done when a 5V boost converter is active to avoid the PMIC
 * trying to charge from the 5V boost converter's output. This is done when
 * an OTG host cable is inserted and the ID pin on the micro-B receptacle is
 * pulled low and the ID pin has an ACPI event handler associated with it
 * which re-enables the vbus-path when the ID pin is pulled high when the
 * OTG host cable is removed. The Type-C connector has no ID pin, there is
 * no ID pin handler and there appears to be no 5V boost converter, so we
 * end up not charging because the vbus-path is disabled, until we unplug
 * the charger which automatically clears the vbus-path disable bit and then
 * on the second plug-in of the adapter we start charging. To solve the not
 * charging on first charger plugin we unconditionally enable the vbus-path at
 * probe on this model, which is safe since there is no 5V boost converter.
 */
static const struct dmi_system_id axp288_hp_x2_dmi_ids[] = {
 {
  .matches = {
   DMI_EXACT_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
   DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
   DMI_EXACT_MATCH(DMI_BOARD_NAME, "815D"),
  },
 },
 {
  .matches = {
   DMI_EXACT_MATCH(DMI_SYS_VENDOR, "HP"),
   DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "HP Pavilion x2 Detachable"),
   DMI_EXACT_MATCH(DMI_BOARD_NAME, "813E"),
  },
 },
 {} /* Terminating entry */
};

static void axp288_charger_extcon_evt_worker(struct work_struct *work)
{
 struct axp288_chrg_info *info =
     container_of(work, struct axp288_chrg_info, cable.work);
 int ret, current_limit;
 struct extcon_dev *edev = info->cable.edev;
 unsigned int val;

 ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "Error reading status (%d)\n", ret);
  return;
 }

 /* Offline? Disable charging and bail */
 if (!(val & PS_STAT_VBUS_VALID)) {
  dev_dbg(&info->pdev->dev, "USB charger disconnected\n");
  axp288_charger_enable_charger(info, false);
  mutex_lock(&info->lock);
  info->valid = false;
  mutex_unlock(&info->lock);
  power_supply_changed(info->psy_usb);
  return;
 }

 /* Determine cable/charger type */
 if (dmi_check_system(axp288_hp_x2_dmi_ids)) {
  /* See comment above axp288_hp_x2_dmi_ids declaration */
  dev_dbg(&info->pdev->dev, "HP X2 with Type-C, setting inlmt to 3A\n");
  current_limit = 3000000;
 } else if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0) {
  dev_dbg(&info->pdev->dev, "USB SDP charger is connected\n");
  current_limit = 500000;
 } else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0) {
  dev_dbg(&info->pdev->dev, "USB CDP charger is connected\n");
  current_limit = 1500000;
 } else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0) {
  dev_dbg(&info->pdev->dev, "USB DCP charger is connected\n");
  current_limit = 2000000;
 } else {
  /* Charger type detection still in progress, bail. */
  return;
 }

 /* Set vbus current limit first, then enable charger */
 ret = axp288_charger_set_vbus_inlmt(info, current_limit);
 if (ret == 0)
  axp288_charger_enable_charger(info, true);
 else
  dev_err(&info->pdev->dev,
   "error setting current limit (%d)\n", ret);

 mutex_lock(&info->lock);
 info->valid = false;
 mutex_unlock(&info->lock);
 power_supply_changed(info->psy_usb);
}

static int axp288_charger_handle_cable_evt(struct notifier_block *nb,
        unsigned long event, void *param)
{
 struct axp288_chrg_info *info =
  container_of(nb, struct axp288_chrg_info, cable.nb);
 schedule_work(&info->cable.work);
 return NOTIFY_OK;
}

static void axp288_charger_otg_evt_worker(struct work_struct *work)
{
 struct axp288_chrg_info *info =
     container_of(work, struct axp288_chrg_info, otg.work);
 struct extcon_dev *edev = info->otg.cable;
 int ret, usb_host = extcon_get_state(edev, EXTCON_USB_HOST);

 dev_dbg(&info->pdev->dev, "external connector USB-Host is %s\n",
    usb_host ? "attached" : "detached");

 /*
 * Set usb_id_short flag to avoid running charger detection logic
 * in case usb host.
 */
 info->otg.id_short = usb_host;

 /* Disable VBUS path before enabling the 5V boost */
 ret = axp288_charger_vbus_path_select(info, !info->otg.id_short);
 if (ret < 0)
  dev_warn(&info->pdev->dev, "vbus path disable failed\n");
}

static int axp288_charger_handle_otg_evt(struct notifier_block *nb,
       unsigned long event, void *param)
{
 struct axp288_chrg_info *info =
     container_of(nb, struct axp288_chrg_info, otg.id_nb);

 schedule_work(&info->otg.work);

 return NOTIFY_OK;
}

static int charger_init_hw_regs(struct axp288_chrg_info *info)
{
 int ret, cc, cv;
 unsigned int val;

 /* Program temperature thresholds */
 ret = regmap_write(info->regmap, AXP20X_V_LTF_CHRG, CHRG_VLTFC_0C);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
       AXP20X_V_LTF_CHRG, ret);
  return ret;
 }

 ret = regmap_write(info->regmap, AXP20X_V_HTF_CHRG, CHRG_VHTFC_45C);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
       AXP20X_V_HTF_CHRG, ret);
  return ret;
 }

 /* Do not turn-off charger o/p after charge cycle ends */
 ret = regmap_update_bits(info->regmap,
    AXP20X_CHRG_CTRL2,
    CNTL2_CHG_OUT_TURNON, CNTL2_CHG_OUT_TURNON);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
      AXP20X_CHRG_CTRL2, ret);
  return ret;
 }

 /* Setup ending condition for charging to be 10% of I(chrg) */
 ret = regmap_update_bits(info->regmap,
    AXP20X_CHRG_CTRL1,
    CHRG_CCCV_ITERM_20P, 0);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
      AXP20X_CHRG_CTRL1, ret);
  return ret;
 }

 /* Disable OCV-SOC curve calibration */
 ret = regmap_update_bits(info->regmap,
    AXP20X_CC_CTRL,
    FG_CNTL_OCV_ADJ_EN, 0);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
      AXP20X_CC_CTRL, ret);
  return ret;
 }

 if (dmi_check_system(axp288_hp_x2_dmi_ids)) {
  /* See comment above axp288_hp_x2_dmi_ids declaration */
  ret = axp288_charger_vbus_path_select(info, true);
  if (ret < 0)
   return ret;
 } else {
  /* Set Vhold to the factory default / recommended 4.4V */
  val = VBUS_ISPOUT_VHOLD_SET_4400MV << VBUS_ISPOUT_VHOLD_SET_BIT_POS;
  ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
      VBUS_ISPOUT_VHOLD_SET_MASK, val);
  if (ret < 0) {
   dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
    AXP20X_VBUS_IPSOUT_MGMT, ret);
   return ret;
  }
 }

 /* Read current charge voltage and current limit */
 ret = regmap_read(info->regmap, AXP20X_CHRG_CTRL1, &val);
 if (ret < 0) {
  dev_err(&info->pdev->dev, "register(%x) read error(%d)\n",
   AXP20X_CHRG_CTRL1, ret);
  return ret;
 }

 /* Determine charge voltage */
 cv = (val & CHRG_CCCV_CV_MASK) >> CHRG_CCCV_CV_BIT_POS;
 switch (cv) {
 case CHRG_CCCV_CV_4100MV:
  info->cv = CV_4100MV;
  break;
 case CHRG_CCCV_CV_4150MV:
  info->cv = CV_4150MV;
  break;
 case CHRG_CCCV_CV_4200MV:
  info->cv = CV_4200MV;
  break;
 case CHRG_CCCV_CV_4350MV:
  info->cv = CV_4350MV;
  break;
 }

 /* Determine charge current limit */
 cc = (val & CHRG_CCCV_CC_MASK) >> CHRG_CCCV_CC_BIT_POS;
 cc = (cc * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
 info->cc = cc;

 /*
 * Do not allow the user to configure higher settings then those
 * set by the firmware
 */
 info->max_cv = info->cv;
 info->max_cc = info->cc;

 return 0;
}

static void axp288_charger_cancel_work(void *data)
{
 struct axp288_chrg_info *info = data;

 cancel_work_sync(&info->otg.work);
 cancel_work_sync(&info->cable.work);
}

static int axp288_charger_probe(struct platform_device *pdev)
{
 int ret, i, pirq;
 struct axp288_chrg_info *info;
 struct device *dev = &pdev->dev;
 struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
 struct power_supply_config charger_cfg = {};
 const char *extcon_name = NULL;
 unsigned int val;

 /*
 * Normally the native AXP288 fg/charger drivers are preferred but
 * on some devices the ACPI drivers should be used instead.
 */
 if (!acpi_quirk_skip_acpi_ac_and_battery())
  return -ENODEV;

 /*
 * On some devices the fuelgauge and charger parts of the axp288 are
 * not used, check that the fuelgauge is enabled (CC_CTRL != 0).
 */
 ret = regmap_read(axp20x->regmap, AXP20X_CC_CTRL, &val);
 if (ret < 0)
  return ret;
 if (val == 0)
  return -ENODEV;

 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
 if (!info)
  return -ENOMEM;

 mutex_init(&info->lock);
 info->pdev = pdev;
 info->regmap = axp20x->regmap;
 info->regmap_irqc = axp20x->regmap_irqc;

 info->cable.edev = extcon_get_extcon_dev(AXP288_EXTCON_DEV_NAME);
 if (IS_ERR(info->cable.edev)) {
  dev_err_probe(dev, PTR_ERR(info->cable.edev),
         "extcon_get_extcon_dev(%s) failed\n",
         AXP288_EXTCON_DEV_NAME);
  return PTR_ERR(info->cable.edev);
 }

 /*
 * On devices with broken ACPI GPIO event handlers there also is no ACPI
 * "INT3496" (USB_HOST_EXTCON_HID) device. x86-android-tablets.ko
 * instantiates an "intel-int3496" extcon on these devs as a workaround.
 */
 if (acpi_quirk_skip_gpio_event_handlers())
  extcon_name = "intel-int3496";
 else if (acpi_dev_present(USB_HOST_EXTCON_HID, NULL, -1))
  extcon_name = USB_HOST_EXTCON_NAME;

 if (extcon_name) {
  info->otg.cable = extcon_get_extcon_dev(extcon_name);
  if (IS_ERR(info->otg.cable)) {
   dev_err_probe(dev, PTR_ERR(info->otg.cable),
          "extcon_get_extcon_dev(%s) failed\n",
          USB_HOST_EXTCON_NAME);
   return PTR_ERR(info->otg.cable);
  }
  dev_info(dev, "Using " USB_HOST_EXTCON_HID " extcon for usb-id\n");
 }

 platform_set_drvdata(pdev, info);

 ret = charger_init_hw_regs(info);
 if (ret)
  return ret;

 /* Register with power supply class */
 charger_cfg.drv_data = info;
 info->psy_usb = devm_power_supply_register(dev, &axp288_charger_desc,
         &charger_cfg);
 if (IS_ERR(info->psy_usb)) {
  ret = PTR_ERR(info->psy_usb);
  dev_err(dev, "failed to register power supply: %d\n", ret);
  return ret;
 }

 /* Cancel our work on cleanup, register this before the notifiers */
 ret = devm_add_action(dev, axp288_charger_cancel_work, info);
 if (ret)
  return ret;

 /* Register for extcon notification */
 INIT_WORK(&info->cable.work, axp288_charger_extcon_evt_worker);
 info->cable.nb.notifier_call = axp288_charger_handle_cable_evt;
 ret = devm_extcon_register_notifier_all(dev, info->cable.edev,
      &info->cable.nb);
 if (ret) {
  dev_err(dev, "failed to register cable extcon notifier\n");
  return ret;
 }
 schedule_work(&info->cable.work);

 /* Register for OTG notification */
 INIT_WORK(&info->otg.work, axp288_charger_otg_evt_worker);
 info->otg.id_nb.notifier_call = axp288_charger_handle_otg_evt;
 if (info->otg.cable) {
  ret = devm_extcon_register_notifier(dev, info->otg.cable,
     EXTCON_USB_HOST, &info->otg.id_nb);
  if (ret) {
   dev_err(dev, "failed to register EXTCON_USB_HOST notifier\n");
   return ret;
  }
  schedule_work(&info->otg.work);
 }

 /* Register charger interrupts */
 for (i = 0; i < CHRG_INTR_END; i++) {
  pirq = platform_get_irq(info->pdev, i);
  if (pirq < 0)
   return pirq;

  info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
  if (info->irq[i] < 0) {
   dev_warn(&info->pdev->dev,
    "failed to get virtual interrupt=%d\n", pirq);
   return info->irq[i];
  }
  ret = devm_request_threaded_irq(&info->pdev->dev, info->irq[i],
     NULL, axp288_charger_irq_thread_handler,
     IRQF_ONESHOT, info->pdev->name, info);
  if (ret) {
   dev_err(dev, "failed to request interrupt=%d\n",
        info->irq[i]);
   return ret;
  }
 }

 return 0;
}

static const struct platform_device_id axp288_charger_id_table[] = {
 { .name = "axp288_charger" },
 {},
};
MODULE_DEVICE_TABLE(platform, axp288_charger_id_table);

static struct platform_driver axp288_charger_driver = {
 .probe = axp288_charger_probe,
 .id_table = axp288_charger_id_table,
 .driver = {
  .name = "axp288_charger",
 },
};

module_platform_driver(axp288_charger_driver);

MODULE_AUTHOR("Ramakrishna Pallala ");
MODULE_DESCRIPTION("X-power AXP288 Charger Driver");
MODULE_LICENSE("GPL v2");