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, ®); 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, ®); 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, ®); 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, ®); 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, ®); 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, ®); 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