1015 lines
25 KiB
C
1015 lines
25 KiB
C
/*
|
|
* sabresd_battery.c - Maxim 8903 USB/Adapter Charger Driver
|
|
*
|
|
* Copyright (C) 2011 Samsung Electronics
|
|
* Copyright (C) 2011-2015 Freescale Semiconductor, Inc.
|
|
* Based on max8903_charger.c
|
|
* 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.
|
|
*
|
|
* 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/delay.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/of_gpio.h>
|
|
#include <linux/power_supply.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/power/sabresd_battery.h>
|
|
#include <linux/slab.h>
|
|
|
|
#define BATTERY_UPDATE_INTERVAL 5 /*seconds*/
|
|
#define LOW_VOLT_THRESHOLD 2800000
|
|
#define HIGH_VOLT_THRESHOLD 4200000
|
|
#define ADC_SAMPLE_COUNT 6
|
|
|
|
struct max8903_data {
|
|
struct max8903_pdata *pdata;
|
|
struct device *dev;
|
|
struct power_supply *psy;
|
|
struct power_supply *usb;
|
|
struct power_supply *bat;
|
|
struct power_supply *detect_usb;
|
|
bool fault;
|
|
bool usb_in;
|
|
bool ta_in;
|
|
bool chg_state;
|
|
struct delayed_work work;
|
|
unsigned int interval;
|
|
unsigned short thermal_raw;
|
|
int voltage_uV;
|
|
int current_uA;
|
|
int battery_status;
|
|
int charger_online;
|
|
int charger_voltage_uV;
|
|
int real_capacity;
|
|
int percent;
|
|
int old_percent;
|
|
int usb_charger_online;
|
|
int first_delay_count;
|
|
};
|
|
|
|
typedef struct {
|
|
u32 voltage;
|
|
u32 percent;
|
|
} battery_capacity , *pbattery_capacity;
|
|
|
|
static int offset_discharger;
|
|
static int offset_charger;
|
|
static int offset_usb_charger;
|
|
|
|
static battery_capacity chargingTable[] = {
|
|
{4050, 99},
|
|
{4040, 98},
|
|
{4020, 97},
|
|
{4010, 96},
|
|
{3990, 95},
|
|
{3980, 94},
|
|
{3970, 93},
|
|
{3960, 92},
|
|
{3950, 91},
|
|
{3940, 90},
|
|
{3930, 85},
|
|
{3920, 81},
|
|
{3910, 77},
|
|
{3900, 73},
|
|
{3890, 70},
|
|
{3860, 65},
|
|
{3830, 60},
|
|
{3780, 55},
|
|
{3760, 50},
|
|
{3740, 45},
|
|
{3720, 40},
|
|
{3700, 35},
|
|
{3680, 30},
|
|
{3660, 25},
|
|
{3640, 20},
|
|
{3620, 17},
|
|
{3600, 14},
|
|
{3580, 13},
|
|
{3560, 12},
|
|
{3540, 11},
|
|
{3520, 10},
|
|
{3500, 9},
|
|
{3480, 8},
|
|
{3460, 7},
|
|
{3440, 6},
|
|
{3430, 5},
|
|
{3420, 4},
|
|
{3020, 0},
|
|
};
|
|
|
|
static battery_capacity dischargingTable[] = {
|
|
{4050, 100},
|
|
{4035, 99},
|
|
{4020, 98},
|
|
{4010, 97},
|
|
{4000, 96},
|
|
{3990, 96},
|
|
{3980, 95},
|
|
{3970, 92},
|
|
{3960, 91},
|
|
{3950, 90},
|
|
{3940, 88},
|
|
{3930, 86},
|
|
{3920, 84},
|
|
{3910, 82},
|
|
{3900, 80},
|
|
{3890, 74},
|
|
{3860, 69},
|
|
{3830, 64},
|
|
{3780, 59},
|
|
{3760, 54},
|
|
{3740, 49},
|
|
{3720, 44},
|
|
{3700, 39},
|
|
{3680, 34},
|
|
{3660, 29},
|
|
{3640, 24},
|
|
{3620, 19},
|
|
{3600, 14},
|
|
{3580, 13},
|
|
{3560, 12},
|
|
{3540, 11},
|
|
{3520, 10},
|
|
{3500, 9},
|
|
{3480, 8},
|
|
{3460, 7},
|
|
{3440, 6},
|
|
{3430, 5},
|
|
{3420, 4},
|
|
{3020, 0},
|
|
};
|
|
|
|
u32 calibrate_battery_capability_percent(struct max8903_data *data)
|
|
{
|
|
u8 i;
|
|
pbattery_capacity pTable;
|
|
u32 tableSize;
|
|
|
|
if (data->battery_status == POWER_SUPPLY_STATUS_DISCHARGING) {
|
|
pTable = dischargingTable;
|
|
tableSize = sizeof(dischargingTable)/
|
|
sizeof(dischargingTable[0]);
|
|
} else {
|
|
pTable = chargingTable;
|
|
tableSize = sizeof(chargingTable)/
|
|
sizeof(chargingTable[0]);
|
|
}
|
|
for (i = 0; i < tableSize; i++) {
|
|
if (data->voltage_uV >= pTable[i].voltage)
|
|
return pTable[i].percent;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static enum power_supply_property max8903_charger_props[] = {
|
|
POWER_SUPPLY_PROP_ONLINE,
|
|
};
|
|
|
|
static enum power_supply_property max8903_battery_props[] = {
|
|
POWER_SUPPLY_PROP_VOLTAGE_NOW,
|
|
POWER_SUPPLY_PROP_STATUS,
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
POWER_SUPPLY_PROP_CAPACITY,
|
|
POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
|
|
POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
|
|
POWER_SUPPLY_PROP_HEALTH,
|
|
POWER_SUPPLY_PROP_CAPACITY_LEVEL,
|
|
};
|
|
|
|
extern int max11801_read_adc(void);
|
|
|
|
static void max8903_charger_update_status(struct max8903_data *data)
|
|
{
|
|
if (data->ta_in) {
|
|
data->charger_online = 1;
|
|
} else if (data->usb_in) {
|
|
data->usb_charger_online = 1;
|
|
} else {
|
|
data->charger_online = 0;
|
|
data->usb_charger_online = 0;
|
|
}
|
|
|
|
if (!data->charger_online && !data->usb_charger_online) {
|
|
data->battery_status = POWER_SUPPLY_STATUS_DISCHARGING;
|
|
} else if (gpio_get_value(data->pdata->chg) == 0) {
|
|
data->battery_status = POWER_SUPPLY_STATUS_CHARGING;
|
|
} else if ((data->ta_in || data->usb_in) &&
|
|
gpio_get_value(data->pdata->chg) > 0) {
|
|
if (!data->pdata->feature_flag) {
|
|
if (data->percent >= 99)
|
|
data->battery_status = POWER_SUPPLY_STATUS_FULL;
|
|
else
|
|
data->battery_status =
|
|
POWER_SUPPLY_STATUS_NOT_CHARGING;
|
|
} else {
|
|
data->battery_status = POWER_SUPPLY_STATUS_FULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
u32 calibration_voltage(struct max8903_data *data)
|
|
{
|
|
u32 voltage_data = 0;
|
|
int adc_val = 0;
|
|
int i;
|
|
int offset;
|
|
|
|
if (!data->charger_online && !data->usb_charger_online)
|
|
offset = offset_discharger;
|
|
else if (data->usb_charger_online)
|
|
offset = offset_usb_charger;
|
|
else if (data->charger_online)
|
|
offset = offset_charger;
|
|
|
|
/* simple average */
|
|
for (i = 0; i < ADC_SAMPLE_COUNT; i++) {
|
|
adc_val = max11801_read_adc();
|
|
/* Check if touch driver is probed */
|
|
if (max11801_read_adc() < 0)
|
|
break;
|
|
voltage_data += adc_val - offset;
|
|
}
|
|
voltage_data = voltage_data / ADC_SAMPLE_COUNT;
|
|
dev_dbg(data->dev, "volt: %d\n", voltage_data);
|
|
|
|
return voltage_data;
|
|
}
|
|
|
|
static void max8903_battery_update_status(struct max8903_data *data)
|
|
{
|
|
if (!data->pdata->feature_flag) {
|
|
data->voltage_uV = calibration_voltage(data);
|
|
data->percent = calibrate_battery_capability_percent(data);
|
|
if (data->percent != data->old_percent) {
|
|
data->old_percent = data->percent;
|
|
power_supply_changed(data->bat);
|
|
}
|
|
/*
|
|
* because boot time gap between led framwork and charger
|
|
* framwork,when system boots with charger attatched,
|
|
* charger led framwork loses the first charger online event,
|
|
* add once extra power_supply_changed can fix this issure
|
|
*/
|
|
if (data->first_delay_count < 200) {
|
|
data->first_delay_count = data->first_delay_count + 1;
|
|
power_supply_changed(data->bat);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int max8903_battery_get_property(struct power_supply *bat,
|
|
enum power_supply_property psp,
|
|
union power_supply_propval *val)
|
|
{
|
|
struct max8903_data *di = power_supply_get_drvdata(bat);
|
|
|
|
switch (psp) {
|
|
case POWER_SUPPLY_PROP_STATUS:
|
|
val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
|
|
if (gpio_get_value(di->pdata->chg) == 0) {
|
|
di->battery_status = POWER_SUPPLY_STATUS_CHARGING;
|
|
} else if ((di->ta_in || di->usb_in) &&
|
|
gpio_get_value(di->pdata->chg) > 0) {
|
|
if (!di->pdata->feature_flag) {
|
|
if (di->percent >= 99)
|
|
di->battery_status =
|
|
POWER_SUPPLY_STATUS_FULL;
|
|
else
|
|
di->battery_status =
|
|
POWER_SUPPLY_STATUS_NOT_CHARGING;
|
|
} else {
|
|
di->battery_status = POWER_SUPPLY_STATUS_FULL;
|
|
}
|
|
}
|
|
val->intval = di->battery_status;
|
|
return 0;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (psp) {
|
|
case POWER_SUPPLY_PROP_VOLTAGE_NOW:
|
|
val->intval = di->voltage_uV;
|
|
break;
|
|
case POWER_SUPPLY_PROP_CHARGE_NOW:
|
|
val->intval = 0;
|
|
break;
|
|
case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
|
|
val->intval = HIGH_VOLT_THRESHOLD;
|
|
break;
|
|
case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
|
|
val->intval = LOW_VOLT_THRESHOLD;
|
|
break;
|
|
case POWER_SUPPLY_PROP_PRESENT:
|
|
val->intval = 1;
|
|
break;
|
|
case POWER_SUPPLY_PROP_CAPACITY:
|
|
val->intval = di->percent < 0 ? 0 :
|
|
(di->percent > 100 ? 100 : di->percent);
|
|
break;
|
|
case POWER_SUPPLY_PROP_HEALTH:
|
|
val->intval = POWER_SUPPLY_HEALTH_GOOD;
|
|
if (di->fault)
|
|
val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
|
|
break;
|
|
case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
|
|
if (di->battery_status == POWER_SUPPLY_STATUS_FULL)
|
|
val->intval = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
|
|
else if (di->percent <= 15)
|
|
val->intval = POWER_SUPPLY_CAPACITY_LEVEL_LOW;
|
|
else
|
|
val->intval = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int max8903_get_property(struct power_supply *psy,
|
|
enum power_supply_property psp,
|
|
union power_supply_propval *val)
|
|
{
|
|
struct max8903_data *data = power_supply_get_drvdata(psy);
|
|
|
|
switch (psp) {
|
|
case POWER_SUPPLY_PROP_ONLINE:
|
|
val->intval = 0;
|
|
if (data->ta_in)
|
|
val->intval = 1;
|
|
data->charger_online = val->intval;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int max8903_get_usb_property(struct power_supply *usb,
|
|
enum power_supply_property psp,
|
|
union power_supply_propval *val)
|
|
{
|
|
struct max8903_data *data = power_supply_get_drvdata(usb);
|
|
|
|
switch (psp) {
|
|
case POWER_SUPPLY_PROP_ONLINE:
|
|
val->intval = 0;
|
|
if (data->usb_in)
|
|
val->intval = 1;
|
|
data->usb_charger_online = val->intval;
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static irqreturn_t max8903_dcin(int irq, void *_data)
|
|
{
|
|
struct max8903_data *data = _data;
|
|
struct max8903_pdata *pdata = data->pdata;
|
|
bool ta_in = false;
|
|
|
|
if (pdata->dok)
|
|
ta_in = gpio_get_value(pdata->dok) ? false : true;
|
|
|
|
if (ta_in == data->ta_in)
|
|
return IRQ_HANDLED;
|
|
|
|
data->ta_in = ta_in;
|
|
dev_info(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ?
|
|
"Connected" : "Disconnected");
|
|
max8903_charger_update_status(data);
|
|
power_supply_changed(data->psy);
|
|
power_supply_changed(data->bat);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static irqreturn_t max8903_usbin(int irq, void *_data)
|
|
{
|
|
struct max8903_data *data = _data;
|
|
struct max8903_pdata *pdata = data->pdata;
|
|
bool usb_in = false;
|
|
|
|
if (pdata->uok)
|
|
usb_in = gpio_get_value(pdata->uok) ? false : true;
|
|
if (usb_in == data->usb_in)
|
|
return IRQ_HANDLED;
|
|
data->usb_in = usb_in;
|
|
dev_info(data->dev, "USB Charger %s.\n", usb_in ?
|
|
"Connected" : "Disconnected");
|
|
max8903_charger_update_status(data);
|
|
power_supply_changed(data->bat);
|
|
power_supply_changed(data->usb);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static irqreturn_t max8903_fault(int irq, void *_data)
|
|
{
|
|
struct max8903_data *data = _data;
|
|
struct max8903_pdata *pdata = data->pdata;
|
|
bool fault;
|
|
|
|
fault = gpio_get_value(pdata->flt) ? false : true;
|
|
|
|
if (fault == data->fault)
|
|
return IRQ_HANDLED;
|
|
data->fault = fault;
|
|
|
|
if (fault)
|
|
dev_err(data->dev, "Charger suffers a fault and stops.\n");
|
|
else
|
|
dev_err(data->dev, "Charger recovered from a fault.\n");
|
|
max8903_charger_update_status(data);
|
|
power_supply_changed(data->psy);
|
|
power_supply_changed(data->bat);
|
|
power_supply_changed(data->usb);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static irqreturn_t max8903_chg(int irq, void *_data)
|
|
{
|
|
struct max8903_data *data = _data;
|
|
struct max8903_pdata *pdata = data->pdata;
|
|
int chg_state;
|
|
|
|
chg_state = gpio_get_value(pdata->chg) ? false : true;
|
|
|
|
if (chg_state == data->chg_state)
|
|
return IRQ_HANDLED;
|
|
data->chg_state = chg_state;
|
|
max8903_charger_update_status(data);
|
|
power_supply_changed(data->psy);
|
|
power_supply_changed(data->bat);
|
|
power_supply_changed(data->usb);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static void max8903_battery_work(struct work_struct *work)
|
|
{
|
|
struct max8903_data *data;
|
|
|
|
data = container_of(work, struct max8903_data, work.work);
|
|
data->interval = HZ * BATTERY_UPDATE_INTERVAL;
|
|
|
|
max8903_charger_update_status(data);
|
|
max8903_battery_update_status(data);
|
|
dev_dbg(data->dev, "battery voltage: %4d mV\n", data->voltage_uV);
|
|
dev_dbg(data->dev, "charger online status: %d\n",
|
|
data->charger_online);
|
|
dev_dbg(data->dev, "battery status : %d\n" , data->battery_status);
|
|
dev_dbg(data->dev, "battery capacity percent: %3d\n", data->percent);
|
|
dev_dbg(data->dev, "data->usb_in: %x , data->ta_in: %x\n",
|
|
data->usb_in, data->ta_in);
|
|
/* reschedule for the next time */
|
|
schedule_delayed_work(&data->work, data->interval);
|
|
}
|
|
|
|
static ssize_t max8903_voltage_offset_discharger_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return sprintf(buf, "read offset_discharger:%04d\n",
|
|
offset_discharger);
|
|
}
|
|
|
|
static ssize_t max8903_voltage_offset_discharger_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf,
|
|
size_t count)
|
|
{
|
|
int ret;
|
|
unsigned long data;
|
|
|
|
ret = kstrtoul(buf, 10, &data);
|
|
offset_discharger = (int)data;
|
|
pr_info("read offset_discharger:%04d\n", offset_discharger);
|
|
|
|
return count;
|
|
}
|
|
|
|
static ssize_t max8903_voltage_offset_charger_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return sprintf(buf, "read offset_charger:%04d\n",
|
|
offset_charger);
|
|
}
|
|
|
|
static ssize_t max8903_voltage_offset_charger_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf,
|
|
size_t count)
|
|
{
|
|
int ret;
|
|
unsigned long data;
|
|
|
|
ret = kstrtoul(buf, 10, &data);
|
|
offset_charger = (int)data;
|
|
pr_info("read offset_charger:%04d\n", offset_charger);
|
|
return count;
|
|
}
|
|
|
|
static ssize_t max8903_voltage_offset_usb_charger_show(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
return sprintf(buf, "read offset_usb_charger:%04d\n",
|
|
offset_usb_charger);
|
|
}
|
|
|
|
static ssize_t max8903_voltage_offset_usb_charger_store(struct device *dev,
|
|
struct device_attribute *attr, const char *buf,
|
|
size_t count)
|
|
{
|
|
int ret;
|
|
unsigned long data;
|
|
|
|
ret = kstrtoul(buf, 10, &data);
|
|
offset_usb_charger = (int)data;
|
|
pr_info("read offset_charger:%04d\n", offset_usb_charger);
|
|
|
|
return count;
|
|
}
|
|
|
|
static struct device_attribute max8903_discharger_dev_attr = {
|
|
.attr = {
|
|
.name = "max8903_ctl_offset_discharger",
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
},
|
|
.show = max8903_voltage_offset_discharger_show,
|
|
.store = max8903_voltage_offset_discharger_store,
|
|
};
|
|
|
|
static struct device_attribute max8903_charger_dev_attr = {
|
|
.attr = {
|
|
.name = "max8903_ctl_offset_charger",
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
},
|
|
.show = max8903_voltage_offset_charger_show,
|
|
.store = max8903_voltage_offset_charger_store,
|
|
};
|
|
|
|
static struct device_attribute max8903_usb_charger_dev_attr = {
|
|
.attr = {
|
|
.name = "max8903_ctl_offset_usb_charger",
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
},
|
|
.show = max8903_voltage_offset_usb_charger_show,
|
|
.store = max8903_voltage_offset_usb_charger_store,
|
|
};
|
|
|
|
#if defined(CONFIG_OF)
|
|
static const struct of_device_id max8903_dt_ids[] = {
|
|
{ .compatible = "fsl,max8903-charger", },
|
|
{ /* sentinel */ }
|
|
};
|
|
MODULE_DEVICE_TABLE(of, max8903_dt_ids);
|
|
|
|
static struct max8903_pdata *max8903_of_populate_pdata(
|
|
struct device *dev)
|
|
{
|
|
struct device_node *of_node = dev->of_node;
|
|
struct max8903_pdata *pdata = dev->platform_data;
|
|
|
|
if (!of_node || pdata)
|
|
return pdata;
|
|
|
|
pdata = devm_kzalloc(dev, sizeof(struct max8903_pdata),
|
|
GFP_KERNEL);
|
|
if (!pdata)
|
|
return pdata;
|
|
|
|
if (of_get_property(of_node, "fsl,dcm_always_high", NULL))
|
|
pdata->dcm_always_high = true;
|
|
if (of_get_property(of_node, "fsl,dc_valid", NULL))
|
|
pdata->dc_valid = true;
|
|
if (of_get_property(of_node, "fsl,usb_valid", NULL))
|
|
pdata->usb_valid = true;
|
|
if (of_get_property(of_node, "fsl,adc_disable", NULL))
|
|
pdata->feature_flag = true;
|
|
|
|
if (pdata->dc_valid) {
|
|
pdata->dok = of_get_named_gpio(of_node, "dok_input", 0);
|
|
if (!gpio_is_valid(pdata->dok)) {
|
|
dev_err(dev, "pin pdata->dok: invalid gpio %d\n", pdata->dok);
|
|
return NULL;
|
|
}
|
|
}
|
|
if (pdata->usb_valid) {
|
|
pdata->uok = of_get_named_gpio(of_node, "uok_input", 0);
|
|
if (!gpio_is_valid(pdata->uok)) {
|
|
dev_err(dev, "pin pdata->uok: invalid gpio %d\n", pdata->uok);
|
|
return NULL;
|
|
}
|
|
}
|
|
pdata->chg = of_get_named_gpio(of_node, "chg_input", 0);
|
|
if (!gpio_is_valid(pdata->chg)) {
|
|
dev_err(dev, "pin pdata->chg: invalid gpio %d\n", pdata->chg);
|
|
return NULL;
|
|
}
|
|
pdata->flt = of_get_named_gpio(of_node, "flt_input", 0);
|
|
if (!gpio_is_valid(pdata->flt)) {
|
|
dev_err(dev, "pin pdata->flt: invalid gpio %d\n", pdata->flt);
|
|
return NULL;
|
|
}
|
|
|
|
/* no need check offset without adc converter */
|
|
if (!pdata->feature_flag) {
|
|
if (of_property_read_u32(of_node, "offset-charger",
|
|
&offset_charger))
|
|
dev_err(dev, "Not setting offset-charger in dts!\n");
|
|
|
|
if (of_property_read_u32(of_node, "offset-discharger",
|
|
&offset_discharger))
|
|
dev_err(dev, "Not setting offset-discharger in dts!\n");
|
|
|
|
if (of_property_read_u32(of_node, "offset-usb-charger",
|
|
&offset_usb_charger))
|
|
dev_err(dev, "Not setting offset-usb-charger in dts!\n");
|
|
}
|
|
|
|
return pdata;
|
|
}
|
|
#endif
|
|
|
|
static const struct power_supply_desc max8903_ac_desc = {
|
|
.name = "max8903-ac",
|
|
.type = POWER_SUPPLY_TYPE_MAINS,
|
|
.get_property = max8903_get_property,
|
|
.properties = max8903_charger_props,
|
|
.num_properties = ARRAY_SIZE(max8903_charger_props),
|
|
};
|
|
|
|
static const struct power_supply_desc max8903_usb_desc = {
|
|
.name = "max8903-usb",
|
|
.type = POWER_SUPPLY_TYPE_USB,
|
|
.get_property = max8903_get_usb_property,
|
|
.properties = max8903_charger_props,
|
|
.num_properties = ARRAY_SIZE(max8903_charger_props),
|
|
};
|
|
|
|
static const struct power_supply_desc max8903_bat_desc = {
|
|
.name = "max8903-charger",
|
|
.type = POWER_SUPPLY_TYPE_BATTERY,
|
|
.properties = max8903_battery_props,
|
|
.num_properties = ARRAY_SIZE(max8903_battery_props),
|
|
.get_property = max8903_battery_get_property,
|
|
.use_for_apm = 1,
|
|
};
|
|
|
|
static int max8903_probe(struct platform_device *pdev)
|
|
{
|
|
struct max8903_data *data;
|
|
struct device *dev = &pdev->dev;
|
|
struct max8903_pdata *pdata = pdev->dev.platform_data;
|
|
int ret = 0;
|
|
int gpio = 0;
|
|
int ta_in = 0;
|
|
int usb_in = 0;
|
|
struct power_supply_config psy_cfg = {};
|
|
|
|
data = devm_kzalloc(dev, sizeof(struct max8903_data), GFP_KERNEL);
|
|
if (!data)
|
|
return -ENOMEM;
|
|
|
|
pdata = pdev->dev.platform_data;
|
|
if (!pdata) {
|
|
pdata = max8903_of_populate_pdata(&pdev->dev);
|
|
if (!pdata)
|
|
return -EINVAL;
|
|
}
|
|
|
|
data->first_delay_count = 0;
|
|
data->pdata = pdata;
|
|
data->dev = dev;
|
|
data->usb_in = 0;
|
|
data->ta_in = 0;
|
|
platform_set_drvdata(pdev, data);
|
|
|
|
if (pdata->dc_valid == false && pdata->usb_valid == false) {
|
|
dev_err(dev, "No valid power sources.\n");
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
if (pdata->dc_valid) {
|
|
if (pdata->dok && pdata->dcm_always_high) {
|
|
gpio = pdata->dok;
|
|
ret = gpio_request_one(gpio, GPIOF_IN, "max8903-DOK");
|
|
if (ret) {
|
|
dev_err(dev, "request max8903-DOK error!!\n");
|
|
goto err;
|
|
}
|
|
ta_in = gpio_get_value(gpio) ? 0 : 1;
|
|
} else {
|
|
dev_err(dev, "When DC is wired, DOK and DCM should be"
|
|
" wired as well or set dcm always high!\n");
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if (pdata->usb_valid) {
|
|
if (pdata->uok) {
|
|
gpio = pdata->uok;
|
|
ret = gpio_request_one(gpio, GPIOF_IN, "max8903-UOK");
|
|
if (ret) {
|
|
dev_err(dev, "request max8903-UOK error!!\n");
|
|
goto err;
|
|
}
|
|
usb_in = gpio_get_value(gpio) ? 0 : 1;
|
|
} else {
|
|
dev_err(dev, "When USB is wired, UOK should be wired"
|
|
" as well.\n");
|
|
ret = -EINVAL;
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if (pdata->chg) {
|
|
ret = gpio_request_one(pdata->chg, GPIOF_IN, "max8903-CHG");
|
|
if (ret) {
|
|
dev_err(dev, "request max8903-CHG error!!\n");
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
if (pdata->flt) {
|
|
ret = gpio_request_one(pdata->flt, GPIOF_IN, "max8903-FLT");
|
|
if (ret) {
|
|
dev_err(dev, "request max8903-FLT error!!\n");
|
|
goto err;
|
|
}
|
|
}
|
|
|
|
data->fault = false;
|
|
data->ta_in = ta_in;
|
|
data->usb_in = usb_in;
|
|
|
|
psy_cfg.of_node = dev->of_node;
|
|
psy_cfg.drv_data = data;
|
|
|
|
data->psy = power_supply_register(dev, &max8903_ac_desc, &psy_cfg);
|
|
if (IS_ERR(data->psy)) {
|
|
dev_err(dev, "failed: power supply register.\n");
|
|
goto err;
|
|
}
|
|
|
|
data->usb = power_supply_register(dev, &max8903_usb_desc, &psy_cfg);
|
|
if (IS_ERR(data->usb)) {
|
|
dev_err(dev, "failed: power supply register.\n");
|
|
goto err_psy;
|
|
}
|
|
|
|
data->bat = power_supply_register(dev, &max8903_bat_desc, &psy_cfg);
|
|
if (IS_ERR(data->bat)) {
|
|
dev_err(data->dev, "failed to register battery\n");
|
|
goto err_usb;
|
|
}
|
|
|
|
INIT_DELAYED_WORK(&data->work, max8903_battery_work);
|
|
schedule_delayed_work(&data->work, data->interval);
|
|
|
|
if (pdata->dc_valid) {
|
|
ret = request_threaded_irq(gpio_to_irq(pdata->dok), NULL,
|
|
max8903_dcin, IRQF_TRIGGER_FALLING |
|
|
IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 DC IN",
|
|
data);
|
|
if (ret) {
|
|
dev_err(dev, "Cannot request irq %d for DC (%d)\n",
|
|
gpio_to_irq(pdata->dok), ret);
|
|
goto err_dc_irq;
|
|
}
|
|
}
|
|
|
|
if (pdata->usb_valid) {
|
|
ret = request_threaded_irq(gpio_to_irq(pdata->uok), NULL,
|
|
max8903_usbin, IRQF_TRIGGER_FALLING |
|
|
IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 USB IN",
|
|
data);
|
|
if (ret) {
|
|
dev_err(dev, "Cannot request irq %d for USB (%d)\n",
|
|
gpio_to_irq(pdata->uok), ret);
|
|
goto err_usb_irq;
|
|
}
|
|
}
|
|
|
|
if (pdata->flt) {
|
|
ret = request_threaded_irq(gpio_to_irq(pdata->flt), NULL,
|
|
max8903_fault, IRQF_TRIGGER_FALLING |
|
|
IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 Fault",
|
|
data);
|
|
if (ret) {
|
|
dev_err(dev, "Cannot request irq %d for Fault (%d)\n",
|
|
gpio_to_irq(pdata->flt), ret);
|
|
goto err_flt_irq;
|
|
}
|
|
}
|
|
|
|
if (pdata->chg) {
|
|
ret = request_threaded_irq(gpio_to_irq(pdata->chg), NULL,
|
|
max8903_chg, IRQF_TRIGGER_FALLING |
|
|
IRQF_TRIGGER_RISING | IRQF_ONESHOT, "MAX8903 Status",
|
|
data);
|
|
if (ret) {
|
|
dev_err(dev, "Cannot request irq %d for Status (%d)\n",
|
|
gpio_to_irq(pdata->flt), ret);
|
|
goto err_chg_irq;
|
|
}
|
|
}
|
|
|
|
ret = device_create_file(&pdev->dev, &max8903_discharger_dev_attr);
|
|
if (ret)
|
|
dev_err(&pdev->dev, "create device file failed!\n");
|
|
ret = device_create_file(&pdev->dev, &max8903_charger_dev_attr);
|
|
if (ret)
|
|
dev_err(&pdev->dev, "create device file failed!\n");
|
|
ret = device_create_file(&pdev->dev, &max8903_usb_charger_dev_attr);
|
|
if (ret)
|
|
dev_err(&pdev->dev, "create device file failed!\n");
|
|
|
|
device_set_wakeup_capable(&pdev->dev, true);
|
|
|
|
max8903_charger_update_status(data);
|
|
max8903_battery_update_status(data);
|
|
|
|
return 0;
|
|
err_chg_irq:
|
|
if (pdata->chg)
|
|
free_irq(gpio_to_irq(pdata->chg), data);
|
|
err_flt_irq:
|
|
if (pdata->flt)
|
|
free_irq(gpio_to_irq(pdata->flt), data);
|
|
err_usb_irq:
|
|
if (pdata->usb_valid)
|
|
free_irq(gpio_to_irq(pdata->uok), data);
|
|
err_dc_irq:
|
|
if (pdata->dc_valid)
|
|
free_irq(gpio_to_irq(pdata->dok), data);
|
|
cancel_delayed_work(&data->work);
|
|
power_supply_unregister(data->bat);
|
|
err_usb:
|
|
power_supply_unregister(data->usb);
|
|
err_psy:
|
|
power_supply_unregister(data->psy);
|
|
err:
|
|
if (pdata->uok)
|
|
gpio_free(pdata->uok);
|
|
if (pdata->dok)
|
|
gpio_free(pdata->dok);
|
|
if (pdata->flt)
|
|
gpio_free(pdata->flt);
|
|
if (pdata->chg)
|
|
gpio_free(pdata->chg);
|
|
return ret;
|
|
}
|
|
|
|
static int max8903_remove(struct platform_device *pdev)
|
|
{
|
|
struct max8903_data *data = platform_get_drvdata(pdev);
|
|
if (data) {
|
|
struct max8903_pdata *pdata = data->pdata;
|
|
|
|
cancel_delayed_work_sync(&data->work);
|
|
power_supply_unregister(data->psy);
|
|
power_supply_unregister(data->usb);
|
|
power_supply_unregister(data->bat);
|
|
|
|
if (pdata->flt) {
|
|
free_irq(gpio_to_irq(pdata->flt), data);
|
|
gpio_free(pdata->flt);
|
|
}
|
|
if (pdata->usb_valid && pdata->uok) {
|
|
free_irq(gpio_to_irq(pdata->uok), data);
|
|
gpio_free(pdata->uok);
|
|
}
|
|
if (pdata->dc_valid) {
|
|
if (pdata->dok) {
|
|
free_irq(gpio_to_irq(pdata->dok), data);
|
|
gpio_free(pdata->dok);
|
|
} else if (pdata->chg) {
|
|
free_irq(gpio_to_irq(pdata->chg), data);
|
|
gpio_free(pdata->chg);
|
|
}
|
|
}
|
|
|
|
device_remove_file(&pdev->dev, &max8903_discharger_dev_attr);
|
|
device_remove_file(&pdev->dev, &max8903_charger_dev_attr);
|
|
device_remove_file(&pdev->dev, &max8903_usb_charger_dev_attr);
|
|
|
|
platform_set_drvdata(pdev, NULL);
|
|
kfree(data);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int max8903_suspend(struct platform_device *pdev,
|
|
pm_message_t state)
|
|
{
|
|
struct max8903_data *data = platform_get_drvdata(pdev);
|
|
int irq;
|
|
if (data) {
|
|
struct max8903_pdata *pdata = data->pdata;
|
|
if (pdata) {
|
|
if (pdata->dc_valid && device_may_wakeup(&pdev->dev)) {
|
|
irq = gpio_to_irq(pdata->dok);
|
|
enable_irq_wake(irq);
|
|
}
|
|
|
|
if (pdata->usb_valid && device_may_wakeup(&pdev->dev)) {
|
|
irq = gpio_to_irq(pdata->uok);
|
|
enable_irq_wake(irq);
|
|
}
|
|
cancel_delayed_work(&data->work);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int max8903_resume(struct platform_device *pdev)
|
|
{
|
|
struct max8903_data *data = platform_get_drvdata(pdev);
|
|
bool ta_in = false;
|
|
bool usb_in = false;
|
|
int irq;
|
|
|
|
if (data) {
|
|
struct max8903_pdata *pdata = data->pdata;
|
|
|
|
if (pdata) {
|
|
if (pdata->dok)
|
|
ta_in = gpio_get_value(pdata->dok) ? false : true;
|
|
if (pdata->uok)
|
|
usb_in = gpio_get_value(pdata->uok) ? false : true;
|
|
|
|
if (ta_in != data->ta_in) {
|
|
data->ta_in = ta_in;
|
|
dev_info(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ?
|
|
"Connected" : "Disconnected");
|
|
max8903_charger_update_status(data);
|
|
power_supply_changed(data->psy);
|
|
}
|
|
|
|
if (usb_in != data->usb_in) {
|
|
data->usb_in = usb_in;
|
|
dev_info(data->dev, "USB Charger %s.\n", usb_in ?
|
|
"Connected" : "Disconnected");
|
|
max8903_charger_update_status(data);
|
|
power_supply_changed(data->usb);
|
|
}
|
|
|
|
if (pdata->dc_valid && device_may_wakeup(&pdev->dev)) {
|
|
irq = gpio_to_irq(pdata->dok);
|
|
disable_irq_wake(irq);
|
|
}
|
|
if (pdata->usb_valid && device_may_wakeup(&pdev->dev)) {
|
|
irq = gpio_to_irq(pdata->uok);
|
|
disable_irq_wake(irq);
|
|
}
|
|
|
|
schedule_delayed_work(&data->work,
|
|
BATTERY_UPDATE_INTERVAL);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver max8903_driver = {
|
|
.probe = max8903_probe,
|
|
.remove = max8903_remove,
|
|
.suspend = max8903_suspend,
|
|
.resume = max8903_resume,
|
|
.driver = {
|
|
.name = "max8903-charger",
|
|
.owner = THIS_MODULE,
|
|
.of_match_table = max8903_dt_ids,
|
|
},
|
|
};
|
|
module_platform_driver(max8903_driver);
|
|
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_AUTHOR("Freescale Semiconductor, Inc.");
|
|
MODULE_DESCRIPTION("Sabresd Battery Driver");
|
|
MODULE_ALIAS("sabresd_battery");
|