power/supply/cpcap-battery.c

147 cpcap_battery_get_state(struct cpcap_battery_ddata *ddata,
153 	return &ddata->state[state];
157 cpcap_battery_latest(struct cpcap_battery_ddata *ddata)
159 	return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_LATEST);
163 cpcap_battery_previous(struct cpcap_battery_ddata *ddata)
165 	return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_PREVIOUS);
169 cpcap_battery_get_empty(struct cpcap_battery_ddata *ddata)
171 	return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_EMPTY);
175 cpcap_battery_get_full(struct cpcap_battery_ddata *ddata)
177 	return cpcap_battery_get_state(ddata, CPCAP_BATTERY_STATE_FULL);
180 static int cpcap_charger_battery_temperature(struct cpcap_battery_ddata *ddata,
186 	channel = ddata->channels[CPCAP_BATTERY_IIO_BATTDET];
190 			dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
201 static int cpcap_battery_get_voltage(struct cpcap_battery_ddata *ddata)
206 	channel = ddata->channels[CPCAP_BATTERY_IIO_VOLTAGE];
209 		dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
217 static int cpcap_battery_get_current(struct cpcap_battery_ddata *ddata)
222 	channel = ddata->channels[CPCAP_BATTERY_IIO_BATT_CURRENT];
225 		dev_warn(ddata->dev, "%s failed: %i\n", __func__, error);
235  * @ddata: device driver data
254 static int cpcap_battery_cc_raw_div(struct cpcap_battery_ddata *ddata,
265 	acc *= ddata->cc_lsb;
273 static int cpcap_battery_cc_to_uah(struct cpcap_battery_ddata *ddata,
277 	return cpcap_battery_cc_raw_div(ddata, sample,
282 static int cpcap_battery_cc_to_ua(struct cpcap_battery_ddata *ddata,
286 	return cpcap_battery_cc_raw_div(ddata, sample,
294  * @ddata: device driver data
308 cpcap_battery_read_accumulated(struct cpcap_battery_ddata *ddata,
320 	error = regmap_bulk_read(ddata->reg, CPCAP_REG_CCS1,
328 	if (ddata->vendor == CPCAP_VENDOR_TI)
343 	if (ddata->vendor == CPCAP_VENDOR_TI)
348 	return cpcap_battery_cc_to_uah(ddata,
407 static void cpcap_battery_detect_battery_type(struct cpcap_battery_ddata *ddata)
412 	ddata->check_nvmem = false;
416 		ddata->check_nvmem = true;
417 		dev_info_once(ddata->dev, "Can not find battery nvmem device. Assuming generic lipo battery\n");
420 		ddata->check_nvmem = true;
421 		dev_warn(ddata->dev, "Can not read battery nvmem device. Assuming generic lipo battery\n");
426 		ddata->config = cpcap_battery_eb41_data;
429 		ddata->config = cpcap_battery_bw8x_data;
432 		ddata->config = cpcap_battery_unkown_data;
438  * @ddata: cpcap battery driver device data
440 static int cpcap_battery_cc_get_avg_current(struct cpcap_battery_ddata *ddata)
447 	error = regmap_read(ddata->reg, CPCAP_REG_CCI, &value);
451 	if (ddata->vendor == CPCAP_VENDOR_TI) {
460 	error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
466 	return cpcap_battery_cc_to_ua(ddata, sample, acc, offset);
469 static int cpcap_battery_get_charger_status(struct cpcap_battery_ddata *ddata,
492 static bool cpcap_battery_full(struct cpcap_battery_ddata *ddata)
494 	struct cpcap_battery_state_data *state = cpcap_battery_latest(ddata);
498 	error = cpcap_battery_get_charger_status(ddata, &val);
502 			dev_dbg(ddata->dev, "charger disconnected\n");
503 			ddata->is_full = 0;
506 			dev_dbg(ddata->dev, "charger full status\n");
507 			ddata->is_full = 1;
519 	vfull = ddata->config.bat.constant_charge_voltage_max_uv - 120000;
521 	if (ddata->is_full && state->voltage < vfull)
522 		ddata->is_full = 0;
524 	return ddata->is_full;
527 static bool cpcap_battery_low(struct cpcap_battery_ddata *ddata)
529 	struct cpcap_battery_state_data *state = cpcap_battery_latest(ddata);
540 static int cpcap_battery_update_status(struct cpcap_battery_ddata *ddata)
550 	latest = cpcap_battery_latest(ddata);
559 	state.voltage = cpcap_battery_get_voltage(ddata);
560 	state.current_ua = cpcap_battery_get_current(ddata);
561 	state.counter_uah = cpcap_battery_read_accumulated(ddata, &state.cc);
563 	error = cpcap_charger_battery_temperature(ddata,
568 	previous = cpcap_battery_previous(ddata);
572 	if (cpcap_battery_full(ddata)) {
573 		full = cpcap_battery_get_full(ddata);
576 		empty = cpcap_battery_get_empty(ddata);
579 			ddata->charge_full =
581 		} else if (ddata->charge_full) {
584 				full->counter_uah + ddata->charge_full;
586 	} else if (cpcap_battery_low(ddata)) {
587 		empty = cpcap_battery_get_empty(ddata);
590 		full = cpcap_battery_get_full(ddata);
593 			ddata->charge_full =
639 	struct cpcap_battery_ddata *ddata = power_supply_get_drvdata(psy);
646 	cached = cpcap_battery_update_status(ddata);
650 	latest = cpcap_battery_latest(ddata);
651 	previous = cpcap_battery_previous(ddata);
653 	if (ddata->check_nvmem)
654 		cpcap_battery_detect_battery_type(ddata);
664 		if (cpcap_battery_full(ddata)) {
668 		if (cpcap_battery_cc_get_avg_current(ddata) < 0)
674 		val->intval = ddata->config.info.technology;
677 		val->intval = cpcap_battery_get_voltage(ddata);
680 		val->intval = ddata->config.info.voltage_max_design;
683 		val->intval = ddata->config.info.voltage_min_design;
686 		val->intval = ddata->config.bat.constant_charge_voltage_max_uv;
691 			val->intval = cpcap_battery_cc_get_avg_current(ddata);
695 		val->intval = cpcap_battery_cc_to_ua(ddata, sample,
712 			tmp = cpcap_battery_cc_get_avg_current(ddata);
718 		tmp = cpcap_battery_cc_to_ua(ddata, sample, accumulator,
724 		empty = cpcap_battery_get_empty(ddata);
725 		if (!empty->voltage || !ddata->charge_full)
727 		/* (ddata->charge_full / 200) is needed for rounding */
729 			ddata->charge_full / 200;
730 		val->intval = clamp(val->intval, 0, ddata->charge_full);
731 		val->intval = val->intval * 100 / ddata->charge_full;
734 		if (cpcap_battery_full(ddata))
748 		empty = cpcap_battery_get_empty(ddata);
754 			if (ddata->charge_full && abs(val->intval) > ddata->charge_full/5) {
756 				ddata->charge_full = 0;
760 		} else if (ddata->charge_full && ddata->charge_full < val->intval) {
762 			if (val->intval > (6*ddata->charge_full)/5) {
764 				ddata->charge_full = 0;
767 			val->intval = ddata->charge_full;
771 		if (!ddata->charge_full)
773 		val->intval = ddata->charge_full;
776 		val->intval = ddata->config.info.charge_full_design;
793 static int cpcap_battery_update_charger(struct cpcap_battery_ddata *ddata,
830 	struct cpcap_battery_ddata *ddata = power_supply_get_drvdata(psy);
834 		if (val->intval < ddata->config.info.voltage_min_design)
836 		if (val->intval > ddata->config.info.voltage_max_design)
839 		ddata->config.bat.constant_charge_voltage_max_uv = val->intval;
841 		return cpcap_battery_update_charger(ddata, val->intval);
845 		if (val->intval > (6*ddata->config.info.charge_full_design)/5)
848 		ddata->charge_full = val->intval;
872 	struct cpcap_battery_ddata *ddata = data;
876 	if (!atomic_read(&ddata->active))
879 	list_for_each_entry(d, &ddata->irq_list, node) {
884 	if (list_entry_is_head(d, &ddata->irq_list, node))
887 	latest = cpcap_battery_latest(ddata);
891 		dev_info(ddata->dev, "Coulomb counter calibration done\n");
895 			dev_warn(ddata->dev, "Battery low at %imV!\n",
900 			dev_emerg(ddata->dev,
910 	power_supply_changed(ddata->psy);
916 				  struct cpcap_battery_ddata *ddata,
926 	error = devm_request_threaded_irq(ddata->dev, irq, NULL,
929 					  name, ddata);
931 		dev_err(ddata->dev, "could not get irq %s: %i\n",
937 	d = devm_kzalloc(ddata->dev, sizeof(*d), GFP_KERNEL);
951 	list_add(&d->node, &ddata->irq_list);
957 					 struct cpcap_battery_ddata *ddata)
966 		error = cpcap_battery_init_irq(pdev, ddata,
973 	cpcap_battery_init_irq(pdev, ddata, "cccal");
976 	error = regmap_update_bits(ddata->reg, CPCAP_REG_BPEOL,
985 static int cpcap_battery_init_iio(struct cpcap_battery_ddata *ddata)
993 		ddata->channels[i] = devm_iio_channel_get(ddata->dev,
995 		if (IS_ERR(ddata->channels[i])) {
996 			error = PTR_ERR(ddata->channels[i]);
1000 		if (!ddata->channels[i]->indio_dev) {
1009 	return dev_err_probe(ddata->dev, error,
1014 static int cpcap_battery_calibrate(struct cpcap_battery_ddata *ddata)
1019 	error = regmap_read(ddata->reg, CPCAP_REG_CCC1, &ccc1);
1026 	error = regmap_update_bits(ddata->reg, CPCAP_REG_CCC1,
1033 		error = regmap_read(ddata->reg, CPCAP_REG_CCC1, &value);
1040 		error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
1048 	error = regmap_read(ddata->reg, CPCAP_REG_CCM, &value);
1052 	dev_info(ddata->dev, "calibration done: 0x%04x\n", value);
1056 		dev_err(ddata->dev, "%s: error %i\n", __func__, error);
1058 	error = regmap_update_bits(ddata->reg, CPCAP_REG_CCC1,
1061 		dev_err(ddata->dev, "%s: restore error %i\n",
1090 	struct cpcap_battery_ddata *ddata;
1094 	ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
1095 	if (!ddata)
1098 	cpcap_battery_detect_battery_type(ddata);
1100 	INIT_LIST_HEAD(&ddata->irq_list);
1101 	ddata->dev = &pdev->dev;
1103 	ddata->reg = dev_get_regmap(ddata->dev->parent, NULL);
1104 	if (!ddata->reg)
1107 	error = cpcap_get_vendor(ddata->dev, ddata->reg, &ddata->vendor);
1111 	switch (ddata->vendor) {
1113 		ddata->cc_lsb = 95374;	/* ��Ams per LSB */
1116 		ddata->cc_lsb = 91501;	/* ��Ams per LSB */
1121 	ddata->cc_lsb = (ddata->cc_lsb * ddata->config.cd_factor) / 1000;
1123 	platform_set_drvdata(pdev, ddata);
1125 	error = cpcap_battery_init_interrupts(pdev, ddata);
1129 	error = cpcap_battery_init_iio(ddata);
1134 	psy_cfg.drv_data = ddata;
1136 	ddata->psy = devm_power_supply_register(ddata->dev,
1139 	error = PTR_ERR_OR_ZERO(ddata->psy);
1141 		dev_err(ddata->dev, "failed to register power supply\n");
1145 	atomic_set(&ddata->active, 1);
1147 	error = cpcap_battery_calibrate(ddata);
1156 	struct cpcap_battery_ddata *ddata = platform_get_drvdata(pdev);
1159 	atomic_set(&ddata->active, 0);
1160 	error = regmap_update_bits(ddata->reg, CPCAP_REG_BPEOL,