1232 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * Charger Driver for Rockchip rk8174 *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 <linux/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 */21enum 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 lowest35 * current, this is per the datasheet.36 */37enum 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 48struct 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 ADC59 * voltage readings. While they are documented in the BSP kernel and60 * datasheet as voltage_k and voltage_b, there is no further61 * 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 a70 * remaining state of charge (rsoc). This value will be used for both71 * purposes here so we don't do any fancy math to try and "smooth" the72 * charge and just report it as it is. Note for example an soc of 10073 * 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 design79 * 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 use86 * 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 124static 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 else143 return -EINVAL;144}145 146static 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 170static 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 191static 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 values204 * are to ensure we can remain backwards compatible with the BSP kernel.205 */206static 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 kernel213 * 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 by222 * 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 240static 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 full251 * charge capacity. Note that if the device is unplugged for a252 * period of several days the columb counter will have a large253 * margin of error, so setting it back to the full charge on254 * a completed charge cycle should correct this (my device was255 * showing 33% battery after 3 days unplugged when it should256 * have been closer to 95% based on voltage and charge257 * 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 for275 * 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 keep295 * enough precision until the last step to keep from296 * 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 full309 * battery (soc_cal = 1) and are now empty (at or below minimum design310 * voltage). If our columb counter is still positive, subtract that311 * from our fcc value to get a calibrated fcc, and if our columb312 * counter is negative add that to our fcc (but not to exceed our313 * 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 we328 * want) and if it's positive this will subtract (also what329 * 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 /*339 * Set the SOC to 0 if we are below the minimum system voltage.340 */341 if (volt_avg <= charger->bat_voltage_min_design_uv) {342 charger->soc = 0;343 charge_now_adc = CHARGE_TO_ADC(0, charger->res_div);344 put_unaligned_be32(charge_now_adc, bulk_reg);345 regmap_bulk_write(rk808->regmap,346 RK817_GAS_GAUGE_Q_INIT_H3, bulk_reg, 4);347 dev_warn(charger->dev,348 "Battery voltage %d below minimum voltage %d\n",349 volt_avg, charger->bat_voltage_min_design_uv);350 }351 352 rk817_record_battery_nvram_values(charger);353 354 return 0;355}356 357static void rk817_read_props(struct rk817_charger *charger)358{359 int tmp, reg;360 u8 bulk_reg[4];361 362 /*363 * Recalibrate voltage and current readings if we need to BSP does both364 * on CUR_CALIB_UPD, ignoring VOL_CALIB_UPD. Curiously enough, both365 * documentation and the BSP show that you perform an update if bit 7366 * is 1, but you clear the status by writing a 1 to bit 7.367 */368 regmap_read(charger->rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG1, ®);369 if (reg & RK817_VOL_CUR_CALIB_UPD) {370 rk817_bat_calib_cur(charger);371 rk817_bat_calib_vol(charger);372 regmap_write_bits(charger->rk808->regmap,373 RK817_GAS_GAUGE_ADC_CONFIG1,374 RK817_VOL_CUR_CALIB_UPD,375 RK817_VOL_CUR_CALIB_UPD);376 }377 378 /* Update reported charge. */379 regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3,380 bulk_reg, 4);381 tmp = get_unaligned_be32(bulk_reg);382 charger->charge_now_uah = ADC_TO_CHARGE_UAH(tmp, charger->res_div);383 if (charger->charge_now_uah < 0)384 charger->charge_now_uah = 0;385 if (charger->charge_now_uah > charger->fcc_mah * 1000)386 charger->charge_now_uah = charger->fcc_mah * 1000;387 388 /* Update soc based on reported charge. */389 charger->soc = charger->charge_now_uah * 100 / charger->fcc_mah;390 391 /* Update reported voltage. */392 regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_VOL_H,393 bulk_reg, 2);394 tmp = get_unaligned_be16(bulk_reg);395 charger->volt_avg_uv = (charger->voltage_k * tmp) + 1000 *396 charger->voltage_b;397 398 /*399 * Update reported current. Note value from registers is a signed 16400 * bit int.401 */402 regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_CUR_H,403 bulk_reg, 2);404 tmp = (short int)get_unaligned_be16(bulk_reg);405 charger->cur_avg_ua = ADC_TO_CURRENT(tmp, charger->res_div);406 407 /*408 * Update the max charge current. This value shouldn't change, but we409 * can read it to report what the PMIC says it is instead of simply410 * returning the default value.411 */412 regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_OUT, ®);413 charger->max_chg_cur_ua =414 rk817_chg_cur_from_reg(reg & RK817_CHRG_CUR_SEL);415 416 /*417 * Update max charge voltage. Like the max charge current this value418 * shouldn't change, but we can report what the PMIC says.419 */420 regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_OUT, ®);421 charger->max_chg_volt_uv = ((((reg & RK817_CHRG_VOL_SEL) >> 4) *422 50000) + 4100000);423 424 /* Check if battery still present. */425 regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_STS, ®);426 charger->battery_present = (reg & RK817_BAT_EXS);427 428 /* Get which type of charge we are using (if any). */429 regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_STS, ®);430 charger->charge_status = (reg >> 4) & 0x07;431 432 /*433 * Get charger input voltage. Note that on my example hardware (an434 * Odroid Go Advance) the voltage of the power connector is measured435 * on the register labelled USB in the datasheet; I don't know if this436 * is how it is designed or just a quirk of the implementation. I437 * believe this will also measure the voltage of the USB output when in438 * OTG mode, if that is the case we may need to change this in the439 * future to return 0 if the power supply status is offline (I can't440 * test this with my current implementation. Also, when the voltage441 * should be zero sometimes the ADC still shows a single bit (which442 * would register as 20000uv). When this happens set it to 0.443 */444 regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_USB_VOL_H,445 bulk_reg, 2);446 reg = get_unaligned_be16(bulk_reg);447 if (reg > 1) {448 tmp = ((charger->voltage_k * reg / 1000 + charger->voltage_b) *449 60 / 46);450 charger->charger_input_volt_avg_uv = tmp * 1000;451 } else {452 charger->charger_input_volt_avg_uv = 0;453 }454 455 /* Calibrate battery capacity and soc. */456 rk817_bat_calib_cap(charger);457}458 459static int rk817_bat_get_prop(struct power_supply *ps,460 enum power_supply_property prop,461 union power_supply_propval *val)462{463 struct rk817_charger *charger = power_supply_get_drvdata(ps);464 465 switch (prop) {466 case POWER_SUPPLY_PROP_PRESENT:467 val->intval = charger->battery_present;468 break;469 case POWER_SUPPLY_PROP_STATUS:470 if (charger->cur_avg_ua < 0) {471 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;472 break;473 }474 switch (charger->charge_status) {475 case CHRG_OFF:476 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;477 break;478 /*479 * Dead charge is documented, but not explained. I never480 * observed it but assume it's a pre-charge for a dead481 * battery.482 */483 case DEAD_CHRG:484 case TRICKLE_CHRG:485 case CC_OR_CV_CHRG:486 val->intval = POWER_SUPPLY_STATUS_CHARGING;487 break;488 case CHARGE_FINISH:489 val->intval = POWER_SUPPLY_STATUS_FULL;490 break;491 default:492 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;493 return -EINVAL;494 495 }496 break;497 case POWER_SUPPLY_PROP_CHARGE_TYPE:498 switch (charger->charge_status) {499 case CHRG_OFF:500 case CHARGE_FINISH:501 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;502 break;503 case TRICKLE_CHRG:504 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;505 break;506 case DEAD_CHRG:507 case CC_OR_CV_CHRG:508 val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD;509 break;510 default:511 val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;512 break;513 }514 break;515 case POWER_SUPPLY_PROP_CHARGE_FULL:516 val->intval = charger->fcc_mah * 1000;517 break;518 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:519 val->intval = charger->bat_charge_full_design_uah;520 break;521 case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:522 val->intval = 0;523 break;524 case POWER_SUPPLY_PROP_CHARGE_NOW:525 val->intval = charger->charge_now_uah;526 break;527 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:528 val->intval = charger->bat_voltage_min_design_uv;529 break;530 case POWER_SUPPLY_PROP_CAPACITY:531 /* Add 500 so that values like 99999 are 100% not 99%. */532 val->intval = (charger->soc + 500) / 1000;533 if (val->intval > 100)534 val->intval = 100;535 if (val->intval < 0)536 val->intval = 0;537 break;538 case POWER_SUPPLY_PROP_VOLTAGE_AVG:539 val->intval = charger->volt_avg_uv;540 break;541 case POWER_SUPPLY_PROP_CURRENT_AVG:542 val->intval = charger->cur_avg_ua;543 break;544 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:545 val->intval = charger->max_chg_cur_ua;546 break;547 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:548 val->intval = charger->max_chg_volt_uv;549 break;550 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:551 val->intval = charger->bat_voltage_max_design_uv;552 break;553 default:554 return -EINVAL;555 }556 return 0;557}558 559static int rk817_chg_get_prop(struct power_supply *ps,560 enum power_supply_property prop,561 union power_supply_propval *val)562{563 struct rk817_charger *charger = power_supply_get_drvdata(ps);564 565 switch (prop) {566 case POWER_SUPPLY_PROP_ONLINE:567 val->intval = charger->plugged_in;568 break;569 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:570 /* max voltage from datasheet at 5.5v (default 5.0v) */571 val->intval = 5500000;572 break;573 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:574 /* min voltage from datasheet at 3.8v (default 5.0v) */575 val->intval = 3800000;576 break;577 case POWER_SUPPLY_PROP_VOLTAGE_AVG:578 val->intval = charger->charger_input_volt_avg_uv;579 break;580 /*581 * While it's possible that other implementations could use different582 * USB types, the current implementation for this PMIC (the Odroid Go583 * Advance) only uses a dedicated charging port with no rx/tx lines.584 */585 case POWER_SUPPLY_PROP_USB_TYPE:586 val->intval = POWER_SUPPLY_USB_TYPE_DCP;587 break;588 default:589 return -EINVAL;590 }591 return 0;592 593}594 595static irqreturn_t rk817_plug_in_isr(int irq, void *cg)596{597 struct rk817_charger *charger;598 599 charger = (struct rk817_charger *)cg;600 charger->plugged_in = 1;601 power_supply_changed(charger->chg_ps);602 power_supply_changed(charger->bat_ps);603 /* try to recalibrate capacity if we hit full charge. */604 charger->soc_cal = 0;605 606 rk817_read_props(charger);607 608 dev_dbg(charger->dev, "Power Cord Inserted\n");609 610 return IRQ_HANDLED;611}612 613static irqreturn_t rk817_plug_out_isr(int irq, void *cg)614{615 struct rk817_charger *charger;616 struct rk808 *rk808;617 618 charger = (struct rk817_charger *)cg;619 rk808 = charger->rk808;620 charger->plugged_in = 0;621 power_supply_changed(charger->bat_ps);622 power_supply_changed(charger->chg_ps);623 624 /*625 * For some reason the bits of RK817_PMIC_CHRG_IN reset whenever the626 * power cord is unplugged. This was not documented in the BSP kernel627 * or the datasheet and only discovered by trial and error. Set minimum628 * USB input voltage to 4.5v and enable USB voltage input limit.629 */630 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,631 RK817_USB_VLIM_SEL, (0x05 << 4));632 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_VLIM_EN,633 (0x01 << 7));634 635 /*636 * Set average USB input current limit to 1.5A and enable USB current637 * input limit.638 */639 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,640 RK817_USB_ILIM_SEL, 0x03);641 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_ILIM_EN,642 (0x01 << 3));643 644 rk817_read_props(charger);645 646 dev_dbg(charger->dev, "Power Cord Removed\n");647 648 return IRQ_HANDLED;649}650 651static enum power_supply_property rk817_bat_props[] = {652 POWER_SUPPLY_PROP_PRESENT,653 POWER_SUPPLY_PROP_STATUS,654 POWER_SUPPLY_PROP_CHARGE_TYPE,655 POWER_SUPPLY_PROP_CHARGE_FULL,656 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,657 POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN,658 POWER_SUPPLY_PROP_CHARGE_NOW,659 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,660 POWER_SUPPLY_PROP_VOLTAGE_AVG,661 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,662 POWER_SUPPLY_PROP_CURRENT_AVG,663 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,664 POWER_SUPPLY_PROP_CAPACITY,665 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,666};667 668static enum power_supply_property rk817_chg_props[] = {669 POWER_SUPPLY_PROP_ONLINE,670 POWER_SUPPLY_PROP_USB_TYPE,671 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,672 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,673 POWER_SUPPLY_PROP_VOLTAGE_AVG,674};675 676static const struct power_supply_desc rk817_bat_desc = {677 .name = "rk817-battery",678 .type = POWER_SUPPLY_TYPE_BATTERY,679 .properties = rk817_bat_props,680 .num_properties = ARRAY_SIZE(rk817_bat_props),681 .get_property = rk817_bat_get_prop,682};683 684static const struct power_supply_desc rk817_chg_desc = {685 .name = "rk817-charger",686 .type = POWER_SUPPLY_TYPE_USB,687 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_DCP) |688 BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN),689 .properties = rk817_chg_props,690 .num_properties = ARRAY_SIZE(rk817_chg_props),691 .get_property = rk817_chg_get_prop,692};693 694static int rk817_read_battery_nvram_values(struct rk817_charger *charger)695{696 u8 bulk_reg[3];697 int ret;698 699 /* Read the nvram data for full charge capacity. */700 ret = regmap_bulk_read(charger->rk808->regmap,701 RK817_GAS_GAUGE_DATA3, bulk_reg, 3);702 if (ret < 0)703 return ret;704 charger->fcc_mah = get_unaligned_le24(bulk_reg);705 706 /*707 * Sanity checking for values equal to zero or less than would be708 * practical for this device (BSP Kernel assumes 500mAH or less) for709 * practicality purposes. Also check if the value is too large and710 * correct it.711 */712 if ((charger->fcc_mah < 500) ||713 ((charger->fcc_mah * 1000) > charger->bat_charge_full_design_uah)) {714 dev_info(charger->dev,715 "Invalid NVRAM max charge, setting to %u uAH\n",716 charger->bat_charge_full_design_uah);717 charger->fcc_mah = charger->bat_charge_full_design_uah / 1000;718 }719 720 /*721 * Read the nvram for state of charge. Sanity check for values greater722 * than 100 (10000) or less than 0, because other things (BSP kernels,723 * U-Boot, or even i2cset) can write to this register. If the value is724 * off it should get corrected automatically when the voltage drops to725 * the min (soc is 0) or when the battery is full (soc is 100).726 */727 ret = regmap_bulk_read(charger->rk808->regmap,728 RK817_GAS_GAUGE_BAT_R1, bulk_reg, 3);729 if (ret < 0)730 return ret;731 charger->soc = get_unaligned_le24(bulk_reg);732 if (charger->soc > 10000)733 charger->soc = 10000;734 if (charger->soc < 0)735 charger->soc = 0;736 737 return 0;738}739 740static int741rk817_read_or_set_full_charge_on_boot(struct rk817_charger *charger,742 struct power_supply_battery_info *bat_info)743{744 struct rk808 *rk808 = charger->rk808;745 u8 bulk_reg[4];746 u32 boot_voltage, boot_charge_mah;747 int ret, reg, off_time, tmp;748 bool first_boot;749 750 /*751 * Check if the battery is uninitalized. If it is, the columb counter752 * needs to be set up.753 */754 ret = regmap_read(rk808->regmap, RK817_GAS_GAUGE_GG_STS, ®);755 if (ret < 0)756 return ret;757 first_boot = reg & RK817_BAT_CON;758 /*759 * If the battery is uninitialized, use the poweron voltage and an ocv760 * lookup to guess our charge. The number won't be very accurate until761 * we hit either our minimum voltage (0%) or full charge (100%).762 */763 if (first_boot) {764 regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_PWRON_VOL_H,765 bulk_reg, 2);766 tmp = get_unaligned_be16(bulk_reg);767 boot_voltage = (charger->voltage_k * tmp) +768 1000 * charger->voltage_b;769 /*770 * Since only implementation has no working thermistor, assume771 * 20C for OCV lookup. If lookup fails, report error with OCV772 * table.773 */774 charger->soc = power_supply_batinfo_ocv2cap(bat_info,775 boot_voltage,776 20) * 1000;777 if (charger->soc < 0)778 charger->soc = 0;779 780 /* Guess that full charge capacity is the design capacity */781 charger->fcc_mah = charger->bat_charge_full_design_uah / 1000;782 /*783 * Set battery as "set up". BSP driver uses this value even784 * though datasheet claims it's a read-only value.785 */786 regmap_write_bits(rk808->regmap, RK817_GAS_GAUGE_GG_STS,787 RK817_BAT_CON, 0);788 /* Save nvram values */789 ret = rk817_record_battery_nvram_values(charger);790 if (ret < 0)791 return ret;792 } else {793 ret = rk817_read_battery_nvram_values(charger);794 if (ret < 0)795 return ret;796 797 regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3,798 bulk_reg, 4);799 tmp = get_unaligned_be32(bulk_reg);800 if (tmp < 0)801 tmp = 0;802 boot_charge_mah = ADC_TO_CHARGE_UAH(tmp,803 charger->res_div) / 1000;804 /*805 * Check if the columb counter has been off for more than 30806 * minutes as it tends to drift downward. If so, re-init soc807 * with the boot voltage instead. Note the unit values for the808 * OFF_CNT register appear to be in decaminutes and stops809 * counting at 2550 (0xFF) minutes. BSP kernel used OCV, but810 * for me occasionally that would show invalid values. Boot811 * voltage is only accurate for me on first poweron (not812 * reboots), but we shouldn't ever encounter an OFF_CNT more813 * than 0 on a reboot anyway.814 */815 regmap_read(rk808->regmap, RK817_GAS_GAUGE_OFF_CNT, &off_time);816 if (off_time >= 3) {817 regmap_bulk_read(rk808->regmap,818 RK817_GAS_GAUGE_PWRON_VOL_H,819 bulk_reg, 2);820 tmp = get_unaligned_be16(bulk_reg);821 boot_voltage = (charger->voltage_k * tmp) +822 1000 * charger->voltage_b;823 charger->soc =824 power_supply_batinfo_ocv2cap(bat_info,825 boot_voltage,826 20) * 1000;827 } else {828 charger->soc = (boot_charge_mah * 1000 * 100 /829 charger->fcc_mah);830 }831 }832 833 /*834 * Now we have our full charge capacity and soc, init the columb835 * counter.836 */837 boot_charge_mah = charger->soc * charger->fcc_mah / 100 / 1000;838 if (boot_charge_mah > charger->fcc_mah)839 boot_charge_mah = charger->fcc_mah;840 tmp = CHARGE_TO_ADC(boot_charge_mah, charger->res_div);841 put_unaligned_be32(tmp, bulk_reg);842 ret = regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_H3,843 bulk_reg, 4);844 if (ret < 0)845 return ret;846 847 /* Set QMAX value to max design capacity. */848 tmp = CHARGE_TO_ADC((charger->bat_charge_full_design_uah / 1000),849 charger->res_div);850 put_unaligned_be32(tmp, bulk_reg);851 ret = regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_MAX_H3,852 bulk_reg, 4);853 if (ret < 0)854 return ret;855 856 return 0;857}858 859static int rk817_battery_init(struct rk817_charger *charger,860 struct power_supply_battery_info *bat_info)861{862 struct rk808 *rk808 = charger->rk808;863 u32 tmp, max_chg_vol_mv, max_chg_cur_ma;864 u8 max_chg_vol_reg, chg_term_i_reg;865 int ret, chg_term_ma, max_chg_cur_reg;866 u8 bulk_reg[2];867 868 /* Get initial plug state */869 regmap_read(rk808->regmap, RK817_SYS_STS, &tmp);870 charger->plugged_in = (tmp & RK817_PLUG_IN_STS);871 872 /*873 * Turn on all ADC functions to measure battery, USB, and sys voltage,874 * as well as batt temp. Note only tested implementation so far does875 * not use a battery with a thermistor.876 */877 regmap_write(rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG0, 0xfc);878 879 /*880 * Set relax mode voltage sampling interval and ADC offset calibration881 * interval to 8 minutes to mirror BSP kernel. Set voltage and current882 * modes to average to mirror BSP kernel.883 */884 regmap_write(rk808->regmap, RK817_GAS_GAUGE_GG_CON, 0x04);885 886 /* Calibrate voltage like the BSP does here. */887 rk817_bat_calib_vol(charger);888 889 /* Write relax threshold, derived from sleep enter current. */890 tmp = CURRENT_TO_ADC(charger->sleep_enter_current_ua,891 charger->res_div);892 put_unaligned_be16(tmp, bulk_reg);893 regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_RELAX_THRE_H,894 bulk_reg, 2);895 896 /* Write sleep sample current, derived from sleep filter current. */897 tmp = CURRENT_TO_ADC(charger->sleep_filter_current_ua,898 charger->res_div);899 put_unaligned_be16(tmp, bulk_reg);900 regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_SLEEP_CON_SAMP_CUR_H,901 bulk_reg, 2);902 903 /* Restart battery relax voltage */904 regmap_write_bits(rk808->regmap, RK817_GAS_GAUGE_GG_STS,905 RK817_RELAX_VOL_UPD, (0x0 << 2));906 907 /*908 * Set OCV Threshold Voltage to 127.5mV. This was hard coded like this909 * in the BSP.910 */911 regmap_write(rk808->regmap, RK817_GAS_GAUGE_OCV_THRE_VOL, 0xff);912 913 /*914 * Set maximum charging voltage to battery max voltage. Trying to be915 * incredibly safe with these value, as setting them wrong could916 * overcharge the battery, which would be very bad.917 */918 max_chg_vol_mv = bat_info->constant_charge_voltage_max_uv / 1000;919 max_chg_cur_ma = bat_info->constant_charge_current_max_ua / 1000;920 921 if (max_chg_vol_mv < 4100) {922 return dev_err_probe(charger->dev, -EINVAL,923 "invalid max charger voltage, value %u unsupported\n",924 max_chg_vol_mv * 1000);925 }926 if (max_chg_vol_mv > 4450) {927 dev_info(charger->dev,928 "Setting max charge voltage to 4450000uv\n");929 max_chg_vol_mv = 4450;930 }931 932 if (max_chg_cur_ma < 500) {933 return dev_err_probe(charger->dev, -EINVAL,934 "invalid max charger current, value %u unsupported\n",935 max_chg_cur_ma * 1000);936 }937 if (max_chg_cur_ma > 3500)938 dev_info(charger->dev,939 "Setting max charge current to 3500000ua\n");940 941 /*942 * Now that the values are sanity checked, if we subtract 4100 from the943 * max voltage and divide by 50, we conviently get the exact value for944 * the registers, which are 4.1v, 4.15v, 4.2v, 4.25v, 4.3v, 4.35v,945 * 4.4v, and 4.45v; these correspond to values 0x00 through 0x07.946 */947 max_chg_vol_reg = (max_chg_vol_mv - 4100) / 50;948 949 max_chg_cur_reg = rk817_chg_cur_to_reg(max_chg_cur_ma);950 951 if (max_chg_vol_reg < 0 || max_chg_vol_reg > 7) {952 return dev_err_probe(charger->dev, -EINVAL,953 "invalid max charger voltage, value %u unsupported\n",954 max_chg_vol_mv * 1000);955 }956 if (max_chg_cur_reg < 0 || max_chg_cur_reg > 7) {957 return dev_err_probe(charger->dev, -EINVAL,958 "invalid max charger current, value %u unsupported\n",959 max_chg_cur_ma * 1000);960 }961 962 /*963 * Write the values to the registers, and deliver an emergency warning964 * in the event they are not written correctly.965 */966 ret = regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_OUT,967 RK817_CHRG_VOL_SEL, (max_chg_vol_reg << 4));968 if (ret) {969 dev_emerg(charger->dev,970 "Danger, unable to set max charger voltage: %u\n",971 ret);972 }973 974 ret = regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_OUT,975 RK817_CHRG_CUR_SEL, max_chg_cur_reg);976 if (ret) {977 dev_emerg(charger->dev,978 "Danger, unable to set max charger current: %u\n",979 ret);980 }981 982 /* Set charge finishing mode to analog */983 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_TERM,984 RK817_CHRG_TERM_ANA_DIG, (0x0 << 2));985 986 /*987 * Set charge finish current, warn if value not in range and keep988 * default.989 */990 chg_term_ma = bat_info->charge_term_current_ua / 1000;991 if (chg_term_ma < 150 || chg_term_ma > 400) {992 dev_warn(charger->dev,993 "Invalid charge termination %u, keeping default\n",994 chg_term_ma * 1000);995 chg_term_ma = 200;996 }997 998 /*999 * Values of 150ma, 200ma, 300ma, and 400ma correspond to 00, 01, 10,1000 * and 11.1001 */1002 chg_term_i_reg = (chg_term_ma - 100) / 100;1003 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_TERM,1004 RK817_CHRG_TERM_ANA_SEL, chg_term_i_reg);1005 1006 ret = rk817_read_or_set_full_charge_on_boot(charger, bat_info);1007 if (ret < 0)1008 return ret;1009 1010 /*1011 * Set minimum USB input voltage to 4.5v and enable USB voltage input1012 * limit.1013 */1014 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,1015 RK817_USB_VLIM_SEL, (0x05 << 4));1016 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_VLIM_EN,1017 (0x01 << 7));1018 1019 /*1020 * Set average USB input current limit to 1.5A and enable USB current1021 * input limit.1022 */1023 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN,1024 RK817_USB_ILIM_SEL, 0x03);1025 regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_ILIM_EN,1026 (0x01 << 3));1027 1028 return 0;1029}1030 1031static void rk817_charging_monitor(struct work_struct *work)1032{1033 struct rk817_charger *charger;1034 1035 charger = container_of(work, struct rk817_charger, work.work);1036 1037 rk817_read_props(charger);1038 1039 /* Run every 8 seconds like the BSP driver did. */1040 queue_delayed_work(system_wq, &charger->work, msecs_to_jiffies(8000));1041}1042 1043static void rk817_cleanup_node(void *data)1044{1045 struct device_node *node = data;1046 1047 of_node_put(node);1048}1049 1050static int rk817_charger_probe(struct platform_device *pdev)1051{1052 struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);1053 struct rk817_charger *charger;1054 struct device_node *node;1055 struct power_supply_battery_info *bat_info;1056 struct device *dev = &pdev->dev;1057 struct power_supply_config pscfg = {};1058 int plugin_irq, plugout_irq;1059 int of_value;1060 int ret;1061 1062 node = of_get_child_by_name(dev->parent->of_node, "charger");1063 if (!node)1064 return -ENODEV;1065 1066 ret = devm_add_action_or_reset(&pdev->dev, rk817_cleanup_node, node);1067 if (ret)1068 return ret;1069 1070 charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL);1071 if (!charger)1072 return -ENOMEM;1073 1074 charger->rk808 = rk808;1075 1076 charger->dev = &pdev->dev;1077 platform_set_drvdata(pdev, charger);1078 1079 rk817_bat_calib_vol(charger);1080 1081 pscfg.drv_data = charger;1082 pscfg.of_node = node;1083 1084 /*1085 * Get sample resistor value. Note only values of 10000 or 200001086 * microohms are allowed. Schematic for my test implementation (an1087 * Odroid Go Advance) shows a 10 milliohm resistor for reference.1088 */1089 ret = of_property_read_u32(node, "rockchip,resistor-sense-micro-ohms",1090 &of_value);1091 if (ret < 0) {1092 return dev_err_probe(dev, ret,1093 "Error reading sample resistor value\n");1094 }1095 /*1096 * Store as a 1 or a 2, since all we really use the value for is as a1097 * divisor in some calculations.1098 */1099 charger->res_div = (of_value == 20000) ? 2 : 1;1100 1101 /*1102 * Get sleep enter current value. Not sure what this value is for1103 * other than to help calibrate the relax threshold.1104 */1105 ret = of_property_read_u32(node,1106 "rockchip,sleep-enter-current-microamp",1107 &of_value);1108 if (ret < 0) {1109 return dev_err_probe(dev, ret,1110 "Error reading sleep enter cur value\n");1111 }1112 charger->sleep_enter_current_ua = of_value;1113 1114 /* Get sleep filter current value */1115 ret = of_property_read_u32(node,1116 "rockchip,sleep-filter-current-microamp",1117 &of_value);1118 if (ret < 0) {1119 return dev_err_probe(dev, ret,1120 "Error reading sleep filter cur value\n");1121 }1122 1123 charger->sleep_filter_current_ua = of_value;1124 1125 charger->bat_ps = devm_power_supply_register(&pdev->dev,1126 &rk817_bat_desc, &pscfg);1127 if (IS_ERR(charger->bat_ps))1128 return dev_err_probe(dev, -EINVAL,1129 "Battery failed to probe\n");1130 1131 charger->chg_ps = devm_power_supply_register(&pdev->dev,1132 &rk817_chg_desc, &pscfg);1133 if (IS_ERR(charger->chg_ps))1134 return dev_err_probe(dev, -EINVAL,1135 "Charger failed to probe\n");1136 1137 ret = power_supply_get_battery_info(charger->bat_ps,1138 &bat_info);1139 if (ret) {1140 return dev_err_probe(dev, ret,1141 "Unable to get battery info\n");1142 }1143 1144 if ((bat_info->charge_full_design_uah <= 0) ||1145 (bat_info->voltage_min_design_uv <= 0) ||1146 (bat_info->voltage_max_design_uv <= 0) ||1147 (bat_info->constant_charge_voltage_max_uv <= 0) ||1148 (bat_info->constant_charge_current_max_ua <= 0) ||1149 (bat_info->charge_term_current_ua <= 0)) {1150 return dev_err_probe(dev, -EINVAL,1151 "Required bat info missing or invalid\n");1152 }1153 1154 charger->bat_charge_full_design_uah = bat_info->charge_full_design_uah;1155 charger->bat_voltage_min_design_uv = bat_info->voltage_min_design_uv;1156 charger->bat_voltage_max_design_uv = bat_info->voltage_max_design_uv;1157 1158 /*1159 * Has to run after power_supply_get_battery_info as it depends on some1160 * values discovered from that routine.1161 */1162 ret = rk817_battery_init(charger, bat_info);1163 if (ret)1164 return ret;1165 1166 power_supply_put_battery_info(charger->bat_ps, bat_info);1167 1168 plugin_irq = platform_get_irq(pdev, 0);1169 if (plugin_irq < 0)1170 return plugin_irq;1171 1172 plugout_irq = platform_get_irq(pdev, 1);1173 if (plugout_irq < 0)1174 return plugout_irq;1175 1176 ret = devm_request_threaded_irq(charger->dev, plugin_irq, NULL,1177 rk817_plug_in_isr,1178 IRQF_TRIGGER_RISING | IRQF_ONESHOT,1179 "rk817_plug_in", charger);1180 if (ret) {1181 return dev_err_probe(&pdev->dev, ret,1182 "plug_in_irq request failed!\n");1183 }1184 1185 ret = devm_request_threaded_irq(charger->dev, plugout_irq, NULL,1186 rk817_plug_out_isr,1187 IRQF_TRIGGER_RISING | IRQF_ONESHOT,1188 "rk817_plug_out", charger);1189 if (ret) {1190 return dev_err_probe(&pdev->dev, ret,1191 "plug_out_irq request failed!\n");1192 }1193 1194 ret = devm_delayed_work_autocancel(&pdev->dev, &charger->work,1195 rk817_charging_monitor);1196 if (ret)1197 return ret;1198 1199 /* Force the first update immediately. */1200 mod_delayed_work(system_wq, &charger->work, 0);1201 1202 return 0;1203}1204 1205static int __maybe_unused rk817_resume(struct device *dev)1206{1207 1208 struct rk817_charger *charger = dev_get_drvdata(dev);1209 1210 /* force an immediate update */1211 mod_delayed_work(system_wq, &charger->work, 0);1212 1213 return 0;1214}1215 1216static SIMPLE_DEV_PM_OPS(rk817_charger_pm, NULL, rk817_resume);1217 1218static struct platform_driver rk817_charger_driver = {1219 .probe = rk817_charger_probe,1220 .driver = {1221 .name = "rk817-charger",1222 .pm = &rk817_charger_pm,1223 },1224};1225module_platform_driver(rk817_charger_driver);1226 1227MODULE_DESCRIPTION("Battery power supply driver for RK817 PMIC");1228MODULE_AUTHOR("Maya Matuszczyk <maccraft123mc@gmail.com>");1229MODULE_AUTHOR("Chris Morgan <macromorgan@hotmail.com>");1230MODULE_LICENSE("GPL");1231MODULE_ALIAS("platform:rk817-charger");1232