jenna
/
kernel_samsung_sm7125
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
762308 Commits
5 Branches
0 Tags
1.2 GiB
 
 
 
Tag: Branch: Tree: fourteen
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'fourteen'
${ noResults }
kernel_samsung_sm7125/drivers/power/supply/qcom_r1/smb1351-charger.c

3134 lines
79 KiB
Raw Permalink Blame History

/* Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#define pr_fmt(fmt) "%s: " fmt, __func__
#include <linux/i2c.h>
#include <linux/debugfs.h>
#include <linux/errno.h>
#include <linux/extcon.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/power_supply.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regulator/machine.h>
#include <linux/of.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/pinctrl/consumer.h>
/* Mask/Bit helpers */
#define _SMB1351_MASK(BITS, POS) \
((unsigned char)(((1 << (BITS)) - 1) << (POS)))
#define SMB1351_MASK(LEFT_BIT_POS, RIGHT_BIT_POS) \
_SMB1351_MASK((LEFT_BIT_POS) - (RIGHT_BIT_POS) + 1, \
(RIGHT_BIT_POS))
/* Configuration registers */
#define CHG_CURRENT_CTRL_REG 0x0
#define FAST_CHG_CURRENT_MASK SMB1351_MASK(7, 4)
#define AC_INPUT_CURRENT_LIMIT_MASK SMB1351_MASK(3, 0)
#define CHG_OTH_CURRENT_CTRL_REG 0x1
#define PRECHG_CURRENT_MASK SMB1351_MASK(7, 5)
#define ITERM_MASK SMB1351_MASK(4, 2)
#define USB_2_3_MODE_SEL_BIT BIT(1)
#define USB_2_3_MODE_SEL_BY_I2C 0
#define USB_2_3_MODE_SEL_BY_PIN 0x2
#define USB_5_1_CMD_POLARITY_BIT BIT(0)
#define USB_CMD_POLARITY_500_1_100_0 0
#define USB_CMD_POLARITY_500_0_100_1 0x1
#define VARIOUS_FUNC_REG 0x2
#define SUSPEND_MODE_CTRL_BIT BIT(7)
#define SUSPEND_MODE_CTRL_BY_PIN 0
#define SUSPEND_MODE_CTRL_BY_I2C 0x80
#define BATT_TO_SYS_POWER_CTRL_BIT BIT(6)
#define MAX_SYS_VOLTAGE BIT(5)
#define AICL_EN_BIT BIT(4)
#define AICL_DET_TH_BIT BIT(3)
#define APSD_EN_BIT BIT(2)
#define BATT_OV_BIT BIT(1)
#define VCHG_FUNC_BIT BIT(0)
#define VFLOAT_REG 0x3
#define PRECHG_TO_FAST_VOLTAGE_CFG_MASK SMB1351_MASK(7, 6)
#define VFLOAT_MASK SMB1351_MASK(5, 0)
#define CHG_CTRL_REG 0x4
#define AUTO_RECHG_BIT BIT(7)
#define AUTO_RECHG_ENABLE 0
#define AUTO_RECHG_DISABLE 0x80
#define ITERM_EN_BIT BIT(6)
#define ITERM_ENABLE 0
#define ITERM_DISABLE 0x40
#define MAPPED_AC_INPUT_CURRENT_LIMIT_MASK SMB1351_MASK(5, 4)
#define AUTO_RECHG_TH_BIT BIT(3)
#define AUTO_RECHG_TH_50MV 0
#define AUTO_RECHG_TH_100MV 0x8
#define AFCV_MASK SMB1351_MASK(2, 0)
#define CHG_STAT_TIMERS_CTRL_REG 0x5
#define STAT_OUTPUT_POLARITY_BIT BIT(7)
#define STAT_OUTPUT_MODE_BIT BIT(6)
#define STAT_OUTPUT_CTRL_BIT BIT(5)
#define OTH_CHG_IL_BIT BIT(4)
#define COMPLETE_CHG_TIMEOUT_MASK SMB1351_MASK(3, 2)
#define PRECHG_TIMEOUT_MASK SMB1351_MASK(1, 0)
#define CHG_PIN_EN_CTRL_REG 0x6
#define LED_BLINK_FUNC_BIT BIT(7)
#define EN_PIN_CTRL_MASK SMB1351_MASK(6, 5)
#define EN_BY_I2C_0_DISABLE 0
#define EN_BY_I2C_0_ENABLE 0x20
#define EN_BY_PIN_HIGH_ENABLE 0x40
#define EN_BY_PIN_LOW_ENABLE 0x60
#define USBCS_CTRL_BIT BIT(4)
#define USBCS_CTRL_BY_I2C 0
#define USBCS_CTRL_BY_PIN 0x10
#define USBCS_INPUT_STATE_BIT BIT(3)
#define CHG_ERR_BIT BIT(2)
#define APSD_DONE_BIT BIT(1)
#define USB_FAIL_BIT BIT(0)
#define THERM_A_CTRL_REG 0x7
#define MIN_SYS_VOLTAGE_MASK SMB1351_MASK(7, 6)
#define LOAD_BATT_10MA_FVC_BIT BIT(5)
#define THERM_MONITOR_BIT BIT(4)
#define THERM_MONITOR_EN 0
#define SOFT_COLD_TEMP_LIMIT_MASK SMB1351_MASK(3, 2)
#define SOFT_HOT_TEMP_LIMIT_MASK SMB1351_MASK(1, 0)
#define WDOG_SAFETY_TIMER_CTRL_REG 0x8
#define AICL_FAIL_OPTION_BIT BIT(7)
#define AICL_FAIL_TO_SUSPEND 0
#define AICL_FAIL_TO_150_MA 0x80
#define WDOG_TIMEOUT_MASK SMB1351_MASK(6, 5)
#define WDOG_IRQ_SAFETY_TIMER_MASK SMB1351_MASK(4, 3)
#define WDOG_IRQ_SAFETY_TIMER_EN_BIT BIT(2)
#define WDOG_OPTION_BIT BIT(1)
#define WDOG_TIMER_EN_BIT BIT(0)
#define OTG_USBIN_AICL_CTRL_REG 0x9
#define OTG_ID_PIN_CTRL_MASK SMB1351_MASK(7, 6)
#define OTG_PIN_POLARITY_BIT BIT(5)
#define DCIN_IC_GLITCH_FILTER_HV_ADAPTER_MASK SMB1351_MASK(4, 3)
#define DCIN_IC_GLITCH_FILTER_LV_ADAPTER_BIT BIT(2)
#define USBIN_AICL_CFG1_BIT BIT(1)
#define USBIN_AICL_CFG0_BIT BIT(0)
#define OTG_TLIM_CTRL_REG 0xA
#define SWITCH_FREQ_MASK SMB1351_MASK(7, 6)
#define THERM_LOOP_TEMP_SEL_MASK SMB1351_MASK(5, 4)
#define OTG_OC_LIMIT_MASK SMB1351_MASK(3, 2)
#define OTG_BATT_UVLO_TH_MASK SMB1351_MASK(1, 0)
#define HARD_SOFT_LIMIT_CELL_TEMP_REG 0xB
#define HARD_LIMIT_COLD_TEMP_ALARM_TRIP_MASK SMB1351_MASK(7, 6)
#define HARD_LIMIT_HOT_TEMP_ALARM_TRIP_MASK SMB1351_MASK(5, 4)
#define SOFT_LIMIT_COLD_TEMP_ALARM_TRIP_MASK SMB1351_MASK(3, 2)
#define SOFT_LIMIT_HOT_TEMP_ALARM_TRIP_MASK SMB1351_MASK(1, 0)
#define FAULT_INT_REG 0xC
#define HOT_COLD_HARD_LIMIT_BIT BIT(7)
#define HOT_COLD_SOFT_LIMIT_BIT BIT(6)
#define BATT_UVLO_IN_OTG_BIT BIT(5)
#define OTG_OC_BIT BIT(4)
#define INPUT_OVLO_BIT BIT(3)
#define INPUT_UVLO_BIT BIT(2)
#define AICL_DONE_FAIL_BIT BIT(1)
#define INTERNAL_OVER_TEMP_BIT BIT(0)
#define STATUS_INT_REG 0xD
#define CHG_OR_PRECHG_TIMEOUT_BIT BIT(7)
#define RID_CHANGE_BIT BIT(6)
#define BATT_OVP_BIT BIT(5)
#define FAST_TERM_TAPER_RECHG_INHIBIT_BIT BIT(4)
#define WDOG_TIMER_BIT BIT(3)
#define POK_BIT BIT(2)
#define BATT_MISSING_BIT BIT(1)
#define BATT_LOW_BIT BIT(0)
#define VARIOUS_FUNC_2_REG 0xE
#define CHG_HOLD_OFF_TIMER_AFTER_PLUGIN_BIT BIT(7)
#define CHG_INHIBIT_BIT BIT(6)
#define FAST_CHG_CC_IN_BATT_SOFT_LIMIT_MODE_BIT BIT(5)
#define FVCL_IN_BATT_SOFT_LIMIT_MODE_MASK SMB1351_MASK(4, 3)
#define HARD_TEMP_LIMIT_BEHAVIOR_BIT BIT(2)
#define PRECHG_TO_FASTCHG_BIT BIT(1)
#define STAT_PIN_CONFIG_BIT BIT(0)
#define FLEXCHARGER_REG 0x10
#define AFVC_IRQ_BIT BIT(7)
#define CHG_CONFIG_MASK SMB1351_MASK(6, 4)
#define LOW_BATT_VOLTAGE_DET_TH_MASK SMB1351_MASK(3, 0)
#define VARIOUS_FUNC_3_REG 0x11
#define SAFETY_TIMER_EN_MASK SMB1351_MASK(7, 6)
#define BLOCK_SUSPEND_DURING_VBATT_LOW_BIT BIT(5)
#define TIMEOUT_SEL_FOR_APSD_BIT BIT(4)
#define SDP_SUSPEND_BIT BIT(3)
#define QC_2P1_AUTO_INCREMENT_MODE_BIT BIT(2)
#define QC_2P1_AUTH_ALGO_BIT BIT(1)
#define DCD_EN_BIT BIT(0)
#define HVDCP_BATT_MISSING_CTRL_REG 0x12
#define HVDCP_ADAPTER_SEL_MASK SMB1351_MASK(7, 6)
#define HVDCP_EN_BIT BIT(5)
#define HVDCP_AUTO_INCREMENT_LIMIT_BIT BIT(4)
#define BATT_MISSING_ON_INPUT_PLUGIN_BIT BIT(3)
#define BATT_MISSING_2P6S_POLLER_BIT BIT(2)
#define BATT_MISSING_ALGO_BIT BIT(1)
#define BATT_MISSING_THERM_PIN_SOURCE_BIT BIT(0)
#define PON_OPTIONS_REG 0x13
#define SYSOK_INOK_POLARITY_BIT BIT(7)
#define SYSOK_OPTIONS_MASK SMB1351_MASK(6, 4)
#define INPUT_MISSING_POLLER_CONFIG_BIT BIT(3)
#define VBATT_LOW_DISABLED_OR_RESET_STATE_BIT BIT(2)
#define QC_2P1_AUTH_ALGO_IRQ_EN_BIT BIT(0)
#define OTG_MODE_POWER_OPTIONS_REG 0x14
#define ADAPTER_CONFIG_MASK SMB1351_MASK(7, 6)
#define MAP_HVDCP_BIT BIT(5)
#define SDP_LOW_BATT_FORCE_USB5_OVER_USB1_BIT BIT(4)
#define OTG_HICCUP_MODE_BIT BIT(2)
#define INPUT_CURRENT_LIMIT_MASK SMB1351_MASK(1, 0)
#define CHARGER_I2C_CTRL_REG 0x15
#define FULLON_MODE_EN_BIT BIT(7)
#define I2C_HS_MODE_EN_BIT BIT(6)
#define SYSON_LDO_OUTPUT_SEL_BIT BIT(5)
#define VBATT_TRACKING_VOLTAGE_DIFF_BIT BIT(4)
#define DISABLE_AFVC_WHEN_ENTER_TAPER_BIT BIT(3)
#define VCHG_IINV_BIT BIT(2)
#define AFVC_OVERRIDE_BIT BIT(1)
#define SYSOK_PIN_CONFIG_BIT BIT(0)
#define VERSION_REG 0x2E
#define VERSION_MASK BIT(1)
/* Command registers */
#define CMD_I2C_REG 0x30
#define CMD_RELOAD_BIT BIT(7)
#define CMD_BQ_CFG_ACCESS_BIT BIT(6)
#define CMD_INPUT_LIMIT_REG 0x31
#define CMD_OVERRIDE_BIT BIT(7)
#define CMD_SUSPEND_MODE_BIT BIT(6)
#define CMD_INPUT_CURRENT_MODE_BIT BIT(3)
#define CMD_INPUT_CURRENT_MODE_APSD 0
#define CMD_INPUT_CURRENT_MODE_CMD 0x08
#define CMD_USB_2_3_SEL_BIT BIT(2)
#define CMD_USB_2_MODE 0
#define CMD_USB_3_MODE 0x4
#define CMD_USB_1_5_AC_CTRL_MASK SMB1351_MASK(1, 0)
#define CMD_USB_100_MODE 0
#define CMD_USB_500_MODE 0x2
#define CMD_USB_AC_MODE 0x1
#define CMD_CHG_REG 0x32
#define CMD_DISABLE_THERM_MONITOR_BIT BIT(4)
#define CMD_TURN_OFF_STAT_PIN_BIT BIT(3)
#define CMD_PRE_TO_FAST_EN_BIT BIT(2)
#define CMD_CHG_EN_BIT BIT(1)
#define CMD_CHG_DISABLE 0
#define CMD_CHG_ENABLE 0x2
#define CMD_OTG_EN_BIT BIT(0)
#define CMD_DEAD_BATT_REG 0x33
#define CMD_STOP_DEAD_BATT_TIMER_MASK SMB1351_MASK(7, 0)
#define CMD_HVDCP_REG 0x34
#define CMD_APSD_RE_RUN_BIT BIT(7)
#define CMD_FORCE_HVDCP_2P0_BIT BIT(5)
#define CMD_HVDCP_MODE_MASK SMB1351_MASK(5, 0)
/* Status registers */
#define STATUS_0_REG 0x36
#define STATUS_AICL_BIT BIT(7)
#define STATUS_INPUT_CURRENT_LIMIT_MASK SMB1351_MASK(6, 5)
#define STATUS_DCIN_INPUT_CURRENT_LIMIT_MASK SMB1351_MASK(4, 0)
#define STATUS_1_REG 0x37
#define STATUS_INPUT_RANGE_MASK SMB1351_MASK(7, 4)
#define STATUS_INPUT_USB_BIT BIT(0)
#define STATUS_2_REG 0x38
#define STATUS_FAST_CHG_BIT BIT(7)
#define STATUS_HARD_LIMIT_BIT BIT(6)
#define STATUS_FLOAT_VOLTAGE_MASK SMB1351_MASK(5, 0)
#define STATUS_3_REG 0x39
#define STATUS_CHG_BIT BIT(7)
#define STATUS_PRECHG_CURRENT_MASK SMB1351_MASK(6, 4)
#define STATUS_FAST_CHG_CURRENT_MASK SMB1351_MASK(3, 0)
#define STATUS_4_REG 0x3A
#define STATUS_OTG_BIT BIT(7)
#define STATUS_AFVC_BIT BIT(6)
#define STATUS_DONE_BIT BIT(5)
#define STATUS_BATT_LESS_THAN_2V_BIT BIT(4)
#define STATUS_HOLD_OFF_BIT BIT(3)
#define STATUS_CHG_MASK SMB1351_MASK(2, 1)
#define STATUS_NO_CHARGING 0
#define STATUS_FAST_CHARGING 0x4
#define STATUS_PRE_CHARGING 0x2
#define STATUS_TAPER_CHARGING 0x6
#define STATUS_CHG_EN_STATUS_BIT BIT(0)
#define STATUS_5_REG 0x3B
#define STATUS_SOURCE_DETECTED_MASK SMB1351_MASK(7, 0)
#define STATUS_PORT_CDP 0x80
#define STATUS_PORT_DCP 0x40
#define STATUS_PORT_OTHER 0x20
#define STATUS_PORT_SDP 0x10
#define STATUS_PORT_ACA_A 0x8
#define STATUS_PORT_ACA_B 0x4
#define STATUS_PORT_ACA_C 0x2
#define STATUS_PORT_ACA_DOCK 0x1
#define STATUS_6_REG 0x3C
#define STATUS_DCD_TIMEOUT_BIT BIT(7)
#define STATUS_DCD_GOOD_DG_BIT BIT(6)
#define STATUS_OCD_GOOD_DG_BIT BIT(5)
#define STATUS_RID_ABD_DG_BIT BIT(4)
#define STATUS_RID_FLOAT_STATE_MACHINE_BIT BIT(3)
#define STATUS_RID_A_STATE_MACHINE_BIT BIT(2)
#define STATUS_RID_B_STATE_MACHINE_BIT BIT(1)
#define STATUS_RID_C_STATE_MACHINE_BIT BIT(0)
#define STATUS_7_REG 0x3D
#define STATUS_HVDCP_MASK SMB1351_MASK(7, 0)
#define STATUS_8_REG 0x3E
#define STATUS_USNIN_HV_INPUT_SEL_BIT BIT(5)
#define STATUS_USBIN_LV_UNDER_INPUT_SEL_BIT BIT(4)
#define STATUS_USBIN_LV_INPUT_SEL_BIT BIT(3)
/* Revision register */
#define CHG_REVISION_REG 0x3F
#define GUI_REVISION_MASK SMB1351_MASK(7, 4)
#define DEVICE_REVISION_MASK SMB1351_MASK(3, 0)
/* IRQ status registers */
#define IRQ_A_REG 0x40
#define IRQ_HOT_HARD_BIT BIT(6)
#define IRQ_COLD_HARD_BIT BIT(4)
#define IRQ_HOT_SOFT_BIT BIT(2)
#define IRQ_COLD_SOFT_BIT BIT(0)
#define IRQ_B_REG 0x41
#define IRQ_BATT_TERMINAL_REMOVED_BIT BIT(6)
#define IRQ_BATT_MISSING_BIT BIT(4)
#define IRQ_LOW_BATT_VOLTAGE_BIT BIT(2)
#define IRQ_INTERNAL_TEMP_LIMIT_BIT BIT(0)
#define IRQ_C_REG 0x42
#define IRQ_PRE_TO_FAST_VOLTAGE_BIT BIT(6)
#define IRQ_RECHG_BIT BIT(4)
#define IRQ_TAPER_BIT BIT(2)
#define IRQ_TERM_BIT BIT(0)
#define IRQ_D_REG 0x43
#define IRQ_BATT_OV_BIT BIT(6)
#define IRQ_CHG_ERROR_BIT BIT(4)
#define IRQ_CHG_TIMEOUT_BIT BIT(2)
#define IRQ_PRECHG_TIMEOUT_BIT BIT(0)
#define IRQ_E_REG 0x44
#define IRQ_USBIN_OV_BIT BIT(6)
#define IRQ_USBIN_UV_BIT BIT(4)
#define IRQ_AFVC_BIT BIT(2)
#define IRQ_POWER_OK_BIT BIT(0)
#define IRQ_F_REG 0x45
#define IRQ_OTG_OVER_CURRENT_BIT BIT(6)
#define IRQ_OTG_FAIL_BIT BIT(4)
#define IRQ_RID_BIT BIT(2)
#define IRQ_OTG_OC_RETRY_BIT BIT(0)
#define IRQ_G_REG 0x46
#define IRQ_SOURCE_DET_BIT BIT(6)
#define IRQ_AICL_DONE_BIT BIT(4)
#define IRQ_AICL_FAIL_BIT BIT(2)
#define IRQ_CHG_INHIBIT_BIT BIT(0)
#define IRQ_H_REG 0x47
#define IRQ_IC_LIMIT_STATUS_BIT BIT(5)
#define IRQ_HVDCP_2P1_STATUS_BIT BIT(4)
#define IRQ_HVDCP_AUTH_DONE_BIT BIT(2)
#define IRQ_WDOG_TIMEOUT_BIT BIT(0)
/* constants */
#define USB2_MIN_CURRENT_MA 100
#define USB2_MAX_CURRENT_MA 500
#define USB3_MIN_CURRENT_MA 150
#define USB3_MAX_CURRENT_MA 900
#define DCP_MAX_CURRENT_MA 1500
#define SMB1351_IRQ_REG_COUNT 8
#define SMB1351_CHG_PRE_MIN_MA 100
#define SMB1351_CHG_FAST_MIN_MA 1000
#define SMB1351_CHG_FAST_MAX_MA 4500
#define SMB1351_CHG_PRE_SHIFT 5
#define SMB1351_CHG_FAST_SHIFT 4
#define DEFAULT_BATT_CAPACITY 50
#define DEFAULT_BATT_TEMP 250
#define SUSPEND_CURRENT_MA 2
#define CHG_ITERM_200MA 0x0
#define CHG_ITERM_300MA 0x04
#define CHG_ITERM_400MA 0x08
#define CHG_ITERM_500MA 0x0C
#define CHG_ITERM_600MA 0x10
#define CHG_ITERM_700MA 0x14
#define OTG_ID_PIN_CTRL_SHIFT 6
enum otg_control {
RID_DISABLED_OTG_I2C = 0,
RID_DISABLED_OTG_PIN,
RID_ENABLED_OTG_I2C,
RID_ENABLED_OTG_AUTO,
};
enum reason {
USER = BIT(0),
THERMAL = BIT(1),
CURRENT = BIT(2),
SOC = BIT(3),
};
static char *pm_batt_supplied_to[] = {
"bms",
};
struct smb1351_regulator {
struct regulator_desc rdesc;
struct regulator_dev *rdev;
};
enum chip_version {
SMB_UNKNOWN = 0,
SMB1350,
SMB1351,
SMB_MAX_TYPE,
};
static const char *smb1351_version_str[SMB_MAX_TYPE] = {
[SMB_UNKNOWN] = "Unknown",
[SMB1350] = "SMB1350",
[SMB1351] = "SMB1351",
};
static const unsigned int smb1351_extcon_cable[] = {
EXTCON_USB,
EXTCON_USB_HOST,
EXTCON_NONE,
};
struct smb1351_charger {
struct i2c_client *client;
struct device *dev;
bool recharge_disabled;
int recharge_mv;
bool iterm_disabled;
int iterm_ma;
int vfloat_mv;
int chg_present;
int fake_battery_soc;
bool chg_autonomous_mode;
bool disable_apsd;
bool battery_missing;
const char *bms_psy_name;
bool resume_completed;
bool irq_waiting;
struct delayed_work chg_remove_work;
struct delayed_work hvdcp_det_work;
/* status tracking */
bool batt_full;
bool batt_hot;
bool batt_cold;
bool batt_warm;
bool batt_cool;
int battchg_disabled_status;
int usb_suspended_status;
int target_fastchg_current_max_ma;
int fastchg_current_max_ma;
int workaround_flags;
int parallel_pin_polarity_setting;
int parallel_mode;
int pl_batfet_mode;
bool parallel_charger;
bool parallel_charger_suspended;
bool bms_controlled_charging;
bool apsd_rerun;
bool usbin_ov;
bool chg_remove_work_scheduled;
bool force_hvdcp_2p0;
enum chip_version version;
/* psy */
struct power_supply_desc usb_psy_d;
struct power_supply *usb_psy;
int usb_psy_ma;
struct power_supply *bms_psy;
struct power_supply_desc batt_psy_d;
struct power_supply *batt_psy;
struct power_supply *parallel_psy;
struct power_supply_desc parallel_psy_d;
struct smb1351_regulator otg_vreg;
struct mutex irq_complete;
struct dentry *debug_root;
u32 peek_poke_address;
/* pinctrl parameters */
const char *pinctrl_state_name;
struct pinctrl *smb_pinctrl;
/* standalone */
bool charger_present;
struct extcon_dev *extcon;
struct regulator *dpdm_reg;
enum power_supply_type charger_type;
bool otg_enable;
};
struct smb_irq_info {
const char *name;
int (*smb_irq)(struct smb1351_charger *chip, u8 rt_stat);
int high;
int low;
};
struct irq_handler_info {
u8 stat_reg;
u8 val;
u8 prev_val;
struct smb_irq_info irq_info[4];
};
/* USB input charge current */
static int usb_chg_current[] = {
500, 685, 1000, 1100, 1200, 1300, 1500, 1600,
1700, 1800, 2000, 2200, 2500, 3000,
};
static int fast_chg_current[] = {
1000, 1200, 1400, 1600, 1800, 2000, 2200,
2400, 2600, 2800, 3000, 3400, 3600, 3800,
4000, 4640,
};
static int pre_chg_current[] = {
200, 300, 400, 500, 600, 700,
};
static int smb1351_read_reg(struct smb1351_charger *chip, int reg, u8 *val)
{
s32 ret;
pm_stay_awake(chip->dev);
ret = i2c_smbus_read_byte_data(chip->client, reg);
if (ret < 0) {
pr_err("i2c read fail: can't read from %02x: %d\n", reg, ret);
pm_relax(chip->dev);
return ret;
}
*val = ret;
pm_relax(chip->dev);
pr_debug("Reading 0x%02x=0x%02x\n", reg, *val);
return 0;
}
static int smb1351_write_reg(struct smb1351_charger *chip, int reg, u8 val)
{
s32 ret;
pm_stay_awake(chip->dev);
ret = i2c_smbus_write_byte_data(chip->client, reg, val);
if (ret < 0) {
pr_err("i2c write fail: can't write %02x to %02x: %d\n",
val, reg, ret);
pm_relax(chip->dev);
return ret;
}
pm_relax(chip->dev);
pr_debug("Writing 0x%02x=0x%02x\n", reg, val);
return 0;
}
static int smb1351_masked_write(struct smb1351_charger *chip, int reg,
u8 mask, u8 val)
{
s32 rc;
u8 temp;
rc = smb1351_read_reg(chip, reg, &temp);
if (rc) {
pr_err("read failed: reg=%03X, rc=%d\n", reg, rc);
return rc;
}
temp &= ~mask;
temp |= val & mask;
rc = smb1351_write_reg(chip, reg, temp);
if (rc) {
pr_err("write failed: reg=%03X, rc=%d\n", reg, rc);
return rc;
}
return 0;
}
static int smb1351_enable_volatile_writes(struct smb1351_charger *chip)
{
int rc;
rc = smb1351_masked_write(chip, CMD_I2C_REG, CMD_BQ_CFG_ACCESS_BIT,
CMD_BQ_CFG_ACCESS_BIT);
if (rc)
pr_err("Couldn't write CMD_BQ_CFG_ACCESS_BIT rc=%d\n", rc);
return rc;
}
static int smb1351_get_closest_usb_setpoint(int val)
{
int i;
for (i = ARRAY_SIZE(usb_chg_current) - 1; i >= 0; i--) {
if (usb_chg_current[i] <= val)
break;
}
if (i < 0)
i = 0;
if (i >= ARRAY_SIZE(usb_chg_current) - 1)
return ARRAY_SIZE(usb_chg_current) - 1;
/* check what is closer, i or i + 1 */
if (abs(usb_chg_current[i] - val) < abs(usb_chg_current[i + 1] - val))
return i;
else
return i + 1;
}
static int smb1351_request_dpdm(struct smb1351_charger *chip, bool enable)
{
int rc = 0;
/* fetch the DPDM regulator */
if (!chip->dpdm_reg && of_get_property(chip->dev->of_node,
"dpdm-supply", NULL)) {
chip->dpdm_reg = devm_regulator_get(chip->dev, "dpdm");
if (IS_ERR(chip->dpdm_reg)) {
rc = PTR_ERR(chip->dpdm_reg);
pr_err("Couldn't get dpdm regulator rc=%d\n",
rc);
chip->dpdm_reg = NULL;
return rc;
}
}
if (enable) {
if (chip->dpdm_reg && !regulator_is_enabled(chip->dpdm_reg)) {
pr_err("enabling DPDM regulator\n");
rc = regulator_enable(chip->dpdm_reg);
if (rc < 0)
pr_err("Couldn't enable dpdm regulator rc=%d\n",
rc);
}
} else {
if (chip->dpdm_reg && regulator_is_enabled(chip->dpdm_reg)) {
pr_err("disabling DPDM regulator\n");
rc = regulator_disable(chip->dpdm_reg);
if (rc < 0)
pr_err("Couldn't disable dpdm regulator rc=%d\n",
rc);
}
}
return rc;
}
static int smb1351_usb_suspend(struct smb1351_charger *chip, int reason,
bool suspend)
{
int rc = 0;
int suspended;
suspended = chip->usb_suspended_status;
pr_debug("reason = %d requested_suspend = %d suspended_status = %d\n",
reason, suspend, suspended);
if (suspend == false)
suspended &= ~reason;
else
suspended |= reason;
pr_debug("new suspended_status = %d\n", suspended);
rc = smb1351_masked_write(chip, CMD_INPUT_LIMIT_REG,
CMD_SUSPEND_MODE_BIT,
suspended ? CMD_SUSPEND_MODE_BIT : 0);
if (rc)
pr_err("Couldn't suspend rc = %d\n", rc);
else
chip->usb_suspended_status = suspended;
return rc;
}
static int smb1351_battchg_disable(struct smb1351_charger *chip,
int reason, int disable)
{
int rc = 0;
int disabled;
if (chip->chg_autonomous_mode) {
pr_debug("Charger in autonomous mode\n");
return 0;
}
disabled = chip->battchg_disabled_status;
pr_debug("reason = %d requested_disable = %d disabled_status = %d\n",
reason, disable, disabled);
if (disable == true)
disabled |= reason;
else
disabled &= ~reason;
pr_debug("new disabled_status = %d\n", disabled);
rc = smb1351_masked_write(chip, CMD_CHG_REG, CMD_CHG_EN_BIT,
disabled ? 0 : CMD_CHG_ENABLE);
if (rc)
pr_err("Couldn't %s charging rc=%d\n",
disable ? "disable" : "enable", rc);
else
chip->battchg_disabled_status = disabled;
return rc;
}
static int smb1351_fastchg_current_set(struct smb1351_charger *chip,
unsigned int fastchg_current)
{
int i, rc;
bool is_pre_chg = false;
if ((fastchg_current < SMB1351_CHG_PRE_MIN_MA) ||
(fastchg_current > SMB1351_CHG_FAST_MAX_MA)) {
pr_err("bad pre_fastchg current mA=%d asked to set\n",
fastchg_current);
return -EINVAL;
}
/*
* fast chg current could not support less than 1000mA
* use pre chg to instead for the parallel charging
*/
if (fastchg_current < SMB1351_CHG_FAST_MIN_MA) {
is_pre_chg = true;
pr_debug("is_pre_chg true, current is %d\n", fastchg_current);
}
if (is_pre_chg) {
/* set prechg current */
for (i = ARRAY_SIZE(pre_chg_current) - 1; i >= 0; i--) {
if (pre_chg_current[i] <= fastchg_current)
break;
}
if (i < 0)
i = 0;
chip->fastchg_current_max_ma = pre_chg_current[i];
pr_debug("prechg setting %02x\n", i);
i = i << SMB1351_CHG_PRE_SHIFT;
rc = smb1351_masked_write(chip, CHG_OTH_CURRENT_CTRL_REG,
PRECHG_CURRENT_MASK, i);
if (rc)
pr_err("Couldn't write CHG_OTH_CURRENT_CTRL_REG rc=%d\n",
rc);
return smb1351_masked_write(chip, VARIOUS_FUNC_2_REG,
PRECHG_TO_FASTCHG_BIT, PRECHG_TO_FASTCHG_BIT);
} else {
if (chip->version == SMB_UNKNOWN)
return -EINVAL;
/* SMB1350 supports FCC upto 2600 mA */
if (chip->version == SMB1350 && fastchg_current > 2600)
fastchg_current = 2600;
/* set fastchg current */
for (i = ARRAY_SIZE(fast_chg_current) - 1; i >= 0; i--) {
if (fast_chg_current[i] <= fastchg_current)
break;
}
if (i < 0)
i = 0;
chip->fastchg_current_max_ma = fast_chg_current[i];
i = i << SMB1351_CHG_FAST_SHIFT;
pr_debug("fastchg limit=%d setting %02x\n",
chip->fastchg_current_max_ma, i);
/* make sure pre chg mode is disabled */
rc = smb1351_masked_write(chip, VARIOUS_FUNC_2_REG,
PRECHG_TO_FASTCHG_BIT, 0);
if (rc)
pr_err("Couldn't write VARIOUS_FUNC_2_REG rc=%d\n", rc);
return smb1351_masked_write(chip, CHG_CURRENT_CTRL_REG,
FAST_CHG_CURRENT_MASK, i);
}
}
#define MIN_FLOAT_MV 3500
#define MAX_FLOAT_MV 4500
#define VFLOAT_STEP_MV 20
static int smb1351_float_voltage_set(struct smb1351_charger *chip,
int vfloat_mv)
{
u8 temp;
if ((vfloat_mv < MIN_FLOAT_MV) || (vfloat_mv > MAX_FLOAT_MV)) {
pr_err("bad float voltage mv =%d asked to set\n", vfloat_mv);
return -EINVAL;
}
temp = (vfloat_mv - MIN_FLOAT_MV) / VFLOAT_STEP_MV;
return smb1351_masked_write(chip, VFLOAT_REG, VFLOAT_MASK, temp);
}
static int smb1351_iterm_set(struct smb1351_charger *chip, int iterm_ma)
{
int rc;
u8 reg;
if (iterm_ma <= 200)
reg = CHG_ITERM_200MA;
else if (iterm_ma <= 300)
reg = CHG_ITERM_300MA;
else if (iterm_ma <= 400)
reg = CHG_ITERM_400MA;
else if (iterm_ma <= 500)
reg = CHG_ITERM_500MA;
else if (iterm_ma <= 600)
reg = CHG_ITERM_600MA;
else
reg = CHG_ITERM_700MA;
rc = smb1351_masked_write(chip, CHG_OTH_CURRENT_CTRL_REG,
ITERM_MASK, reg);
if (rc) {
pr_err("Couldn't set iterm rc = %d\n", rc);
return rc;
}
/* enable the iterm */
rc = smb1351_masked_write(chip, CHG_CTRL_REG,
ITERM_EN_BIT, ITERM_ENABLE);
if (rc) {
pr_err("Couldn't enable iterm rc = %d\n", rc);
return rc;
}
return 0;
}
static int smb1351_chg_otg_regulator_enable(struct regulator_dev *rdev)
{
int rc = 0;
struct smb1351_charger *chip = rdev_get_drvdata(rdev);
rc = smb1351_masked_write(chip, CMD_CHG_REG, CMD_OTG_EN_BIT,
CMD_OTG_EN_BIT);
if (rc)
pr_err("Couldn't enable OTG mode rc=%d\n", rc);
return rc;
}
static int smb1351_chg_otg_regulator_disable(struct regulator_dev *rdev)
{
int rc = 0;
struct smb1351_charger *chip = rdev_get_drvdata(rdev);
rc = smb1351_masked_write(chip, CMD_CHG_REG, CMD_OTG_EN_BIT, 0);
if (rc)
pr_err("Couldn't disable OTG mode rc=%d\n", rc);
return rc;
}
static int smb1351_chg_otg_regulator_is_enable(struct regulator_dev *rdev)
{
int rc = 0;
u8 reg = 0;
struct smb1351_charger *chip = rdev_get_drvdata(rdev);
rc = smb1351_read_reg(chip, CMD_CHG_REG, &reg);
if (rc) {
pr_err("Couldn't read OTG enable bit rc=%d\n", rc);
return rc;
}
return (reg & CMD_OTG_EN_BIT) ? 1 : 0;
}
static struct regulator_ops smb1351_chg_otg_reg_ops = {
.enable = smb1351_chg_otg_regulator_enable,
.disable = smb1351_chg_otg_regulator_disable,
.is_enabled = smb1351_chg_otg_regulator_is_enable,
};
static int smb1351_regulator_init(struct smb1351_charger *chip)
{
int rc = 0;
struct regulator_config cfg = {};
struct regulator_init_data *init_data;
chip->otg_vreg.rdesc.owner = THIS_MODULE;
chip->otg_vreg.rdesc.type = REGULATOR_VOLTAGE;
chip->otg_vreg.rdesc.ops = &smb1351_chg_otg_reg_ops;
chip->otg_vreg.rdesc.name =
chip->dev->of_node->name;
chip->otg_vreg.rdesc.of_match =
chip->dev->of_node->name;
init_data = of_get_regulator_init_data(chip->dev, chip->dev->of_node,
&chip->otg_vreg.rdesc);
if (!init_data) {
pr_err("regulator init data is missing\n");
return -EINVAL;
}
cfg.dev = chip->dev;
cfg.driver_data = chip;
cfg.init_data = init_data;
cfg.of_node = chip->dev->of_node;
chip->otg_vreg.rdev = regulator_register(
&chip->otg_vreg.rdesc, &cfg);
if (IS_ERR(chip->otg_vreg.rdev)) {
rc = PTR_ERR(chip->otg_vreg.rdev);
chip->otg_vreg.rdev = NULL;
if (rc != -EPROBE_DEFER)
pr_err("OTG reg failed, rc=%d\n", rc);
}
return rc;
}
static int smb_chip_get_version(struct smb1351_charger *chip)
{
u8 ver;
int rc = 0;
if (chip->version == SMB_UNKNOWN) {
rc = smb1351_read_reg(chip, VERSION_REG, &ver);
if (rc) {
pr_err("Couldn't read version rc=%d\n", rc);
return rc;
}
/* If bit 1 is set, it is SMB1350 */
if (ver & VERSION_MASK)
chip->version = SMB1350;
else
chip->version = SMB1351;
}
return rc;
}
static int smb1351_hw_init(struct smb1351_charger *chip)
{
int rc;
u8 reg = 0, mask = 0;
/* configure smb_pinctrl to enable irqs */
if (chip->pinctrl_state_name) {
chip->smb_pinctrl = pinctrl_get_select(chip->dev,
chip->pinctrl_state_name);
if (IS_ERR(chip->smb_pinctrl)) {
pr_err("Could not get/set %s pinctrl state rc = %ld\n",
chip->pinctrl_state_name,
PTR_ERR(chip->smb_pinctrl));
return PTR_ERR(chip->smb_pinctrl);
}
}
/*
* If the charger is pre-configured for autonomous operation,
* do not apply additional settings
*/
if (chip->chg_autonomous_mode) {
pr_debug("Charger configured for autonomous mode\n");
return 0;
}
rc = smb_chip_get_version(chip);
if (rc) {
pr_err("Couldn't get version rc = %d\n", rc);
return rc;
}
rc = smb1351_enable_volatile_writes(chip);
if (rc) {
pr_err("Couldn't configure volatile writes rc=%d\n", rc);
return rc;
}
/* enable/disable charging by suspending usb */
rc = smb1351_usb_suspend(chip, USER, chip->usb_suspended_status);
if (rc) {
pr_err("Unable to %ssuspend usb. rc=%d\n",
chip->usb_suspended_status ? "" : "un-", rc);
return rc;
}
/* enable/disable battery charging */
rc = smb1351_battchg_disable(chip, USER, chip->battchg_disabled_status);
if (rc) {
pr_err("Unable to %s battery charging. rc=%d\n",
chip->battchg_disabled_status ? "disable" : "enable",
rc);
return rc;
}
/* setup battery missing source */
reg = BATT_MISSING_THERM_PIN_SOURCE_BIT;
mask = BATT_MISSING_THERM_PIN_SOURCE_BIT;
rc = smb1351_masked_write(chip, HVDCP_BATT_MISSING_CTRL_REG,
mask, reg);
if (rc) {
pr_err("Couldn't set HVDCP_BATT_MISSING_CTRL_REG rc=%d\n", rc);
return rc;
}
/* setup defaults for CHG_PIN_EN_CTRL_REG */
reg = EN_BY_I2C_0_DISABLE | USBCS_CTRL_BY_I2C | CHG_ERR_BIT |
APSD_DONE_BIT | LED_BLINK_FUNC_BIT;
mask = EN_PIN_CTRL_MASK | USBCS_CTRL_BIT | CHG_ERR_BIT |
APSD_DONE_BIT | LED_BLINK_FUNC_BIT;
rc = smb1351_masked_write(chip, CHG_PIN_EN_CTRL_REG, mask, reg);
if (rc) {
pr_err("Couldn't set CHG_PIN_EN_CTRL_REG rc=%d\n", rc);
return rc;
}
/* setup USB 2.0/3.0 detection and USB 500/100 command polarity */
reg = USB_2_3_MODE_SEL_BY_I2C | USB_CMD_POLARITY_500_1_100_0;
mask = USB_2_3_MODE_SEL_BIT | USB_5_1_CMD_POLARITY_BIT;
rc = smb1351_masked_write(chip, CHG_OTH_CURRENT_CTRL_REG, mask, reg);
if (rc) {
pr_err("Couldn't set CHG_OTH_CURRENT_CTRL_REG rc=%d\n", rc);
return rc;
}
/* setup USB suspend, AICL and APSD */
reg = SUSPEND_MODE_CTRL_BY_I2C | AICL_EN_BIT;
if (!chip->disable_apsd)
reg |= APSD_EN_BIT;
mask = SUSPEND_MODE_CTRL_BIT | AICL_EN_BIT | APSD_EN_BIT;
rc = smb1351_masked_write(chip, VARIOUS_FUNC_REG, mask, reg);
if (rc) {
pr_err("Couldn't set VARIOUS_FUNC_REG rc=%d\n", rc);
return rc;
}
/* Fault and Status IRQ configuration */
reg = HOT_COLD_HARD_LIMIT_BIT | HOT_COLD_SOFT_LIMIT_BIT
| INPUT_OVLO_BIT | INPUT_UVLO_BIT | AICL_DONE_FAIL_BIT;
rc = smb1351_write_reg(chip, FAULT_INT_REG, reg);
if (rc) {
pr_err("Couldn't set FAULT_INT_REG rc=%d\n", rc);
return rc;
}
reg = CHG_OR_PRECHG_TIMEOUT_BIT | BATT_OVP_BIT |
FAST_TERM_TAPER_RECHG_INHIBIT_BIT |
BATT_MISSING_BIT | BATT_LOW_BIT;
if (chip->otg_enable)
reg = reg | RID_CHANGE_BIT;
rc = smb1351_write_reg(chip, STATUS_INT_REG, reg);
if (rc) {
pr_err("Couldn't set STATUS_INT_REG rc=%d\n", rc);
return rc;
}
/* setup THERM Monitor */
rc = smb1351_masked_write(chip, THERM_A_CTRL_REG,
THERM_MONITOR_BIT, THERM_MONITOR_EN);
if (rc) {
pr_err("Couldn't set THERM_A_CTRL_REG rc=%d\n", rc);
return rc;
}
/* set the fast charge current limit */
rc = smb1351_fastchg_current_set(chip,
chip->target_fastchg_current_max_ma);
if (rc) {
pr_err("Couldn't set fastchg current rc=%d\n", rc);
return rc;
}
/* set the float voltage */
if (chip->vfloat_mv != -EINVAL) {
rc = smb1351_float_voltage_set(chip, chip->vfloat_mv);
if (rc) {
pr_err("Couldn't set float voltage rc = %d\n", rc);
return rc;
}
}
/* set iterm */
if (chip->iterm_ma != -EINVAL) {
if (chip->iterm_disabled) {
pr_err("Error: Both iterm_disabled and iterm_ma set\n");
return -EINVAL;
}
rc = smb1351_iterm_set(chip, chip->iterm_ma);
if (rc) {
pr_err("Couldn't set iterm rc = %d\n", rc);
return rc;
}
} else if (chip->iterm_disabled) {
rc = smb1351_masked_write(chip, CHG_CTRL_REG,
ITERM_EN_BIT, ITERM_DISABLE);
if (rc) {
pr_err("Couldn't set iterm rc = %d\n", rc);
return rc;
}
}
/* set recharge-threshold */
if (chip->recharge_mv != -EINVAL) {
if (chip->recharge_disabled) {
pr_err("Error: Both recharge_disabled and recharge_mv set\n");
return -EINVAL;
}
reg = AUTO_RECHG_ENABLE;
if (chip->recharge_mv > 50)
reg |= AUTO_RECHG_TH_100MV;
else
reg |= AUTO_RECHG_TH_50MV;
rc = smb1351_masked_write(chip, CHG_CTRL_REG,
AUTO_RECHG_BIT |
AUTO_RECHG_TH_BIT, reg);
if (rc) {
pr_err("Couldn't set rechg-cfg rc = %d\n", rc);
return rc;
}
} else if (chip->recharge_disabled) {
rc = smb1351_masked_write(chip, CHG_CTRL_REG,
AUTO_RECHG_BIT,
AUTO_RECHG_DISABLE);
if (rc) {
pr_err("Couldn't disable auto-rechg rc = %d\n", rc);
return rc;
}
}
if (chip->otg_enable) {
/* Configure OTG/ID pin control: RID enabled, OTG I2C control */
rc = smb1351_masked_write(chip, OTG_USBIN_AICL_CTRL_REG,
OTG_ID_PIN_CTRL_MASK,
RID_ENABLED_OTG_I2C << OTG_ID_PIN_CTRL_SHIFT);
if (rc) {
pr_err("Couldn't configure RID enable rc = %d\n", rc);
return rc;
}
}
/* Disable watchdog */
rc = smb1351_masked_write(chip, WDOG_SAFETY_TIMER_CTRL_REG,
WDOG_TIMER_EN_BIT, 0);
if (rc) {
pr_err("Couldn't disable watchdog rc = %d\n", rc);
return rc;
}
return rc;
}
static enum power_supply_property smb1351_battery_properties[] = {
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_CHARGING_ENABLED,
POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED,
POWER_SUPPLY_PROP_CHARGE_TYPE,
POWER_SUPPLY_PROP_CAPACITY,
POWER_SUPPLY_PROP_HEALTH,
POWER_SUPPLY_PROP_TEMP,
POWER_SUPPLY_PROP_TECHNOLOGY,
POWER_SUPPLY_PROP_MODEL_NAME,
};
static int smb1351_get_prop_batt_status(struct smb1351_charger *chip)
{
int rc;
u8 reg = 0;
if (chip->batt_full)
return POWER_SUPPLY_STATUS_FULL;
rc = smb1351_read_reg(chip, STATUS_4_REG, &reg);
if (rc) {
pr_err("Couldn't read STATUS_4 rc = %d\n", rc);
return POWER_SUPPLY_STATUS_UNKNOWN;
}
pr_debug("STATUS_4_REG(0x3A)=%x\n", reg);
if (reg & STATUS_HOLD_OFF_BIT)
return POWER_SUPPLY_STATUS_NOT_CHARGING;
if (reg & STATUS_CHG_MASK)
return POWER_SUPPLY_STATUS_CHARGING;
return POWER_SUPPLY_STATUS_DISCHARGING;
}
static int smb1351_get_prop_batt_present(struct smb1351_charger *chip)
{
return !chip->battery_missing;
}
static int smb1351_get_prop_batt_capacity(struct smb1351_charger *chip)
{
union power_supply_propval ret = {0, };
if (chip->fake_battery_soc >= 0)
return chip->fake_battery_soc;
if (chip->bms_psy) {
power_supply_get_property(chip->bms_psy,
POWER_SUPPLY_PROP_CAPACITY, &ret);
return ret.intval;
}
pr_debug("return DEFAULT_BATT_CAPACITY\n");
return DEFAULT_BATT_CAPACITY;
}
static int smb1351_get_prop_batt_temp(struct smb1351_charger *chip)
{
union power_supply_propval ret = {0, };
if (chip->bms_psy) {
power_supply_get_property(chip->bms_psy,
POWER_SUPPLY_PROP_TEMP, &ret);
return ret.intval;
}
pr_debug("return default temperature\n");
return DEFAULT_BATT_TEMP;
}
static int smb1351_get_prop_charge_type(struct smb1351_charger *chip)
{
int rc;
u8 reg = 0;
rc = smb1351_read_reg(chip, STATUS_4_REG, &reg);
if (rc) {
pr_err("Couldn't read STATUS_4 rc = %d\n", rc);
return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
}
pr_debug("STATUS_4_REG(0x3A)=%x\n", reg);
reg &= STATUS_CHG_MASK;
if (reg == STATUS_FAST_CHARGING)
return POWER_SUPPLY_CHARGE_TYPE_FAST;
else if (reg == STATUS_TAPER_CHARGING)
return POWER_SUPPLY_CHARGE_TYPE_TAPER;
else if (reg == STATUS_PRE_CHARGING)
return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
else
return POWER_SUPPLY_CHARGE_TYPE_NONE;
}
static int smb1351_get_prop_batt_health(struct smb1351_charger *chip)
{
union power_supply_propval ret = {0, };
if (chip->batt_hot)
ret.intval = POWER_SUPPLY_HEALTH_OVERHEAT;
else if (chip->batt_cold)
ret.intval = POWER_SUPPLY_HEALTH_COLD;
else if (chip->batt_warm)
ret.intval = POWER_SUPPLY_HEALTH_WARM;
else if (chip->batt_cool)
ret.intval = POWER_SUPPLY_HEALTH_COOL;
else
ret.intval = POWER_SUPPLY_HEALTH_GOOD;
return ret.intval;
}
static int smb1351_set_usb_chg_current(struct smb1351_charger *chip,
int current_ma)
{
int i, rc = 0;
u8 reg = 0, mask = 0;
pr_debug("USB current_ma = %d\n", current_ma);
if (chip->chg_autonomous_mode) {
pr_debug("Charger in autonomous mode\n");
return 0;
}
/* set suspend bit when urrent_ma <= 2 */
if (current_ma <= SUSPEND_CURRENT_MA) {
smb1351_usb_suspend(chip, CURRENT, true);
pr_debug("USB suspend\n");
return 0;
}
if (current_ma > SUSPEND_CURRENT_MA &&
current_ma < USB2_MIN_CURRENT_MA)
current_ma = USB2_MIN_CURRENT_MA;
if (current_ma == USB2_MIN_CURRENT_MA) {
/* USB 2.0 - 100mA */
reg = CMD_USB_2_MODE | CMD_USB_100_MODE;
} else if (current_ma == USB3_MIN_CURRENT_MA) {
/* USB 3.0 - 150mA */
reg = CMD_USB_3_MODE | CMD_USB_100_MODE;
} else if (current_ma == USB2_MAX_CURRENT_MA) {
/* USB 2.0 - 500mA */
reg = CMD_USB_2_MODE | CMD_USB_500_MODE;
} else if (current_ma == USB3_MAX_CURRENT_MA) {
/* USB 3.0 - 900mA */
reg = CMD_USB_3_MODE | CMD_USB_500_MODE;
} else if (current_ma > USB2_MAX_CURRENT_MA) {
/* HC mode - if none of the above */
reg = CMD_USB_AC_MODE;
for (i = ARRAY_SIZE(usb_chg_current) - 1; i >= 0; i--) {
if (usb_chg_current[i] <= current_ma)
break;
}
if (i < 0)
i = 0;
rc = smb1351_masked_write(chip, CHG_CURRENT_CTRL_REG,
AC_INPUT_CURRENT_LIMIT_MASK, i);
if (rc) {
pr_err("Couldn't set input mA rc=%d\n", rc);
return rc;
}
}
/* control input current mode by command */
reg |= CMD_INPUT_CURRENT_MODE_CMD;
mask = CMD_INPUT_CURRENT_MODE_BIT | CMD_USB_2_3_SEL_BIT |
CMD_USB_1_5_AC_CTRL_MASK;
rc = smb1351_masked_write(chip, CMD_INPUT_LIMIT_REG, mask, reg);
if (rc) {
pr_err("Couldn't set charging mode rc = %d\n", rc);
return rc;
}
/* unset the suspend bit here */
smb1351_usb_suspend(chip, CURRENT, false);
return rc;
}
static char *smb1351_usb_supplicants[] = {
"bms",
};
static enum power_supply_property smb1351_usb_properties[] = {
POWER_SUPPLY_PROP_PRESENT,
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_CURRENT_MAX,
POWER_SUPPLY_PROP_TYPE,
POWER_SUPPLY_PROP_REAL_TYPE,
POWER_SUPPLY_PROP_SDP_CURRENT_MAX,
};
static int smb1351_usb_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct smb1351_charger *chip = power_supply_get_drvdata(psy);
switch (psp) {
case POWER_SUPPLY_PROP_CURRENT_MAX:
case POWER_SUPPLY_PROP_SDP_CURRENT_MAX:
val->intval = chip->usb_psy_ma * 1000;
break;
case POWER_SUPPLY_PROP_PRESENT:
val->intval = chip->chg_present;
break;
case POWER_SUPPLY_PROP_ONLINE:
val->intval = chip->chg_present && !chip->usb_suspended_status;
break;
case POWER_SUPPLY_PROP_TYPE:
val->intval = chip->charger_type;
break;
case POWER_SUPPLY_PROP_REAL_TYPE:
if (chip->charger_type == POWER_SUPPLY_TYPE_USB_HVDCP)
val->intval = POWER_SUPPLY_TYPE_USB_DCP;
else if (chip->charger_type == POWER_SUPPLY_TYPE_UNKNOWN)
val->intval = POWER_SUPPLY_TYPE_USB;
else
val->intval = chip->charger_type;
break;
default:
return -EINVAL;
}
return 0;
}
static int smb1351_usb_set_property(struct power_supply *psy,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct smb1351_charger *chip = power_supply_get_drvdata(psy);
switch (psp) {
case POWER_SUPPLY_PROP_CURRENT_MAX:
case POWER_SUPPLY_PROP_SDP_CURRENT_MAX:
chip->usb_psy_ma = val->intval / 1000;
smb1351_enable_volatile_writes(chip);
smb1351_set_usb_chg_current(chip, chip->usb_psy_ma);
break;
default:
return -EINVAL;
}
power_supply_changed(psy);
return 0;
}
static int smb1351_usb_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
switch (psp) {
case POWER_SUPPLY_PROP_CURRENT_MAX:
return 1;
default:
break;
}
return 0;
}
static int smb1351_batt_property_is_writeable(struct power_supply *psy,
enum power_supply_property psp)
{
switch (psp) {
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
case POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED:
case POWER_SUPPLY_PROP_CAPACITY:
return 1;
default:
break;
}
return 0;
}
static int smb1351_battery_set_property(struct power_supply *psy,
enum power_supply_property prop,
const union power_supply_propval *val)
{
int rc;
struct smb1351_charger *chip = power_supply_get_drvdata(psy);
switch (prop) {
case POWER_SUPPLY_PROP_STATUS:
if (!chip->bms_controlled_charging)
return -EINVAL;
switch (val->intval) {
case POWER_SUPPLY_STATUS_FULL:
rc = smb1351_battchg_disable(chip, SOC, true);
if (rc) {
pr_err("Couldn't disable charging rc = %d\n",
rc);
} else {
chip->batt_full = true;
pr_debug("status = FULL, batt_full = %d\n",
chip->batt_full);
}
break;
case POWER_SUPPLY_STATUS_DISCHARGING:
chip->batt_full = false;
power_supply_changed(chip->batt_psy);
pr_debug("status = DISCHARGING, batt_full = %d\n",
chip->batt_full);
break;
case POWER_SUPPLY_STATUS_CHARGING:
rc = smb1351_battchg_disable(chip, SOC, false);
if (rc) {
pr_err("Couldn't enable charging rc = %d\n",
rc);
} else {
chip->batt_full = false;
pr_debug("status = CHARGING, batt_full = %d\n",
chip->batt_full);
}
break;
default:
return -EINVAL;
}
break;
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
smb1351_usb_suspend(chip, USER, !val->intval);
break;
case POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED:
smb1351_battchg_disable(chip, USER, !val->intval);
break;
case POWER_SUPPLY_PROP_CAPACITY:
chip->fake_battery_soc = val->intval;
power_supply_changed(chip->batt_psy);
break;
default:
return -EINVAL;
}
return 0;
}
static int smb1351_battery_get_property(struct power_supply *psy,
enum power_supply_property prop,
union power_supply_propval *val)
{
struct smb1351_charger *chip = power_supply_get_drvdata(psy);
switch (prop) {
case POWER_SUPPLY_PROP_STATUS:
val->intval = smb1351_get_prop_batt_status(chip);
break;
case POWER_SUPPLY_PROP_PRESENT:
val->intval = smb1351_get_prop_batt_present(chip);
break;
case POWER_SUPPLY_PROP_CAPACITY:
val->intval = smb1351_get_prop_batt_capacity(chip);
break;
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
val->intval = !chip->usb_suspended_status;
break;
case POWER_SUPPLY_PROP_BATTERY_CHARGING_ENABLED:
val->intval = !chip->battchg_disabled_status;
break;
case POWER_SUPPLY_PROP_CHARGE_TYPE:
val->intval = smb1351_get_prop_charge_type(chip);
break;
case POWER_SUPPLY_PROP_HEALTH:
val->intval = smb1351_get_prop_batt_health(chip);
break;
case POWER_SUPPLY_PROP_TEMP:
val->intval = smb1351_get_prop_batt_temp(chip);
break;
case POWER_SUPPLY_PROP_TECHNOLOGY:
val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
break;
case POWER_SUPPLY_PROP_MODEL_NAME:
val->strval = "smb1351";
break;
default:
return -EINVAL;
}
return 0;
}
static enum power_supply_property smb1351_parallel_properties[] = {
POWER_SUPPLY_PROP_CHARGING_ENABLED,
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_CURRENT_MAX,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
POWER_SUPPLY_PROP_INPUT_CURRENT_LIMITED,
POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
POWER_SUPPLY_PROP_CHARGE_TYPE,
POWER_SUPPLY_PROP_PARALLEL_MODE,
POWER_SUPPLY_PROP_INPUT_SUSPEND,
POWER_SUPPLY_PROP_PARALLEL_BATFET_MODE,
};
static int smb1351_parallel_set_chg_suspend(struct smb1351_charger *chip,
int suspend)
{
int rc;
u8 reg, mask = 0;
if (chip->parallel_charger_suspended == suspend) {
pr_debug("Skip same state request suspended = %d suspend=%d\n",
chip->parallel_charger_suspended, !suspend);
return 0;
}
if (!suspend) {
rc = smb_chip_get_version(chip);
if (rc) {
pr_err("Couldn't get version rc = %d\n", rc);
return rc;
}
rc = smb1351_enable_volatile_writes(chip);
if (rc) {
pr_err("Couldn't configure for volatile rc = %d\n", rc);
return rc;
}
/* set the float voltage */
if (chip->vfloat_mv != -EINVAL) {
rc = smb1351_float_voltage_set(chip, chip->vfloat_mv);
if (rc) {
pr_err("Couldn't set float voltage rc = %d\n",
rc);
return rc;
}
}
/* set recharge-threshold and enable auto recharge */
if (chip->recharge_mv != -EINVAL) {
reg = AUTO_RECHG_ENABLE;
if (chip->recharge_mv > 50)
reg |= AUTO_RECHG_TH_100MV;
else
reg |= AUTO_RECHG_TH_50MV;
rc = smb1351_masked_write(chip, CHG_CTRL_REG,
AUTO_RECHG_BIT |
AUTO_RECHG_TH_BIT, reg);
if (rc) {
pr_err("Couldn't set rechg-cfg rc = %d\n", rc);
return rc;
}
}
/* control USB suspend via command bits */
rc = smb1351_masked_write(chip, VARIOUS_FUNC_REG,
APSD_EN_BIT | SUSPEND_MODE_CTRL_BIT,
SUSPEND_MODE_CTRL_BY_I2C);
if (rc) {
pr_err("Couldn't set USB suspend rc=%d\n", rc);
return rc;
}
/*
* When present is being set force USB suspend, start charging
* only when POWER_SUPPLY_PROP_CURRENT_MAX is set.
*/
rc = smb1351_usb_suspend(chip, CURRENT, true);
if (rc) {
pr_err("failed to suspend rc=%d\n", rc);
return rc;
}
chip->usb_psy_ma = SUSPEND_CURRENT_MA;
/* set chg en by pin active low */
reg = chip->parallel_pin_polarity_setting | USBCS_CTRL_BY_I2C;
rc = smb1351_masked_write(chip, CHG_PIN_EN_CTRL_REG,
EN_PIN_CTRL_MASK | USBCS_CTRL_BIT, reg);
if (rc) {
pr_err("Couldn't set en pin rc=%d\n", rc);
return rc;
}
/*
* setup USB 2.0/3.0 detection and USB 500/100
* command polarity
*/
reg = USB_2_3_MODE_SEL_BY_I2C | USB_CMD_POLARITY_500_1_100_0;
mask = USB_2_3_MODE_SEL_BIT | USB_5_1_CMD_POLARITY_BIT;
rc = smb1351_masked_write(chip,
CHG_OTH_CURRENT_CTRL_REG, mask, reg);
if (rc) {
pr_err("Couldn't set CHG_OTH_CURRENT_CTRL_REG rc=%d\n",
rc);
return rc;
}
rc = smb1351_fastchg_current_set(chip,
chip->target_fastchg_current_max_ma);
if (rc) {
pr_err("Couldn't set fastchg current rc=%d\n", rc);
return rc;
}
chip->parallel_charger_suspended = false;
} else {
rc = smb1351_usb_suspend(chip, CURRENT, true);
if (rc)
pr_debug("failed to suspend rc=%d\n", rc);
chip->usb_psy_ma = SUSPEND_CURRENT_MA;
chip->parallel_charger_suspended = true;
}
return 0;
}
static bool smb1351_is_input_current_limited(struct smb1351_charger *chip)
{
int rc;
u8 reg;
rc = smb1351_read_reg(chip, IRQ_H_REG, &reg);
if (rc) {
pr_err("Failed to read IRQ_H_REG for ICL status: %d\n", rc);
return false;
}
return !!(reg & IRQ_IC_LIMIT_STATUS_BIT);
}
static bool smb1351_is_usb_present(struct smb1351_charger *chip)
{
int rc;
union power_supply_propval val = {0, };
if (!chip->usb_psy)
chip->usb_psy = power_supply_get_by_name("usb");
if (!chip->usb_psy) {
pr_err("USB psy not found\n");
return false;
}
rc = power_supply_get_property(chip->usb_psy,
POWER_SUPPLY_PROP_ONLINE, &val);
if (rc < 0) {
pr_err("Failed to get present property rc=%d\n", rc);
return false;
}
if (val.intval)
return true;
return false;
}
static int smb1351_parallel_set_property(struct power_supply *psy,
enum power_supply_property prop,
const union power_supply_propval *val)
{
int rc = 0, index;
struct smb1351_charger *chip = power_supply_get_drvdata(psy);
switch (prop) {
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
/*
*CHG EN is controlled by pin in the parallel charging.
*Use suspend if disable charging by command.
*/
if (!chip->parallel_charger_suspended)
rc = smb1351_usb_suspend(chip, USER, !val->intval);
break;
case POWER_SUPPLY_PROP_INPUT_SUSPEND:
rc = smb1351_parallel_set_chg_suspend(chip, val->intval);
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
chip->target_fastchg_current_max_ma =
val->intval / 1000;
if (!chip->parallel_charger_suspended)
rc = smb1351_fastchg_current_set(chip,
chip->target_fastchg_current_max_ma);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
index = smb1351_get_closest_usb_setpoint(val->intval / 1000);
chip->usb_psy_ma = usb_chg_current[index];
if (!chip->parallel_charger_suspended)
rc = smb1351_set_usb_chg_current(chip,
chip->usb_psy_ma);
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
chip->vfloat_mv = val->intval / 1000;
if (!chip->parallel_charger_suspended)
rc = smb1351_float_voltage_set(chip, val->intval);
break;
default:
return -EINVAL;
}
return rc;
}
static int smb1351_parallel_is_writeable(struct power_supply *psy,
enum power_supply_property prop)
{
switch (prop) {
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
return 1;
default:
return 0;
}
}
static int smb1351_parallel_get_property(struct power_supply *psy,
enum power_supply_property prop,
union power_supply_propval *val)
{
struct smb1351_charger *chip = power_supply_get_drvdata(psy);
switch (prop) {
case POWER_SUPPLY_PROP_CHARGING_ENABLED:
val->intval = !chip->parallel_charger_suspended;
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
if (!chip->parallel_charger_suspended)
val->intval = chip->usb_psy_ma * 1000;
else
val->intval = 0;
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
if (!chip->parallel_charger_suspended)
val->intval = chip->vfloat_mv;
else
val->intval = 0;
break;
case POWER_SUPPLY_PROP_CHARGE_TYPE:
val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
/* Check if SMB1351 is present */
if (smb1351_is_usb_present(chip)) {
val->intval = smb1351_get_prop_charge_type(chip);
if (val->intval == POWER_SUPPLY_CHARGE_TYPE_UNKNOWN) {
pr_debug("Failed to charge type, charger may be absent\n");
return -ENODEV;
}
}
break;
case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
if (!chip->parallel_charger_suspended)
val->intval = chip->fastchg_current_max_ma * 1000;
else
val->intval = 0;
break;
case POWER_SUPPLY_PROP_STATUS:
if (!chip->parallel_charger_suspended)
val->intval = smb1351_get_prop_batt_status(chip);
else
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
break;
case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMITED:
if (!chip->parallel_charger_suspended)
val->intval =
smb1351_is_input_current_limited(chip) ? 1 : 0;
else
val->intval = 0;
break;
case POWER_SUPPLY_PROP_PARALLEL_MODE:
val->intval = chip->parallel_mode;
break;
case POWER_SUPPLY_PROP_INPUT_SUSPEND:
val->intval = chip->parallel_charger_suspended;
break;
case POWER_SUPPLY_PROP_PARALLEL_BATFET_MODE:
val->intval = chip->pl_batfet_mode;
break;
default:
return -EINVAL;
}
return 0;
}
static int rerun_apsd(struct smb1351_charger *chip)
{
int rc;
pr_debug("Reruning APSD\nDisabling APSD\n");
rc = smb1351_masked_write(chip, CMD_HVDCP_REG, CMD_APSD_RE_RUN_BIT,
CMD_APSD_RE_RUN_BIT);
if (rc)
pr_err("Couldn't re-run APSD algo\n");
return 0;
}
static void smb1351_hvdcp_det_work(struct work_struct *work)
{
int rc;
u8 reg;
union power_supply_propval pval = {0, };
struct smb1351_charger *chip = container_of(work,
struct smb1351_charger,
hvdcp_det_work.work);
rc = smb1351_read_reg(chip, STATUS_7_REG, &reg);
if (rc) {
pr_err("Couldn't read STATUS_7_REG rc == %d\n", rc);
goto end;
}
pr_debug("STATUS_7_REG = 0x%02X\n", reg);
if (reg) {
pr_debug("HVDCP detected; notifying USB PSY\n");
pval.intval = POWER_SUPPLY_TYPE_USB_HVDCP;
power_supply_set_property(chip->usb_psy,
POWER_SUPPLY_PROP_TYPE, &pval);
}
end:
pm_relax(chip->dev);
}
#define HVDCP_NOTIFY_MS 2500
static int smb1351_apsd_complete_handler(struct smb1351_charger *chip,
u8 status)
{
int rc, usb_psy_ma = 0;
u8 reg = 0;
enum power_supply_type type = POWER_SUPPLY_TYPE_UNKNOWN;
union extcon_property_value val;
/*
* If apsd is disabled, charger detection is done by
* USB phy driver.
*/
if (chip->disable_apsd || chip->usbin_ov) {
pr_debug("APSD %s, status = %d\n",
chip->disable_apsd ? "disabled" : "enabled", !!status);
pr_debug("USBIN ov, status = %d\n", chip->usbin_ov);
return 0;
}
rc = smb1351_read_reg(chip, STATUS_5_REG, &reg);
if (rc) {
pr_err("Couldn't read STATUS_5 rc = %d\n", rc);
return rc;
}
pr_debug("STATUS_5_REG(0x3B)=%x\n", reg);
switch (reg) {
case STATUS_PORT_ACA_DOCK:
case STATUS_PORT_ACA_C:
case STATUS_PORT_ACA_B:
case STATUS_PORT_ACA_A:
type = POWER_SUPPLY_TYPE_USB_ACA;
break;
case STATUS_PORT_CDP:
type = POWER_SUPPLY_TYPE_USB_CDP;
break;
case STATUS_PORT_DCP:
type = POWER_SUPPLY_TYPE_USB_DCP;
break;
case STATUS_PORT_SDP:
type = POWER_SUPPLY_TYPE_USB;
break;
case STATUS_PORT_OTHER:
type = POWER_SUPPLY_TYPE_USB_DCP;
break;
default:
type = POWER_SUPPLY_TYPE_USB;
break;
}
if (status) {
chip->chg_present = true;
pr_debug("APSD complete. USB type detected=%d chg_present=%d\n",
type, chip->chg_present);
if (!chip->battery_missing && !chip->apsd_rerun) {
if (type == POWER_SUPPLY_TYPE_USB) {
smb1351_request_dpdm(chip, false);
smb1351_request_dpdm(chip, true);
chip->apsd_rerun = true;
rerun_apsd(chip);
return 0;
}
}
/*
* If defined force hvdcp 2p0 property,
* we force to hvdcp 2p0 in the APSD handler.
*/
if (chip->force_hvdcp_2p0) {
pr_debug("Force set to HVDCP 2.0 mode\n");
smb1351_masked_write(chip, VARIOUS_FUNC_3_REG,
QC_2P1_AUTH_ALGO_BIT, 0);
smb1351_masked_write(chip, CMD_HVDCP_REG,
CMD_FORCE_HVDCP_2P0_BIT,
CMD_FORCE_HVDCP_2P0_BIT);
type = POWER_SUPPLY_TYPE_USB_HVDCP;
} else if (type == POWER_SUPPLY_TYPE_USB_DCP) {
pr_debug("schedule hvdcp detection worker\n");
pm_stay_awake(chip->dev);
schedule_delayed_work(&chip->hvdcp_det_work,
msecs_to_jiffies(HVDCP_NOTIFY_MS));
}
chip->charger_type = type;
if (type == POWER_SUPPLY_TYPE_USB
|| type == POWER_SUPPLY_TYPE_USB_CDP) {
val.intval = true;
extcon_set_property(chip->extcon, EXTCON_USB,
EXTCON_PROP_USB_SS, val);
extcon_set_state_sync(chip->extcon, EXTCON_USB, true);
pr_debug("extcon notify: EXTCON_USB present = 1\n");
}
chip->apsd_rerun = false;
/* set the charge current as required */
if (type == POWER_SUPPLY_TYPE_USB)
usb_psy_ma = USB2_MIN_CURRENT_MA;
else /* DCP */
usb_psy_ma = DCP_MAX_CURRENT_MA;
chip->usb_psy_ma = usb_psy_ma;
smb1351_enable_volatile_writes(chip);
rc = smb1351_set_usb_chg_current(chip, chip->usb_psy_ma);
if (rc < 0)
pr_err("Failed to set USB current rc=%d\n", rc);
} else if (!chip->apsd_rerun) {
/* Handle Charger removal */
chip->chg_present = 0;
chip->charger_type = POWER_SUPPLY_TYPE_UNKNOWN;
val.intval = false;
extcon_set_property(chip->extcon, EXTCON_USB,
EXTCON_PROP_USB_SS, val);
extcon_set_state_sync(chip->extcon, EXTCON_USB, false);
pr_debug("extcon notify: EXTCON_USB present = 0\n");
smb1351_request_dpdm(chip, false);
}
return 0;
}
/*
* As source detect interrupt is not triggered on the falling edge,
* we need to schedule a work for checking source detect status after
* charger UV interrupt fired.
*/
#define FIRST_CHECK_DELAY 100
#define SECOND_CHECK_DELAY 1000
static void smb1351_chg_remove_work(struct work_struct *work)
{
int rc;
u8 reg;
struct smb1351_charger *chip = container_of(work,
struct smb1351_charger, chg_remove_work.work);
rc = smb1351_read_reg(chip, IRQ_G_REG, &reg);
if (rc) {
pr_err("Couldn't read IRQ_G_REG rc = %d\n", rc);
goto end;
}
if (!(reg & IRQ_SOURCE_DET_BIT)) {
pr_debug("chg removed\n");
smb1351_apsd_complete_handler(chip, 0);
} else if (!chip->chg_remove_work_scheduled) {
chip->chg_remove_work_scheduled = true;
goto reschedule;
} else {
pr_debug("charger is present\n");
}
end:
chip->chg_remove_work_scheduled = false;
pm_relax(chip->dev);
return;
reschedule:
pr_debug("reschedule after 1s\n");
schedule_delayed_work(&chip->chg_remove_work,
msecs_to_jiffies(SECOND_CHECK_DELAY));
}
static int smb1351_usbin_uv_handler(struct smb1351_charger *chip, u8 status)
{
smb1351_request_dpdm(chip, !!status);
if (status) {
cancel_delayed_work_sync(&chip->hvdcp_det_work);
pm_relax(chip->dev);
pr_debug("schedule charger remove worker\n");
schedule_delayed_work(&chip->chg_remove_work,
msecs_to_jiffies(FIRST_CHECK_DELAY));
pm_stay_awake(chip->dev);
}
pr_debug("chip->chg_present = %d\n", chip->chg_present);
return 0;
}
static int smb1351_usbin_ov_handler(struct smb1351_charger *chip, u8 status)
{
int rc;
u8 reg = 0;
rc = smb1351_read_reg(chip, IRQ_E_REG, &reg);
if (rc)
pr_err("Couldn't read IRQ_E rc = %d\n", rc);
if (status != 0) {
chip->usbin_ov = true;
chip->charger_type = POWER_SUPPLY_TYPE_UNKNOWN;
if (chip->chg_present) {
extcon_set_state_sync(chip->extcon, EXTCON_USB, false);
pr_debug("extcon notify: EXTCON_USB present = 0\n");
}
chip->chg_present = false;
} else {
chip->usbin_ov = false;
if (reg & IRQ_USBIN_UV_BIT)
pr_debug("Charger unplugged from OV\n");
else
smb1351_apsd_complete_handler(chip, 1);
}
pr_debug("chip->chg_present = %d\n", chip->chg_present);
return 0;
}
static int smb1351_fast_chg_handler(struct smb1351_charger *chip, u8 status)
{
pr_debug("enter\n");
return 0;
}
static int smb1351_chg_term_handler(struct smb1351_charger *chip, u8 status)
{
pr_debug("enter\n");
if (!chip->bms_controlled_charging)
chip->batt_full = !!status;
return 0;
}
static int smb1351_safety_timeout_handler(struct smb1351_charger *chip,
u8 status)
{
pr_debug("safety_timeout triggered\n");
return 0;
}
static int smb1351_aicl_done_handler(struct smb1351_charger *chip, u8 status)
{
pr_debug("aicl_done triggered\n");
return 0;
}
static int smb1351_hot_hard_handler(struct smb1351_charger *chip, u8 status)
{
pr_debug("status = 0x%02x\n", status);
chip->batt_hot = !!status;
return 0;
}
static int smb1351_cold_hard_handler(struct smb1351_charger *chip, u8 status)
{
pr_debug("status = 0x%02x\n", status);
chip->batt_cold = !!status;
return 0;
}
static int smb1351_hot_soft_handler(struct smb1351_charger *chip, u8 status)
{
pr_debug("status = 0x%02x\n", status);
chip->batt_warm = !!status;
return 0;
}
static int smb1351_cold_soft_handler(struct smb1351_charger *chip, u8 status)
{
pr_debug("status = 0x%02x\n", status);
chip->batt_cool = !!status;
return 0;
}
static int smb1351_battery_missing_handler(struct smb1351_charger *chip,
u8 status)
{
if (status)
chip->battery_missing = true;
else
chip->battery_missing = false;
return 0;
}
static int smb1351_rid_handler(struct smb1351_charger *chip,
u8 status)
{
union extcon_property_value val;
bool rid_status;
u8 reg = 0;
int rc;
rc = smb1351_read_reg(chip, STATUS_6_REG, &reg);
if (rc < 0)
pr_err("Couldn't read status_6_reg, rc=%d\n", rc);
pr_debug("rt_status = 0x%02x, status_6_reg=0x%x\n", status, reg);
rid_status = (!!status) || !(reg & STATUS_RID_FLOAT_STATE_MACHINE_BIT);
if (rid_status) {
val.intval = true;
extcon_set_property(chip->extcon, EXTCON_USB_HOST,
EXTCON_PROP_USB_SS, val);
}
extcon_set_state_sync(chip->extcon, EXTCON_USB_HOST, rid_status);
pr_debug("extcon notify: EXTCON_USB_HOST present = %d\n", rid_status);
return 0;
}
static struct irq_handler_info handlers[] = {
[0] = {
.stat_reg = IRQ_A_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "cold_soft",
.smb_irq = smb1351_cold_soft_handler,
},
{ .name = "hot_soft",
.smb_irq = smb1351_hot_soft_handler,
},
{ .name = "cold_hard",
.smb_irq = smb1351_cold_hard_handler,
},
{ .name = "hot_hard",
.smb_irq = smb1351_hot_hard_handler,
},
},
},
[1] = {
.stat_reg = IRQ_B_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "internal_temp_limit",
},
{ .name = "vbatt_low",
},
{ .name = "battery_missing",
.smb_irq = smb1351_battery_missing_handler,
},
{ .name = "batt_therm_removed",
},
},
},
[2] = {
.stat_reg = IRQ_C_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "chg_term",
.smb_irq = smb1351_chg_term_handler,
},
{ .name = "taper",
},
{ .name = "recharge",
},
{ .name = "fast_chg",
.smb_irq = smb1351_fast_chg_handler,
},
},
},
[3] = {
.stat_reg = IRQ_D_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "prechg_timeout",
},
{ .name = "safety_timeout",
.smb_irq = smb1351_safety_timeout_handler,
},
{ .name = "chg_error",
},
{ .name = "batt_ov",
},
},
},
[4] = {
.stat_reg = IRQ_E_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "power_ok",
},
{ .name = "afvc",
},
{ .name = "usbin_uv",
.smb_irq = smb1351_usbin_uv_handler,
},
{ .name = "usbin_ov",
.smb_irq = smb1351_usbin_ov_handler,
},
},
},
[5] = {
.stat_reg = IRQ_F_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "otg_oc_retry",
},
{ .name = "rid",
.smb_irq = smb1351_rid_handler,
},
{ .name = "otg_fail",
},
{ .name = "otg_oc",
},
},
},
[6] = {
.stat_reg = IRQ_G_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "chg_inhibit",
},
{ .name = "aicl_fail",
},
{ .name = "aicl_done",
.smb_irq = smb1351_aicl_done_handler,
},
{ .name = "apsd_complete",
.smb_irq = smb1351_apsd_complete_handler,
},
},
},
[7] = {
.stat_reg = IRQ_H_REG,
.val = 0,
.prev_val = 0,
.irq_info = {
{ .name = "wdog_timeout",
},
{ .name = "hvdcp_auth_done",
},
},
},
};
#define IRQ_LATCHED_MASK 0x02
#define IRQ_STATUS_MASK 0x01
#define BITS_PER_IRQ 2
static irqreturn_t smb1351_chg_stat_handler(int irq, void *dev_id)
{
struct smb1351_charger *chip = dev_id;
int i, j;
u8 triggered;
u8 changed;
u8 rt_stat, prev_rt_stat;
int rc;
int handler_count = 0;
mutex_lock(&chip->irq_complete);
chip->irq_waiting = true;
if (!chip->resume_completed) {
pr_debug("IRQ triggered before device-resume\n");
disable_irq_nosync(irq);
mutex_unlock(&chip->irq_complete);
return IRQ_HANDLED;
}
chip->irq_waiting = false;
for (i = 0; i < ARRAY_SIZE(handlers); i++) {
rc = smb1351_read_reg(chip, handlers[i].stat_reg,
&handlers[i].val);
if (rc) {
pr_err("Couldn't read %d rc = %d\n",
handlers[i].stat_reg, rc);
continue;
}
for (j = 0; j < ARRAY_SIZE(handlers[i].irq_info); j++) {
triggered = handlers[i].val
& (IRQ_LATCHED_MASK << (j * BITS_PER_IRQ));
rt_stat = handlers[i].val
& (IRQ_STATUS_MASK << (j * BITS_PER_IRQ));
prev_rt_stat = handlers[i].prev_val
& (IRQ_STATUS_MASK << (j * BITS_PER_IRQ));
changed = prev_rt_stat ^ rt_stat;
if (triggered || changed)
rt_stat ? handlers[i].irq_info[j].high++ :
handlers[i].irq_info[j].low++;
if ((triggered || changed)
&& handlers[i].irq_info[j].smb_irq != NULL) {
handler_count++;
rc = handlers[i].irq_info[j].smb_irq(chip,
rt_stat);
if (rc)
pr_err("Couldn't handle %d irq for reg 0x%02x rc = %d\n",
j, handlers[i].stat_reg, rc);
}
}
handlers[i].prev_val = handlers[i].val;
}
pr_debug("handler count = %d\n", handler_count);
if (handler_count) {
pr_debug("batt psy changed\n");
power_supply_changed(chip->batt_psy);
}
mutex_unlock(&chip->irq_complete);
return IRQ_HANDLED;
}
#define LAST_CNFG_REG 0x16
static int show_cnfg_regs(struct seq_file *m, void *data)
{
struct smb1351_charger *chip = m->private;
int rc;
u8 reg;
u8 addr;
for (addr = 0; addr <= LAST_CNFG_REG; addr++) {
rc = smb1351_read_reg(chip, addr, &reg);
if (!rc)
seq_printf(m, "0x%02x = 0x%02x\n", addr, reg);
}
return 0;
}
static int cnfg_debugfs_open(struct inode *inode, struct file *file)
{
struct smb1351_charger *chip = inode->i_private;
return single_open(file, show_cnfg_regs, chip);
}
static const struct file_operations cnfg_debugfs_ops = {
.owner = THIS_MODULE,
.open = cnfg_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
#define FIRST_CMD_REG 0x30
#define LAST_CMD_REG 0x34
static int show_cmd_regs(struct seq_file *m, void *data)
{
struct smb1351_charger *chip = m->private;
int rc;
u8 reg;
u8 addr;
for (addr = FIRST_CMD_REG; addr <= LAST_CMD_REG; addr++) {
rc = smb1351_read_reg(chip, addr, &reg);
if (!rc)
seq_printf(m, "0x%02x = 0x%02x\n", addr, reg);
}
return 0;
}
static int cmd_debugfs_open(struct inode *inode, struct file *file)
{
struct smb1351_charger *chip = inode->i_private;
return single_open(file, show_cmd_regs, chip);
}
static const struct file_operations cmd_debugfs_ops = {
.owner = THIS_MODULE,
.open = cmd_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
#define FIRST_STATUS_REG 0x36
#define LAST_STATUS_REG 0x3F
static int show_status_regs(struct seq_file *m, void *data)
{
struct smb1351_charger *chip = m->private;
int rc;
u8 reg;
u8 addr;
for (addr = FIRST_STATUS_REG; addr <= LAST_STATUS_REG; addr++) {
rc = smb1351_read_reg(chip, addr, &reg);
if (!rc)
seq_printf(m, "0x%02x = 0x%02x\n", addr, reg);
}
return 0;
}
static int status_debugfs_open(struct inode *inode, struct file *file)
{
struct smb1351_charger *chip = inode->i_private;
return single_open(file, show_status_regs, chip);
}
static const struct file_operations status_debugfs_ops = {
.owner = THIS_MODULE,
.open = status_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int show_irq_count(struct seq_file *m, void *data)
{
int i, j, total = 0;
for (i = 0; i < ARRAY_SIZE(handlers); i++)
for (j = 0; j < 4; j++) {
seq_printf(m, "%s=%d\t(high=%d low=%d)\n",
handlers[i].irq_info[j].name,
handlers[i].irq_info[j].high
+ handlers[i].irq_info[j].low,
handlers[i].irq_info[j].high,
handlers[i].irq_info[j].low);
total += (handlers[i].irq_info[j].high
+ handlers[i].irq_info[j].low);
}
seq_printf(m, "\n\tTotal = %d\n", total);
return 0;
}
static int irq_count_debugfs_open(struct inode *inode, struct file *file)
{
struct smb1351_charger *chip = inode->i_private;
return single_open(file, show_irq_count, chip);
}
static const struct file_operations irq_count_debugfs_ops = {
.owner = THIS_MODULE,
.open = irq_count_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int get_reg(void *data, u64 *val)
{
struct smb1351_charger *chip = data;
int rc;
u8 temp;
rc = smb1351_read_reg(chip, chip->peek_poke_address, &temp);
if (rc) {
pr_err("Couldn't read reg %x rc = %d\n",
chip->peek_poke_address, rc);
return -EAGAIN;
}
*val = temp;
return 0;
}
static int set_reg(void *data, u64 val)
{
struct smb1351_charger *chip = data;
int rc;
u8 temp;
temp = (u8) val;
rc = smb1351_write_reg(chip, chip->peek_poke_address, temp);
if (rc) {
pr_err("Couldn't write 0x%02x to 0x%02x rc= %d\n",
temp, chip->peek_poke_address, rc);
return -EAGAIN;
}
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(poke_poke_debug_ops, get_reg, set_reg, "0x%02llx\n");
static int force_irq_set(void *data, u64 val)
{
struct smb1351_charger *chip = data;
smb1351_chg_stat_handler(chip->client->irq, data);
return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(force_irq_ops, NULL, force_irq_set, "0x%02llx\n");
#ifdef DEBUG
static void dump_regs(struct smb1351_charger *chip)
{
int rc;
u8 reg;
u8 addr;
for (addr = 0; addr <= LAST_CNFG_REG; addr++) {
rc = smb1351_read_reg(chip, addr, &reg);
if (rc)
pr_err("Couldn't read 0x%02x rc = %d\n", addr, rc);
else
pr_debug("0x%02x = 0x%02x\n", addr, reg);
}
for (addr = FIRST_STATUS_REG; addr <= LAST_STATUS_REG; addr++) {
rc = smb1351_read_reg(chip, addr, &reg);
if (rc)
pr_err("Couldn't read 0x%02x rc = %d\n", addr, rc);
else
pr_debug("0x%02x = 0x%02x\n", addr, reg);
}
for (addr = FIRST_CMD_REG; addr <= LAST_CMD_REG; addr++) {
rc = smb1351_read_reg(chip, addr, &reg);
if (rc)
pr_err("Couldn't read 0x%02x rc = %d\n", addr, rc);
else
pr_debug("0x%02x = 0x%02x\n", addr, reg);
}
}
#else
static void dump_regs(struct smb1351_charger *chip)
{
}
#endif
static int smb1351_parse_dt(struct smb1351_charger *chip)
{
int rc;
struct device_node *node = chip->dev->of_node;
if (!node) {
pr_err("device tree info. missing\n");
return -EINVAL;
}
chip->usb_suspended_status = of_property_read_bool(node,
"qcom,charging-disabled");
chip->battchg_disabled_status = of_property_read_bool(node,
"qcom,batt-charging-disabled");
chip->chg_autonomous_mode = of_property_read_bool(node,
"qcom,chg-autonomous-mode");
chip->disable_apsd = of_property_read_bool(node, "qcom,disable-apsd");
chip->bms_controlled_charging = of_property_read_bool(node,
"qcom,bms-controlled-charging");
chip->force_hvdcp_2p0 = of_property_read_bool(node,
"qcom,force-hvdcp-2p0");
rc = of_property_read_string(node, "qcom,bms-psy-name",
&chip->bms_psy_name);
if (rc)
chip->bms_psy_name = NULL;
rc = of_property_read_u32(node, "qcom,fastchg-current-max-ma",
&chip->target_fastchg_current_max_ma);
if (rc)
chip->target_fastchg_current_max_ma = SMB1351_CHG_FAST_MAX_MA;
chip->iterm_disabled = of_property_read_bool(node,
"qcom,iterm-disabled");
rc = of_property_read_u32(node, "qcom,iterm-ma", &chip->iterm_ma);
if (rc)
chip->iterm_ma = -EINVAL;
rc = of_property_read_u32(node, "qcom,float-voltage-mv",
&chip->vfloat_mv);
if (rc)
chip->vfloat_mv = -EINVAL;
rc = of_property_read_u32(node, "qcom,recharge-mv",
&chip->recharge_mv);
if (rc)
chip->recharge_mv = -EINVAL;
chip->recharge_disabled = of_property_read_bool(node,
"qcom,recharge-disabled");
chip->pinctrl_state_name = of_get_property(node, "pinctrl-names", NULL);
chip->otg_enable = of_property_read_bool(node, "qcom,otg-enable");
return 0;
}
static int smb1351_determine_initial_state(struct smb1351_charger *chip)
{
int rc;
u8 reg = 0;
/*
* It is okay to read the interrupt status here since
* interrupts aren't requested. Reading interrupt status
* clears the interrupt so be careful to read interrupt
* status only in interrupt handling code
*/
rc = smb1351_read_reg(chip, IRQ_B_REG, &reg);
if (rc) {
pr_err("Couldn't read IRQ_B rc = %d\n", rc);
goto fail_init_status;
}
chip->battery_missing = (reg & IRQ_BATT_MISSING_BIT) ? true : false;
rc = smb1351_read_reg(chip, IRQ_C_REG, &reg);
if (rc) {
pr_err("Couldn't read IRQ_C rc = %d\n", rc);
goto fail_init_status;
}
chip->batt_full = (reg & IRQ_TERM_BIT) ? true : false;
rc = smb1351_read_reg(chip, IRQ_A_REG, &reg);
if (rc) {
pr_err("Couldn't read irq A rc = %d\n", rc);
return rc;
}
if (reg & IRQ_HOT_HARD_BIT)
chip->batt_hot = true;
if (reg & IRQ_COLD_HARD_BIT)
chip->batt_cold = true;
if (reg & IRQ_HOT_SOFT_BIT)
chip->batt_warm = true;
if (reg & IRQ_COLD_SOFT_BIT)
chip->batt_cool = true;
rc = smb1351_read_reg(chip, IRQ_E_REG, &reg);
if (rc) {
pr_err("Couldn't read IRQ_E rc = %d\n", rc);
goto fail_init_status;
}
if (reg & IRQ_USBIN_UV_BIT) {
smb1351_usbin_uv_handler(chip, 1);
} else {
smb1351_usbin_uv_handler(chip, 0);
smb1351_apsd_complete_handler(chip, 1);
}
rc = smb1351_read_reg(chip, IRQ_G_REG, &reg);
if (rc) {
pr_err("Couldn't read IRQ_G rc = %d\n", rc);
goto fail_init_status;
}
if (reg & IRQ_SOURCE_DET_BIT)
smb1351_apsd_complete_handler(chip, 1);
return 0;
fail_init_status:
pr_err("Couldn't determine initial status\n");
return rc;
}
static int is_parallel_charger(struct i2c_client *client)
{
struct device_node *node = client->dev.of_node;
return of_property_read_bool(node, "qcom,parallel-charger");
}
static int create_debugfs_entries(struct smb1351_charger *chip)
{
struct dentry *ent;
chip->debug_root = debugfs_create_dir("smb1351", NULL);
if (!chip->debug_root) {
pr_err("Couldn't create debug dir\n");
} else {
ent = debugfs_create_file("config_registers", S_IFREG | 0444,
chip->debug_root, chip,
&cnfg_debugfs_ops);
if (!ent)
pr_err("Couldn't create cnfg debug file\n");
ent = debugfs_create_file("status_registers", S_IFREG | 0444,
chip->debug_root, chip,
&status_debugfs_ops);
if (!ent)
pr_err("Couldn't create status debug file\n");
ent = debugfs_create_file("cmd_registers", S_IFREG | 0444,
chip->debug_root, chip,
&cmd_debugfs_ops);
if (!ent)
pr_err("Couldn't create cmd debug file\n");
ent = debugfs_create_x32("address", S_IFREG | 0644,
chip->debug_root,
&(chip->peek_poke_address));
if (!ent)
pr_err("Couldn't create address debug file\n");
ent = debugfs_create_file("data", S_IFREG | 0644,
chip->debug_root, chip,
&poke_poke_debug_ops);
if (!ent)
pr_err("Couldn't create data debug file\n");
ent = debugfs_create_file("force_irq",
S_IFREG | 0644,
chip->debug_root, chip,
&force_irq_ops);
if (!ent)
pr_err("Couldn't create data debug file\n");
ent = debugfs_create_file("irq_count", S_IFREG | 0444,
chip->debug_root, chip,
&irq_count_debugfs_ops);
if (!ent)
pr_err("Couldn't create count debug file\n");
}
return 0;
}
static int smb1351_main_charger_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc;
struct smb1351_charger *chip;
struct power_supply_config batt_psy_cfg = {};
struct power_supply_config usb_psy_cfg = {};
u8 reg = 0;
chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
if (!chip)
return -ENOMEM;
chip->client = client;
chip->dev = &client->dev;
chip->fake_battery_soc = -EINVAL;
chip->extcon = devm_extcon_dev_allocate(chip->dev,
smb1351_extcon_cable);
if (IS_ERR(chip->extcon)) {
pr_err("failed to allocate extcon device\n");
rc = PTR_ERR(chip->extcon);
return rc;
}
rc = devm_extcon_dev_register(chip->dev, chip->extcon);
if (rc) {
pr_err("failed to register extcon device\n");
return rc;
}
rc = extcon_set_property_capability(chip->extcon,
EXTCON_USB, EXTCON_PROP_USB_SS);
rc |= extcon_set_property_capability(chip->extcon,
EXTCON_USB_HOST, EXTCON_PROP_USB_SS);
if (rc < 0) {
pr_err("Failed to register extcon capability rc=%d\n", rc);
return rc;
}
chip->usb_psy_d.name = "usb";
chip->usb_psy_d.type = POWER_SUPPLY_TYPE_USB;
chip->usb_psy_d.get_property = smb1351_usb_get_property;
chip->usb_psy_d.set_property = smb1351_usb_set_property;
chip->usb_psy_d.properties = smb1351_usb_properties;
chip->usb_psy_d.num_properties = ARRAY_SIZE(smb1351_usb_properties);
chip->usb_psy_d.property_is_writeable = smb1351_usb_is_writeable;
usb_psy_cfg.drv_data = chip;
usb_psy_cfg.supplied_to = smb1351_usb_supplicants;
usb_psy_cfg.num_supplicants = ARRAY_SIZE(smb1351_usb_supplicants);
chip->usb_psy = devm_power_supply_register(chip->dev,
&chip->usb_psy_d, &usb_psy_cfg);
if (IS_ERR(chip->usb_psy)) {
pr_err("Unable to register usb_psy rc = %ld\n",
PTR_ERR(chip->usb_psy));
rc = PTR_ERR(chip->usb_psy);
return rc;
}
INIT_DELAYED_WORK(&chip->chg_remove_work, smb1351_chg_remove_work);
INIT_DELAYED_WORK(&chip->hvdcp_det_work, smb1351_hvdcp_det_work);
device_init_wakeup(chip->dev, true);
/* probe the device to check if its actually connected */
rc = smb1351_read_reg(chip, CHG_REVISION_REG, &reg);
if (rc) {
pr_err("Failed to detect smb1351, device may be absent\n");
return -ENODEV;
}
pr_debug("smb1351 chip revision is %d\n", reg);
rc = smb1351_parse_dt(chip);
if (rc) {
pr_err("Couldn't parse DT nodes rc=%d\n", rc);
return rc;
}
i2c_set_clientdata(client, chip);
chip->batt_psy_d.name = "battery";
chip->batt_psy_d.type = POWER_SUPPLY_TYPE_BATTERY;
chip->batt_psy_d.get_property = smb1351_battery_get_property;
chip->batt_psy_d.set_property = smb1351_battery_set_property;
chip->batt_psy_d.property_is_writeable =
smb1351_batt_property_is_writeable;
chip->batt_psy_d.properties = smb1351_battery_properties;
chip->batt_psy_d.num_properties =
ARRAY_SIZE(smb1351_battery_properties);
chip->resume_completed = true;
mutex_init(&chip->irq_complete);
batt_psy_cfg.drv_data = chip;
batt_psy_cfg.supplied_to = pm_batt_supplied_to;
batt_psy_cfg.num_supplicants = ARRAY_SIZE(pm_batt_supplied_to);
chip->batt_psy = devm_power_supply_register(chip->dev,
&chip->batt_psy_d,
&batt_psy_cfg);
if (IS_ERR(chip->batt_psy)) {
pr_err("Couldn't register batt psy rc=%ld\n",
PTR_ERR(chip->batt_psy));
return rc;
}
dump_regs(chip);
rc = smb1351_regulator_init(chip);
if (rc) {
pr_err("Couldn't initialize smb1351 ragulator rc=%d\n", rc);
goto fail_smb1351_regulator_init;
}
rc = smb1351_hw_init(chip);
if (rc) {
pr_err("Couldn't initialize hardware rc=%d\n", rc);
goto fail_smb1351_hw_init;
}
rc = smb1351_determine_initial_state(chip);
if (rc) {
pr_err("Couldn't determine initial state rc=%d\n", rc);
goto fail_smb1351_hw_init;
}
/* STAT irq configuration */
if (client->irq) {
rc = devm_request_threaded_irq(&client->dev, client->irq, NULL,
smb1351_chg_stat_handler,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
"smb1351_chg_stat_irq", chip);
if (rc) {
pr_err("Failed STAT irq=%d request rc = %d\n",
client->irq, rc);
goto fail_smb1351_hw_init;
}
enable_irq_wake(client->irq);
}
create_debugfs_entries(chip);
dump_regs(chip);
pr_info("smb1351 successfully probed. charger=%d, batt=%d version=%s\n",
chip->chg_present,
smb1351_get_prop_batt_present(chip),
smb1351_version_str[chip->version]);
return 0;
fail_smb1351_hw_init:
regulator_unregister(chip->otg_vreg.rdev);
fail_smb1351_regulator_init:
return rc;
}
static int smb1351_parallel_charger_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc;
struct smb1351_charger *chip;
struct device_node *node = client->dev.of_node;
struct power_supply_config parallel_psy_cfg = {};
chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
if (!chip)
return -ENOMEM;
chip->client = client;
chip->dev = &client->dev;
chip->parallel_charger = true;
chip->parallel_charger_suspended = true;
chip->usb_suspended_status = of_property_read_bool(node,
"qcom,charging-disabled");
rc = of_property_read_u32(node, "qcom,float-voltage-mv",
&chip->vfloat_mv);
if (rc)
chip->vfloat_mv = -EINVAL;
rc = of_property_read_u32(node, "qcom,recharge-mv",
&chip->recharge_mv);
if (rc)
chip->recharge_mv = -EINVAL;
rc = of_property_read_u32(node, "qcom,parallel-en-pin-polarity",
&chip->parallel_pin_polarity_setting);
if (rc)
chip->parallel_pin_polarity_setting = EN_BY_PIN_LOW_ENABLE;
else
chip->parallel_pin_polarity_setting =
chip->parallel_pin_polarity_setting ?
EN_BY_PIN_HIGH_ENABLE : EN_BY_PIN_LOW_ENABLE;
if (of_property_read_bool(node,
"qcom,parallel-external-current-sense"))
chip->parallel_mode = POWER_SUPPLY_PL_USBIN_USBIN_EXT;
else
chip->parallel_mode = POWER_SUPPLY_PL_USBIN_USBIN;
chip->pl_batfet_mode = POWER_SUPPLY_PL_NON_STACKED_BATFET;
if (of_property_read_bool(node, "qcom,stacked-batfet"))
chip->pl_batfet_mode = POWER_SUPPLY_PL_STACKED_BATFET;
i2c_set_clientdata(client, chip);
chip->parallel_psy_d.name = "parallel";
chip->parallel_psy_d.type = POWER_SUPPLY_TYPE_PARALLEL;
chip->parallel_psy_d.get_property = smb1351_parallel_get_property;
chip->parallel_psy_d.set_property = smb1351_parallel_set_property;
chip->parallel_psy_d.properties = smb1351_parallel_properties;
chip->parallel_psy_d.property_is_writeable
= smb1351_parallel_is_writeable;
chip->parallel_psy_d.num_properties
= ARRAY_SIZE(smb1351_parallel_properties);
parallel_psy_cfg.drv_data = chip;
parallel_psy_cfg.num_supplicants = 0;
chip->parallel_psy = devm_power_supply_register(chip->dev,
&chip->parallel_psy_d,
&parallel_psy_cfg);
if (IS_ERR(chip->parallel_psy)) {
pr_err("Couldn't register parallel psy rc=%ld\n",
PTR_ERR(chip->parallel_psy));
return rc;
}
chip->resume_completed = true;
mutex_init(&chip->irq_complete);
create_debugfs_entries(chip);
pr_info("smb1351 parallel successfully probed.\n");
return 0;
}
static int smb1351_charger_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
if (is_parallel_charger(client))
return smb1351_parallel_charger_probe(client, id);
else
return smb1351_main_charger_probe(client, id);
}
static int smb1351_charger_remove(struct i2c_client *client)
{
struct smb1351_charger *chip = i2c_get_clientdata(client);
cancel_delayed_work_sync(&chip->chg_remove_work);
mutex_destroy(&chip->irq_complete);
debugfs_remove_recursive(chip->debug_root);
return 0;
}
static int smb1351_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct smb1351_charger *chip = i2c_get_clientdata(client);
/* no suspend resume activities for parallel charger */
if (chip->parallel_charger)
return 0;
mutex_lock(&chip->irq_complete);
chip->resume_completed = false;
mutex_unlock(&chip->irq_complete);
return 0;
}
static int smb1351_suspend_noirq(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct smb1351_charger *chip = i2c_get_clientdata(client);
/* no suspend resume activities for parallel charger */
if (chip->parallel_charger)
return 0;
if (chip->irq_waiting) {
pr_err_ratelimited("Aborting suspend, an interrupt was detected while suspending\n");
return -EBUSY;
}
return 0;
}
static int smb1351_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct smb1351_charger *chip = i2c_get_clientdata(client);
/* no suspend resume activities for parallel charger */
if (chip->parallel_charger)
return 0;
mutex_lock(&chip->irq_complete);
chip->resume_completed = true;
if (chip->irq_waiting) {
mutex_unlock(&chip->irq_complete);
smb1351_chg_stat_handler(client->irq, chip);
enable_irq(client->irq);
} else {
mutex_unlock(&chip->irq_complete);
}
return 0;
}
static const struct dev_pm_ops smb1351_pm_ops = {
.suspend = smb1351_suspend,
.suspend_noirq = smb1351_suspend_noirq,
.resume = smb1351_resume,
};
static const struct of_device_id smb1351_match_table[] = {
{ .compatible = "qcom,smb1351-charger",},
{ },
};
static const struct i2c_device_id smb1351_charger_id[] = {
{"smb1351-charger", 0},
{},
};
MODULE_DEVICE_TABLE(i2c, smb1351_charger_id);
static struct i2c_driver smb1351_charger_driver = {
.driver = {
.name = "smb1351-charger",
.owner = THIS_MODULE,
.of_match_table = smb1351_match_table,
.pm = &smb1351_pm_ops,
},
.probe = smb1351_charger_probe,
.remove = smb1351_charger_remove,
.id_table = smb1351_charger_id,
};
module_i2c_driver(smb1351_charger_driver);
MODULE_DESCRIPTION("smb1351 Charger");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("i2c:smb1351-charger");