mirror of
https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git
synced 2025-09-07 08:48:05 -04:00
640 lines
18 KiB
C
Executable file
640 lines
18 KiB
C
Executable file
/*
|
|
* sec_charging_common.h
|
|
* Samsung Mobile Charging Common Header
|
|
*
|
|
* Copyright (C) 2012 Samsung Electronics, Inc.
|
|
*
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
#ifndef __SEC_CHARGING_COMMON_H
|
|
#define __SEC_CHARGING_COMMON_H __FILE__
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/err.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/irq.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/i2c.h>
|
|
#include <linux/power_supply.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/device.h>
|
|
|
|
/* definitions */
|
|
#define SEC_SIZEOF_POWER_SUPPLY_TYPE POWER_SUPPLY_TYPE_WIRELESS_REMOVE
|
|
|
|
enum sec_battery_voltage_mode {
|
|
/* average voltage */
|
|
SEC_BATTERY_VOLTAGE_AVERAGE = 0,
|
|
/* open circuit voltage */
|
|
SEC_BATTERY_VOLTAGE_OCV,
|
|
};
|
|
|
|
enum sec_battery_current_mode {
|
|
/* uA */
|
|
SEC_BATTERY_CURRENT_UA = 0,
|
|
/* mA */
|
|
SEC_BATTERY_CURRENT_MA,
|
|
};
|
|
|
|
enum sec_battery_capacity_mode {
|
|
/* designed capacity */
|
|
SEC_BATTERY_CAPACITY_DESIGNED = 0,
|
|
/* absolute capacity by fuel gauge */
|
|
SEC_BATTERY_CAPACITY_ABSOLUTE,
|
|
/* temperary capacity in the time */
|
|
SEC_BATTERY_CAPACITY_TEMPERARY,
|
|
/* current capacity now */
|
|
SEC_BATTERY_CAPACITY_CURRENT,
|
|
};
|
|
|
|
/* ADC type */
|
|
enum sec_battery_adc_type {
|
|
/* NOT using this ADC channel */
|
|
SEC_BATTERY_ADC_TYPE_NONE = 0,
|
|
/* ADC in AP */
|
|
SEC_BATTERY_ADC_TYPE_AP,
|
|
/* ADC by additional IC */
|
|
SEC_BATTERY_ADC_TYPE_IC,
|
|
SEC_BATTERY_ADC_TYPE_NUM
|
|
};
|
|
|
|
enum sec_battery_adc_channel {
|
|
SEC_BAT_ADC_CHANNEL_CABLE_CHECK = 0,
|
|
SEC_BAT_ADC_CHANNEL_BAT_CHECK,
|
|
SEC_BAT_ADC_CHANNEL_TEMP,
|
|
SEC_BAT_ADC_CHANNEL_TEMP_AMBIENT,
|
|
SEC_BAT_ADC_CHANNEL_FULL_CHECK,
|
|
SEC_BAT_ADC_CHANNEL_VOLTAGE_NOW,
|
|
SEC_BAT_ADC_CHANNEL_NUM
|
|
};
|
|
|
|
/* charging mode */
|
|
enum sec_battery_charging_mode {
|
|
/* no charging */
|
|
SEC_BATTERY_CHARGING_NONE = 0,
|
|
/* 1st charging */
|
|
SEC_BATTERY_CHARGING_1ST,
|
|
/* 2nd charging */
|
|
SEC_BATTERY_CHARGING_2ND,
|
|
/* recharging */
|
|
SEC_BATTERY_CHARGING_RECHARGING,
|
|
};
|
|
|
|
struct sec_bat_adc_api {
|
|
bool (*init)(struct platform_device *);
|
|
bool (*exit)(void);
|
|
int (*read)(unsigned int);
|
|
};
|
|
#define sec_bat_adc_api_t struct sec_bat_adc_api
|
|
|
|
/* monitor activation */
|
|
enum sec_battery_polling_time_type {
|
|
/* same order with power supply status */
|
|
SEC_BATTERY_POLLING_TIME_BASIC = 0,
|
|
SEC_BATTERY_POLLING_TIME_CHARGING,
|
|
SEC_BATTERY_POLLING_TIME_DISCHARGING,
|
|
SEC_BATTERY_POLLING_TIME_NOT_CHARGING,
|
|
SEC_BATTERY_POLLING_TIME_SLEEP,
|
|
};
|
|
|
|
enum sec_battery_monitor_polling {
|
|
/* polling work queue */
|
|
SEC_BATTERY_MONITOR_WORKQUEUE,
|
|
/* alarm polling */
|
|
SEC_BATTERY_MONITOR_ALARM,
|
|
/* timer polling (NOT USE) */
|
|
SEC_BATTERY_MONITOR_TIMER,
|
|
};
|
|
#define sec_battery_monitor_polling_t \
|
|
enum sec_battery_monitor_polling
|
|
|
|
/* full charged check : POWER_SUPPLY_PROP_STATUS */
|
|
enum sec_battery_full_charged {
|
|
SEC_BATTERY_FULLCHARGED_NONE = 0,
|
|
/* current check by ADC */
|
|
SEC_BATTERY_FULLCHARGED_ADC,
|
|
/* fuel gauge current check */
|
|
SEC_BATTERY_FULLCHARGED_FG_CURRENT,
|
|
/* time check */
|
|
SEC_BATTERY_FULLCHARGED_TIME,
|
|
/* SOC check */
|
|
SEC_BATTERY_FULLCHARGED_SOC,
|
|
/* charger GPIO, NO additional full condition */
|
|
SEC_BATTERY_FULLCHARGED_CHGGPIO,
|
|
/* charger interrupt, NO additional full condition */
|
|
SEC_BATTERY_FULLCHARGED_CHGINT,
|
|
/* charger power supply property, NO additional full condition */
|
|
SEC_BATTERY_FULLCHARGED_CHGPSY,
|
|
};
|
|
#define sec_battery_full_charged_t \
|
|
enum sec_battery_full_charged
|
|
|
|
/* full check condition type (can be used overlapped) */
|
|
#define sec_battery_full_condition_t unsigned int
|
|
/* SEC_BATTERY_FULL_CONDITION_NOTIMEFULL
|
|
* full-charged by absolute-timer only in high voltage
|
|
*/
|
|
#define SEC_BATTERY_FULL_CONDITION_NOTIMEFULL 1
|
|
/* SEC_BATTERY_FULL_CONDITION_SLEEPINFULL
|
|
* change polling time as sleep polling time even in full-charged
|
|
*/
|
|
#define SEC_BATTERY_FULL_CONDITION_NOSLEEPINFULL 2
|
|
/* SEC_BATTERY_FULL_CONDITION_SOC
|
|
* use capacity for full-charged check
|
|
*/
|
|
#define SEC_BATTERY_FULL_CONDITION_SOC 4
|
|
/* SEC_BATTERY_FULL_CONDITION_VCELL
|
|
* use VCELL for full-charged check
|
|
*/
|
|
#define SEC_BATTERY_FULL_CONDITION_VCELL 8
|
|
/* SEC_BATTERY_FULL_CONDITION_AVGVCELL
|
|
* use average VCELL for full-charged check
|
|
*/
|
|
#define SEC_BATTERY_FULL_CONDITION_AVGVCELL 16
|
|
/* SEC_BATTERY_FULL_CONDITION_OCV
|
|
* use OCV for full-charged check
|
|
*/
|
|
#define SEC_BATTERY_FULL_CONDITION_OCV 32
|
|
|
|
/* recharge check condition type (can be used overlapped) */
|
|
#define sec_battery_recharge_condition_t unsigned int
|
|
/* SEC_BATTERY_RECHARGE_CONDITION_SOC
|
|
* use capacity for recharging check
|
|
*/
|
|
#define SEC_BATTERY_RECHARGE_CONDITION_SOC 1
|
|
/* SEC_BATTERY_RECHARGE_CONDITION_AVGVCELL
|
|
* use average VCELL for recharging check
|
|
*/
|
|
#define SEC_BATTERY_RECHARGE_CONDITION_AVGVCELL 2
|
|
/* SEC_BATTERY_RECHARGE_CONDITION_VCELL
|
|
* use VCELL for recharging check
|
|
*/
|
|
#define SEC_BATTERY_RECHARGE_CONDITION_VCELL 4
|
|
|
|
/* battery check : POWER_SUPPLY_PROP_PRESENT */
|
|
enum sec_battery_check {
|
|
/* No Check for internal battery */
|
|
SEC_BATTERY_CHECK_NONE,
|
|
/* by ADC */
|
|
SEC_BATTERY_CHECK_ADC,
|
|
/* by callback function (battery certification by 1 wired)*/
|
|
SEC_BATTERY_CHECK_CALLBACK,
|
|
/* by PMIC */
|
|
SEC_BATTERY_CHECK_PMIC,
|
|
/* by fuel gauge */
|
|
SEC_BATTERY_CHECK_FUELGAUGE,
|
|
/* by charger */
|
|
SEC_BATTERY_CHECK_CHARGER,
|
|
/* by interrupt (use check_battery_callback() to check battery) */
|
|
SEC_BATTERY_CHECK_INT,
|
|
};
|
|
#define sec_battery_check_t \
|
|
enum sec_battery_check
|
|
|
|
/* OVP, UVLO check : POWER_SUPPLY_PROP_HEALTH */
|
|
enum sec_battery_ovp_uvlo {
|
|
/* by callback function */
|
|
SEC_BATTERY_OVP_UVLO_CALLBACK,
|
|
/* by PMIC polling */
|
|
SEC_BATTERY_OVP_UVLO_PMICPOLLING,
|
|
/* by PMIC interrupt */
|
|
SEC_BATTERY_OVP_UVLO_PMICINT,
|
|
/* by charger polling */
|
|
SEC_BATTERY_OVP_UVLO_CHGPOLLING,
|
|
/* by charger interrupt */
|
|
SEC_BATTERY_OVP_UVLO_CHGINT,
|
|
};
|
|
#define sec_battery_ovp_uvlo_t \
|
|
enum sec_battery_ovp_uvlo
|
|
|
|
/* thermal source */
|
|
enum sec_battery_thermal_source {
|
|
/* by fuel gauge */
|
|
SEC_BATTERY_THERMAL_SOURCE_FG,
|
|
/* by external source */
|
|
SEC_BATTERY_THERMAL_SOURCE_CALLBACK,
|
|
/* by ADC */
|
|
SEC_BATTERY_THERMAL_SOURCE_ADC,
|
|
};
|
|
#define sec_battery_thermal_source_t \
|
|
enum sec_battery_thermal_source
|
|
|
|
/* temperature check type */
|
|
enum sec_battery_temp_check {
|
|
SEC_BATTERY_TEMP_CHECK_NONE = 0, /* no temperature check */
|
|
SEC_BATTERY_TEMP_CHECK_ADC, /* by ADC value */
|
|
SEC_BATTERY_TEMP_CHECK_TEMP, /* by temperature */
|
|
};
|
|
#define sec_battery_temp_check_t \
|
|
enum sec_battery_temp_check
|
|
|
|
/* cable check (can be used overlapped) */
|
|
#define sec_battery_cable_check_t unsigned int
|
|
/* SEC_BATTERY_CABLE_CHECK_NOUSBCHARGE
|
|
* for USB cable in tablet model,
|
|
* status is stuck into discharging,
|
|
* but internal charging logic is working
|
|
*/
|
|
#define SEC_BATTERY_CABLE_CHECK_NOUSBCHARGE 1
|
|
/* SEC_BATTERY_CABLE_CHECK_NOINCOMPATIBLECHARGE
|
|
* for incompatible charger
|
|
* (Not compliant to USB specification,
|
|
* cable type is POWER_SUPPLY_TYPE_UNKNOWN),
|
|
* do NOT charge and show message to user
|
|
* (only for VZW)
|
|
*/
|
|
#define SEC_BATTERY_CABLE_CHECK_NOINCOMPATIBLECHARGE 2
|
|
/* SEC_BATTERY_CABLE_CHECK_PSY
|
|
* check cable by power supply set_property
|
|
*/
|
|
#define SEC_BATTERY_CABLE_CHECK_PSY 4
|
|
/* SEC_BATTERY_CABLE_CHECK_INT
|
|
* check cable by interrupt
|
|
*/
|
|
#define SEC_BATTERY_CABLE_CHECK_INT 8
|
|
/* SEC_BATTERY_CABLE_CHECK_CHGINT
|
|
* check cable by charger interrupt
|
|
*/
|
|
#define SEC_BATTERY_CABLE_CHECK_CHGINT 16
|
|
/* SEC_BATTERY_CABLE_CHECK_POLLING
|
|
* check cable by GPIO polling
|
|
*/
|
|
#define SEC_BATTERY_CABLE_CHECK_POLLING 32
|
|
|
|
/* check cable source (can be used overlapped) */
|
|
#define sec_battery_cable_source_t unsigned int
|
|
/* SEC_BATTERY_CABLE_SOURCE_EXTERNAL
|
|
* already given by external argument
|
|
*/
|
|
#define SEC_BATTERY_CABLE_SOURCE_EXTERNAL 1
|
|
/* SEC_BATTERY_CABLE_SOURCE_CALLBACK
|
|
* by callback (MUIC, USB switch)
|
|
*/
|
|
#define SEC_BATTERY_CABLE_SOURCE_CALLBACK 2
|
|
/* SEC_BATTERY_CABLE_SOURCE_ADC
|
|
* by ADC
|
|
*/
|
|
#define SEC_BATTERY_CABLE_SOURCE_ADC 4
|
|
/* SEC_BATTERY_CABLE_SOURCE_EXTENDED
|
|
* use extended cable type
|
|
*/
|
|
#define SEC_BATTERY_CABLE_SOURCE_EXTENDED 8
|
|
|
|
/* capacity calculation type (can be used overlapped) */
|
|
#define sec_fuelgauge_capacity_type_t int
|
|
/* SEC_FUELGAUGE_CAPACITY_TYPE_RESET
|
|
* use capacity information to reset fuel gauge
|
|
* (only for driver algorithm, can NOT be set by user)
|
|
*/
|
|
#define SEC_FUELGAUGE_CAPACITY_TYPE_RESET (-1)
|
|
/* SEC_FUELGAUGE_CAPACITY_TYPE_RAW
|
|
* use capacity information from fuel gauge directly
|
|
*/
|
|
#define SEC_FUELGAUGE_CAPACITY_TYPE_RAW 1
|
|
/* SEC_FUELGAUGE_CAPACITY_TYPE_SCALE
|
|
* rescale capacity by scaling, need min and max value for scaling
|
|
*/
|
|
#define SEC_FUELGAUGE_CAPACITY_TYPE_SCALE 2
|
|
/* SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE
|
|
* change only maximum capacity dynamically
|
|
* to keep time for every SOC unit
|
|
*/
|
|
#define SEC_FUELGAUGE_CAPACITY_TYPE_DYNAMIC_SCALE 4
|
|
/* SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC
|
|
* change capacity value by only -1 or +1
|
|
* no sudden change of capacity
|
|
*/
|
|
#define SEC_FUELGAUGE_CAPACITY_TYPE_ATOMIC 8
|
|
/* SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL
|
|
* skip current capacity value
|
|
* if it is abnormal value
|
|
*/
|
|
#define SEC_FUELGAUGE_CAPACITY_TYPE_SKIP_ABNORMAL 16
|
|
|
|
/* charger function settings (can be used overlapped) */
|
|
#define sec_charger_functions_t unsigned int
|
|
/* SEC_CHARGER_NO_GRADUAL_CHARGING_CURRENT
|
|
* disable gradual charging current setting
|
|
* SUMMIT:AICL, MAXIM:regulation loop
|
|
*/
|
|
#define SEC_CHARGER_NO_GRADUAL_CHARGING_CURRENT 1
|
|
|
|
/* SEC_CHARGER_MINIMUM_SIOP_CHARGING_CURRENT
|
|
* charging current should be over than USB charging current
|
|
*/
|
|
#define SEC_CHARGER_MINIMUM_SIOP_CHARGING_CURRENT 2
|
|
|
|
/**
|
|
* struct sec_bat_adc_table_data - adc to temperature table for sec battery
|
|
* driver
|
|
* @adc: adc value
|
|
* @temperature: temperature(C) * 10
|
|
*/
|
|
|
|
struct sec_bat_adc_table_data {
|
|
#ifdef CONFIG_OF
|
|
int adc;
|
|
int data;
|
|
#else
|
|
int adc;
|
|
int data;
|
|
#endif
|
|
};
|
|
#define sec_bat_adc_table_data_t \
|
|
struct sec_bat_adc_table_data
|
|
|
|
struct sec_bat_adc_region {
|
|
int min;
|
|
int max;
|
|
};
|
|
#define sec_bat_adc_region_t \
|
|
struct sec_bat_adc_region
|
|
|
|
struct sec_charging_current {
|
|
#ifdef CONFIG_OF
|
|
unsigned int input_current_limit;
|
|
unsigned int fast_charging_current;
|
|
unsigned int full_check_current_1st;
|
|
unsigned int full_check_current_2nd;
|
|
#else
|
|
int input_current_limit;
|
|
int fast_charging_current;
|
|
int full_check_current_1st;
|
|
int full_check_current_2nd;
|
|
#endif
|
|
};
|
|
#define sec_charging_current_t \
|
|
struct sec_charging_current
|
|
|
|
struct sec_battery_platform_data {
|
|
/* NO NEED TO BE CHANGED */
|
|
/* callback functions */
|
|
void (*initial_check)(void);
|
|
void (*monitor_additional_check)(void);
|
|
bool (*bat_gpio_init)(void);
|
|
bool (*fg_gpio_init)(void);
|
|
bool (*chg_gpio_init)(void);
|
|
bool (*is_lpm)(void);
|
|
bool (*check_jig_status) (void);
|
|
bool (*is_interrupt_cable_check_possible)(int);
|
|
int (*check_cable_callback)(void);
|
|
int (*get_cable_from_extended_cable_type)(int);
|
|
bool (*cable_switch_check)(void);
|
|
bool (*cable_switch_normal)(void);
|
|
bool (*check_cable_result_callback)(int);
|
|
bool (*check_battery_callback)(void);
|
|
bool (*check_battery_result_callback)(void);
|
|
int (*ovp_uvlo_callback)(void);
|
|
bool (*ovp_uvlo_result_callback)(int);
|
|
bool (*fuelalert_process)(bool);
|
|
bool (*get_temperature_callback)(
|
|
enum power_supply_property,
|
|
union power_supply_propval*);
|
|
|
|
/* ADC API for each ADC type */
|
|
sec_bat_adc_api_t adc_api[SEC_BATTERY_ADC_TYPE_NUM];
|
|
/* ADC region by power supply type
|
|
* ADC region should be exclusive
|
|
*/
|
|
sec_bat_adc_region_t *cable_adc_value;
|
|
/* charging current for type (0: not use) */
|
|
sec_charging_current_t *charging_current;
|
|
#ifdef CONFIG_OF
|
|
unsigned int *polling_time;
|
|
char *chip_vendor;
|
|
unsigned int temp_adc_type;
|
|
#else
|
|
int *polling_time;
|
|
#endif
|
|
/* NO NEED TO BE CHANGED */
|
|
|
|
char *pmic_name;
|
|
|
|
/* battery */
|
|
char *vendor;
|
|
int technology;
|
|
int battery_type;
|
|
void *battery_data;
|
|
|
|
int bat_gpio_ta_nconnected;
|
|
/* 1 : active high, 0 : active low */
|
|
int bat_polarity_ta_nconnected;
|
|
int bat_irq;
|
|
int bat_irq_gpio;
|
|
unsigned long bat_irq_attr;
|
|
int jig_irq;
|
|
unsigned long jig_irq_attr;
|
|
sec_battery_cable_check_t cable_check_type;
|
|
sec_battery_cable_source_t cable_source_type;
|
|
|
|
bool use_LED; /* use charging LED */
|
|
|
|
bool event_check;
|
|
/* sustaining event after deactivated (second) */
|
|
unsigned int event_waiting_time;
|
|
|
|
/* Monitor setting */
|
|
sec_battery_monitor_polling_t polling_type;
|
|
/* for initial check */
|
|
unsigned int monitor_initial_count;
|
|
|
|
/* Battery check */
|
|
sec_battery_check_t battery_check_type;
|
|
/* how many times do we need to check battery */
|
|
unsigned int check_count;
|
|
/* ADC */
|
|
/* battery check ADC maximum value */
|
|
unsigned int check_adc_max;
|
|
/* battery check ADC minimum value */
|
|
unsigned int check_adc_min;
|
|
|
|
/* OVP/UVLO check */
|
|
sec_battery_ovp_uvlo_t ovp_uvlo_check_type;
|
|
|
|
sec_battery_thermal_source_t thermal_source;
|
|
#ifdef CONFIG_OF
|
|
sec_bat_adc_table_data_t *temp_adc_table;
|
|
sec_bat_adc_table_data_t *temp_amb_adc_table;
|
|
#else
|
|
const sec_bat_adc_table_data_t *temp_adc_table;
|
|
const sec_bat_adc_table_data_t *temp_amb_adc_table;
|
|
#endif
|
|
unsigned int temp_adc_table_size;
|
|
unsigned int temp_amb_adc_table_size;
|
|
|
|
sec_battery_temp_check_t temp_check_type;
|
|
unsigned int temp_check_count;
|
|
/*
|
|
* limit can be ADC value or Temperature
|
|
* depending on temp_check_type
|
|
* temperature should be temp x 10 (0.1 degree)
|
|
*/
|
|
int temp_highlimit_threshold_event;
|
|
int temp_highlimit_recovery_event;
|
|
int temp_high_threshold_event;
|
|
int temp_high_recovery_event;
|
|
int temp_low_threshold_event;
|
|
int temp_low_recovery_event;
|
|
int temp_highlimit_threshold_normal;
|
|
int temp_highlimit_recovery_normal;
|
|
int temp_high_threshold_normal;
|
|
int temp_high_recovery_normal;
|
|
int temp_low_threshold_normal;
|
|
int temp_low_recovery_normal;
|
|
int temp_highlimit_threshold_lpm;
|
|
int temp_highlimit_recovery_lpm;
|
|
int temp_high_threshold_lpm;
|
|
int temp_high_recovery_lpm;
|
|
int temp_low_threshold_lpm;
|
|
int temp_low_recovery_lpm;
|
|
|
|
/* If these is NOT full check type or NONE full check type,
|
|
* it is skipped
|
|
*/
|
|
/* 1st full check */
|
|
sec_battery_full_charged_t full_check_type;
|
|
/* 2nd full check */
|
|
sec_battery_full_charged_t full_check_type_2nd;
|
|
unsigned int full_check_count;
|
|
int chg_gpio_full_check;
|
|
/* 1 : active high, 0 : active low */
|
|
int chg_polarity_full_check;
|
|
sec_battery_full_condition_t full_condition_type;
|
|
unsigned int full_condition_soc;
|
|
unsigned int full_condition_vcell;
|
|
unsigned int full_condition_avgvcell;
|
|
unsigned int full_condition_ocv;
|
|
|
|
unsigned int recharge_check_count;
|
|
sec_battery_recharge_condition_t recharge_condition_type;
|
|
unsigned int recharge_condition_soc;
|
|
unsigned int recharge_condition_avgvcell;
|
|
unsigned int recharge_condition_vcell;
|
|
|
|
/* for absolute timer (second) */
|
|
unsigned long charging_total_time;
|
|
/* for recharging timer (second) */
|
|
unsigned long recharging_total_time;
|
|
/* reset charging for abnormal malfunction (0: not use) */
|
|
unsigned long charging_reset_time;
|
|
|
|
/* fuel gauge */
|
|
char *fuelgauge_name;
|
|
int fg_irq;
|
|
unsigned long fg_irq_attr;
|
|
/* fuel alert SOC (-1: not use) */
|
|
int fuel_alert_soc;
|
|
/* fuel alert can be repeated */
|
|
bool repeated_fuelalert;
|
|
sec_fuelgauge_capacity_type_t capacity_calculation_type;
|
|
/* soc should be soc x 10 (0.1% degree)
|
|
* only for scaling
|
|
*/
|
|
int capacity_max;
|
|
int capacity_max_margin;
|
|
int capacity_min;
|
|
|
|
/* charger */
|
|
char *charger_name;
|
|
int chg_gpio_en;
|
|
/* 1 : active high, 0 : active low */
|
|
int chg_polarity_en;
|
|
int chg_gpio_curr_adj;
|
|
/* 1 : active high, 0 : active low */
|
|
int chg_polarity_curr_adj;
|
|
int chg_gpio_status;
|
|
/* 1 : active high, 0 : active low */
|
|
int chg_polarity_status;
|
|
int chg_irq;
|
|
unsigned long chg_irq_attr;
|
|
/* float voltage (mV) */
|
|
#ifdef CONFIG_OF
|
|
unsigned int chg_float_voltage;
|
|
#else
|
|
int chg_float_voltage;
|
|
#endif
|
|
sec_charger_functions_t chg_functions_setting;
|
|
|
|
/* ADC setting */
|
|
unsigned int adc_check_count;
|
|
/* ADC type for each channel */
|
|
unsigned int adc_type[];
|
|
};
|
|
#define sec_battery_platform_data_t \
|
|
struct sec_battery_platform_data
|
|
|
|
static inline struct power_supply *get_power_supply_by_name(char *name)
|
|
{
|
|
if (!name)
|
|
return (struct power_supply *)NULL;
|
|
else
|
|
return power_supply_get_by_name(name);
|
|
}
|
|
|
|
#define psy_do_property(name, function, property, value) \
|
|
{ \
|
|
struct power_supply *psy; \
|
|
int ret; \
|
|
psy = get_power_supply_by_name((name)); \
|
|
if (!psy) { \
|
|
value.intval = 0; \
|
|
} else { \
|
|
ret = psy->function##_property(psy, (property), &(value)); \
|
|
if (ret < 0) { \
|
|
value.intval = 0; \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define psy_do_property_dup(name, function, property, value) \
|
|
{ \
|
|
int ret; \
|
|
psy = get_power_supply_by_name((name)); \
|
|
if (!psy) { \
|
|
value.intval = 0; \
|
|
} else { \
|
|
ret = psy->function##_property(psy, (property), &(value)); \
|
|
if (ret < 0) { \
|
|
value.intval = 0; \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#ifndef CONFIG_OF
|
|
#define adc_init(pdev, pdata, channel) \
|
|
(((pdata)->adc_api)[((((pdata)->adc_type[(channel)]) < \
|
|
SEC_BATTERY_ADC_TYPE_NUM) ? ((pdata)->adc_type[(channel)]) : \
|
|
SEC_BATTERY_ADC_TYPE_NONE)].init((pdev)))
|
|
|
|
#define adc_exit(pdata, channel) \
|
|
(((pdata)->adc_api)[((pdata)->adc_type[(channel)])].exit())
|
|
|
|
#define adc_read(pdata, channel) \
|
|
(((pdata)->adc_api)[((pdata)->adc_type[(channel)])].read((channel)))
|
|
#endif
|
|
|
|
#define get_battery_data(driver) \
|
|
(((struct battery_data_t *)(driver)->pdata->battery_data) \
|
|
[(driver)->pdata->battery_type])
|
|
|
|
#define GET_MAIN_CABLE_TYPE(extended) \
|
|
((extended >> ONLINE_TYPE_MAIN_SHIFT)&0xf)
|
|
#define GET_SUB_CABLE_TYPE(extended) \
|
|
((extended >> ONLINE_TYPE_SUB_SHIFT)&0xf)
|
|
#define GET_POWER_CABLE_TYPE(extended) \
|
|
((extended >> ONLINE_TYPE_PWR_SHIFT)&0xf)
|
|
|
|
#endif /* __SEC_CHARGING_COMMON_H */
|