/* drivers/battery/s2mu003_charger.c * S2MU003 Charger Driver * * Copyright (C) 2013 * Author: Patrick Chang * * 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; either version 2 * of the License, or (at your option) any later version. */ #include #include #include #define ENABLE_MIVR 0 #define EN_OVP_IRQ 1 #define EN_IEOC_IRQ 1 #define EN_RECHG_REQ_IRQ 0 #define EN_TR_IRQ 0 #define EN_MIVR_SW_REGULATION 0 #define EN_BST_IRQ 0 #define MINVAL(a, b) ((a <= b) ? a : b) #define EOC_DEBOUNCE_CNT 2 #define HEALTH_DEBOUNCE_CNT 3 #define EOC_SLEEP 200 #define EOC_TIMEOUT (EOC_SLEEP * 6) #ifndef EN_TEST_READ #define EN_TEST_READ 0 #endif static int s2mu003_reg_map[] = { S2MU003_CHG_STATUS1, S2MU003_CHG_CTRL1, S2MU003_CHG_CTRL2, S2MU003_CHG_CTRL3, S2MU003_CHG_CTRL4, S2MU003_CHG_CTRL5, S2MU003_SOFTRESET, S2MU003_CHG_CTRL6, S2MU003_CHG_CTRL7, S2MU003_CHG_CTRL8, S2MU003_CHG_STATUS2, S2MU003_CHG_STATUS3, S2MU003_CHG_STATUS4, S2MU003_CHG_CTRL9, }; struct s2mu003_charger_data { struct i2c_client *client; s2mu003_mfd_chip_t *s2mu003; struct power_supply psy_chg; s2mu003_charger_platform_data_t *pdata; int charging_current; int siop_level; int cable_type; bool is_charging; struct mutex io_lock; /* register programming */ int reg_addr; int reg_data; bool full_charged; bool ovp; int unhealth_cnt; int status; }; static enum power_supply_property sec_charger_props[] = { POWER_SUPPLY_PROP_STATUS, POWER_SUPPLY_PROP_CHARGE_TYPE, POWER_SUPPLY_PROP_HEALTH, POWER_SUPPLY_PROP_ONLINE, POWER_SUPPLY_PROP_CURRENT_MAX, POWER_SUPPLY_PROP_CURRENT_AVG, POWER_SUPPLY_PROP_CURRENT_NOW, POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL, }; static int s2mu003_get_charging_health(struct s2mu003_charger_data *charger); static void s2mu003_read_regs(struct i2c_client *i2c, char *str) { u8 data = 0; int i = 0; for (i = 0; i < ARRAY_SIZE(s2mu003_reg_map); i++) { data = s2mu003_reg_read(i2c, s2mu003_reg_map[i]); sprintf(str+strlen(str), "0x%02x, ", data); } } static void s2mu003_test_read(struct i2c_client *i2c) { int data; char str[1024] = {0,}; int i; /* S2MU003 REG: 0x00 ~ 0x08 */ for (i = 0x0; i <= 0x0E; i++) { data = s2mu003_reg_read(i2c, i); sprintf(str+strlen(str), "0x%02x, ", data); } pr_info("%s: %s\n", __func__, str); } static void s2mu003_charger_otg_control(struct s2mu003_charger_data *charger, bool enable) { pr_info("%s: called charger otg control : %s\n", __func__, enable ? "on" : "off"); if (!enable) { /* turn off OTG */ s2mu003_clr_bits(charger->client, S2MU003_CHG_CTRL1, S2MU003_OPAMODE_MASK); s2mu003_clr_bits(charger->client, S2MU003_CHG_CTRL8, 0x80); } else { /* Set OTG boost vout = 5V, turn on OTG */ s2mu003_assign_bits(charger->client, S2MU003_CHG_CTRL2, S2MU003_VOREG_MASK, 0x23 << S2MU003_VOREG_SHIFT); s2mu003_set_bits(charger->client, S2MU003_CHG_CTRL1, S2MU003_OPAMODE_MASK); s2mu003_set_bits(charger->client, S2MU003_CHG_CTRL8, 0x80); charger->cable_type = POWER_SUPPLY_TYPE_OTG; } } /* this function will work well on CHIP_REV = 3 or later */ static void s2mu003_enable_charger_switch(struct s2mu003_charger_data *charger, int onoff) { int prev_charging_status = charger->is_charging; union power_supply_propval val; charger->is_charging = onoff ? true : false; if ((onoff > 0) && (prev_charging_status == false)) { pr_info("%s: turn on charger\n", __func__); s2mu003_set_bits(charger->client, S2MU003_CHG_CTRL3, S2MU003_CHG_EN_MASK); } else if (onoff == 0) { psy_do_property("battery", get, POWER_SUPPLY_PROP_STATUS, val); if (val.intval != POWER_SUPPLY_STATUS_FULL) charger->full_charged = false; pr_info("%s: turn off charger\n", __func__); charger->charging_current = 0; s2mu003_clr_bits(charger->client, S2MU003_CHG_CTRL3, S2MU003_CHG_EN_MASK); } else { pr_info("%s: repeated to set charger switch(%d), prev stat = %d\n", __func__, onoff, prev_charging_status ? 1 : 0); } } static void s2mu003_enable_charging_termination(struct i2c_client *i2c, int onoff) { pr_info("%s:[BATT] Do termination set(%d)\n", __func__, onoff); if (onoff) s2mu003_set_bits(i2c, S2MU003_CHG_CTRL1, S2MU003_TEEN_MASK); else s2mu003_clr_bits(i2c, S2MU003_CHG_CTRL1, S2MU003_TEEN_MASK); } static int s2mu003_input_current_limit[] = { 100, 500, 700, 900, 1000, 1500, 2000, }; static void s2mu003_set_input_current_limit(struct s2mu003_charger_data *charger, int current_limit) { int i = 0, curr_reg = 0; for (i = 0; i < ARRAY_SIZE(s2mu003_input_current_limit); i++) { if (current_limit <= s2mu003_input_current_limit[i]) curr_reg = i+1; } if (curr_reg < 0) curr_reg = 0; mutex_lock(&charger->io_lock); s2mu003_assign_bits(charger->client, S2MU003_CHG_CTRL1, S2MU003_AICR_LIMIT_MASK, curr_reg << S2MU003_AICR_LIMIT_SHIFT); mutex_unlock(&charger->io_lock); } static int s2mu003_get_input_current_limit(struct i2c_client *i2c) { int ret; ret = s2mu003_reg_read(i2c, S2MU003_CHG_CTRL1); if (ret < 0) return ret; ret &= S2MU003_AICR_LIMIT_MASK; ret >>= S2MU003_AICR_LIMIT_SHIFT; if (ret == 0) return 2000 + 1; /* no limitation */ return s2mu003_input_current_limit[ret - 1]; } static void s2mu003_set_regulation_voltage(struct s2mu003_charger_data *charger, int float_voltage) { int data; if (float_voltage < 3650) data = 0; else if (float_voltage >= 3650 && float_voltage <= 4375) data = (float_voltage - 3650) / 25; else data = 0x23; mutex_lock(&charger->io_lock); s2mu003_assign_bits(charger->client, S2MU003_CHG_CTRL2, S2MU003_VOREG_MASK, data << S2MU003_VOREG_SHIFT); mutex_unlock(&charger->io_lock); } static void s2mu003_set_fast_charging_current(struct i2c_client *i2c, int charging_current) { int data; if (charging_current < 700) data = 0; else if (charging_current >= 700 && charging_current <= 2000) data = (charging_current - 700) / 100; else data = 0xd; s2mu003_assign_bits(i2c, S2MU003_CHG_CTRL5, S2MU003_ICHRG_MASK, data << S2MU003_ICHRG_SHIFT); } static int s2mu003_eoc_level[] = { 0, 150, 200, 250, 300, 400, 500, 600, }; static int s2mu003_get_eoc_level(int eoc_current) { int i; for (i = 0; i < ARRAY_SIZE(s2mu003_eoc_level); i++) { if (eoc_current < s2mu003_eoc_level[i]) { if (i == 0) return 0; return i - 1; } } return ARRAY_SIZE(s2mu003_eoc_level) - 1; } static int s2mu003_get_current_eoc_setting(struct s2mu003_charger_data *charger) { int ret; mutex_lock(&charger->io_lock); ret = s2mu003_reg_read(charger->client, S2MU003_CHG_CTRL4); mutex_unlock(&charger->io_lock); if (ret < 0) { pr_info("%s: warning --> fail to read i2c register(%d)\n", __func__, ret); return ret; } return s2mu003_eoc_level[(S2MU003_IEOC_MASK & ret) >> S2MU003_IEOC_SHIFT]; } static int s2mu003_get_fast_charging_current(struct i2c_client *i2c) { int data = s2mu003_reg_read(i2c, S2MU003_CHG_CTRL5); if (data < 0) return data; data = (data >> 4) & 0x0f; if (data > 0xd) data = 0xd; return data * 100 + 700; } static void s2mu003_set_termination_current_limit(struct i2c_client *i2c, int current_limit) { int data = s2mu003_get_eoc_level(current_limit); int ret; pr_info("%s : Set Termination\n", __func__); ret = s2mu003_assign_bits(i2c, S2MU003_CHG_CTRL4, S2MU003_IEOC_MASK, data << S2MU003_IEOC_SHIFT); /* reset chg_en */ s2mu003_clr_bits(i2c, S2MU003_CHG_CTRL3, S2MU003_CHG_EN_MASK); s2mu003_set_bits(i2c, S2MU003_CHG_CTRL3, S2MU003_CHG_EN_MASK); } /* eoc re set */ static void s2mu003_set_charging_current(struct s2mu003_charger_data *charger, int eoc) { int adj_current = 0; adj_current = charger->charging_current * charger->siop_level / 100; mutex_lock(&charger->io_lock); s2mu003_set_fast_charging_current(charger->client, adj_current); if (eoc) { /* set EOC RESET */ s2mu003_set_termination_current_limit(charger->client, eoc); } mutex_unlock(&charger->io_lock); } enum { S2MU003_MIVR_DISABLE = 0, S2MU003_MIVR_4200MV, S2MU003_MIVR_4300MV, S2MU003_MIVR_4400MV, S2MU003_MIVR_4500MV, S2MU003_MIVR_4600MV, S2MU003_MIVR_4700MV, S2MU003_MIVR_4800MV, }; #if ENABLE_MIVR /* charger input regulation voltage setting */ static void s2mu003_set_mivr_level(struct s2mu003_charger_data *charger) { int mivr; switch (charger->cable_type) { case POWER_SUPPLY_TYPE_USB ... POWER_SUPPLY_TYPE_USB_ACA: mivr = S2MU003_MIVR_4600MV; break; default: mivr = S2MU003_MIVR_DISABLE; } mutex_lock(&charger->io_lock); s2mu003_assign_bits(charger->i2c_client, S2MU003_CHG_CTRL4, S2MU003_MIVR_MASK, mivr << S2MU003_MIVR_SHIFT); mutex_unlock(&charger->io_lock); } #endif /*ENABLE_MIVR*/ static void s2mu003_configure_charger(struct s2mu003_charger_data *charger) { int eoc; union power_supply_propval val; pr_info("%s : Set config charging\n", __func__); if (charger->charging_current < 0) { pr_info("%s : OTG is activated. Ignore command!\n", __func__); return; } #if ENABLE_MIVR s2mu003_set_mivr_level(charger); #endif /*DISABLE_MIVR*/ psy_do_property("battery", get, POWER_SUPPLY_PROP_CHARGE_NOW, val); /* TEMP_TEST : disable charging current termination for 2nd charging */ /* s2mu003_enable_charging_termination(charger->s2mu003->i2c_client, 1);*/ /* Input current limit */ pr_info("%s : input current (%dmA)\n", __func__, charger->pdata->charging_current_table [charger->cable_type].input_current_limit); s2mu003_set_input_current_limit(charger, charger->pdata->charging_current_table [charger->cable_type].input_current_limit); /* Float voltage */ pr_info("%s : float voltage (%dmV)\n", __func__, charger->pdata->chg_float_voltage); s2mu003_set_regulation_voltage(charger, charger->pdata->chg_float_voltage); charger->charging_current = charger->pdata->charging_current_table [charger->cable_type].fast_charging_current; eoc = charger->pdata->charging_current_table [charger->cable_type].full_check_current_1st; /* Fast charge and Termination current */ pr_info("%s : fast charging current (%dmA)\n", __func__, charger->charging_current); pr_info("%s : termination current (%dmA)\n", __func__, eoc); s2mu003_set_charging_current(charger, eoc); s2mu003_enable_charger_switch(charger, 1); } /* here is set init charger data */ static bool s2mu003_chg_init(struct s2mu003_charger_data *charger) { int ret = 0, rev_id; s2mu003_set_bits(charger->client, 0x6b, 0x01); /* delay 100 us to wait for normal read (from e-fuse) */ msleep(20); ret = s2mu003_reg_read(charger->client, 0x03); s2mu003_clr_bits(charger->client, 0x6b, 0x01); if (ret < 0) pr_err("%s : failed to read revision ID\n", __func__); rev_id = ret & 0x0f; if (charger->pdata->is_750kHz_switching) ret = s2mu003_clr_bits(charger->client, S2MU003_CHG_CTRL1, S2MU003_SEL_SWFREQ_MASK); else ret = s2mu003_set_bits(charger->client, S2MU003_CHG_CTRL1, S2MU003_SEL_SWFREQ_MASK); /* Disable Timer function (Charging timeout fault) */ s2mu003_clr_bits(charger->client, S2MU003_CHG_CTRL3, S2MU003_TIMEREN_MASK); s2mu003_clr_bits(charger->client, S2MU003_CHG_CTRL3, S2MU003_CHG_EN_MASK); s2mu003_set_bits(charger->client, S2MU003_CHG_CTRL3, S2MU003_CHG_EN_MASK); /* Disable TE */ s2mu003_enable_charging_termination(charger->client, 0); /* EMI improvement , let reg0x18 bit2~5 be 1100*/ /* s2mu003_assign_bits(charger->s2mu003->i2c_client, 0x18, 0x3C, 0x30); */ /* MUST set correct regulation voltage first * Before MUIC pass cable type information to charger * charger would be already enabled (default setting) * it might cause EOC event by incorrect regulation voltage */ s2mu003_set_regulation_voltage(charger, charger->pdata->chg_float_voltage); #if !(ENABLE_MIVR) s2mu003_assign_bits(charger->client, S2MU003_CHG_CTRL4, S2MU003_MIVR_MASK, S2MU003_MIVR_DISABLE << S2MU003_MIVR_SHIFT); #endif return true; } static int s2mu003_get_charging_status(struct s2mu003_charger_data *charger) { int status = POWER_SUPPLY_STATUS_UNKNOWN; int ret; ret = s2mu003_reg_read(charger->client, S2MU003_CHG_STATUS1); if (ret < 0) { pr_info("Error : can't get charging status (%d)\n", ret); } if (charger->full_charged) return POWER_SUPPLY_STATUS_FULL; switch (ret & 0x30) { case 0x00: status = POWER_SUPPLY_STATUS_DISCHARGING; break; case 0x20: case 0x10: status = POWER_SUPPLY_STATUS_CHARGING; break; case 0x30: status = POWER_SUPPLY_STATUS_NOT_CHARGING; break; } /* TEMP_TEST : when OTG is enabled(charging_current -1), handle OTG func. */ if (charger->charging_current < 0) { /* For OTG mode, S2MU003 would still report "charging" */ status = POWER_SUPPLY_STATUS_DISCHARGING; ret = s2mu003_reg_read(charger->client, S2MU003_CHG_IRQ3); if (ret & 0x80) { pr_info("%s: otg overcurrent limit\n", __func__); s2mu003_charger_otg_control(charger, false); } } return status; } static int s2mu003_get_charge_type(struct i2c_client *iic) { int status = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; int ret; ret = s2mu003_reg_read(iic, S2MU003_CHG_STATUS1); if (ret < 0) dev_err(&iic->dev, "%s fail\n", __func__); switch (ret&0x40) { case 0x40: status = POWER_SUPPLY_CHARGE_TYPE_FAST; break; default: /* pre-charge mode */ status = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; break; } return status; } static bool s2mu003_get_batt_present(struct i2c_client *iic) { int ret = s2mu003_reg_read(iic, S2MU003_CHG_STATUS2); if (ret < 0) return false; return (ret & 0x08) ? false : true; } static int s2mu003_get_charging_health(struct s2mu003_charger_data *charger) { int ret = s2mu003_reg_read(charger->client, S2MU003_CHG_STATUS1); if (ret < 0) return POWER_SUPPLY_HEALTH_UNKNOWN; if (ret & (0x03 << 2)) { charger->ovp = false; charger->unhealth_cnt = 0; return POWER_SUPPLY_HEALTH_GOOD; } charger->unhealth_cnt++; if (charger->unhealth_cnt < HEALTH_DEBOUNCE_CNT) return POWER_SUPPLY_HEALTH_GOOD; charger->unhealth_cnt = HEALTH_DEBOUNCE_CNT; if (charger->ovp) return POWER_SUPPLY_HEALTH_OVERVOLTAGE; return POWER_SUPPLY_HEALTH_UNDERVOLTAGE; } static int sec_chg_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val) { int chg_curr, aicr; struct s2mu003_charger_data *charger = container_of(psy, struct s2mu003_charger_data, psy_chg); switch (psp) { case POWER_SUPPLY_PROP_ONLINE: val->intval = charger->charging_current ? 1 : 0; break; case POWER_SUPPLY_PROP_STATUS: val->intval = s2mu003_get_charging_status(charger); break; case POWER_SUPPLY_PROP_HEALTH: val->intval = s2mu003_get_charging_health(charger); s2mu003_test_read(charger->client); break; case POWER_SUPPLY_PROP_CURRENT_MAX: val->intval = 2000; break; case POWER_SUPPLY_PROP_CURRENT_NOW: if (charger->charging_current) { aicr = s2mu003_get_input_current_limit(charger->client); chg_curr = s2mu003_get_fast_charging_current(charger->client); val->intval = MINVAL(aicr, chg_curr); } else val->intval = 0; break; case POWER_SUPPLY_PROP_CHARGE_TYPE: val->intval = s2mu003_get_charge_type(charger->client); break; case POWER_SUPPLY_PROP_PRESENT: val->intval = s2mu003_get_batt_present(charger->client); break; default: return -EINVAL; } return 0; } static int sec_chg_set_property(struct power_supply *psy, enum power_supply_property psp, const union power_supply_propval *val) { struct s2mu003_charger_data *charger = container_of(psy, struct s2mu003_charger_data, psy_chg); int eoc; int previous_cable_type = charger->cable_type; switch (psp) { case POWER_SUPPLY_PROP_STATUS: charger->status = val->intval; break; /* val->intval : type */ case POWER_SUPPLY_PROP_ONLINE: charger->cable_type = val->intval; if (charger->cable_type == POWER_SUPPLY_TYPE_BATTERY || charger->cable_type == POWER_SUPPLY_TYPE_UNKNOWN) { pr_info("%s:[BATT] Type Battery\n", __func__); s2mu003_enable_charger_switch(charger, 0); if (previous_cable_type == POWER_SUPPLY_TYPE_OTG) s2mu003_charger_otg_control(charger, false); } else if (charger->cable_type == POWER_SUPPLY_TYPE_OTG) { pr_info("%s: OTG mode\n", __func__); s2mu003_charger_otg_control(charger, true); } else { pr_info("%s:[BATT] Set charging" ", Cable type = %d\n", __func__, charger->cable_type); /* Enable charger */ s2mu003_configure_charger(charger); } #if EN_TEST_READ msleep(100); s2mu003_test_read(charger->s2mu003->i2c_client); #endif break; case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: case POWER_SUPPLY_PROP_CURRENT_NOW: /* set charging current */ if (charger->is_charging) { /* decrease the charging current according to siop level */ charger->siop_level = val->intval; pr_info("%s:SIOP level = %d, chg current = %d\n", __func__, val->intval, charger->charging_current); eoc = s2mu003_get_current_eoc_setting(charger); s2mu003_set_charging_current(charger, 0); } break; case POWER_SUPPLY_PROP_POWER_NOW: eoc = s2mu003_get_current_eoc_setting(charger); pr_info("%s:Set Power Now -> chg current = %d mA, eoc = %d mA\n", __func__, val->intval, eoc); s2mu003_set_charging_current(charger, 0); break; case POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL: s2mu003_charger_otg_control(charger, val->intval); break; default: return -EINVAL; } return 0; } ssize_t s2mu003_chg_show_attrs(struct device *dev, const ptrdiff_t offset, char *buf) { struct power_supply *psy = dev_get_drvdata(dev); struct s2mu003_charger_data *charger = container_of(psy, struct s2mu003_charger_data, psy_chg); int i = 0; char *str = NULL; switch (offset) { case CHG_REG: i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n", charger->reg_addr); break; case CHG_DATA: i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n", charger->reg_data); break; case CHG_REGS: str = kzalloc(sizeof(char) * 256, GFP_KERNEL); if (!str) return -ENOMEM; s2mu003_read_regs(charger->client, str); i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n", str); kfree(str); break; default: i = -EINVAL; break; } return i; } ssize_t s2mu003_chg_store_attrs(struct device *dev, const ptrdiff_t offset, const char *buf, size_t count) { struct power_supply *psy = dev_get_drvdata(dev); struct s2mu003_charger_data *charger = container_of(psy, struct s2mu003_charger_data, psy_chg); int ret = 0; int x = 0; uint8_t data = 0; switch (offset) { case CHG_REG: if (sscanf(buf, "%x\n", &x) == 1) { charger->reg_addr = x; data = s2mu003_reg_read(charger->client, charger->reg_addr); charger->reg_data = data; dev_dbg(dev, "%s: (read) addr = 0x%x, data = 0x%x\n", __func__, charger->reg_addr, charger->reg_data); ret = count; } break; case CHG_DATA: if (sscanf(buf, "%x\n", &x) == 1) { data = (u8)x; dev_dbg(dev, "%s: (write) addr = 0x%x, data = 0x%x\n", __func__, charger->reg_addr, data); ret = s2mu003_reg_write(charger->client, charger->reg_addr, data); if (ret < 0) { dev_dbg(dev, "I2C write fail Reg0x%x = 0x%x\n", (int)charger->reg_addr, (int)data); } ret = count; } break; default: ret = -EINVAL; break; } return ret; } struct s2mu003_chg_irq_handler { char *name; int irq_index; irqreturn_t (*handler)(int irq, void *data); }; #if EN_OVP_IRQ static irqreturn_t s2mu003_chg_vin_ovp_irq_handler(int irq, void *data) { struct s2mu003_charger_data *charger = data; union power_supply_propval value; int status; /* Delay 100ms for debounce */ msleep(100); status = s2mu003_reg_read(charger->client, S2MU003_CHG_STATUS1); /* PWR ready = 0*/ if ((status & (0x04)) == 0) { /* No need to disable charger, * H/W will do it automatically */ charger->unhealth_cnt = HEALTH_DEBOUNCE_CNT; charger->ovp = true; pr_info("%s: OVP triggered\n", __func__); value.intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; psy_do_property("battery", set, POWER_SUPPLY_PROP_HEALTH, value); } else { charger->unhealth_cnt = 0; charger->ovp = false; } return IRQ_HANDLED; } #endif /* EN_OVP_IRQ */ #if EN_IEOC_IRQ static irqreturn_t s2mu003_chg_ieoc_irq_handler(int irq, void *data) { struct s2mu003_charger_data *charger = data; pr_info("%s : Full charged\n", __func__); charger->full_charged = true; return IRQ_HANDLED; } #endif /* EN_IEOC_IRQ */ #if EN_RECHG_REQ_IRQ static irqreturn_t s2mu003_chg_rechg_request_irq_handler(int irq, void *data) { struct s2mu003_charger_data *charger = data; pr_info("%s: Recharging requesting\n", __func__); charger->full_charged = false; return IRQ_HANDLED; } #endif /* EN_RECHG_REQ_IRQ */ #if EN_TR_IRQ static irqreturn_t s2mu003_chg_otp_tr_irq_handler(int irq, void *data) { pr_info("%s : Over temperature : thermal regulation loop active\n", __func__); /* if needs callback, do it here */ return IRQ_HANDLED; } #endif const struct s2mu003_chg_irq_handler s2mu003_chg_irq_handlers[] = { #if EN_OVP_IRQ { .name = "chg_cinovp", .handler = s2mu003_chg_vin_ovp_irq_handler, .irq_index = S2MU003_CINOVP_IRQ, }, #endif /* EN_OVP_IRQ */ #if EN_IEOC_IRQ { .name = "chg_eoc", .handler = s2mu003_chg_ieoc_irq_handler, .irq_index = S2MU003_EOC_IRQ, }, #endif /* EN_IEOC_IRQ */ #if EN_RECHG_REQ_IRQ { .name = "chg_rechg", .handler = s2mu003_chg_rechg_request_irq_handler, .irq_index = S2MU003_RECHG_IRQ, }, #endif /* EN_RECHG_REQ_IRQ*/ #if EN_TR_IRQ { .name = "chg_chgtr", .handler = s2mu003_chg_otp_tr_irq_handler, .irq_index = S2MU003_CHGTR_IRQ, }, #endif /* EN_TR_IRQ */ #if EN_MIVR_SW_REGULATION { .name = "chg_chgvinvr", .handler = s2mu003_chg_mivr_irq_handler, .irq_index = S2MU003_CHGVINVR_IRQ, }, #endif /* EN_MIVR_SW_REGULATION */ #if EN_BST_IRQ { .name = "chg_bstinlv", .handler = s2mu003_chg_otg_fail_irq_handler, .irq_index = S2MU003_BSTINLV_IRQ, }, { .name = "chg_bstilim", .handler = s2mu003_chg_otg_fail_irq_handler, .irq_index = S2MU003_BSTILIM_IRQ, }, { .name = "chg_vmidovp", .handler = s2mu003_chg_otg_fail_irq_handler, .irq_index = S2MU003_VMIDOVP_IRQ, }, #endif /* EN_BST_IRQ */ }; static int register_irq(struct platform_device *pdev, struct s2mu003_charger_data *charger) { int irq; int i, j; int ret; const struct s2mu003_chg_irq_handler *irq_handler = s2mu003_chg_irq_handlers; const char *irq_name; for (i = 0; i < ARRAY_SIZE(s2mu003_chg_irq_handlers); i++) { irq_name = s2mu003_get_irq_name_by_index(irq_handler[i].irq_index); irq = platform_get_irq_byname(pdev, irq_name); ret = request_threaded_irq(irq, NULL, irq_handler[i].handler, IRQF_ONESHOT | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND, irq_name, charger); if (ret < 0) { pr_err("%s : Failed to request IRQ (%s): #%d: %d\n", __func__, irq_name, irq, ret); goto err_irq; } pr_info("%s : Register IRQ%d(%s) successfully\n", __func__, irq, irq_name); } return 0; err_irq: for (j = 0; j < i; j++) { irq_name = s2mu003_get_irq_name_by_index(irq_handler[j].irq_index); irq = platform_get_irq_byname(pdev, irq_name); free_irq(irq, charger); } return ret; } static void unregister_irq(struct platform_device *pdev, struct s2mu003_charger_data *charger) { int irq; int i; const char *irq_name; const struct s2mu003_chg_irq_handler *irq_handler = s2mu003_chg_irq_handlers; for (i = 0; i < ARRAY_SIZE(s2mu003_chg_irq_handlers); i++) { irq_name = s2mu003_get_irq_name_by_index(irq_handler[i].irq_index); irq = platform_get_irq_byname(pdev, irq_name); free_irq(irq, charger); } } #ifdef CONFIG_OF static int s2mu003_charger_parse_dt(struct device *dev, struct s2mu003_charger_platform_data *pdata) { struct device_node *np = of_find_node_by_name(NULL, "s2mu003-charger"); const u32 *p; int ret, i, len; if (of_find_property(np, "is_750kHz_switching", NULL)) pdata->is_750kHz_switching = 1; if (of_find_property(np, "is_fixed_switching", NULL)) pdata->is_fixed_switching = 1; pr_info("%s : is_750kHz_switching = %d\n", __func__, pdata->is_750kHz_switching); pr_info("%s : is_fixed_switching = %d\n", __func__, pdata->is_fixed_switching); if (np == NULL) { pr_err("%s np NULL\n", __func__); } else { ret = of_property_read_u32(np, "battery,chg_float_voltage", &pdata->chg_float_voltage); } np = of_find_node_by_name(NULL, "battery"); if (!np) { pr_err("%s np NULL\n", __func__); } else { ret = of_property_read_string(np, "battery,charger_name", (char const **)&pdata->charger_name); p = of_get_property(np, "battery,input_current_limit", &len); if (!p) return 1; len = len / sizeof(u32); pdata->charging_current_table = kzalloc(sizeof(sec_charging_current_t) * len, GFP_KERNEL); for (i = 0; i < len; i++) { ret = of_property_read_u32_index(np, "battery,input_current_limit", i, &pdata->charging_current_table[i].input_current_limit); ret = of_property_read_u32_index(np, "battery,fast_charging_current", i, &pdata->charging_current_table[i].fast_charging_current); ret = of_property_read_u32_index(np, "battery,full_check_current_1st", i, &pdata->charging_current_table[i].full_check_current_1st); ret = of_property_read_u32_index(np, "battery,full_check_current_2nd", i, &pdata->charging_current_table[i].full_check_current_2nd); } } dev_info(dev, "s2mu003 charger parse dt retval = %d\n", ret); return ret; } static struct of_device_id s2mu003_charger_match_table[] = { { .compatible = "samsung,s2mu003-charger",}, {}, }; #else static int s2mu003_charger_parse_dt(struct device *dev, struct s2mu003_charger_platform_data *pdata) { return -ENOSYS; } #define s2mu003_charger_match_table NULL #endif /* CONFIG_OF */ static int s2mu003_charger_probe(struct platform_device *pdev) { s2mu003_mfd_chip_t *chip = dev_get_drvdata(pdev->dev.parent); #ifndef CONFIG_OF struct s2mu003_mfd_platform_data *mfd_pdata = dev_get_platdata(chip->dev); #endif struct s2mu003_charger_data *charger; int ret = 0; pr_info("%s:[BATT] S2MU003 Charger driver probe\n", __func__); charger = kzalloc(sizeof(*charger), GFP_KERNEL); if (!charger) return -ENOMEM; mutex_init(&charger->io_lock); charger->s2mu003 = chip; charger->client = chip->i2c_client; #ifdef CONFIG_OF charger->pdata = devm_kzalloc(&pdev->dev, sizeof(*(charger->pdata)), GFP_KERNEL); if (!charger->pdata) { dev_err(&pdev->dev, "Failed to allocate memory\n"); ret = -ENOMEM; goto err_parse_dt_nomem; } ret = s2mu003_charger_parse_dt(&pdev->dev, charger->pdata); if (ret < 0) goto err_parse_dt; #else charger->pdata = mfd_pdata->charger_platform_data; #endif platform_set_drvdata(pdev, charger); if (charger->pdata->charger_name == NULL) charger->pdata->charger_name = "sec-charger"; charger->psy_chg.name = charger->pdata->charger_name; charger->psy_chg.type = POWER_SUPPLY_TYPE_UNKNOWN; charger->psy_chg.get_property = sec_chg_get_property; charger->psy_chg.set_property = sec_chg_set_property; charger->psy_chg.properties = sec_charger_props; charger->psy_chg.num_properties = ARRAY_SIZE(sec_charger_props); charger->siop_level = 100; s2mu003_chg_init(charger); ret = power_supply_register(&pdev->dev, &charger->psy_chg); if (ret) { pr_err("%s: Failed to Register psy_chg\n", __func__); goto err_power_supply_register; } ret = register_irq(pdev, charger); if (ret < 0) goto err_reg_irq; s2mu003_test_read(charger->client); pr_info("%s:[BATT] S2MU003 charger driver loaded OK\n", __func__); return 0; err_reg_irq: power_supply_unregister(&charger->psy_chg); err_power_supply_register: err_parse_dt: err_parse_dt_nomem: mutex_destroy(&charger->io_lock); kfree(charger); return ret; } static int s2mu003_charger_remove(struct platform_device *pdev) { struct s2mu003_charger_data *charger = platform_get_drvdata(pdev); unregister_irq(pdev, charger); power_supply_unregister(&charger->psy_chg); mutex_destroy(&charger->io_lock); kfree(charger); return 0; } #if defined CONFIG_PM static int s2mu003_charger_suspend(struct device *dev) { return 0; } static int s2mu003_charger_resume(struct device *dev) { return 0; } #else #define s2mu003_charger_suspend NULL #define s2mu003_charger_resume NULL #endif static void s2mu003_charger_shutdown(struct device *dev) { pr_info("%s: S2MU003 Charger driver shutdown\n", __func__); } static SIMPLE_DEV_PM_OPS(s2mu003_charger_pm_ops, s2mu003_charger_suspend, s2mu003_charger_resume); static struct platform_driver s2mu003_charger_driver = { .driver = { .name = "s2mu003-charger", .owner = THIS_MODULE, .of_match_table = s2mu003_charger_match_table, .pm = &s2mu003_charger_pm_ops, .shutdown = s2mu003_charger_shutdown, }, .probe = s2mu003_charger_probe, .remove = s2mu003_charger_remove, }; static int __init s2mu003_charger_init(void) { int ret = 0; ret = platform_driver_register(&s2mu003_charger_driver); return ret; } subsys_initcall(s2mu003_charger_init); static void __exit s2mu003_charger_exit(void) { platform_driver_unregister(&s2mu003_charger_driver); } module_exit(s2mu003_charger_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Patrick Chang