netease
/
SmartAudio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
SmartAudio/lichee/linux-4.9/drivers/power/supply/axp/axp20x/axp20x-charger.c

669 lines
17 KiB
C
Executable File
Raw Blame History

/*
* drivers/power/supply/axp/axp20x/axp20x-charger.c
* (C) Copyright 2010-2016
* Allwinner Technology Co., Ltd. <www.allwinnertech.com>
* caiyongheng <caiyongheng@allwinnertech.com>
*
* charger driver of axp20x
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/workqueue.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/power_supply.h>
#include "../axp-core.h"
#include "../axp-charger.h"
#include "axp20x-charger.h"
static int axp20x_get_ac_voltage(struct axp_charger_dev *cdev)
{
return 0;
}
static int axp20x_get_ac_current(struct axp_charger_dev *cdev)
{
return 0;
}
static int axp20x_set_ac_vhold(struct axp_charger_dev *cdev, int vol)
{
return 0;
}
static int axp20x_get_ac_vhold(struct axp_charger_dev *cdev)
{
return 0;
}
static int axp20x_set_ac_ihold(struct axp_charger_dev *cdev, int cur)
{
return 0;
}
static int axp20x_get_ac_ihold(struct axp_charger_dev *cdev)
{
return 0;
}
static struct axp_ac_info axp20x_ac_info = {
.det_bit = 7,
.det_offset = AXP20X_CHARGE_STATUS,
.valid_bit = 6,
.valid_offset = AXP20X_CHARGE_STATUS,
.in_short_bit = 1,
.in_short_offset = AXP20X_CHARGE_STATUS,
.get_ac_voltage = axp20x_get_ac_voltage,
.get_ac_current = axp20x_get_ac_current,
.set_ac_vhold = axp20x_set_ac_vhold,
.get_ac_vhold = axp20x_get_ac_vhold,
.set_ac_ihold = axp20x_set_ac_ihold,
.get_ac_ihold = axp20x_get_ac_ihold,
};
static int axp20x_get_usb_voltage(struct axp_charger_dev *cdev)
{
return 0;
}
static int axp20x_get_usb_current(struct axp_charger_dev *cdev)
{
return 0;
}
static int axp20x_set_usb_vhold(struct axp_charger_dev *cdev, int vol)
{
u8 tmp;
struct axp_regmap *map = cdev->chip->regmap;
if (vol) {
axp_regmap_set_bits(map, AXP20X_CHARGE_VBUS, 0x40);
if (vol >= 4000 && vol <= 4700) {
tmp = (vol - 4000) / 100;
axp_regmap_update(map, AXP20X_CHARGE_VBUS,
tmp << 3, 0x7 << 3);
} else {
pr_err("set usb limit voltage error, %d mV\n",
axp20x_config.pmu_usbpc_vol);
}
} else {
axp_regmap_clr_bits(map, AXP20X_CHARGE_VBUS, 0x40);
}
return 0;
}
static int axp20x_get_usb_vhold(struct axp_charger_dev *cdev)
{
u8 tmp;
struct axp_regmap *map = cdev->chip->regmap;
axp_regmap_read(map, AXP20X_CHARGE_VBUS, &tmp);
tmp = (tmp >> 3) & 0x7;
return 4000 + tmp * 100;
}
static int axp20x_set_usb_ihold(struct axp_charger_dev *cdev, int cur)
{
struct axp_regmap *map = cdev->chip->regmap;
if (cur) {
if (cur == 900)
axp_regmap_clr_bits(map, AXP20X_CHARGE_VBUS, 0x3);
else if (cur == 500)
axp_regmap_update(map, AXP20X_CHARGE_VBUS, 0x1, 0x3);
} else {
axp_regmap_set_bits(map, AXP20X_CHARGE_VBUS, 0x3);
}
return 0;
}
static int axp20x_get_usb_ihold(struct axp_charger_dev *cdev)
{
u8 tmp;
struct axp_regmap *map = cdev->chip->regmap;
axp_regmap_read(map, AXP20X_CHARGE_VBUS, &tmp);
tmp = tmp & 0x3;
if (tmp == 0x1)
return 500;
else if (tmp == 0)
return 900;
else
return 0;
}
static struct axp_usb_info axp20x_usb_info = {
.det_bit = 5,
.det_offset = AXP20X_CHARGE_STATUS,
.valid_bit = 4,
.valid_offset = AXP20X_CHARGE_STATUS,
.get_usb_voltage = axp20x_get_usb_voltage,
.get_usb_current = axp20x_get_usb_current,
.set_usb_vhold = axp20x_set_usb_vhold,
.get_usb_vhold = axp20x_get_usb_vhold,
.set_usb_ihold = axp20x_set_usb_ihold,
.get_usb_ihold = axp20x_get_usb_ihold,
};
static int axp20x_get_rest_cap(struct axp_charger_dev *cdev)
{
u8 val, temp_val[2], batt_max_cap_val[2];
int batt_max_cap, coulumb_counter;
int rest_vol = 0;
struct axp_regmap *map = cdev->chip->regmap;
axp_regmap_read(map, AXP20X_CAP, &val);
rest_vol = (int) (val & 0x7F);
if (rest_vol == 127)
rest_vol = 100;
return rest_vol;
}
static int axp20x_get_bat_health(struct axp_charger_dev *cdev)
{
u8 val;
struct axp_regmap *map = cdev->chip->regmap;
axp_regmap_read(map, AXP20X_FAULT_LOG1, &val);
if (val & AXP20X_FAULT_LOG_BATINACT)
return POWER_SUPPLY_HEALTH_DEAD;
else if (val & AXP20X_FAULT_LOG_OVER_TEMP)
return POWER_SUPPLY_HEALTH_OVERHEAT;
else if (val & AXP20X_FAULT_LOG_COLD)
return POWER_SUPPLY_HEALTH_COLD;
else
return POWER_SUPPLY_HEALTH_GOOD;
}
static inline int axp20x_vbat_to_mV(u32 reg)
{
return ((int)(((reg >> 8) << 4) | (reg & 0x000F))) * 1100 / 1000;
}
static int axp20x_get_vbat(struct axp_charger_dev *cdev)
{
u8 tmp[2];
u32 res;
struct axp_regmap *map = cdev->chip->regmap;
axp_regmap_reads(map, AXP20X_VBATH_RES, 2, tmp);
res = (tmp[0] << 8) | tmp[1];
return axp20x_vbat_to_mV(res);
}
static inline int axp20x_ibat_to_mA(u32 reg)
{
return ((int)(((reg >> 8) << 5) | (reg & 0x001F))) * 500 / 1000;
}
static inline int axp20x_icharge_to_mA(u32 reg)
{
return ((int)(((reg >> 8) << 4) | (reg & 0x000F))) * 500 / 1000;
}
static int axp20x_get_ibat(struct axp_charger_dev *cdev)
{
u8 tmp[2];
u32 res;
struct axp_regmap *map = cdev->chip->regmap;
axp_regmap_reads(map, AXP20X_IBATH_REG, 2, tmp);
res = (tmp[0] << 8) | tmp[1];
return axp20x_icharge_to_mA(res);
}
static int axp20x_get_disibat(struct axp_charger_dev *cdev)
{
u8 tmp[2];
u32 dis_res;
struct axp_regmap *map = cdev->chip->regmap;
axp_regmap_reads(map, AXP20X_DISIBATH_REG, 2, tmp);
dis_res = (tmp[0] << 8) | tmp[1];
return axp20x_ibat_to_mA(dis_res);
}
static int axp20x_set_chg_cur(struct axp_charger_dev *cdev, int cur)
{
uint8_t tmp = 0;
struct axp_regmap *map = cdev->chip->regmap;
if (cur == 0)
axp_regmap_clr_bits(map, AXP20X_CHARGE_CONTROL1, 0x80);
else
axp_regmap_set_bits(map, AXP20X_CHARGE_CONTROL1, 0x80);
pr_info("current_limit = %d\n", cur);
if (cur >= 300 && cur <= 1800) {
tmp = (cur - 300) / 100;
axp_regmap_update(map, AXP20X_CHARGE_CONTROL1, tmp, 0x0F);
} else if (cur < 300) {
axp_regmap_clr_bits(map, AXP20X_CHARGE_CONTROL1, 0x0F);
} else {
axp_regmap_set_bits(map, AXP20X_CHARGE_CONTROL1, 0x0F);
}
return 0;
}
static int axp20x_set_chg_vol(struct axp_charger_dev *cdev, int vol)
{
uint8_t tmp = 0;
struct axp_regmap *map = cdev->chip->regmap;
if (vol < 4150) {
tmp &= ~(3 << 5);
} else if (vol < 4200) {
tmp &= ~(3 << 5);
tmp |= 1 << 5;
} else if (vol < 4360) {
tmp &= ~(3 << 5);
tmp |= 1 << 6;
} else {
tmp |= 3 << 5;
}
axp_regmap_update(map, AXP20X_CHARGE_CONTROL1, tmp, 0x3<<5);
return 0;
}
static struct axp_battery_info axp20x_batt_info = {
.chgstat_bit = 6,
.chgstat_offset = AXP20X_MODE_CHGSTATUS,
.det_bit = 5,
.det_valid_bit = 4,
.det_valid = 1,
.det_offset = AXP20X_MODE_CHGSTATUS,
.cur_direction_bit = 2,
.cur_direction_offset = AXP20X_CHARGE_STATUS,
.get_rest_cap = axp20x_get_rest_cap,
.get_bat_health = axp20x_get_bat_health,
.get_vbat = axp20x_get_vbat,
.get_ibat = axp20x_get_ibat,
.get_disibat = axp20x_get_disibat,
.set_chg_cur = axp20x_set_chg_cur,
.set_chg_vol = axp20x_set_chg_vol,
};
static struct power_supply_info battery_data = {
.name = "PTI PL336078",
.technology = POWER_SUPPLY_TECHNOLOGY_LiFe,
.voltage_max_design = 4200000,
.voltage_min_design = 3500000,
};
static struct axp_supply_info axp20x_spy_info = {
.ac = &axp20x_ac_info,
.usb = &axp20x_usb_info,
.batt = &axp20x_batt_info,
};
static int axp20x_charger_init(struct axp_dev *axp_dev)
{
u8 ocv_cap[32];
u8 val = 0;
int rdc;
struct axp_regmap *map = axp_dev->regmap;
if (axp20x_config.pmu_init_chgend_rate == 10)
val &= ~(1 << 4);
else
val |= 1 << 4;
val &= 0x7F;
axp_regmap_write(map, AXP20X_CHARGE_CONTROL1, val);
if (axp20x_config.pmu_init_chg_pretime < 40)
axp20x_config.pmu_init_chg_pretime = 40;
if (axp20x_config.pmu_init_chg_csttime < 360)
axp20x_config.pmu_init_chg_csttime = 360;
val = ((((axp20x_config.pmu_init_chg_pretime - 40) / 10) << 6)
| ((axp20x_config.pmu_init_chg_csttime - 360) / 120));
axp_regmap_update(map, AXP20X_CHARGE_CONTROL2, val, 0xC3);
/* adc set */
val = AXP20X_ADC_BATVOL_ENABLE | AXP20X_ADC_BATCUR_ENABLE;
if (axp20x_config.pmu_bat_temp_enable != 0)
val = val | AXP20X_ADC_TSVOL_ENABLE;
axp_regmap_update(map, AXP20X_ADC_CONTROL1, val,
AXP20X_ADC_BATVOL_ENABLE
| AXP20X_ADC_BATCUR_ENABLE
| AXP20X_ADC_TSVOL_ENABLE);
axp_regmap_read(map, AXP20X_ADC_CONTROL3, &val);
switch (axp20x_config.pmu_init_adc_freq / 25) {
case 1:
val &= ~(3 << 6);
break;
case 2:
val &= ~(3 << 6);
val |= 1 << 6;
break;
case 4:
val &= ~(3 << 6);
val |= 2 << 6;
break;
case 8:
val |= 3 << 6;
break;
default:
break;
}
if (axp20x_config.pmu_bat_temp_enable != 0)
val &= (~(1 << 2));
axp_regmap_write(map, AXP20X_ADC_CONTROL3, val);
/* bat para */
if (axp20x_config.pmu_battery_warning_level1 >= 2867
&& axp20x_config.pmu_battery_warning_level1 <= 4200) {
val = (axp20x_config.pmu_battery_warning_level1 * 10 - 28672)/56;
axp_regmap_write(map, AXP20X_APS_WARNING1, val);
}
if (axp20x_config.pmu_battery_warning_level2 >= 2867
&& axp20x_config.pmu_battery_warning_level2 <= 4200) {
val = (axp20x_config.pmu_battery_warning_level2 * 10 - 28672)/56;
axp_regmap_write(map, AXP20X_APS_WARNING2, val);
}
/*set target voltage */
if (axp20x_config.pmu_init_chgvol < 4150)
val = 0;
else if (axp20x_config.pmu_init_chgvol < 4200)
val = 1;
else if (axp20x_config.pmu_init_chgvol < 4360)
val = 2;
else
val = 3;
val <<= 5;
axp_regmap_update(map, AXP20X_CHARGE_CONTROL1, val, 0x60);
/* bat para */
ocv_cap[0] = axp20x_config.pmu_bat_para1;
ocv_cap[1] = axp20x_config.pmu_bat_para2;
ocv_cap[2] = axp20x_config.pmu_bat_para3;
ocv_cap[3] = axp20x_config.pmu_bat_para4;
ocv_cap[4] = axp20x_config.pmu_bat_para5;
ocv_cap[5] = axp20x_config.pmu_bat_para6;
ocv_cap[6] = axp20x_config.pmu_bat_para7;
ocv_cap[7] = axp20x_config.pmu_bat_para8;
ocv_cap[8] = axp20x_config.pmu_bat_para9;
ocv_cap[9] = axp20x_config.pmu_bat_para10;
ocv_cap[10] = axp20x_config.pmu_bat_para11;
ocv_cap[11] = axp20x_config.pmu_bat_para12;
ocv_cap[12] = axp20x_config.pmu_bat_para13;
ocv_cap[13] = axp20x_config.pmu_bat_para14;
ocv_cap[14] = axp20x_config.pmu_bat_para15;
ocv_cap[15] = axp20x_config.pmu_bat_para16;
axp_regmap_writes(map, AXP20X_OCV_BASE, 16, ocv_cap);
/*Init 16's Reset PMU en */
if (axp20x_config.pmu_reset)
axp_regmap_set_bits(map, AXP20X_HOTOVER_CTL, 0x08);
else
axp_regmap_clr_bits(map, AXP20X_HOTOVER_CTL, 0x08);
/*Init IRQ wakeup en*/
if (axp20x_config.pmu_irq_wakeup)
axp_regmap_set_bits(map, AXP20X_HOTOVER_CTL, 0x80);
else
axp_regmap_clr_bits(map, AXP20X_HOTOVER_CTL, 0x80);
/*Init CHGLED function*/
if (axp20x_config.pmu_chgled_func)
axp_regmap_set_bits(map, 0x32, 0x08); /* control by pmu */
else
axp_regmap_clr_bits(map, 0x32, 0x08); /* drive charge */
/*set CHGLED Indication Type*/
if (axp20x_config.pmu_chgled_type)
axp_regmap_set_bits(map, AXP20X_CHARGE2, 0x10);
else
axp_regmap_clr_bits(map, AXP20X_CHARGE2, 0x10);
/*Init PMU Over Temperature protection*/
if (axp20x_config.pmu_hot_shutdown)
axp_regmap_set_bits(map, AXP20X_HOTOVER_CTL, 0x04);
else
axp_regmap_clr_bits(map, AXP20X_HOTOVER_CTL, 0x04);
/*Init battery capacity correct function*/
if (axp20x_config.pmu_batt_cap_correct)
axp_regmap_set_bits(map, 0xb8, 0x20); /* enable */
else
axp_regmap_clr_bits(map, 0xb8, 0x20); /* disable */
if (!axp20x_config.pmu_batdeten)
axp_regmap_clr_bits(map, AXP20X_OFF_CTL, 0x40);
else
axp_regmap_set_bits(map, AXP20X_OFF_CTL, 0x40);
/* RDC initial */
axp_regmap_read(map, AXP20X_RDC1, &val);
if ((axp20x_config.pmu_battery_rdc) && (!(val & 0x40))) {
rdc = (axp20x_config.pmu_battery_rdc * 10000 + 5371) / 10742;
axp_regmap_write(map, AXP20X_RDC1, ((rdc >> 8) & 0x1F)|0x80);
axp_regmap_write(map, AXP20X_RDC0, rdc & 0x00FF);
}
/* disable LDO3 low voltage turn off */
axp_regmap_clr_bits(map, AXP20X_OP_MONITOR, 0x04);
if (axp20x_config.pmu_bat_unused == 1)
axp20x_spy_info.batt->det_unused = 1;
else
axp20x_spy_info.batt->det_unused = 0;
return 0;
}
static struct axp_interrupts axp20x_charger_irq[] = {
{"usb in", axp_usb_in_isr},
{"usb out", axp_usb_out_isr},
{"ac in", axp_ac_in_isr},
{"ac out", axp_ac_out_isr},
{"bat in", axp_capchange_isr},
{"bat out", axp_capchange_isr},
{"bat temp low", axp_change_isr},
{"bat temp over", axp_change_isr},
{"charging", axp_change_isr},
{"charge over", axp_change_isr},
};
static int axp20x_charger_probe(struct platform_device *pdev)
{
int ret, i, irq;
struct axp_charger_dev *chg_dev;
struct axp_dev *axp_dev = dev_get_drvdata(pdev->dev.parent);
if (pdev->dev.of_node) {
/* get dt and sysconfig */
ret = axp_charger_dt_parse(pdev->dev.of_node, &axp20x_config);
if (ret) {
pr_err("%s parse device tree err\n", __func__);
return -EINVAL;
}
} else {
pr_err("axp20x charger device tree err!\n");
return -EBUSY;
}
axp20x_ac_info.ac_vol = axp20x_config.pmu_ac_vol;
axp20x_ac_info.ac_cur = axp20x_config.pmu_ac_cur;
axp20x_usb_info.usb_pc_vol = axp20x_config.pmu_usbpc_vol;
axp20x_usb_info.usb_pc_cur = axp20x_config.pmu_usbpc_cur;
axp20x_usb_info.usb_ad_vol = axp20x_config.pmu_ac_vol;
axp20x_usb_info.usb_ad_cur = axp20x_config.pmu_ac_cur;
axp20x_batt_info.runtime_chgcur = axp20x_config.pmu_runtime_chgcur;
axp20x_batt_info.suspend_chgcur = axp20x_config.pmu_suspend_chgcur;
axp20x_batt_info.shutdown_chgcur = axp20x_config.pmu_shutdown_chgcur;
battery_data.voltage_max_design = axp20x_config.pmu_init_chgvol
* 1000;
battery_data.voltage_min_design = axp20x_config.pmu_pwroff_vol
* 1000;
battery_data.energy_full_design = axp20x_config.pmu_battery_cap;
axp20x_charger_init(axp_dev);
chg_dev = axp_power_supply_register(&pdev->dev, axp_dev,
&battery_data, &axp20x_spy_info);
if (IS_ERR_OR_NULL(chg_dev))
goto fail;
chg_dev->private_debug = NULL;
chg_dev->pmic_temp_offset = AXP20X_INTTEMP;
chg_dev->spy_info->batt->bat_temp_offset = AXP20X_VTS_RES;
for (i = 0; i < ARRAY_SIZE(axp20x_charger_irq); i++) {
irq = platform_get_irq_byname(pdev, axp20x_charger_irq[i].name);
if (irq < 0)
continue;
ret = axp_request_irq(axp_dev, irq,
axp20x_charger_irq[i].isr, chg_dev);
if (ret != 0) {
dev_err(&pdev->dev, "failed to request %s IRQ %d: %d\n",
axp20x_charger_irq[i].name, irq, ret);
goto out_irq;
}
dev_dbg(&pdev->dev, "Requested %s IRQ %d: %d\n",
axp20x_charger_irq[i].name, irq, ret);
}
platform_set_drvdata(pdev, chg_dev);
return 0;
out_irq:
for (i = i - 1; i >= 0; i--) {
irq = platform_get_irq_byname(pdev, axp20x_charger_irq[i].name);
if (irq < 0)
continue;
axp_free_irq(axp_dev, irq);
}
fail:
return -1;
}
static int axp20x_charger_remove(struct platform_device *pdev)
{
int i, irq;
struct axp_charger_dev *chg_dev = platform_get_drvdata(pdev);
struct axp_dev *axp_dev = dev_get_drvdata(pdev->dev.parent);
for (i = 0; i < ARRAY_SIZE(axp20x_charger_irq); i++) {
irq = platform_get_irq_byname(pdev, axp20x_charger_irq[i].name);
if (irq < 0)
continue;
axp_free_irq(axp_dev, irq);
}
axp_power_supply_unregister(chg_dev);
return 0;
}
static int axp20x_charger_suspend(struct platform_device *dev,
pm_message_t state)
{
struct axp_charger_dev *chg_dev = platform_get_drvdata(dev);
axp_suspend_flag = AXP_WAS_SUSPEND;
axp_charger_suspend(chg_dev);
return 0;
}
static int axp20x_charger_resume(struct platform_device *dev)
{
struct axp_charger_dev *chg_dev = platform_get_drvdata(dev);
struct axp_regmap *map = chg_dev->chip->regmap;
int pre_rest_vol;
if (axp_suspend_flag == AXP_SUSPEND_WITH_IRQ) {
axp_suspend_flag = AXP_NOT_SUSPEND;
sunxi_nmi_enable();
} else {
axp_suspend_flag = AXP_NOT_SUSPEND;
}
pre_rest_vol = chg_dev->rest_vol;
axp_charger_resume(chg_dev);
if (chg_dev->rest_vol - pre_rest_vol) {
pr_info("battery vol change: %d->%d\n",
pre_rest_vol, chg_dev->rest_vol);
axp_regmap_write(map, AXP20X_DATA_BUFFER1,
chg_dev->rest_vol | 0x80);
}
return 0;
}
static void axp20x_charger_shutdown(struct platform_device *dev)
{
struct axp_charger_dev *chg_dev = platform_get_drvdata(dev);
axp_charger_shutdown(chg_dev);
}
static const struct of_device_id axp20x_charger_dt_ids[] = {
{ .compatible = "axp203-charger", },
{ .compatible = "axp209-charger", },
{},
};
MODULE_DEVICE_TABLE(of, axp20x_charger_dt_ids);
static struct platform_driver axp20x_charger_driver = {
.driver = {
.name = "axp20x-charger",
.of_match_table = axp20x_charger_dt_ids,
},
.probe = axp20x_charger_probe,
.remove = axp20x_charger_remove,
.suspend = axp20x_charger_suspend,
.resume = axp20x_charger_resume,
.shutdown = axp20x_charger_shutdown,
};
static int __init axp20x_charger_initcall(void)
{
int ret;
ret = platform_driver_register(&axp20x_charger_driver);
if (IS_ERR_VALUE(ret)) {
pr_err("%s: failed, errno %d\n", __func__, ret);
return -EINVAL;
}
return 0;
}
fs_initcall_sync(axp20x_charger_initcall);
MODULE_DESCRIPTION("Charger driver of axp20x");
MODULE_AUTHOR("caiyongheng");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink