/*
 * Copyright (C) 2011 Samsung Electronics Co., Ltd.
 * MyungJoo.Ham <myungjoo.ham@samsung.com>
 *
 * Charger Manager.
 * This framework enables to control and multiple chargers and to
 * monitor charging even in the context of suspend-to-RAM with
 * an interface combining the chargers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
**/

#ifndef _CHARGER_MANAGER_H
#define _CHARGER_MANAGER_H

#include <linux/power_supply.h>
#include <linux/extcon.h>

enum data_source {
        CM_BATTERY_PRESENT,
        CM_NO_BATTERY,
        CM_FUEL_GAUGE,
        CM_CHARGER_STAT,
};

enum polling_modes {
        CM_POLL_DISABLE = 0,
        CM_POLL_ALWAYS,
        CM_POLL_EXTERNAL_POWER_ONLY,
        CM_POLL_CHARGING_ONLY,
};

enum cm_event_types {
        CM_EVENT_UNKNOWN = 0,
        CM_EVENT_BATT_FULL,
        CM_EVENT_BATT_IN,
        CM_EVENT_BATT_OUT,
        CM_EVENT_EXT_PWR_IN_OUT,
        CM_EVENT_CHG_START_STOP,
        CM_EVENT_OTHERS,
};

/**
 * struct charger_global_desc
 * @rtc_name: the name of RTC used to wake up the system from suspend.
 * @rtc_only_wakeup:
 *      If the system is woken up by waekup-sources other than the RTC or
 *      callbacks, Charger Manager should recognize with
 *      rtc_only_wakeup() returning false.
 *      If the RTC given to CM is the only wakeup reason,
 *      rtc_only_wakeup should return true.
 * @assume_timer_stops_in_suspend:
 *      Assume that the jiffy timer stops in suspend-to-RAM.
 *      When enabled, CM does not rely on jiffies value in
 *      suspend_again and assumes that jiffies value does not
 *      change during suspend.
 */
struct charger_global_desc {
        char *rtc_name;

        bool (*rtc_only_wakeup)(void);

        bool assume_timer_stops_in_suspend;
};

/**
 * struct charger_cable
 * @extcon_name: the name of extcon device.
 * @name: the name of charger cable(external connector).
 * @extcon_dev: the extcon device.
 * @wq: the workqueue to control charger according to the state of
 *      charger cable. If charger cable is attached, enable charger.
 *      But if charger cable is detached, disable charger.
 * @nb: the notifier block to receive changed state from EXTCON
 *      (External Connector) when charger cable is attached/detached.
 * @attached: the state of charger cable.
 *      true: the charger cable is attached
 *      false: the charger cable is detached
 * @charger: the instance of struct charger_regulator.
 * @cm: the Charger Manager representing the battery.
 */
struct charger_cable {
        const char *extcon_name;
        const char *name;

        /* The charger-manager use Exton framework*/
        struct extcon_specific_cable_nb extcon_dev;
        struct work_struct wq;
        struct notifier_block nb;

        /* The state of charger cable */
        bool attached;

        struct charger_regulator *charger;

        /*
         * Set min/max current of regulator to protect over-current issue
         * according to a kind of charger cable when cable is attached.
         */
        int min_uA;
        int max_uA;

        struct charger_manager *cm;
};

/**
 * struct charger_regulator
 * @regulator_name: the name of regulator for using charger.
 * @consumer: the regulator consumer for the charger.
 * @externally_control:
 *      Set if the charger-manager cannot control charger,
 *      the charger will be maintained with disabled state.
 * @cables:
 *      the array of charger cables to enable/disable charger
 *      and set current limit according to constratint data of
 *      struct charger_cable if only charger cable included
 *      in the array of charger cables is attached/detached.
 * @num_cables: the number of charger cables.
 * @attr_g: Attribute group for the charger(regulator)
 * @attr_name: "name" sysfs entry
 * @attr_state: "state" sysfs entry
 * @attr_externally_control: "externally_control" sysfs entry
 * @attrs: Arrays pointing to attr_name/state/externally_control for attr_g
 */
struct charger_regulator {
        /* The name of regulator for charging */
        const char *regulator_name;
        struct regulator *consumer;

        /* charger never on when system is on */
        int externally_control;

        /*
         * Store constraint information related to current limit,
         * each cable have different condition for charging.
         */
        struct charger_cable *cables;
        int num_cables;

        struct attribute_group attr_g;
        struct device_attribute attr_name;
        struct device_attribute attr_state;
        struct device_attribute attr_externally_control;
        struct attribute *attrs[4];

        struct charger_manager *cm;
};

