power/supply/bq25980_charger.c

275 static int bq25980_get_input_curr_lim(struct bq25980_device *bq)
280 	ret = regmap_read(bq->regmap, BQ25980_BUSOCP, &busocp_reg_code);
287 static int bq25980_set_hiz(struct bq25980_device *bq, int setting)
289 	return regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
293 static int bq25980_set_input_curr_lim(struct bq25980_device *bq, int busocp)
299 		return bq25980_set_hiz(bq, BQ25980_ENABLE_HIZ);
301 	bq25980_set_hiz(bq, BQ25980_DISABLE_HIZ);
306 	if (bq->state.bypass)
307 		busocp = min(busocp, bq->chip_info->busocp_sc_max);
309 		busocp = min(busocp, bq->chip_info->busocp_byp_max);
314 	ret = regmap_write(bq->regmap, BQ25980_BUSOCP, busocp_reg_code);
318 	return regmap_write(bq->regmap, BQ25980_BUSOCP_ALM, busocp_reg_code);
321 static int bq25980_get_input_volt_lim(struct bq25980_device *bq)
328 	if (bq->state.bypass) {
329 		busovp_step = bq->chip_info->busovp_byp_step;
330 		busovp_offset = bq->chip_info->busovp_byp_offset;
332 		busovp_step = bq->chip_info->busovp_sc_step;
333 		busovp_offset = bq->chip_info->busovp_sc_offset;
336 	ret = regmap_read(bq->regmap, BQ25980_BUSOVP, &busovp_reg_code);
343 static int bq25980_set_input_volt_lim(struct bq25980_device *bq, int busovp)
350 	if (bq->state.bypass) {
351 		busovp_step = bq->chip_info->busovp_byp_step;
352 		busovp_offset = bq->chip_info->busovp_byp_offset;
353 		if (busovp > bq->chip_info->busovp_byp_max)
354 			busovp = bq->chip_info->busovp_byp_max;
355 		else if (busovp < bq->chip_info->busovp_byp_min)
356 			busovp = bq->chip_info->busovp_byp_min;
358 		busovp_step = bq->chip_info->busovp_sc_step;
359 		busovp_offset = bq->chip_info->busovp_sc_offset;
360 		if (busovp > bq->chip_info->busovp_sc_max)
361 			busovp = bq->chip_info->busovp_sc_max;
362 		else if (busovp < bq->chip_info->busovp_sc_min)
363 			busovp = bq->chip_info->busovp_sc_min;
368 	ret = regmap_write(bq->regmap, BQ25980_BUSOVP, busovp_reg_code);
372 	return regmap_write(bq->regmap, BQ25980_BUSOVP_ALM, busovp_reg_code);
375 static int bq25980_get_const_charge_curr(struct bq25980_device *bq)
380 	ret = regmap_read(bq->regmap, BQ25980_BATOCP, &batocp_reg_code);
388 static int bq25980_set_const_charge_curr(struct bq25980_device *bq, int batocp)
394 	batocp = min(batocp, bq->chip_info->batocp_max);
398 	ret = regmap_update_bits(bq->regmap, BQ25980_BATOCP,
403 	return regmap_update_bits(bq->regmap, BQ25980_BATOCP_ALM,
407 static int bq25980_get_const_charge_volt(struct bq25980_device *bq)
412 	ret = regmap_read(bq->regmap, BQ25980_BATOVP, &batovp_reg_code);
416 	return ((batovp_reg_code * bq->chip_info->batovp_step) +
417 			bq->chip_info->batovp_offset);
420 static int bq25980_set_const_charge_volt(struct bq25980_device *bq, int batovp)
425 	if (batovp < bq->chip_info->batovp_min)
426 		batovp = bq->chip_info->batovp_min;
428 	if (batovp > bq->chip_info->batovp_max)
429 		batovp = bq->chip_info->batovp_max;
431 	batovp_reg_code = (batovp - bq->chip_info->batovp_offset) /
432 						bq->chip_info->batovp_step;
434 	ret = regmap_write(bq->regmap, BQ25980_BATOVP, batovp_reg_code);
438 	return regmap_write(bq->regmap, BQ25980_BATOVP_ALM, batovp_reg_code);
441 static int bq25980_set_bypass(struct bq25980_device *bq, bool en_bypass)
446 		ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
449 		ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
454 	bq->state.bypass = en_bypass;
456 	return bq->state.bypass;
459 static int bq25980_set_chg_en(struct bq25980_device *bq, bool en_chg)
464 		ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
467 		ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
472 	bq->state.ce = en_chg;
477 static int bq25980_get_adc_ibus(struct bq25980_device *bq)
483 	ret = regmap_read(bq->regmap, BQ25980_IBUS_ADC_MSB, &ibus_adc_msb);
487 	ret = regmap_read(bq->regmap, BQ25980_IBUS_ADC_LSB, &ibus_adc_lsb);
499 static int bq25980_get_adc_vbus(struct bq25980_device *bq)
505 	ret = regmap_read(bq->regmap, BQ25980_VBUS_ADC_MSB, &vbus_adc_msb);
509 	ret = regmap_read(bq->regmap, BQ25980_VBUS_ADC_LSB, &vbus_adc_lsb);
518 static int bq25980_get_ibat_adc(struct bq25980_device *bq)
524 	ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_MSB, &ibat_adc_msb);
528 	ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_LSB, &ibat_adc_lsb);
540 static int bq25980_get_adc_vbat(struct bq25980_device *bq)
546 	ret = regmap_read(bq->regmap, BQ25980_VBAT_ADC_MSB, &vsys_adc_msb);
550 	ret = regmap_read(bq->regmap, BQ25980_VBAT_ADC_LSB, &vsys_adc_lsb);
559 static int bq25980_get_state(struct bq25980_device *bq,
570 	ret = regmap_read(bq->regmap, BQ25980_STAT1, &stat1);
574 	ret = regmap_read(bq->regmap, BQ25980_STAT2, &stat2);
578 	ret = regmap_read(bq->regmap, BQ25980_STAT3, &stat3);
582 	ret = regmap_read(bq->regmap, BQ25980_STAT4, &stat4);
586 	ret = regmap_read(bq->regmap, BQ25980_CHRGR_CTRL_2, &chg_ctrl_2);
590 	ret = regmap_read(bq->regmap, BQ25980_IBAT_ADC_MSB, &ibat_adc_msb);
613 	struct bq25980_device *bq = power_supply_get_drvdata(psy);
618 		val->intval = bq->init_data.ichg_max;
622 		val->intval = bq->init_data.vreg_max;
626 		ret = bq25980_get_ibat_adc(bq);
631 		ret = bq25980_get_adc_vbat(bq);
649 	struct bq25980_device *bq = power_supply_get_drvdata(psy);
654 		ret = bq25980_set_input_curr_lim(bq, val->intval);
660 		ret = bq25980_set_input_volt_lim(bq, val->intval);
666 		ret = bq25980_set_bypass(bq, val->intval);
672 		ret = bq25980_set_chg_en(bq, val->intval);
678 		ret = bq25980_set_const_charge_curr(bq, val->intval);
684 		ret = bq25980_set_const_charge_volt(bq, val->intval);
700 	struct bq25980_device *bq = power_supply_get_drvdata(psy);
704 	mutex_lock(&bq->lock);
705 	ret = bq25980_get_state(bq, &state);
706 	mutex_unlock(&bq->lock);
715 		val->strval = bq->model_name;
722 		ret = bq25980_get_input_volt_lim(bq);
729 		ret = bq25980_get_input_curr_lim(bq);
773 		ret = bq25980_get_adc_ibus(bq);
781 		ret = bq25980_get_adc_vbus(bq);
789 		ret = bq25980_get_const_charge_curr(bq);
797 		ret = bq25980_get_const_charge_volt(bq);
811 static bool bq25980_state_changed(struct bq25980_device *bq,
816 	mutex_lock(&bq->lock);
817 	old_state = bq->state;
818 	mutex_unlock(&bq->lock);
833 	struct bq25980_device *bq = private;
837 	ret = bq25980_get_state(bq, &state);
841 	if (!bq25980_state_changed(bq, &state))
844 	mutex_lock(&bq->lock);
845 	bq->state = state;
846 	mutex_unlock(&bq->lock);
848 	power_supply_changed(bq->charger);
1056 static int bq25980_power_supply_init(struct bq25980_device *bq,
1059 	struct power_supply_config psy_cfg = { .drv_data = bq,
1065 	bq->charger = devm_power_supply_register(bq->dev,
1068 	if (IS_ERR(bq->charger))
1071 	bq->battery = devm_power_supply_register(bq->dev,
1074 	if (IS_ERR(bq->battery))
1080 static int bq25980_hw_init(struct bq25980_device *bq)
1090 	if (bq->watchdog_timer) {
1091 		if (bq->watchdog_timer >= bq25980_watchdog_time[wd_max_val])
1095 				if (bq->watchdog_timer > bq25980_watchdog_time[i] &&
1096 				    bq->watchdog_timer < bq25980_watchdog_time[i + 1]) {
1104 	ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_3,
1109 	ret = power_supply_get_battery_info(bq->charger, &bat_info);
1111 		dev_warn(bq->dev, "battery info missing\n");
1115 	bq->init_data.ichg_max = bat_info->constant_charge_current_max_ua;
1116 	bq->init_data.vreg_max = bat_info->constant_charge_voltage_max_uv;
1118 	if (bq->state.bypass) {
1119 		ret = regmap_update_bits(bq->regmap, BQ25980_CHRGR_CTRL_2,
1124 		curr_val = bq->init_data.bypass_ilim;
1125 		volt_val = bq->init_data.bypass_vlim;
1127 		curr_val = bq->init_data.sc_ilim;
1128 		volt_val = bq->init_data.sc_vlim;
1131 	ret = bq25980_set_input_curr_lim(bq, curr_val);
1135 	ret = bq25980_set_input_volt_lim(bq, volt_val);
1139 	return regmap_update_bits(bq->regmap, BQ25980_ADC_CONTROL1,
1143 static int bq25980_parse_dt(struct bq25980_device *bq)
1147 	ret = device_property_read_u32(bq->dev, "ti,watchdog-timeout-ms",
1148 				       &bq->watchdog_timer);
1150 		bq->watchdog_timer = BQ25980_WATCHDOG_MIN;
1152 	if (bq->watchdog_timer > BQ25980_WATCHDOG_MAX ||
1153 	    bq->watchdog_timer < BQ25980_WATCHDOG_MIN)
1156 	ret = device_property_read_u32(bq->dev,
1158 				       &bq->init_data.sc_vlim);
1160 		bq->init_data.sc_vlim = bq->chip_info->busovp_sc_def;
1162 	if (bq->init_data.sc_vlim > bq->chip_info->busovp_sc_max ||
1163 	    bq->init_data.sc_vlim < bq->chip_info->busovp_sc_min) {
1164 		dev_err(bq->dev, "SC ovp limit is out of range\n");
1168 	ret = device_property_read_u32(bq->dev,
1170 				       &bq->init_data.sc_ilim);
1172 		bq->init_data.sc_ilim = bq->chip_info->busocp_def;
1174 	if (bq->init_data.sc_ilim > bq->chip_info->busocp_sc_max ||
1175 	    bq->init_data.sc_ilim < bq->chip_info->busocp_sc_min) {
1176 		dev_err(bq->dev, "SC ocp limit is out of range\n");
1180 	ret = device_property_read_u32(bq->dev,
1182 				       &bq->init_data.bypass_vlim);
1184 		bq->init_data.bypass_vlim = bq->chip_info->busovp_byp_def;
1186 	if (bq->init_data.bypass_vlim > bq->chip_info->busovp_byp_max ||
1187 	    bq->init_data.bypass_vlim < bq->chip_info->busovp_byp_min) {
1188 		dev_err(bq->dev, "Bypass ovp limit is out of range\n");
1192 	ret = device_property_read_u32(bq->dev,
1194 				       &bq->init_data.bypass_ilim);
1196 		bq->init_data.bypass_ilim = bq->chip_info->busocp_def;
1198 	if (bq->init_data.bypass_ilim > bq->chip_info->busocp_byp_max ||
1199 	    bq->init_data.bypass_ilim < bq->chip_info->busocp_byp_min) {
1200 		dev_err(bq->dev, "Bypass ocp limit is out of range\n");
1205 	bq->state.bypass = device_property_read_bool(bq->dev,
1214 	struct bq25980_device *bq;
1217 	bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
1218 	if (!bq)
1221 	bq->client = client;
1222 	bq->dev = dev;
1224 	mutex_init(&bq->lock);
1226 	strscpy(bq->model_name, id->name, sizeof(bq->model_name));
1227 	bq->chip_info = &bq25980_chip_info_tbl[id->driver_data];
1229 	bq->regmap = devm_regmap_init_i2c(client,
1230 					  bq->chip_info->regmap_config);
1231 	if (IS_ERR(bq->regmap)) {
1233 		return PTR_ERR(bq->regmap);
1236 	i2c_set_clientdata(client, bq);
1238 	ret = bq25980_parse_dt(bq);
1249 						dev_name(&client->dev), bq);
1254 	ret = bq25980_power_supply_init(bq, dev);
1260 	ret = bq25980_hw_init(bq);