static int sec_chg_get_property(struct power_supply *psy,
			    enum power_supply_property psp,
			    union power_supply_propval *val)
{
	struct sec_charger_info *charger =
		container_of(psy, struct sec_charger_info, psy_chg);

	switch (psp) {
	case POWER_SUPPLY_PROP_CURRENT_MAX:	/* input current limit set */
		val->intval = charger->charging_current_max;
		break;

	case POWER_SUPPLY_PROP_ONLINE:
	case POWER_SUPPLY_PROP_STATUS:
	case POWER_SUPPLY_PROP_CHARGE_TYPE:
	case POWER_SUPPLY_PROP_HEALTH:
	case POWER_SUPPLY_PROP_CURRENT_AVG:	/* charging current */
	/* calculated input current limit value */
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		if (!sec_hal_chg_get_property(charger_variable, psp, val))
			return -EINVAL;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}
static int sec_chg_get_property(struct power_supply *psy,
                                enum power_supply_property psp,
                                union power_supply_propval *val)
{
    struct sec_charger_info *charger =
        container_of(psy, struct sec_charger_info, psy_chg);

    switch (psp) {
    case POWER_SUPPLY_PROP_ONLINE:
        val->intval = charger->charging_current ? 1 : 0;
        break;
    case POWER_SUPPLY_PROP_STATUS:
    case POWER_SUPPLY_PROP_HEALTH:
    case POWER_SUPPLY_PROP_CURRENT_NOW:
        if (!sec_hal_chg_get_property(charger->client, psp, val))
            return -EINVAL;
        break;
    default:
        return -EINVAL;
    }
    return 0;
}
static void sec_chg_isr_work(struct work_struct *work)
{
    struct sec_charger_info *charger =
        container_of(work, struct sec_charger_info, isr_work.work);
    union power_supply_propval val;

    dev_info(&charger->client->dev,
             "%s: Charger Interrupt\n", __func__);

    if (charger->pdata->full_check_type ==
            SEC_BATTERY_FULLCHARGED_CHGINT) {
        if (!sec_hal_chg_get_property(charger->client,
                                      POWER_SUPPLY_PROP_STATUS, &val))
            return;

        switch (val.intval) {
        case POWER_SUPPLY_STATUS_DISCHARGING:
            dev_err(&charger->client->dev,
                    "%s: Interrupted but Discharging\n", __func__);
            break;

        case POWER_SUPPLY_STATUS_NOT_CHARGING:
            dev_err(&charger->client->dev,
                    "%s: Interrupted but NOT Charging\n", __func__);
            break;

        case POWER_SUPPLY_STATUS_FULL:
            dev_info(&charger->client->dev,
                     "%s: Interrupted by Full\n", __func__);
            psy_do_property("battery", set,
                            POWER_SUPPLY_PROP_STATUS, val);
            break;

        case POWER_SUPPLY_STATUS_CHARGING:
            dev_err(&charger->client->dev,
                    "%s: Interrupted but Charging\n", __func__);
            break;

        case POWER_SUPPLY_STATUS_UNKNOWN:
        default:
            dev_err(&charger->client->dev,
                    "%s: Invalid Charger Status\n", __func__);
            break;
        }
    }

    if (charger->pdata->ovp_uvlo_check_type ==
            SEC_BATTERY_OVP_UVLO_CHGINT) {
        if (!sec_hal_chg_get_property(charger->client,
                                      POWER_SUPPLY_PROP_HEALTH, &val))
            return;

        switch (val.intval) {
        case POWER_SUPPLY_HEALTH_OVERHEAT:
        case POWER_SUPPLY_HEALTH_COLD:
            dev_err(&charger->client->dev,
                    "%s: Interrupted but Hot/Cold\n", __func__);
            break;

        case POWER_SUPPLY_HEALTH_DEAD:
            dev_err(&charger->client->dev,
                    "%s: Interrupted but Dead\n", __func__);
            break;

        case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
        case POWER_SUPPLY_HEALTH_UNDERVOLTAGE:
            dev_info(&charger->client->dev,
                     "%s: Interrupted by OVP/UVLO\n", __func__);
            psy_do_property("battery", set,
                            POWER_SUPPLY_PROP_HEALTH, val);
            break;

        case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
            dev_err(&charger->client->dev,
                    "%s: Interrupted but Unspec\n", __func__);
            break;

        case POWER_SUPPLY_HEALTH_GOOD:
            dev_err(&charger->client->dev,
                    "%s: Interrupted but Good\n", __func__);
            break;

        case POWER_SUPPLY_HEALTH_UNKNOWN:
        default:
            dev_err(&charger->client->dev,
                    "%s: Invalid Charger Health\n", __func__);
            break;
        }
    }
}
static void sec_chg_isr_work(struct work_struct *work)
{
	struct sec_charger_info *charger =
		container_of(work, struct sec_charger_info, isr_work.work);
	union power_supply_propval val;
	int full_check_type;

	dev_info(&charger->client->dev,
		"%s: Charger Interrupt\n", __func__);

	psy_do_property("battery", get,
		POWER_SUPPLY_PROP_CHARGE_NOW, val);
	if (val.intval == SEC_BATTERY_CHARGING_1ST)
		full_check_type = charger->pdata->full_check_type;
	else
		full_check_type = charger->pdata->full_check_type_2nd;

	if (full_check_type == SEC_BATTERY_FULLCHARGED_CHGINT) {
		if (!sec_hal_chg_get_property(charger_variable,
			POWER_SUPPLY_PROP_STATUS, &val))
			return;

		switch (val.intval) {
		case POWER_SUPPLY_STATUS_DISCHARGING:
			dev_err(&charger->client->dev,
				"%s: Interrupted but Discharging\n", __func__);
			break;

		case POWER_SUPPLY_STATUS_NOT_CHARGING:
			dev_err(&charger->client->dev,
				"%s: Interrupted but NOT Charging\n", __func__);
			break;

		case POWER_SUPPLY_STATUS_FULL:
			dev_info(&charger->client->dev,
				"%s: Interrupted by Full\n", __func__);
			psy_do_property("battery", set,
				POWER_SUPPLY_PROP_STATUS, val);
			break;

		case POWER_SUPPLY_STATUS_CHARGING:
			dev_err(&charger->client->dev,
				"%s: Interrupted but Charging\n", __func__);
			break;

		case POWER_SUPPLY_STATUS_UNKNOWN:
		default:
			dev_err(&charger->client->dev,
				"%s: Invalid Charger Status\n", __func__);
			break;
		}
	}

	if (charger->pdata->ovp_uvlo_check_type ==
		SEC_BATTERY_OVP_UVLO_CHGINT) {
		if (!sec_hal_chg_get_property(charger_variable,
			POWER_SUPPLY_PROP_HEALTH, &val))
			return;

		switch (val.intval) {
		case POWER_SUPPLY_HEALTH_OVERHEAT:
		case POWER_SUPPLY_HEALTH_COLD:
			dev_err(&charger->client->dev,
				"%s: Interrupted but Hot/Cold\n", __func__);
			break;

		case POWER_SUPPLY_HEALTH_DEAD:
			dev_err(&charger->client->dev,
				"%s: Interrupted but Dead\n", __func__);
			break;

		case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
		case POWER_SUPPLY_HEALTH_UNDERVOLTAGE:
			dev_info(&charger->client->dev,
				"%s: Interrupted by OVP/UVLO\n", __func__);
			psy_do_property("battery", set,
				POWER_SUPPLY_PROP_HEALTH, val);
			break;

		case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
			dev_err(&charger->client->dev,
				"%s: Interrupted but Unspec\n", __func__);
			break;

		case POWER_SUPPLY_HEALTH_GOOD:
			dev_err(&charger->client->dev,
				"%s: Interrupted but Good\n", __func__);
			break;

		case POWER_SUPPLY_HEALTH_UNKNOWN:
		default:
			dev_err(&charger->client->dev,
				"%s: Invalid Charger Health\n", __func__);
			break;
		}
	}

	if (charger->pdata->cable_check_type & SEC_BATTERY_CABLE_CHECK_CHGINT) {
		if (!sec_hal_chg_get_property(charger_variable,
			POWER_SUPPLY_PROP_ONLINE, &val))
			return;

		/* use SEC_BATTERY_CABLE_SOURCE_EXTERNAL for cable_source_type
		 * charger would call battery driver to set ONLINE property
		 * check battery driver loaded or not
		 */
		if (get_power_supply_by_name("battery")) {
			psy_do_property("battery", set,
				POWER_SUPPLY_PROP_ONLINE, val);
		} else
			charger->pdata->check_cable_result_callback(val.intval);
	}
}