/**
 * struct charger_desc
 * @psy_name: the name of power-supply-class for charger manager
 * @polling_mode:
 *      Determine which polling mode will be used
 * @fullbatt_vchkdrop_ms:
 * @fullbatt_vchkdrop_uV:
 *      Check voltage drop after the battery is fully charged.
 *      If it has dropped more than fullbatt_vchkdrop_uV after
 *      fullbatt_vchkdrop_ms, CM will restart charging.
 * @fullbatt_uV: voltage in microvolt
 *      If VBATT >= fullbatt_uV, it is assumed to be full.
 * @fullbatt_soc: state of Charge in %
 *      If state of Charge >= fullbatt_soc, it is assumed to be full.
 * @fullbatt_full_capacity: full capacity measure
 *      If full capacity of battery >= fullbatt_full_capacity,
 *      it is assumed to be full.
 * @polling_interval_ms: interval in millisecond at which
 *      charger manager will monitor battery health
 * @battery_present:
 *      Specify where information for existance of battery can be obtained
 * @psy_charger_stat: the names of power-supply for chargers
 * @num_charger_regulator: the number of entries in charger_regulators
 * @charger_regulators: array of charger regulators
 * @psy_fuel_gauge: the name of power-supply for fuel gauge
 * @temperature_out_of_range:
 *      Determine whether the status is overheat or cold or normal.
 *      return_value > 0: overheat
 *      return_value == 0: normal
 *      return_value < 0: cold
 * @measure_battery_temp:
 *      true: measure battery temperature
 *      false: measure ambient temperature
 * @charging_max_duration_ms: Maximum possible duration for charging
 *      If whole charging duration exceed 'charging_max_duration_ms',
 *      cm stop charging.
 * @discharging_max_duration_ms:
 *      Maximum possible duration for discharging with charger cable
 *      after full-batt. If discharging duration exceed 'discharging
 *      max_duration_ms', cm start charging.
 */
struct charger_desc {
        char *psy_name;

        enum polling_modes polling_mode;
        unsigned int polling_interval_ms;

        unsigned int fullbatt_vchkdrop_ms;
        unsigned int fullbatt_vchkdrop_uV;
        unsigned int fullbatt_uV;
        unsigned int fullbatt_soc;
        unsigned int fullbatt_full_capacity;

        enum data_source battery_present;

        char **psy_charger_stat;

        int num_charger_regulators;
        struct charger_regulator *charger_regulators;

        char *psy_fuel_gauge;

        int (*temperature_out_of_range)(int *mC);
        bool measure_battery_temp;

        u64 charging_max_duration_ms;
        u64 discharging_max_duration_ms;
};

#define PSY_NAME_MAX    30

/**
 * struct charger_manager
 * @entry: entry for list
 * @dev: device pointer
 * @desc: instance of charger_desc
 * @fuel_gauge: power_supply for fuel gauge
 * @charger_stat: array of power_supply for chargers
 * @charger_enabled: the state of charger
 * @fullbatt_vchk_jiffies_at:
 *      jiffies at the time full battery check will occur.
 * @fullbatt_vchk_work: work queue for full battery check
 * @emergency_stop:
 *      When setting true, stop charging
 * @last_temp_mC: the measured temperature in milli-Celsius
 * @psy_name_buf: the name of power-supply-class for charger manager
 * @charger_psy: power_supply for charger manager
 * @status_save_ext_pwr_inserted:
 *      saved status of external power before entering suspend-to-RAM
 * @status_save_batt:
 *      saved status of battery before entering suspend-to-RAM
 * @charging_start_time: saved start time of enabling charging
 * @charging_end_time: saved end time of disabling charging
 */
struct charger_manager {
        struct list_head entry;
        struct device *dev;
        struct charger_desc *desc;

        struct power_supply *fuel_gauge;
        struct power_supply **charger_stat;

        bool charger_enabled;

        unsigned long fullbatt_vchk_jiffies_at;
        struct delayed_work fullbatt_vchk_work;

        int emergency_stop;
        int last_temp_mC;

        char psy_name_buf[PSY_NAME_MAX + 1];
        struct power_supply charger_psy;

        bool status_save_ext_pwr_inserted;
        bool status_save_batt;

        u64 charging_start_time;
        u64 charging_end_time;
};

#ifdef CONFIG_CHARGER_MANAGER
extern int setup_charger_manager(struct charger_global_desc *gd);
extern bool cm_suspend_again(void);
extern void cm_notify_event(struct power_supply *psy,
                                enum cm_event_types type, char *msg);
#else
static inline int setup_charger_manager(struct charger_global_desc *gd)
{ return 0; }
static inline bool cm_suspend_again(void) { return false; }
static inline void cm_notify_event(struct power_supply *psy,
                                enum cm_event_types type, char *msg) { }
#endif
#endif /* _CHARGER_MANAGER_H */