Lines Matching refs: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(data->dev, table,
1018 data->table_len * sizeof(*table),
1020 if (!data->cap_table) {
1021 power_supply_put_battery_info(data->battery, info);
1025 data->alarm_cap = power_supply_ocv2cap_simple(data->cap_table,
1026 data->table_len,
1027 data->min_volt);
1028 if (!data->alarm_cap)
1029 data->alarm_cap += 1;
1031 data->resist_table_len = info->resist_table_size;
1032 if (data->resist_table_len > 0) {
1033 data->resist_table = devm_kmemdup(data->dev, info->resist_table,
1034 data->resist_table_len *
1037 if (!data->resist_table) {
1038 power_supply_put_battery_info(data->battery, info);
1043 power_supply_put_battery_info(data->battery, info);
1045 ret = sc27xx_fgu_calibration(data);
1050 ret = regmap_update_bits(data->regmap, SC27XX_MODULE_EN0,
1053 dev_err(data->dev, "failed to enable fgu\n");
1058 ret = regmap_update_bits(data->regmap, SC27XX_CLK_EN0,
1061 dev_err(data->dev, "failed to enable fgu RTC clock\n");
1065 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_CLR,
1068 dev_err(data->dev, "failed to clear interrupt status\n");
1077 alarm_adc = sc27xx_fgu_voltage_to_adc(data, data->min_volt / 1000);
1078 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_LOW_OVERLOAD,
1081 dev_err(data->dev, "failed to set fgu low overload\n");
1092 delta_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, 1);
1094 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTL,
1097 dev_err(data->dev, "failed to set low delta coulomb counter\n");
1101 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_CLBCNT_DELTH,
1105 dev_err(data->dev, "failed to set high delta coulomb counter\n");
1114 ret = sc27xx_fgu_get_boot_capacity(data, &data->init_cap);
1116 dev_err(data->dev, "failed to get boot capacity\n");
1124 data->init_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, data->init_cap);
1125 ret = sc27xx_fgu_set_clbcnt(data, data->init_clbcnt);
1127 dev_err(data->dev, "failed to initialize coulomb counter\n");
1134 regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0);
1136 regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0);
1146 struct sc27xx_fgu_data *data;
1149 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
1150 if (!data)
1153 data->regmap = dev_get_regmap(dev->parent, NULL);
1154 if (!data->regmap) {
1159 ret = device_property_read_u32(dev, "reg", &data->base);
1167 &data->calib_resist);
1174 data->channel = devm_iio_channel_get(dev, "bat-temp");
1175 if (IS_ERR(data->channel)) {
1177 return PTR_ERR(data->channel);
1180 data->charge_chan = devm_iio_channel_get(dev, "charge-vol");
1181 if (IS_ERR(data->charge_chan)) {
1183 return PTR_ERR(data->charge_chan);
1186 data->gpiod = devm_gpiod_get(dev, "bat-detect", GPIOD_IN);
1187 if (IS_ERR(data->gpiod)) {
1189 return PTR_ERR(data->gpiod);
1192 ret = gpiod_get_value_cansleep(data->gpiod);
1198 data->bat_present = !!ret;
1199 mutex_init(&data->lock);
1200 data->dev = dev;
1201 platform_set_drvdata(pdev, data);
1203 fgu_cfg.drv_data = data;
1205 data->battery = devm_power_supply_register(dev, &sc27xx_fgu_desc,
1207 if (IS_ERR(data->battery)) {
1209 return PTR_ERR(data->battery);
1212 ret = sc27xx_fgu_hw_init(data);
1218 ret = devm_add_action_or_reset(dev, sc27xx_fgu_disable, data);
1228 ret = devm_request_threaded_irq(data->dev, irq, NULL,
1231 pdev->name, data);
1233 dev_err(data->dev, "failed to request fgu IRQ\n");
1237 irq = gpiod_to_irq(data->gpiod);
1247 pdev->name, data);
1259 struct sc27xx_fgu_data *data = dev_get_drvdata(dev);
1262 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN,
1266 dev_err(data->dev, "failed to disable fgu interrupts\n");
1275 struct sc27xx_fgu_data *data = dev_get_drvdata(dev);
1278 ret = sc27xx_fgu_get_status(data, &status);
1290 ret = regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN,
1294 dev_err(data->dev, "failed to enable low voltage interrupt\n");
1298 ret = sc27xx_fgu_get_vbat_ocv(data, &ocv);
1307 if (ocv < data->min_volt) {
1308 ret = regmap_update_bits(data->regmap,
1309 data->base + SC27XX_FGU_INT_EN,
1313 dev_err(data->dev,
1322 regmap_update_bits(data->regmap, data->base + SC27XX_FGU_INT_EN,