1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Charger Driver for Rockchip rk817
4  *
5  * Copyright (c) 2021 Maya Matuszczyk <maccraft123mc@gmail.com>
6  *
7  * Authors: Maya Matuszczyk <maccraft123mc@gmail.com>
8  *	    Chris Morgan <macromorgan@hotmail.com>
9  */
10 
11 #include <asm/unaligned.h>
12 #include <linux/devm-helpers.h>
13 #include <linux/mfd/rk808.h>
14 #include <linux/irq.h>
15 #include <linux/of.h>
16 #include <linux/platform_device.h>
17 #include <linux/power_supply.h>
18 #include <linux/regmap.h>
19 
20 /* Charging statuses reported by hardware register */
21 enum rk817_charge_status {
22 	CHRG_OFF,
23 	DEAD_CHRG,
24 	TRICKLE_CHRG,
25 	CC_OR_CV_CHRG,
26 	CHARGE_FINISH,
27 	USB_OVER_VOL,
28 	BAT_TMP_ERR,
29 	BAT_TIM_ERR,
30 };
31 
32 /*
33  * Max charging current read to/written from hardware register.
34  * Note how highest value corresponding to 0x7 is the lowest
35  * current, this is per the datasheet.
36  */
37 enum rk817_chg_cur {
38 	CHG_1A,
39 	CHG_1_5A,
40 	CHG_2A,
41 	CHG_2_5A,
42 	CHG_2_75A,
43 	CHG_3A,
44 	CHG_3_5A,
45 	CHG_0_5A,
46 };
47 
48 struct rk817_charger {
49 	struct device *dev;
50 	struct rk808 *rk808;
51 
52 	struct power_supply *bat_ps;
53 	struct power_supply *chg_ps;
54 	bool plugged_in;
55 	bool battery_present;
56 
57 	/*
58 	 * voltage_k and voltage_b values are used to calibrate the ADC
59 	 * voltage readings. While they are documented in the BSP kernel and
60 	 * datasheet as voltage_k and voltage_b, there is no further
61 	 * information explaining them in more detail.
62 	 */
63 
64 	uint32_t voltage_k;
65 	uint32_t voltage_b;
66 
67 	/*
68 	 * soc - state of charge - like the BSP this is stored as a percentage,
69 	 * to the thousandth. BSP has a display state of charge (dsoc) and a
70 	 * remaining state of charge (rsoc). This value will be used for both
71 	 * purposes here so we don't do any fancy math to try and "smooth" the
72 	 * charge and just report it as it is. Note for example an soc of 100
73 	 * is stored as 100000, an soc of 50 is stored as 50000, etc.
74 	 */
75 	int soc;
76 
77 	/*
78 	 * Capacity of battery when fully charged, equal or less than design
79 	 * capacity depending upon wear. BSP kernel saves to nvram in mAh,
80 	 * so this value is in mAh not the standard uAh.
81 	 */
82 	int fcc_mah;
83 
84 	/*
85 	 * Calibrate the SOC on a fully charged battery, this way we can use
86 	 * the calibrated SOC value to correct for columb counter drift.
87 	 */
88 	bool soc_cal;
89 
90 	/* Implementation specific immutable properties from device tree */
91 	int res_div;
92 	int sleep_enter_current_ua;
93 	int sleep_filter_current_ua;
94 	int bat_charge_full_design_uah;
95 	int bat_voltage_min_design_uv;
96 	int bat_voltage_max_design_uv;
97 
98 	/* Values updated periodically by driver for display. */
99 	int charge_now_uah;
100 	int volt_avg_uv;
101 	int cur_avg_ua;
102 	int max_chg_cur_ua;
103 	int max_chg_volt_uv;
104 	int charge_status;
105 	int charger_input_volt_avg_uv;
106 
107 	/* Work queue to periodically update values. */
108 	struct delayed_work work;
109 };
110 
111 /* ADC coefficients extracted from BSP kernel */
112 #define ADC_TO_CURRENT(adc_value, res_div)	\
113 	(adc_value * 172 / res_div)
114 
115 #define CURRENT_TO_ADC(current, samp_res)	\
116 	(current * samp_res / 172)
117 
118 #define CHARGE_TO_ADC(capacity, res_div)	\
119 	(capacity * res_div * 3600 / 172 * 1000)
120 
121 #define ADC_TO_CHARGE_UAH(adc_value, res_div)	\
122 	(adc_value / 3600 * 172 / res_div)
123 
124 static int rk817_chg_cur_to_reg(u32 chg_cur_ma)
125 {
126 	if (chg_cur_ma >= 3500)
127 		return CHG_3_5A;
128 	else if (chg_cur_ma >= 3000)
129 		return CHG_3A;
130 	else if (chg_cur_ma >= 2750)
131 		return CHG_2_75A;
132 	else if (chg_cur_ma >= 2500)
133 		return CHG_2_5A;
134 	else if (chg_cur_ma >= 2000)
135 		return CHG_2A;
136 	else if (chg_cur_ma >= 1500)
137 		return CHG_1_5A;
138 	else if (chg_cur_ma >= 1000)
139 		return CHG_1A;
140 	else if (chg_cur_ma >= 500)
141 		return CHG_0_5A;
142 	else
143 		return -EINVAL;
144 }
145 
146 static int rk817_chg_cur_from_reg(u8 reg)
147 {
148 	switch (reg) {
149 	case CHG_0_5A:
150 		return 500000;
151 	case CHG_1A:
152 		return 1000000;
153 	case CHG_1_5A:
154 		return 1500000;
155 	case CHG_2A:
156 		return 2000000;
157 	case CHG_2_5A:
158 		return 2500000;
159 	case CHG_2_75A:
160 		return 2750000;
161 	case CHG_3A:
162 		return 3000000;
163 	case CHG_3_5A:
164 		return 3500000;
165 	default:
166 		return -EINVAL;
167 	}
168 }
169 
170 static void rk817_bat_calib_vol(struct rk817_charger *charger)
171 {
172 	uint32_t vcalib0 = 0;
173 	uint32_t vcalib1 = 0;
174 	u8 bulk_reg[2];
175 
176 	/* calibrate voltage */
177 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_VCALIB0_H,
178 			 bulk_reg, 2);
179 	vcalib0 = get_unaligned_be16(bulk_reg);
180 
181 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_VCALIB1_H,
182 			 bulk_reg, 2);
183 	vcalib1 = get_unaligned_be16(bulk_reg);
184 
185 	/* values were taken from BSP kernel */
186 	charger->voltage_k = (4025 - 2300) * 1000 /
187 			     ((vcalib1 - vcalib0) ? (vcalib1 - vcalib0) : 1);
188 	charger->voltage_b = 4025 - (charger->voltage_k * vcalib1) / 1000;
189 }
190 
191 static void rk817_bat_calib_cur(struct rk817_charger *charger)
192 {
193 	u8 bulk_reg[2];
194 
195 	/* calibrate current */
196 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_IOFFSET_H,
197 			 bulk_reg, 2);
198 	regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_CAL_OFFSET_H,
199 			  bulk_reg, 2);
200 }
201 
202 /*
203  * note that only the fcc_mah is really used by this driver, the other values
204  * are to ensure we can remain backwards compatible with the BSP kernel.
205  */
206 static int rk817_record_battery_nvram_values(struct rk817_charger *charger)
207 {
208 	u8 bulk_reg[3];
209 	int ret, rsoc;
210 
211 	/*
212 	 * write the soc value to the nvram location used by the BSP kernel
213 	 * for the dsoc value.
214 	 */
215 	put_unaligned_le24(charger->soc, bulk_reg);
216 	ret = regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_R1,
217 				bulk_reg, 3);
218 	if (ret < 0)
219 		return ret;
220 	/*
221 	 * write the remaining capacity in mah to the nvram location used by
222 	 * the BSP kernel for the rsoc value.
223 	 */
224 	rsoc = (charger->soc * charger->fcc_mah) / 100000;
225 	put_unaligned_le24(rsoc, bulk_reg);
226 	ret = regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_DATA0,
227 				bulk_reg, 3);
228 	if (ret < 0)
229 		return ret;
230 	/* write the fcc_mah in mAh, just as the BSP kernel does. */
231 	put_unaligned_le24(charger->fcc_mah, bulk_reg);
232 	ret = regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_DATA3,
233 				bulk_reg, 3);
234 	if (ret < 0)
235 		return ret;
236 
237 	return 0;
238 }
239 
240 static int rk817_bat_calib_cap(struct rk817_charger *charger)
241 {
242 	struct rk808 *rk808 = charger->rk808;
243 	int tmp, charge_now, charge_now_adc, volt_avg;
244 	u8 bulk_reg[4];
245 
246 	/* Calibrate the soc and fcc on a fully charged battery */
247 
248 	if (charger->charge_status == CHARGE_FINISH && (!charger->soc_cal)) {
249 		/*
250 		 * soc should be 100000 and columb counter should show the full
251 		 * charge capacity. Note that if the device is unplugged for a
252 		 * period of several days the columb counter will have a large
253 		 * margin of error, so setting it back to the full charge on
254 		 * a completed charge cycle should correct this (my device was
255 		 * showing 33% battery after 3 days unplugged when it should
256 		 * have been closer to 95% based on voltage and charge
257 		 * current).
258 		 */
259 
260 		charger->soc = 100000;
261 		charge_now_adc = CHARGE_TO_ADC(charger->fcc_mah,
262 					       charger->res_div);
263 		put_unaligned_be32(charge_now_adc, bulk_reg);
264 		regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_H3,
265 				  bulk_reg, 4);
266 
267 		charger->soc_cal = 1;
268 		dev_dbg(charger->dev,
269 			"Fully charged. SOC is %d, full capacity is %d\n",
270 			charger->soc, charger->fcc_mah * 1000);
271 	}
272 
273 	/*
274 	 * The columb counter can drift up slightly, so we should correct for
275 	 * it. But don't correct it until we're at 100% soc.
276 	 */
277 	if (charger->charge_status == CHARGE_FINISH && charger->soc_cal) {
278 		regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3,
279 				 bulk_reg, 4);
280 		charge_now_adc = get_unaligned_be32(bulk_reg);
281 		if (charge_now_adc < 0)
282 			return charge_now_adc;
283 		charge_now = ADC_TO_CHARGE_UAH(charge_now_adc,
284 					       charger->res_div);
285 
286 		/*
287 		 * Re-init columb counter with updated values to correct drift.
288 		 */
289 		if (charge_now / 1000 > charger->fcc_mah) {
290 			dev_dbg(charger->dev,
291 				"Recalibrating columb counter to %d uah\n",
292 				charge_now);
293 			/*
294 			 * Order of operations matters here to ensure we keep
295 			 * enough precision until the last step to keep from
296 			 * making needless updates to columb counter.
297 			 */
298 			charge_now_adc = CHARGE_TO_ADC(charger->fcc_mah,
299 					 charger->res_div);
300 			put_unaligned_be32(charge_now_adc, bulk_reg);
301 			regmap_bulk_write(rk808->regmap,
302 					  RK817_GAS_GAUGE_Q_INIT_H3,
303 					  bulk_reg, 4);
304 		}
305 	}
306 
307 	/*
308 	 * Calibrate the fully charged capacity when we previously had a full
309 	 * battery (soc_cal = 1) and are now empty (at or below minimum design
310 	 * voltage). If our columb counter is still positive, subtract that
311 	 * from our fcc value to get a calibrated fcc, and if our columb
312 	 * counter is negative add that to our fcc (but not to exceed our
313 	 * design capacity).
314 	 */
315 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_VOL_H,
316 			 bulk_reg, 2);
317 	tmp = get_unaligned_be16(bulk_reg);
318 	volt_avg = (charger->voltage_k * tmp) + 1000 * charger->voltage_b;
319 	if (volt_avg <= charger->bat_voltage_min_design_uv &&
320 	    charger->soc_cal) {
321 		regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3,
322 				 bulk_reg, 4);
323 		charge_now_adc = get_unaligned_be32(bulk_reg);
324 		charge_now = ADC_TO_CHARGE_UAH(charge_now_adc,
325 					       charger->res_div);
326 		/*
327 		 * Note, if charge_now is negative this will add it (what we
328 		 * want) and if it's positive this will subtract (also what
329 		 * we want).
330 		 */
331 		charger->fcc_mah = charger->fcc_mah - (charge_now / 1000);
332 
333 		dev_dbg(charger->dev,
334 			"Recalibrating full charge capacity to %d uah\n",
335 			charger->fcc_mah * 1000);
336 	}
337 
338 	rk817_record_battery_nvram_values(charger);
339 
340 	return 0;
341 }
342 
343 static void rk817_read_props(struct rk817_charger *charger)
344 {
345 	int tmp, reg;
346 	u8 bulk_reg[4];
347 
348 	/*
349 	 * Recalibrate voltage and current readings if we need to BSP does both
350 	 * on CUR_CALIB_UPD, ignoring VOL_CALIB_UPD. Curiously enough, both
351 	 * documentation and the BSP show that you perform an update if bit 7
352 	 * is 1, but you clear the status by writing a 1 to bit 7.
353 	 */
354 	regmap_read(charger->rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG1, &reg);
355 	if (reg & RK817_VOL_CUR_CALIB_UPD) {
356 		rk817_bat_calib_cur(charger);
357 		rk817_bat_calib_vol(charger);
358 		regmap_write_bits(charger->rk808->regmap,
359 				  RK817_GAS_GAUGE_ADC_CONFIG1,
360 				  RK817_VOL_CUR_CALIB_UPD,
361 				  RK817_VOL_CUR_CALIB_UPD);
362 	}
363 
364 	/* Update reported charge. */
365 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3,
366 			 bulk_reg, 4);
367 	tmp = get_unaligned_be32(bulk_reg);
368 	charger->charge_now_uah = ADC_TO_CHARGE_UAH(tmp, charger->res_div);
369 	if (charger->charge_now_uah < 0)
370 		charger->charge_now_uah = 0;
371 	if (charger->charge_now_uah > charger->fcc_mah * 1000)
372 		charger->charge_now_uah = charger->fcc_mah * 1000;
373 
374 	/* Update soc based on reported charge. */
375 	charger->soc = charger->charge_now_uah * 100 / charger->fcc_mah;
376 
377 	/* Update reported voltage. */
378 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_VOL_H,
379 			 bulk_reg, 2);
380 	tmp = get_unaligned_be16(bulk_reg);
381 	charger->volt_avg_uv = (charger->voltage_k * tmp) + 1000 *
382 				charger->voltage_b;
383 
384 	/*
385 	 * Update reported current. Note value from registers is a signed 16
386 	 * bit int.
387 	 */
388 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_CUR_H,
389 			 bulk_reg, 2);
390 	tmp = (short int)get_unaligned_be16(bulk_reg);
391 	charger->cur_avg_ua = ADC_TO_CURRENT(tmp, charger->res_div);
392 
393 	/*
394 	 * Update the max charge current. This value shouldn't change, but we
395 	 * can read it to report what the PMIC says it is instead of simply
396 	 * returning the default value.
397 	 */
398 	regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_OUT, &reg);
399 	charger->max_chg_cur_ua =
400 		rk817_chg_cur_from_reg(reg & RK817_CHRG_CUR_SEL);
401 
402 	/*
403 	 * Update max charge voltage. Like the max charge current this value
404 	 * shouldn't change, but we can report what the PMIC says.
405 	 */
406 	regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_OUT, &reg);
407 	charger->max_chg_volt_uv = ((((reg & RK817_CHRG_VOL_SEL) >> 4) *
408 				    50000) + 4100000);
409 
410 	/* Check if battery still present. */
411 	regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_STS, &reg);
412 	charger->battery_present = (reg & RK817_BAT_EXS);
413 
414 	/* Get which type of charge we are using (if any). */
415 	regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_STS, &reg);
416 	charger->charge_status = (reg >> 4) & 0x07;
417 
418 	/*
419 	 * Get charger input voltage. Note that on my example hardware (an
420 	 * Odroid Go Advance) the voltage of the power connector is measured
421 	 * on the register labelled USB in the datasheet; I don't know if this
422 	 * is how it is designed or just a quirk of the implementation. I
423 	 * believe this will also measure the voltage of the USB output when in
424 	 * OTG mode, if that is the case we may need to change this in the
425 	 * future to return 0 if the power supply status is offline (I can't
426 	 * test this with my current implementation. Also, when the voltage
427 	 * should be zero sometimes the ADC still shows a single bit (which
428 	 * would register as 20000uv). When this happens set it to 0.
429 	 */
430 	regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_USB_VOL_H,
431 			 bulk_reg, 2);
432 	reg = get_unaligned_be16(bulk_reg);
433 	if (reg > 1) {
434 		tmp = ((charger->voltage_k * reg / 1000 + charger->voltage_b) *
435 		       60 / 46);
436 		charger->charger_input_volt_avg_uv = tmp * 1000;
437 	} else {
438 		charger->charger_input_volt_avg_uv = 0;
439 	}
440 
441 	/* Calibrate battery capacity and soc. */
442 	rk817_bat_calib_cap(charger);
443 }
444 
445 static int rk817_bat_get_prop(struct power_supply *ps,
446 		enum power_supply_property prop,
447 		union power_supply_propval *val)
448 {
449 	struct rk817_charger *charger = power_supply_get_drvdata(ps);
450 
451 	switch (prop) {
452 	case POWER_SUPPLY_PROP_PRESENT:
453 		val->intval = charger->battery_present;
454 		break;
455 	case POWER_SUPPLY_PROP_STATUS:
456 		if (charger->cur_avg_ua < 0) {
457 			val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
458 			break;
459 		}
460 		switch (charger->charge_status) {
461 		case CHRG_OFF:
462 			val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
463 			break;
464 		/*
465 		 * Dead charge is documented, but not explained. I never
466 		 * observed it but assume it's a pre-charge for a dead
467 		 * battery.
468 		 */
469 		case DEAD_CHRG:
470 		case TRICKLE_CHRG:
471 		case CC_OR_CV_CHRG:
472 			val->intval = POWER_SUPPLY_STATUS_CHARGING;
473 			break;
474 		case CHARGE_FINISH:
475 			val->intval = POWER_SUPPLY_STATUS_FULL;
476 			break;
477 		default:
478 			val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
479 			return -EINVAL;
480 
481 		}
482 		break;
483 	case POWER_SUPPLY_PROP_CHARGE_TYPE:
484 		switch (charger->charge_status) {
485 		case CHRG_OFF:
486 		case CHARGE_FINISH:
487 			val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
488 			break;
489 		case TRICKLE_CHRG:
490 			val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
491 			break;
492 		case DEAD_CHRG:
493 		case CC_OR_CV_CHRG:
494 			val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD;
495 			break;
496 		default:
497 			val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
498 			break;
499 		}
500 		break;
501 	case POWER_SUPPLY_PROP_CHARGE_FULL:
502 		val->intval = charger->fcc_mah * 1000;
503 		break;
504 	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
505 		val->intval = charger->bat_charge_full_design_uah;
506 		break;
507 	case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
508 		val->intval = 0;
509 		break;
510 	case POWER_SUPPLY_PROP_CHARGE_NOW:
511 		val->intval = charger->charge_now_uah;
512 		break;
513 	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
514 		val->intval = charger->bat_voltage_min_design_uv;
515 		break;
516 	case POWER_SUPPLY_PROP_CAPACITY:
517 		/* Add 500 so that values like 99999 are 100% not 99%. */
518 		val->intval = (charger->soc + 500) / 1000;
519 		if (val->intval > 100)
520 			val->intval = 100;
521 		if (val->intval < 0)
522 			val->intval = 0;
523 		break;
524 	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
525 		val->intval = charger->volt_avg_uv;
526 		break;
527 	case POWER_SUPPLY_PROP_CURRENT_AVG:
528 		val->intval = charger->cur_avg_ua;
529 		break;
530 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
531 		val->intval = charger->max_chg_cur_ua;
532 		break;
533 	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
534 		val->intval = charger->max_chg_volt_uv;
535 		break;
536 	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
537 		val->intval = charger->bat_voltage_max_design_uv;
538 		break;
539 	default:
540 		return -EINVAL;
541 	}
542 	return 0;
543 }
544 
545 static int rk817_chg_get_prop(struct power_supply *ps,
546 			      enum power_supply_property prop,
547 			      union power_supply_propval *val)
548 {
549 	struct rk817_charger *charger = power_supply_get_drvdata(ps);
550 
551 	switch (prop) {
552 	case POWER_SUPPLY_PROP_ONLINE:
553 		val->intval = charger->plugged_in;
554 		break;
555 	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
556 		/* max voltage from datasheet at 5.5v (default 5.0v) */
557 		val->intval = 5500000;
558 		break;
559 	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
560 		/* min voltage from datasheet at 3.8v (default 5.0v) */
561 		val->intval = 3800000;
562 		break;
563 	case POWER_SUPPLY_PROP_VOLTAGE_AVG:
564 		val->intval = charger->charger_input_volt_avg_uv;
565 		break;
566 	/*
567 	 * While it's possible that other implementations could use different
568 	 * USB types, the current implementation for this PMIC (the Odroid Go
569 	 * Advance) only uses a dedicated charging port with no rx/tx lines.
570 	 */
571 	case POWER_SUPPLY_PROP_USB_TYPE:
572 		val->intval = POWER_SUPPLY_USB_TYPE_DCP;
573 		break;
574 	default:
575 		return -EINVAL;
576 	}
577 	return 0;
578 
579 }
580 
581 static irqreturn_t rk817_plug_in_isr(int irq, void *cg)
582 {
583 	struct rk817_charger *charger;
584 
585 	charger = (struct rk817_charger *)cg;
586 	charger->plugged_in = 1;
587 	power_supply_changed(charger->chg_ps);
588 	power_supply_changed(charger->bat_ps);
589 	/* try to recalibrate capacity if we hit full charge. */
590 	charger->soc_cal = 0;
591 
592 	rk817_read_props(charger);
593 
594 	dev_dbg(charger->dev, "Power Cord Inserted\n");
595 
596 	return IRQ_HANDLED;
597 }
598 
599 static irqreturn_t rk817_plug_out_isr(int irq, void *cg)
600 {
601 	struct rk817_charger *charger;
602 	struct rk808 *rk808;
603 
604 	charger = (struct rk817_charger *)cg;
605 	rk808 = charger->rk808;
606 	charger->plugged_in = 0;
607 	power_supply_changed(charger->bat_ps);
608 	power_supply_changed(charger->chg_ps);
609 
610 	/*
611 	 * For some reason the bits of RK817_PMIC_CHRG_IN reset whenever the
612 	 * power cord is unplugged. This was not documented in the BSP kernel
613 	 * or the datasheet and only discovered by trial and error. Set minimum
614 	 * USB input voltage to 4.5v and enable USB voltage input limit.
615 	 */
616 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,
617 			  RK817_USB_VLIM_SEL, (0x05 << 4));
618 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_VLIM_EN,
619 			  (0x01 << 7));
620 
621 	/*
622 	 * Set average USB input current limit to 1.5A and enable USB current
623 	 * input limit.
624 	 */
625 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,
626 			  RK817_USB_ILIM_SEL, 0x03);
627 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_ILIM_EN,
628 			  (0x01 << 3));
629 
630 	rk817_read_props(charger);
631 
632 	dev_dbg(charger->dev, "Power Cord Removed\n");
633 
634 	return IRQ_HANDLED;
635 }
636 
637 static enum power_supply_property rk817_bat_props[] = {
638 	POWER_SUPPLY_PROP_PRESENT,
639 	POWER_SUPPLY_PROP_STATUS,
640 	POWER_SUPPLY_PROP_CHARGE_TYPE,
641 	POWER_SUPPLY_PROP_CHARGE_FULL,
642 	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
643 	POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,
644 	POWER_SUPPLY_PROP_CHARGE_NOW,
645 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
646 	POWER_SUPPLY_PROP_VOLTAGE_AVG,
647 	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
648 	POWER_SUPPLY_PROP_CURRENT_AVG,
649 	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
650 	POWER_SUPPLY_PROP_CAPACITY,
651 	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
652 };
653 
654 static enum power_supply_property rk817_chg_props[] = {
655 	POWER_SUPPLY_PROP_ONLINE,
656 	POWER_SUPPLY_PROP_USB_TYPE,
657 	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
658 	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
659 	POWER_SUPPLY_PROP_VOLTAGE_AVG,
660 };
661 
662 static enum power_supply_usb_type rk817_usb_type[] = {
663 	POWER_SUPPLY_USB_TYPE_DCP,
664 	POWER_SUPPLY_USB_TYPE_UNKNOWN,
665 };
666 
667 static const struct power_supply_desc rk817_bat_desc = {
668 	.name = "rk817-battery",
669 	.type = POWER_SUPPLY_TYPE_BATTERY,
670 	.properties = rk817_bat_props,
671 	.num_properties = ARRAY_SIZE(rk817_bat_props),
672 	.get_property = rk817_bat_get_prop,
673 };
674 
675 static const struct power_supply_desc rk817_chg_desc = {
676 	.name = "rk817-charger",
677 	.type = POWER_SUPPLY_TYPE_USB,
678 	.usb_types = rk817_usb_type,
679 	.num_usb_types = ARRAY_SIZE(rk817_usb_type),
680 	.properties = rk817_chg_props,
681 	.num_properties = ARRAY_SIZE(rk817_chg_props),
682 	.get_property = rk817_chg_get_prop,
683 };
684 
685 static int rk817_read_battery_nvram_values(struct rk817_charger *charger)
686 {
687 	u8 bulk_reg[3];
688 	int ret;
689 
690 	/* Read the nvram data for full charge capacity. */
691 	ret = regmap_bulk_read(charger->rk808->regmap,
692 			       RK817_GAS_GAUGE_DATA3, bulk_reg, 3);
693 	if (ret < 0)
694 		return ret;
695 	charger->fcc_mah = get_unaligned_le24(bulk_reg);
696 
697 	/*
698 	 * Sanity checking for values equal to zero or less than would be
699 	 * practical for this device (BSP Kernel assumes 500mAH or less) for
700 	 * practicality purposes. Also check if the value is too large and
701 	 * correct it.
702 	 */
703 	if ((charger->fcc_mah < 500) ||
704 	   ((charger->fcc_mah * 1000) > charger->bat_charge_full_design_uah)) {
705 		dev_info(charger->dev,
706 			 "Invalid NVRAM max charge, setting to %u uAH\n",
707 			 charger->bat_charge_full_design_uah);
708 		charger->fcc_mah = charger->bat_charge_full_design_uah / 1000;
709 	}
710 
711 	/*
712 	 * Read the nvram for state of charge. Sanity check for values greater
713 	 * than 100 (10000). If the value is off it should get corrected
714 	 * automatically when the voltage drops to the min (soc is 0) or when
715 	 * the battery is full (soc is 100).
716 	 */
717 	ret = regmap_bulk_read(charger->rk808->regmap,
718 			       RK817_GAS_GAUGE_BAT_R1, bulk_reg, 3);
719 	if (ret < 0)
720 		return ret;
721 	charger->soc = get_unaligned_le24(bulk_reg);
722 	if (charger->soc > 10000)
723 		charger->soc = 10000;
724 
725 	return 0;
726 }
727 
728 static int
729 rk817_read_or_set_full_charge_on_boot(struct rk817_charger *charger,
730 				struct power_supply_battery_info *bat_info)
731 {
732 	struct rk808 *rk808 = charger->rk808;
733 	u8 bulk_reg[4];
734 	u32 boot_voltage, boot_charge_mah, tmp;
735 	int ret, reg, off_time;
736 	bool first_boot;
737 
738 	/*
739 	 * Check if the battery is uninitalized. If it is, the columb counter
740 	 * needs to be set up.
741 	 */
742 	ret = regmap_read(rk808->regmap, RK817_GAS_GAUGE_GG_STS, &reg);
743 	if (ret < 0)
744 		return ret;
745 	first_boot = reg & RK817_BAT_CON;
746 	/*
747 	 * If the battery is uninitialized, use the poweron voltage and an ocv
748 	 * lookup to guess our charge. The number won't be very accurate until
749 	 * we hit either our minimum voltage (0%) or full charge (100%).
750 	 */
751 	if (first_boot) {
752 		regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_PWRON_VOL_H,
753 				 bulk_reg, 2);
754 		tmp = get_unaligned_be16(bulk_reg);
755 		boot_voltage = (charger->voltage_k * tmp) +
756 				1000 * charger->voltage_b;
757 		/*
758 		 * Since only implementation has no working thermistor, assume
759 		 * 20C for OCV lookup. If lookup fails, report error with OCV
760 		 * table.
761 		 */
762 		charger->soc = power_supply_batinfo_ocv2cap(bat_info,
763 							    boot_voltage,
764 							    20) * 1000;
765 		if (charger->soc < 0)
766 			charger->soc = 0;
767 
768 		/* Guess that full charge capacity is the design capacity */
769 		charger->fcc_mah = charger->bat_charge_full_design_uah / 1000;
770 		/*
771 		 * Set battery as "set up". BSP driver uses this value even
772 		 * though datasheet claims it's a read-only value.
773 		 */
774 		regmap_write_bits(rk808->regmap, RK817_GAS_GAUGE_GG_STS,
775 				  RK817_BAT_CON, 0);
776 		/* Save nvram values */
777 		ret = rk817_record_battery_nvram_values(charger);
778 		if (ret < 0)
779 			return ret;
780 	} else {
781 		ret = rk817_read_battery_nvram_values(charger);
782 		if (ret < 0)
783 			return ret;
784 
785 		regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3,
786 				 bulk_reg, 4);
787 		tmp = get_unaligned_be32(bulk_reg);
788 		if (tmp < 0)
789 			tmp = 0;
790 		boot_charge_mah = ADC_TO_CHARGE_UAH(tmp,
791 						    charger->res_div) / 1000;
792 		/*
793 		 * Check if the columb counter has been off for more than 300
794 		 * minutes as it tends to drift downward. If so, re-init soc
795 		 * with the boot voltage instead. Note the unit values for the
796 		 * OFF_CNT register appear to be in decaminutes and stops
797 		 * counting at 2550 (0xFF) minutes. BSP kernel used OCV, but
798 		 * for me occasionally that would show invalid values. Boot
799 		 * voltage is only accurate for me on first poweron (not
800 		 * reboots), but we shouldn't ever encounter an OFF_CNT more
801 		 * than 0 on a reboot anyway.
802 		 */
803 		regmap_read(rk808->regmap, RK817_GAS_GAUGE_OFF_CNT, &off_time);
804 		if (off_time >= 30) {
805 			regmap_bulk_read(rk808->regmap,
806 					 RK817_GAS_GAUGE_PWRON_VOL_H,
807 					 bulk_reg, 2);
808 			tmp = get_unaligned_be16(bulk_reg);
809 			boot_voltage = (charger->voltage_k * tmp) +
810 					1000 * charger->voltage_b;
811 			charger->soc =
812 				power_supply_batinfo_ocv2cap(bat_info,
813 							     boot_voltage,
814 							     20) * 1000;
815 		} else {
816 			charger->soc = (boot_charge_mah * 1000 * 100 /
817 					charger->fcc_mah);
818 		}
819 	}
820 
821 	regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_PWRON_VOL_H,
822 			 bulk_reg, 2);
823 	tmp = get_unaligned_be16(bulk_reg);
824 	boot_voltage = (charger->voltage_k * tmp) + 1000 * charger->voltage_b;
825 	regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3,
826 			 bulk_reg, 4);
827 	tmp = get_unaligned_be32(bulk_reg);
828 	if (tmp < 0)
829 		tmp = 0;
830 	boot_charge_mah = ADC_TO_CHARGE_UAH(tmp, charger->res_div) / 1000;
831 	regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_OCV_VOL_H,
832 			 bulk_reg, 2);
833 	tmp = get_unaligned_be16(bulk_reg);
834 	boot_voltage = (charger->voltage_k * tmp) + 1000 * charger->voltage_b;
835 
836 	/*
837 	 * Now we have our full charge capacity and soc, init the columb
838 	 * counter.
839 	 */
840 	boot_charge_mah = charger->soc * charger->fcc_mah / 100 / 1000;
841 	if (boot_charge_mah > charger->fcc_mah)
842 		boot_charge_mah = charger->fcc_mah;
843 	tmp = CHARGE_TO_ADC(boot_charge_mah, charger->res_div);
844 	put_unaligned_be32(tmp, bulk_reg);
845 	ret = regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_H3,
846 			  bulk_reg, 4);
847 	if (ret < 0)
848 		return ret;
849 
850 	/* Set QMAX value to max design capacity. */
851 	tmp = CHARGE_TO_ADC((charger->bat_charge_full_design_uah / 1000),
852 			    charger->res_div);
853 	put_unaligned_be32(tmp, bulk_reg);
854 	ret = regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_MAX_H3,
855 				bulk_reg, 4);
856 	if (ret < 0)
857 		return ret;
858 
859 	return 0;
860 }
861 
862 static int rk817_battery_init(struct rk817_charger *charger,
863 			      struct power_supply_battery_info *bat_info)
864 {
865 	struct rk808 *rk808 = charger->rk808;
866 	u32 tmp, max_chg_vol_mv, max_chg_cur_ma;
867 	u8 max_chg_vol_reg, chg_term_i_reg;
868 	int ret, chg_term_ma, max_chg_cur_reg;
869 	u8 bulk_reg[2];
870 
871 	/* Get initial plug state */
872 	regmap_read(rk808->regmap, RK817_SYS_STS, &tmp);
873 	charger->plugged_in = (tmp & RK817_PLUG_IN_STS);
874 
875 	/*
876 	 * Turn on all ADC functions to measure battery, USB, and sys voltage,
877 	 * as well as batt temp. Note only tested implementation so far does
878 	 * not use a battery with a thermistor.
879 	 */
880 	regmap_write(rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG0, 0xfc);
881 
882 	/*
883 	 * Set relax mode voltage sampling interval and ADC offset calibration
884 	 * interval to 8 minutes to mirror BSP kernel. Set voltage and current
885 	 * modes to average to mirror BSP kernel.
886 	 */
887 	regmap_write(rk808->regmap, RK817_GAS_GAUGE_GG_CON, 0x04);
888 
889 	/* Calibrate voltage like the BSP does here. */
890 	rk817_bat_calib_vol(charger);
891 
892 	/* Write relax threshold, derived from sleep enter current. */
893 	tmp = CURRENT_TO_ADC(charger->sleep_enter_current_ua,
894 			     charger->res_div);
895 	put_unaligned_be16(tmp, bulk_reg);
896 	regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_RELAX_THRE_H,
897 			  bulk_reg, 2);
898 
899 	/* Write sleep sample current, derived from sleep filter current. */
900 	tmp = CURRENT_TO_ADC(charger->sleep_filter_current_ua,
901 			     charger->res_div);
902 	put_unaligned_be16(tmp, bulk_reg);
903 	regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_SLEEP_CON_SAMP_CUR_H,
904 			  bulk_reg, 2);
905 
906 	/* Restart battery relax voltage */
907 	regmap_write_bits(rk808->regmap, RK817_GAS_GAUGE_GG_STS,
908 			  RK817_RELAX_VOL_UPD, (0x0 << 2));
909 
910 	/*
911 	 * Set OCV Threshold Voltage to 127.5mV. This was hard coded like this
912 	 * in the BSP.
913 	 */
914 	regmap_write(rk808->regmap, RK817_GAS_GAUGE_OCV_THRE_VOL, 0xff);
915 
916 	/*
917 	 * Set maximum charging voltage to battery max voltage. Trying to be
918 	 * incredibly safe with these value, as setting them wrong could
919 	 * overcharge the battery, which would be very bad.
920 	 */
921 	max_chg_vol_mv = bat_info->constant_charge_voltage_max_uv / 1000;
922 	max_chg_cur_ma = bat_info->constant_charge_current_max_ua / 1000;
923 
924 	if (max_chg_vol_mv < 4100) {
925 		return dev_err_probe(charger->dev, -EINVAL,
926 		       "invalid max charger voltage, value %u unsupported\n",
927 			max_chg_vol_mv * 1000);
928 	}
929 	if (max_chg_vol_mv > 4450) {
930 		dev_info(charger->dev,
931 			 "Setting max charge voltage to 4450000uv\n");
932 		max_chg_vol_mv = 4450;
933 	}
934 
935 	if (max_chg_cur_ma < 500) {
936 		return dev_err_probe(charger->dev, -EINVAL,
937 		       "invalid max charger current, value %u unsupported\n",
938 		       max_chg_cur_ma * 1000);
939 	}
940 	if (max_chg_cur_ma > 3500)
941 		dev_info(charger->dev,
942 			 "Setting max charge current to 3500000ua\n");
943 
944 	/*
945 	 * Now that the values are sanity checked, if we subtract 4100 from the
946 	 * max voltage and divide by 50, we conviently get the exact value for
947 	 * the registers, which are 4.1v, 4.15v, 4.2v, 4.25v, 4.3v, 4.35v,
948 	 * 4.4v, and 4.45v; these correspond to values 0x00 through 0x07.
949 	 */
950 	max_chg_vol_reg = (max_chg_vol_mv - 4100) / 50;
951 
952 	max_chg_cur_reg = rk817_chg_cur_to_reg(max_chg_cur_ma);
953 
954 	if (max_chg_vol_reg < 0 || max_chg_vol_reg > 7) {
955 		return dev_err_probe(charger->dev, -EINVAL,
956 		       "invalid max charger voltage, value %u unsupported\n",
957 		       max_chg_vol_mv * 1000);
958 	}
959 	if (max_chg_cur_reg < 0 || max_chg_cur_reg > 7) {
960 		return dev_err_probe(charger->dev, -EINVAL,
961 		       "invalid max charger current, value %u unsupported\n",
962 		       max_chg_cur_ma * 1000);
963 	}
964 
965 	/*
966 	 * Write the values to the registers, and deliver an emergency warning
967 	 * in the event they are not written correctly.
968 	 */
969 	ret = regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_OUT,
970 				RK817_CHRG_VOL_SEL, (max_chg_vol_reg << 4));
971 	if (ret) {
972 		dev_emerg(charger->dev,
973 			  "Danger, unable to set max charger voltage: %u\n",
974 			  ret);
975 	}
976 
977 	ret = regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_OUT,
978 				RK817_CHRG_CUR_SEL, max_chg_cur_reg);
979 	if (ret) {
980 		dev_emerg(charger->dev,
981 			  "Danger, unable to set max charger current: %u\n",
982 			  ret);
983 	}
984 
985 	/* Set charge finishing mode to analog */
986 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_TERM,
987 			  RK817_CHRG_TERM_ANA_DIG, (0x0 << 2));
988 
989 	/*
990 	 * Set charge finish current, warn if value not in range and keep
991 	 * default.
992 	 */
993 	chg_term_ma = bat_info->charge_term_current_ua / 1000;
994 	if (chg_term_ma < 150 || chg_term_ma > 400) {
995 		dev_warn(charger->dev,
996 			 "Invalid charge termination %u, keeping default\n",
997 			 chg_term_ma * 1000);
998 		chg_term_ma = 200;
999 	}
1000 
1001 	/*
1002 	 * Values of 150ma, 200ma, 300ma, and 400ma correspond to 00, 01, 10,
1003 	 * and 11.
1004 	 */
1005 	chg_term_i_reg = (chg_term_ma - 100) / 100;
1006 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_TERM,
1007 			  RK817_CHRG_TERM_ANA_SEL, chg_term_i_reg);
1008 
1009 	ret = rk817_read_or_set_full_charge_on_boot(charger, bat_info);
1010 	if (ret < 0)
1011 		return ret;
1012 
1013 	/*
1014 	 * Set minimum USB input voltage to 4.5v and enable USB voltage input
1015 	 * limit.
1016 	 */
1017 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,
1018 			  RK817_USB_VLIM_SEL, (0x05 << 4));
1019 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_VLIM_EN,
1020 			  (0x01 << 7));
1021 
1022 	/*
1023 	 * Set average USB input current limit to 1.5A and enable USB current
1024 	 * input limit.
1025 	 */
1026 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,
1027 			  RK817_USB_ILIM_SEL, 0x03);
1028 	regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_ILIM_EN,
1029 			  (0x01 << 3));
1030 
1031 	return 0;
1032 }
1033 
1034 static void rk817_charging_monitor(struct work_struct *work)
1035 {
1036 	struct rk817_charger *charger;
1037 
1038 	charger = container_of(work, struct rk817_charger, work.work);
1039 
1040 	rk817_read_props(charger);
1041 
1042 	/* Run every 8 seconds like the BSP driver did. */
1043 	queue_delayed_work(system_wq, &charger->work, msecs_to_jiffies(8000));
1044 }
1045 
1046 static int rk817_charger_probe(struct platform_device *pdev)
1047 {
1048 	struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
1049 	struct rk817_charger *charger;
1050 	struct device_node *node;
1051 	struct power_supply_battery_info *bat_info;
1052 	struct device *dev = &pdev->dev;
1053 	struct power_supply_config pscfg = {};
1054 	int plugin_irq, plugout_irq;
1055 	int of_value;
1056 	int ret;
1057 
1058 	node = of_get_child_by_name(dev->parent->of_node, "charger");
1059 	if (!node)
1060 		return -ENODEV;
1061 
1062 	charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL);
1063 	if (!charger) {
1064 		of_node_put(node);
1065 		return -ENOMEM;
1066 	}
1067 
1068 	charger->rk808 = rk808;
1069 
1070 	charger->dev = &pdev->dev;
1071 	platform_set_drvdata(pdev, charger);
1072 
1073 	rk817_bat_calib_vol(charger);
1074 
1075 	pscfg.drv_data = charger;
1076 	pscfg.of_node = node;
1077 
1078 	/*
1079 	 * Get sample resistor value. Note only values of 10000 or 20000
1080 	 * microohms are allowed. Schematic for my test implementation (an
1081 	 * Odroid Go Advance) shows a 10 milliohm resistor for reference.
1082 	 */
1083 	ret = of_property_read_u32(node, "rockchip,resistor-sense-micro-ohms",
1084 				   &of_value);
1085 	if (ret < 0) {
1086 		return dev_err_probe(dev, ret,
1087 				     "Error reading sample resistor value\n");
1088 	}
1089 	/*
1090 	 * Store as a 1 or a 2, since all we really use the value for is as a
1091 	 * divisor in some calculations.
1092 	 */
1093 	charger->res_div = (of_value == 20000) ? 2 : 1;
1094 
1095 	/*
1096 	 * Get sleep enter current value. Not sure what this value is for
1097 	 * other than to help calibrate the relax threshold.
1098 	 */
1099 	ret = of_property_read_u32(node,
1100 				   "rockchip,sleep-enter-current-microamp",
1101 				   &of_value);
1102 	if (ret < 0) {
1103 		return dev_err_probe(dev, ret,
1104 				     "Error reading sleep enter cur value\n");
1105 	}
1106 	charger->sleep_enter_current_ua = of_value;
1107 
1108 	/* Get sleep filter current value */
1109 	ret = of_property_read_u32(node,
1110 				   "rockchip,sleep-filter-current-microamp",
1111 				   &of_value);
1112 	if (ret < 0) {
1113 		return dev_err_probe(dev, ret,
1114 				     "Error reading sleep filter cur value\n");
1115 	}
1116 
1117 	charger->sleep_filter_current_ua = of_value;
1118 
1119 	charger->bat_ps = devm_power_supply_register(&pdev->dev,
1120 						     &rk817_bat_desc, &pscfg);
1121 	if (IS_ERR(charger->bat_ps))
1122 		return dev_err_probe(dev, -EINVAL,
1123 				     "Battery failed to probe\n");
1124 
1125 	charger->chg_ps = devm_power_supply_register(&pdev->dev,
1126 						     &rk817_chg_desc, &pscfg);
1127 	if (IS_ERR(charger->chg_ps))
1128 		return dev_err_probe(dev, -EINVAL,
1129 				     "Charger failed to probe\n");
1130 
1131 	ret = power_supply_get_battery_info(charger->bat_ps,
1132 					    &bat_info);
1133 	if (ret) {
1134 		return dev_err_probe(dev, ret,
1135 				     "Unable to get battery info: %d\n", ret);
1136 	}
1137 
1138 	if ((bat_info->charge_full_design_uah <= 0) ||
1139 	    (bat_info->voltage_min_design_uv <= 0) ||
1140 	    (bat_info->voltage_max_design_uv <= 0) ||
1141 	    (bat_info->constant_charge_voltage_max_uv <= 0) ||
1142 	    (bat_info->constant_charge_current_max_ua <= 0) ||
1143 	    (bat_info->charge_term_current_ua <= 0)) {
1144 		return dev_err_probe(dev, -EINVAL,
1145 				     "Required bat info missing or invalid\n");
1146 	}
1147 
1148 	charger->bat_charge_full_design_uah = bat_info->charge_full_design_uah;
1149 	charger->bat_voltage_min_design_uv = bat_info->voltage_min_design_uv;
1150 	charger->bat_voltage_max_design_uv = bat_info->voltage_max_design_uv;
1151 
1152 	/*
1153 	 * Has to run after power_supply_get_battery_info as it depends on some
1154 	 * values discovered from that routine.
1155 	 */
1156 	ret = rk817_battery_init(charger, bat_info);
1157 	if (ret)
1158 		return ret;
1159 
1160 	power_supply_put_battery_info(charger->bat_ps, bat_info);
1161 
1162 	plugin_irq = platform_get_irq(pdev, 0);
1163 	if (plugin_irq < 0)
1164 		return plugin_irq;
1165 
1166 	plugout_irq = platform_get_irq(pdev, 1);
1167 	if (plugout_irq < 0)
1168 		return plugout_irq;
1169 
1170 	ret = devm_request_threaded_irq(charger->dev, plugin_irq, NULL,
1171 					rk817_plug_in_isr,
1172 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1173 					"rk817_plug_in", charger);
1174 	if (ret) {
1175 		return dev_err_probe(&pdev->dev, ret,
1176 				      "plug_in_irq request failed!\n");
1177 	}
1178 
1179 	ret = devm_request_threaded_irq(charger->dev, plugout_irq, NULL,
1180 					rk817_plug_out_isr,
1181 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1182 					"rk817_plug_out", charger);
1183 	if (ret) {
1184 		return dev_err_probe(&pdev->dev, ret,
1185 				     "plug_out_irq request failed!\n");
1186 	}
1187 
1188 	ret = devm_delayed_work_autocancel(&pdev->dev, &charger->work,
1189 					   rk817_charging_monitor);
1190 	if (ret)
1191 		return ret;
1192 
1193 	/* Force the first update immediately. */
1194 	mod_delayed_work(system_wq, &charger->work, 0);
1195 
1196 	return 0;
1197 }
1198 
1199 
1200 static struct platform_driver rk817_charger_driver = {
1201 	.probe    = rk817_charger_probe,
1202 	.driver   = {
1203 		.name  = "rk817-charger",
1204 	},
1205 };
1206 module_platform_driver(rk817_charger_driver);
1207 
1208 MODULE_DESCRIPTION("Battery power supply driver for RK817 PMIC");
1209 MODULE_AUTHOR("Maya Matuszczyk <maccraft123mc@gmail.com>");
1210 MODULE_AUTHOR("Chris Morgan <macromorgan@hotmail.com>");
1211 MODULE_LICENSE("GPL");
1212