Lines Matching full:data
124 static int sc27xx_fgu_cap_to_clbcnt(struct sc27xx_fgu_data *data, int capacity);
125 static void sc27xx_fgu_capacity_calibration(struct sc27xx_fgu_data *data,
127 static void sc27xx_fgu_adjust_cap(struct sc27xx_fgu_data *data, int cap);
128 static int sc27xx_fgu_get_temp(struct sc27xx_fgu_data *data, int *temp);
137 static int sc27xx_fgu_adc_to_current(struct sc27xx_fgu_data *data, s64 adc)
139 return DIV_S64_ROUND_CLOSEST(adc * 1000, data->cur_1000ma_adc);
142 static int sc27xx_fgu_adc_to_voltage(struct sc27xx_fgu_data *data, s64 adc)
144 return DIV_S64_ROUND_CLOSEST(adc * 1000, data->vol_1000mv_adc);
147 static int sc27xx_fgu_voltage_to_adc(struct sc27xx_fgu_data *data, int vol)
149 return DIV_ROUND_CLOSEST(vol * data->vol_1000mv_adc, 1000);
152 static bool sc27xx_fgu_is_first_poweron(struct sc27xx_fgu_data *data)
156 ret = regmap_read(data->regmap,
157 data->base + SC27XX_FGU_USER_AREA_STATUS, &status);
179 static int sc27xx_fgu_save_boot_mode(struct sc27xx_fgu_data *data,
184 ret = regmap_update_bits(data->regmap,
185 data->base + SC27XX_FGU_USER_AREA_CLEAR,
199 ret = regmap_update_bits(data->regmap,
200 data->base + SC27XX_FGU_USER_AREA_SET,
216 * make the user area data available, otherwise we can not save the user
217 * area data.
219 return regmap_update_bits(data->regmap,
220 data->base + SC27XX_FGU_USER_AREA_CLEAR,
224 static int sc27xx_fgu_save_last_cap(struct sc27xx_fgu_data *data, int cap)
228 ret = regmap_update_bits(data->regmap,
229 data->base + SC27XX_FGU_USER_AREA_CLEAR,
243 ret = regmap_update_bits(data->regmap,
244 data->base + SC27XX_FGU_USER_AREA_SET,
259 * make the user area data available, otherwise we can not save the user
260 * area data.
262 return regmap_update_bits(data->regmap,
263 data->base + SC27XX_FGU_USER_AREA_CLEAR,
267 static int sc27xx_fgu_read_last_cap(struct sc27xx_fgu_data *data, int *cap)
271 ret = regmap_read(data->regmap,
272 data->base + SC27XX_FGU_USER_AREA_STATUS, &value);
286 static int sc27xx_fgu_get_boot_capacity(struct sc27xx_fgu_data *data, int *cap)
289 bool is_first_poweron = sc27xx_fgu_is_first_poweron(data);
297 ret = sc27xx_fgu_read_last_cap(data, cap);
301 return sc27xx_fgu_save_boot_mode(data, SC27XX_FGU_NORMAIL_POWERTON);
308 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_QMAXL,
314 oci = sc27xx_fgu_adc_to_current(data, cur - SC27XX_FGU_CUR_BASIC_ADC);
321 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_POCV, &volt);
325 volt = sc27xx_fgu_adc_to_voltage(data, volt);
326 ocv = volt * 1000 - oci * data->internal_resist;
327 data->boot_volt = ocv;
333 *cap = power_supply_ocv2cap_simple(data->cap_table, data->table_len,
336 ret = sc27xx_fgu_save_last_cap(data, *cap);
340 return sc27xx_fgu_save_boot_mode(data, SC27XX_FGU_NORMAIL_POWERTON);
343 static int sc27xx_fgu_set_clbcnt(struct sc27xx_fgu_data *data, int clbcnt)
347 ret = regmap_update_bits(data->regmap,
348 data->base + SC27XX_FGU_CLBCNT_SETL,
353 ret = regmap_update_bits(data->regmap,
354 data->base + SC27XX_FGU_CLBCNT_SETH,
360 return regmap_update_bits(data->regmap, data->base + SC27XX_FGU_START,
365 static int sc27xx_fgu_get_clbcnt(struct sc27xx_fgu_data *data, int *clb_cnt)
369 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_VALL,
374 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_VALH,
385 static int sc27xx_fgu_get_vol_now(struct sc27xx_fgu_data *data, int *val)
390 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_VOLTAGE_BUF,
399 *val = sc27xx_fgu_adc_to_voltage(data, vol);
404 static int sc27xx_fgu_get_cur_now(struct sc27xx_fgu_data *data, int *val)
409 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CURRENT_BUF,
418 *val = sc27xx_fgu_adc_to_current(data, cur - SC27XX_FGU_CUR_BASIC_ADC);
423 static int sc27xx_fgu_get_capacity(struct sc27xx_fgu_data *data, int *cap)
428 ret = sc27xx_fgu_get_clbcnt(data, &cur_clbcnt);
432 delta_clbcnt = cur_clbcnt - data->init_clbcnt;
439 temp = sc27xx_fgu_adc_to_current(data, temp / 1000);
445 delta_cap = DIV_ROUND_CLOSEST(temp * 100, data->total_cap);
446 *cap = delta_cap + data->init_cap;
449 sc27xx_fgu_capacity_calibration(data, *cap, false);
454 static int sc27xx_fgu_get_vbat_vol(struct sc27xx_fgu_data *data, int *val)
458 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_VOLTAGE, &vol);
466 *val = sc27xx_fgu_adc_to_voltage(data, vol);
471 static int sc27xx_fgu_get_current(struct sc27xx_fgu_data *data, int *val)
475 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CURRENT, &cur);
483 *val = sc27xx_fgu_adc_to_current(data, cur - SC27XX_FGU_CUR_BASIC_ADC);
488 static int sc27xx_fgu_get_vbat_ocv(struct sc27xx_fgu_data *data, int *val)
492 ret = sc27xx_fgu_get_vbat_vol(data, &vol);
496 ret = sc27xx_fgu_get_current(data, &cur);
500 resistance = data->internal_resist;
501 if (data->resist_table_len > 0) {
502 ret = sc27xx_fgu_get_temp(data, &temp);
506 resistance = power_supply_temp2resist_simple(data->resist_table,
507 data->resist_table_len, temp);
508 resistance = data->internal_resist * resistance / 100;
517 static int sc27xx_fgu_get_charge_vol(struct sc27xx_fgu_data *data, int *val)
521 ret = iio_read_channel_processed(data->charge_chan, &vol);
529 static int sc27xx_fgu_get_temp(struct sc27xx_fgu_data *data, int *temp)
531 return iio_read_channel_processed(data->channel, temp);
534 static int sc27xx_fgu_get_health(struct sc27xx_fgu_data *data, int *health)
538 ret = sc27xx_fgu_get_vbat_vol(data, &vol);
542 if (vol > data->max_volt)
550 static int sc27xx_fgu_get_status(struct sc27xx_fgu_data *data, int *status)
577 struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy);
581 mutex_lock(&data->lock);
585 ret = sc27xx_fgu_get_status(data, &value);
593 ret = sc27xx_fgu_get_health(data, &value);
601 val->intval = data->bat_present;
605 ret = sc27xx_fgu_get_temp(data, &value);
617 ret = sc27xx_fgu_get_capacity(data, &value);
625 ret = sc27xx_fgu_get_vbat_vol(data, &value);
633 ret = sc27xx_fgu_get_vbat_ocv(data, &value);
641 ret = sc27xx_fgu_get_charge_vol(data, &value);
649 ret = sc27xx_fgu_get_current(data, &value);
657 val->intval = data->total_cap * 1000;
661 ret = sc27xx_fgu_get_clbcnt(data, &value);
667 val->intval = sc27xx_fgu_adc_to_current(data, value);
672 ret = sc27xx_fgu_get_vol_now(data, &value);
680 ret = sc27xx_fgu_get_cur_now(data, &value);
688 val->intval = data->boot_volt;
697 mutex_unlock(&data->lock);
705 struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy);
708 mutex_lock(&data->lock);
712 ret = sc27xx_fgu_save_last_cap(data, val->intval);
714 dev_err(data->dev, "failed to save battery capacity\n");
718 sc27xx_fgu_adjust_cap(data, val->intval);
723 data->total_cap = val->intval / 1000;
731 mutex_unlock(&data->lock);
775 static void sc27xx_fgu_adjust_cap(struct sc27xx_fgu_data *data, int cap)
779 data->init_cap = cap;
780 ret = sc27xx_fgu_get_clbcnt(data, &data->init_clbcnt);
782 dev_err(data->dev, "failed to get init coulomb counter\n");
785 static void sc27xx_fgu_capacity_calibration(struct sc27xx_fgu_data *data,
790 ret = sc27xx_fgu_get_vbat_ocv(data, &ocv);
792 dev_err(data->dev, "get battery ocv error.\n");
796 ret = sc27xx_fgu_get_status(data, &chg_sts);
798 dev_err(data->dev, "get charger status error.\n");
809 if ((ocv > data->cap_table[0].ocv && cap < 100) || cap > 100) {
815 sc27xx_fgu_adjust_cap(data, 100);
816 } else if (ocv <= data->cap_table[data->table_len - 1].ocv) {
821 sc27xx_fgu_adjust_cap(data, 0);
822 } else if ((ocv > data->cap_table[data->table_len - 1].ocv && cap <= 0) ||
823 (ocv > data->min_volt && cap <= data->alarm_cap)) {
829 int cur_cap = power_supply_ocv2cap_simple(data->cap_table,
830 data->table_len, ocv);
832 sc27xx_fgu_adjust_cap(data, cur_cap);
833 } else if (ocv <= data->min_volt) {
839 if (cap > data->alarm_cap) {
840 sc27xx_fgu_adjust_cap(data, data->alarm_cap);
850 cur_cap = power_supply_ocv2cap_simple(data->cap_table,
851 data->table_len,
853 sc27xx_fgu_adjust_cap(data, cur_cap);
863 data->min_volt = data->cap_table[data->table_len - 1].ocv;
864 data->alarm_cap = power_supply_ocv2cap_simple(data->cap_table,
865 data->table_len,
866 data->min_volt);
868 adc = sc27xx_fgu_voltage_to_adc(data, data->min_volt / 1000);
869 regmap_update_bits(data->regmap,
870 data->base + SC27XX_FGU_LOW_OVERLOAD,
877 struct sc27xx_fgu_data *data = dev_id;
881 mutex_lock(&data->lock);
883 ret = regmap_read(data->regmap, data->base + SC27XX_FGU_INT_STS,
888 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_CLR,
900 ret = sc27xx_fgu_get_capacity(data, &cap);
904 sc27xx_fgu_capacity_calibration(data, cap, true);
907 mutex_unlock(&data->lock);
909 power_supply_changed(data->battery);
915 struct sc27xx_fgu_data *data = dev_id;
918 mutex_lock(&data->lock);
920 state = gpiod_get_value_cansleep(data->gpiod);
922 dev_err(data->dev, "failed to get gpio state\n");
923 mutex_unlock(&data->lock);
927 data->bat_present = !!state;
929 mutex_unlock(&data->lock);
931 power_supply_changed(data->battery);
937 struct sc27xx_fgu_data *data = _data;
939 regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0);
940 regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0);
943 static int sc27xx_fgu_cap_to_clbcnt(struct sc27xx_fgu_data *data, int capacity)
949 int cur_cap = DIV_ROUND_CLOSEST(data->total_cap * capacity, 100);
955 return DIV_ROUND_CLOSEST(cur_cap * 36 * data->cur_1000ma_adc * SC27XX_FGU_SAMPLE_HZ, 10);
958 static int sc27xx_fgu_calibration(struct sc27xx_fgu_data *data)
965 cell = nvmem_cell_get(data->dev, "fgu_calib");
983 data->vol_1000mv_adc = DIV_ROUND_CLOSEST(cal_4200mv * 10, 42);
984 data->cur_1000ma_adc =
985 DIV_ROUND_CLOSEST(data->vol_1000mv_adc * 4 * data->calib_resist,
992 static int sc27xx_fgu_hw_init(struct sc27xx_fgu_data *data)
998 ret = power_supply_get_battery_info(data->battery, &info);
1000 dev_err(data->dev, "failed to get battery information\n");
1004 data->total_cap = info->charge_full_design_uah / 1000;
1005 data->max_volt = info->constant_charge_voltage_max_uv / 1000;
1006 data->internal_resist = info->factory_internal_resistance_uohm / 1000;
1007 data->min_volt = info->voltage_min_design_uv;
1013 table = power_supply_find_ocv2cap_table(info, 20, &data->table_len);
1017 data->cap_table = devm_kmemdup_array(data->dev, table, data->table_len,
1019 if (!data->cap_table) {
1020 power_supply_put_battery_info(data->battery, info);
1024 data->alarm_cap = power_supply_ocv2cap_simple(data->cap_table,
1025 data->table_len,
1026 data->min_volt);
1027 if (!data->alarm_cap)
1028 data->alarm_cap += 1;
1030 data->resist_table_len = info->resist_table_size;
1031 if (data->resist_table_len > 0) {
1032 data->resist_table = devm_kmemdup(data->dev, info->resist_table,
1033 data->resist_table_len *
1036 if (!data->resist_table) {
1037 power_supply_put_battery_info(data->battery, info);
1042 power_supply_put_battery_info(data->battery, info);
1044 ret = sc27xx_fgu_calibration(data);
1049 ret = regmap_update_bits(data->regmap, SC27XX_MODULE_EN0,
1052 dev_err(data->dev, "failed to enable fgu\n");
1057 ret = regmap_update_bits(data->regmap, SC27XX_CLK_EN0,
1060 dev_err(data->dev, "failed to enable fgu RTC clock\n");
1064 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_CLR,
1067 dev_err(data->dev, "failed to clear interrupt status\n");
1076 alarm_adc = sc27xx_fgu_voltage_to_adc(data, data->min_volt / 1000);
1077 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_LOW_OVERLOAD,
1080 dev_err(data->dev, "failed to set fgu low overload\n");
1091 delta_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, 1);
1093 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTL,
1096 dev_err(data->dev, "failed to set low delta coulomb counter\n");
1100 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTH,
1104 dev_err(data->dev, "failed to set high delta coulomb counter\n");
1113 ret = sc27xx_fgu_get_boot_capacity(data, &data->init_cap);
1115 dev_err(data->dev, "failed to get boot capacity\n");
1123 data->init_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, data->init_cap);
1124 ret = sc27xx_fgu_set_clbcnt(data, data->init_clbcnt);
1126 dev_err(data->dev, "failed to initialize coulomb counter\n");
1133 regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0);
1135 regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0);
1144 struct sc27xx_fgu_data *data;
1147 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
1148 if (!data)
1151 data->regmap = dev_get_regmap(dev->parent, NULL);
1152 if (!data->regmap) {
1157 ret = device_property_read_u32(dev, "reg", &data->base);
1165 &data->calib_resist);
1172 data->channel = devm_iio_channel_get(dev, "bat-temp");
1173 if (IS_ERR(data->channel)) {
1175 return PTR_ERR(data->channel);
1178 data->charge_chan = devm_iio_channel_get(dev, "charge-vol");
1179 if (IS_ERR(data->charge_chan)) {
1181 return PTR_ERR(data->charge_chan);
1184 data->gpiod = devm_gpiod_get(dev, "battery-detect", GPIOD_IN);
1185 if (IS_ERR(data->gpiod)) {
1186 data->gpiod = devm_gpiod_get(dev, "bat-detect", GPIOD_IN);
1187 if (IS_ERR(data->gpiod)) {
1189 return PTR_ERR(data->gpiod);
1194 ret = gpiod_get_value_cansleep(data->gpiod);
1200 data->bat_present = !!ret;
1201 mutex_init(&data->lock);
1202 data->dev = dev;
1203 platform_set_drvdata(pdev, data);
1205 fgu_cfg.drv_data = data;
1207 data->battery = devm_power_supply_register(dev, &sc27xx_fgu_desc,
1209 if (IS_ERR(data->battery)) {
1211 return PTR_ERR(data->battery);
1214 ret = sc27xx_fgu_hw_init(data);
1220 ret = devm_add_action_or_reset(dev, sc27xx_fgu_disable, data);
1230 ret = devm_request_threaded_irq(data->dev, irq, NULL,
1233 pdev->name, data);
1235 dev_err(data->dev, "failed to request fgu IRQ\n");
1239 irq = gpiod_to_irq(data->gpiod);
1249 pdev->name, data);
1261 struct sc27xx_fgu_data *data = dev_get_drvdata(dev);
1264 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN,
1268 dev_err(data->dev, "failed to disable fgu interrupts\n");
1277 struct sc27xx_fgu_data *data = dev_get_drvdata(dev);
1280 ret = sc27xx_fgu_get_status(data, &status);
1292 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN,
1296 dev_err(data->dev, "failed to enable low voltage interrupt\n");
1300 ret = sc27xx_fgu_get_vbat_ocv(data, &ocv);
1309 if (ocv < data->min_volt) {
1310 ret = regmap_update_bits(data->regmap,
1311 data->base + SC27XX_FGU_INT_EN,
1315 dev_err(data->dev,
1324 regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN,