static bool msic_battery_check(void)
{
if (get_oem0_table() == NULL) {
pr_info("Invalid battery detected\n");
return false;
} else {
pr_info("Valid battery detected\n");
return true;
}
}
static bool msic_battery_check(char *battid)
{
struct sfi_table_simple *sb;
sb = (struct sfi_table_simple *)get_oem0_table();
if (sb == NULL) {
pr_info("invalid battery detected\n");
snprintf(battid, BATTID_LEN + 1 , "UNKNOWNB");
return false;
} else {
pr_info("valid battery detected\n");
/* First entry in OEM0 table is the BATTID. Read battid
* if pentry is not NULL and header length is greater
* than BATTID length*/
if (sb->pentry && sb->header.len >= BATTID_LEN)
snprintf(battid, BATTID_LEN + 1, "%s",
(char *)sb->pentry);
return true;
}
return false;
}
static void platform_get_sfi_batt_table(void *table, bool fpo_override_bit)
{
struct sfi_table_simple *sb =
(struct sfi_table_simple *)get_oem0_table();
struct platform_batt_profile *batt_prof;
u8 *bprof_ptr;
int num_entries, i;
pr_debug("%s\n", __func__);
if (sb == NULL) {
pr_debug("Invalid Battery detected\n");
return;
}
/* Allocate the memory for sharing battery profile */
ps_pse_mod_prof = kzalloc(
sizeof(*ps_pse_mod_prof),
GFP_KERNEL);
if (!ps_pse_mod_prof) {
pr_debug("%s: Error in kzalloc\n", __func__);
kfree(ps_pse_mod_prof);
ps_pse_mod_prof = NULL;
return;
}
ps_batt_chrg_prof = kzalloc(
sizeof(*ps_batt_chrg_prof),
GFP_KERNEL);
if (!ps_batt_chrg_prof) {
pr_debug("%s: Error in kzalloc\n", __func__);
kfree(ps_batt_chrg_prof);
kfree(ps_pse_mod_prof);
ps_batt_chrg_prof = NULL;
ps_pse_mod_prof = NULL;
return;
}
bprof_ptr = (u8 *)sb->pentry;
memcpy(ps_pse_mod_prof->batt_id, bprof_ptr, BATTID_STR_LEN);
bprof_ptr += BATTID_STR_LEN;
ps_pse_mod_prof->voltage_max = *(u16 *)bprof_ptr;
bprof_ptr += 2;
if (fpo_override_bit) {
pr_info("OVERRIDE. Read battery profile from SMIP\n");
ps_pse_mod_prof->capacity = *(u32 *)(bprof_ptr);
bprof_ptr += 4;
} else if (INTEL_MID_BOARD(3, PHONE, CLVTP, VB, PRO, PR1B)) {
pr_info("PR1 Battery detected\n");
ps_pse_mod_prof->capacity = *(u16 *)(bprof_ptr);
bprof_ptr += 2;
} else {
pr_info("PR2 Battery detected\n");
ps_pse_mod_prof->capacity = *(u32 *)(bprof_ptr);
bprof_ptr += 4;
}
ps_pse_mod_prof->battery_type = *bprof_ptr;
ps_pse_mod_prof->temp_mon_ranges = *++bprof_ptr;
ps_pse_mod_prof->chrg_term_ma = 128;
ps_pse_mod_prof->low_batt_mV = 3400;
ps_pse_mod_prof->disch_tmp_ul = 60;
ps_pse_mod_prof->disch_tmp_ll = 0;
num_entries = SFI_GET_NUM_ENTRIES(sb, struct platform_batt_profile);
batt_prof = (struct platform_batt_profile *)table;
pr_info("num_entries = %d\n", num_entries);
if (num_entries) {
/* Fill the local structure for back up*/
memcpy(batt_prof->batt_id,
ps_pse_mod_prof->batt_id, BATTID_STR_LEN);
batt_prof->voltage_max = ps_pse_mod_prof->voltage_max;
batt_prof->capacity = ps_pse_mod_prof->capacity;
batt_prof->battery_type = ps_pse_mod_prof->battery_type;
batt_prof->temp_mon_ranges = ps_pse_mod_prof->temp_mon_ranges;
memcpy(batt_prof->temp_mon_range, bprof_ptr+1,
TEMP_NR_RNG * sizeof(struct platform_temp_mon_table));
} else {
batt_prof->temp_mon_ranges = 0;
memcpy((void *)batt_prof->batt_id,
(void *)"UNKNOWN", 8);
}
for (i = 0; i < batt_prof->temp_mon_ranges; i++) {
ps_pse_mod_prof->temp_mon_range[i].temp_up_lim =
batt_prof->temp_mon_range[i].temp_up_lim;
ps_pse_mod_prof->temp_mon_range[i].full_chrg_vol =
batt_prof->temp_mon_range[i].full_chrg_vol;
ps_pse_mod_prof->temp_mon_range[i].full_chrg_cur =
batt_prof->temp_mon_range[i].full_chrg_cur;
ps_pse_mod_prof->temp_mon_range[i].maint_chrg_vol_ll =
batt_prof->temp_mon_range[i].maint_chrg_vol_ll;
ps_pse_mod_prof->temp_mon_range[i].maint_chrg_vol_ul =
batt_prof->temp_mon_range[i].maint_chrg_vol_ul;
ps_pse_mod_prof->temp_mon_range[i].maint_chrg_cur =
batt_prof->temp_mon_range[i].maint_chrg_cur;
}
/* Change need in SMIP since temp zone 4 has all 0's */
ps_pse_mod_prof->temp_mon_range[0].temp_up_lim = 60;
ps_batt_chrg_prof->chrg_prof_type = PSE_MOD_CHRG_PROF;
ps_batt_chrg_prof->batt_prof = ps_pse_mod_prof;
/* Dump the battery charging profile*/
dump_batt_chrg_profile(ps_pse_mod_prof, batt_prof);
#ifdef CONFIG_POWER_SUPPLY_BATTID
battery_prop_changed(POWER_SUPPLY_BATTERY_INSERTED,
ps_batt_chrg_prof);
#endif
}
static bool msic_battery_check(struct max17042_platform_data *pdata)
{
struct sfi_table_simple *sb;
char *mrfl_batt_str = "INTN0001";
#ifdef CONFIG_SFI
sb = (struct sfi_table_simple *)get_oem0_table();
#else
sb = NULL;
#endif
if (sb == NULL) {
pr_info("invalid battery detected\n");
snprintf(pdata->battid, BATTID_LEN + 1, "UNKNOWNB");
snprintf(pdata->serial_num, SERIAL_NUM_LEN + 1, "000000");
return false;
} else {
pr_info("valid battery detected\n");
/* First entry in OEM0 table is the BATTID. Read battid
* if pentry is not NULL and header length is greater
* than BATTID length*/
if (sb->pentry && sb->header.len >= BATTID_LEN) {
if (!((INTEL_MID_BOARD(1, TABLET, MRFL)) ||
(INTEL_MID_BOARD(1, PHONE, MRFL)) ||
(INTEL_MID_BOARD(1, PHONE, MOFD)) ||
(INTEL_MID_BOARD(1, TABLET, MOFD)))) {
snprintf(pdata->battid, BATTID_LEN + 1, "%s",
(char *)sb->pentry);
} else {
if (strncmp((char *)sb->pentry,
"PG000001", (BATTID_LEN)) == 0) {
snprintf(pdata->battid,
(BATTID_LEN + 1),
"%s", mrfl_batt_str);
} else {
snprintf(pdata->battid,
(BATTID_LEN + 1),
"%s", (char *)sb->pentry);
}
}
/* First 2 bytes represent the model name
* and the remaining 6 bytes represent the
* serial number. */
if (pdata->battid[0] == 'I' &&
pdata->battid[1] >= '0'
&& pdata->battid[1] <= '9') {
unsigned char tmp[SERIAL_NUM_LEN + 2];
int i, ret = 0;
snprintf(pdata->model_name,
(MODEL_NAME_LEN) + 1,
"%s", pdata->battid);
ret = memcpy_safe(tmp, BATTID_LEN, sb->pentry,
BATTID_LEN);
if (ret) {
pr_err("%s, err:%d copying BATTID\n",
__func__, ret);
return false;
}
for (i = 0; i < SERIAL_NUM_LEN; i++) {
snprintf(pdata->serial_num + i*2,
sizeof(pdata->serial_num) - i*2,
"%02x", tmp[i + MODEL_NAME_LEN]);
}
if ((2 * SERIAL_NUM_LEN) <
ARRAY_SIZE(pdata->serial_num))
pdata->serial_num[2 * SERIAL_NUM_LEN]
= '\0';
} else {
snprintf(pdata->model_name,
(MODEL_NAME_LEN + 1),
"%s", pdata->battid);
snprintf(pdata->serial_num,
(SERIAL_NUM_LEN + 1), "%s",
pdata->battid + MODEL_NAME_LEN);
}
}
return true;
}
return false;
}
