1// SPDX-License-Identifier: GPL-2.0-or-later 2// 3// Copyright (C) 2018 ROHM Semiconductors 4// 5// power-supply driver for ROHM BD70528 PMIC 6 7/* 8 * BD70528 charger HW state machine. 9 * 10 * The thermal shutdown state is not drawn. From any other state but 11 * battery error and suspend it is possible to go to TSD/TMP states 12 * if temperature is out of bounds. 13 * 14 * CHG_RST = H 15 * or CHG_EN=L 16 * or (DCIN2_UVLO=L && DCIN1_UVLO=L) 17 * or (DCIN2_OVLO=H & DCIN1_UVKLO=L) 18 * 19 * +--------------+ +--------------+ 20 * | | | | 21 * | Any state +-------> | Suspend | 22 * | | | | 23 * +--------------+ +------+-------+ 24 * | 25 * CHG_EN = H && BAT_DET = H && | 26 * No errors (temp, bat_ov, UVLO, | 27 * OVLO...) | 28 * | 29 * BAT_OV or +---------v----------+ 30 * (DBAT && TTRI) | | 31 * +-----------------+ Trickle Charge | <---------------+ 32 * | | | | 33 * | +-------+------------+ | 34 * | | | 35 * | | ^ | 36 * | V_BAT > VTRI_TH | | VBAT < VTRI_TH - 50mV | 37 * | | | | 38 * | v | | 39 * | | | 40 * | BAT_OV or +----------+----+ | 41 * | (DBAT && TFST) | | | 42 * | +----------------+ Fast Charge | | 43 * | | | | | 44 * v v +----+----------+ | 45 * | | 46 *+----------------+ ILIM_DET=L | ^ ILIM_DET | 47 *| | & CV_DET=H | | or CV_DET=L | 48 *| Battery Error | & VBAT > | | or VBAT < VRECHG_TH | 49 *| | VRECHG_TH | | or IBAT > IFST/x | 50 *+----------------+ & IBAT < | | | 51 * IFST/x v | | 52 * ^ | | 53 * | +---------+-+ | 54 * | | | | 55 * +-------------------+ Top OFF | | 56 * BAT_OV = H or | | | 57 * (DBAT && TFST) +-----+-----+ | 58 * | | 59 * Stay top-off for 15s | | 60 * v | 61 * | 62 * +--------+ | 63 * | | | 64 * | Done +-------------------------+ 65 * | | 66 * +--------+ VBAT < VRECHG_TH 67 */ 68 69#include <linux/kernel.h> 70#include <linux/interrupt.h> 71#include <linux/mfd/rohm-bd70528.h> 72#include <linux/module.h> 73#include <linux/platform_device.h> 74#include <linux/power_supply.h> 75#include <linux/linear_range.h> 76 77#define CHG_STAT_SUSPEND 0x0 78#define CHG_STAT_TRICKLE 0x1 79#define CHG_STAT_FAST 0x3 80#define CHG_STAT_TOPOFF 0xe 81#define CHG_STAT_DONE 0xf 82#define CHG_STAT_OTP_TRICKLE 0x10 83#define CHG_STAT_OTP_FAST 0x11 84#define CHG_STAT_OTP_DONE 0x12 85#define CHG_STAT_TSD_TRICKLE 0x20 86#define CHG_STAT_TSD_FAST 0x21 87#define CHG_STAT_TSD_TOPOFF 0x22 88#define CHG_STAT_BAT_ERR 0x7f 89 90static const char *bd70528_charger_model = "BD70528"; 91static const char *bd70528_charger_manufacturer = "ROHM Semiconductors"; 92 93#define BD_ERR_IRQ_HND(_name_, _wrn_) \ 94static irqreturn_t bd0528_##_name_##_interrupt(int irq, void *arg) \ 95{ \ 96 struct power_supply *psy = (struct power_supply *)arg; \ 97 \ 98 power_supply_changed(psy); \ 99 dev_err(&psy->dev, (_wrn_)); \ 100 \ 101 return IRQ_HANDLED; \ 102} 103 104#define BD_INFO_IRQ_HND(_name_, _wrn_) \ 105static irqreturn_t bd0528_##_name_##_interrupt(int irq, void *arg) \ 106{ \ 107 struct power_supply *psy = (struct power_supply *)arg; \ 108 \ 109 power_supply_changed(psy); \ 110 dev_dbg(&psy->dev, (_wrn_)); \ 111 \ 112 return IRQ_HANDLED; \ 113} 114 115#define BD_IRQ_HND(_name_) bd0528_##_name_##_interrupt 116 117struct bd70528_psy { 118 struct regmap *regmap; 119 struct device *dev; 120 struct power_supply *psy; 121}; 122 123BD_ERR_IRQ_HND(BAT_OV_DET, "Battery overvoltage detected\n"); 124BD_ERR_IRQ_HND(DBAT_DET, "Dead battery detected\n"); 125BD_ERR_IRQ_HND(COLD_DET, "Battery cold\n"); 126BD_ERR_IRQ_HND(HOT_DET, "Battery hot\n"); 127BD_ERR_IRQ_HND(CHG_TSD, "Charger thermal shutdown\n"); 128BD_ERR_IRQ_HND(DCIN2_OV_DET, "DCIN2 overvoltage detected\n"); 129 130BD_INFO_IRQ_HND(BAT_OV_RES, "Battery voltage back to normal\n"); 131BD_INFO_IRQ_HND(COLD_RES, "Battery temperature back to normal\n"); 132BD_INFO_IRQ_HND(HOT_RES, "Battery temperature back to normal\n"); 133BD_INFO_IRQ_HND(BAT_RMV, "Battery removed\n"); 134BD_INFO_IRQ_HND(BAT_DET, "Battery detected\n"); 135BD_INFO_IRQ_HND(DCIN2_OV_RES, "DCIN2 voltage back to normal\n"); 136BD_INFO_IRQ_HND(DCIN2_RMV, "DCIN2 removed\n"); 137BD_INFO_IRQ_HND(DCIN2_DET, "DCIN2 detected\n"); 138BD_INFO_IRQ_HND(DCIN1_RMV, "DCIN1 removed\n"); 139BD_INFO_IRQ_HND(DCIN1_DET, "DCIN1 detected\n"); 140 141struct irq_name_pair { 142 const char *n; 143 irqreturn_t (*h)(int irq, void *arg); 144}; 145 146static int bd70528_get_irqs(struct platform_device *pdev, 147 struct bd70528_psy *bdpsy) 148{ 149 int irq, i, ret; 150 unsigned int mask; 151 static const struct irq_name_pair bd70528_chg_irqs[] = { 152 { .n = "bd70528-bat-ov-res", .h = BD_IRQ_HND(BAT_OV_RES) }, 153 { .n = "bd70528-bat-ov-det", .h = BD_IRQ_HND(BAT_OV_DET) }, 154 { .n = "bd70528-bat-dead", .h = BD_IRQ_HND(DBAT_DET) }, 155 { .n = "bd70528-bat-warmed", .h = BD_IRQ_HND(COLD_RES) }, 156 { .n = "bd70528-bat-cold", .h = BD_IRQ_HND(COLD_DET) }, 157 { .n = "bd70528-bat-cooled", .h = BD_IRQ_HND(HOT_RES) }, 158 { .n = "bd70528-bat-hot", .h = BD_IRQ_HND(HOT_DET) }, 159 { .n = "bd70528-chg-tshd", .h = BD_IRQ_HND(CHG_TSD) }, 160 { .n = "bd70528-bat-removed", .h = BD_IRQ_HND(BAT_RMV) }, 161 { .n = "bd70528-bat-detected", .h = BD_IRQ_HND(BAT_DET) }, 162 { .n = "bd70528-dcin2-ov-res", .h = BD_IRQ_HND(DCIN2_OV_RES) }, 163 { .n = "bd70528-dcin2-ov-det", .h = BD_IRQ_HND(DCIN2_OV_DET) }, 164 { .n = "bd70528-dcin2-removed", .h = BD_IRQ_HND(DCIN2_RMV) }, 165 { .n = "bd70528-dcin2-detected", .h = BD_IRQ_HND(DCIN2_DET) }, 166 { .n = "bd70528-dcin1-removed", .h = BD_IRQ_HND(DCIN1_RMV) }, 167 { .n = "bd70528-dcin1-detected", .h = BD_IRQ_HND(DCIN1_DET) }, 168 }; 169 170 for (i = 0; i < ARRAY_SIZE(bd70528_chg_irqs); i++) { 171 irq = platform_get_irq_byname(pdev, bd70528_chg_irqs[i].n); 172 if (irq < 0) { 173 dev_err(&pdev->dev, "Bad IRQ information for %s (%d)\n", 174 bd70528_chg_irqs[i].n, irq); 175 return irq; 176 } 177 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 178 bd70528_chg_irqs[i].h, 179 IRQF_ONESHOT, 180 bd70528_chg_irqs[i].n, 181 bdpsy->psy); 182 183 if (ret) 184 return ret; 185 } 186 /* 187 * BD70528 irq controller is not touching the main mask register. 188 * So enable the charger block interrupts at main level. We can just 189 * leave them enabled as irq-controller should disable irqs 190 * from sub-registers when IRQ is disabled or freed. 191 */ 192 mask = BD70528_REG_INT_BAT1_MASK | BD70528_REG_INT_BAT2_MASK; 193 ret = regmap_update_bits(bdpsy->regmap, 194 BD70528_REG_INT_MAIN_MASK, mask, 0); 195 if (ret) 196 dev_err(&pdev->dev, "Failed to enable charger IRQs\n"); 197 198 return ret; 199} 200 201static int bd70528_get_charger_status(struct bd70528_psy *bdpsy, int *val) 202{ 203 int ret; 204 unsigned int v; 205 206 ret = regmap_read(bdpsy->regmap, BD70528_REG_CHG_CURR_STAT, &v); 207 if (ret) { 208 dev_err(bdpsy->dev, "Charger state read failure %d\n", 209 ret); 210 return ret; 211 } 212 213 switch (v & BD70528_MASK_CHG_STAT) { 214 case CHG_STAT_SUSPEND: 215 /* Maybe we should check the CHG_TTRI_EN? */ 216 case CHG_STAT_OTP_TRICKLE: 217 case CHG_STAT_OTP_FAST: 218 case CHG_STAT_OTP_DONE: 219 case CHG_STAT_TSD_TRICKLE: 220 case CHG_STAT_TSD_FAST: 221 case CHG_STAT_TSD_TOPOFF: 222 case CHG_STAT_BAT_ERR: 223 *val = POWER_SUPPLY_STATUS_NOT_CHARGING; 224 break; 225 case CHG_STAT_DONE: 226 *val = POWER_SUPPLY_STATUS_FULL; 227 break; 228 case CHG_STAT_TRICKLE: 229 case CHG_STAT_FAST: 230 case CHG_STAT_TOPOFF: 231 *val = POWER_SUPPLY_STATUS_CHARGING; 232 break; 233 default: 234 *val = POWER_SUPPLY_STATUS_UNKNOWN; 235 break; 236 } 237 238 return 0; 239} 240 241static int bd70528_get_charge_type(struct bd70528_psy *bdpsy, int *val) 242{ 243 int ret; 244 unsigned int v; 245 246 ret = regmap_read(bdpsy->regmap, BD70528_REG_CHG_CURR_STAT, &v); 247 if (ret) { 248 dev_err(bdpsy->dev, "Charger state read failure %d\n", 249 ret); 250 return ret; 251 } 252 253 switch (v & BD70528_MASK_CHG_STAT) { 254 case CHG_STAT_TRICKLE: 255 *val = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; 256 break; 257 case CHG_STAT_FAST: 258 case CHG_STAT_TOPOFF: 259 *val = POWER_SUPPLY_CHARGE_TYPE_FAST; 260 break; 261 case CHG_STAT_DONE: 262 case CHG_STAT_SUSPEND: 263 /* Maybe we should check the CHG_TTRI_EN? */ 264 case CHG_STAT_OTP_TRICKLE: 265 case CHG_STAT_OTP_FAST: 266 case CHG_STAT_OTP_DONE: 267 case CHG_STAT_TSD_TRICKLE: 268 case CHG_STAT_TSD_FAST: 269 case CHG_STAT_TSD_TOPOFF: 270 case CHG_STAT_BAT_ERR: 271 *val = POWER_SUPPLY_CHARGE_TYPE_NONE; 272 break; 273 default: 274 *val = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; 275 break; 276 } 277 278 return 0; 279} 280 281static int bd70528_get_battery_health(struct bd70528_psy *bdpsy, int *val) 282{ 283 int ret; 284 unsigned int v; 285 286 ret = regmap_read(bdpsy->regmap, BD70528_REG_CHG_BAT_STAT, &v); 287 if (ret) { 288 dev_err(bdpsy->dev, "Battery state read failure %d\n", 289 ret); 290 return ret; 291 } 292 /* No battery? */ 293 if (!(v & BD70528_MASK_CHG_BAT_DETECT)) 294 *val = POWER_SUPPLY_HEALTH_DEAD; 295 else if (v & BD70528_MASK_CHG_BAT_OVERVOLT) 296 *val = POWER_SUPPLY_HEALTH_OVERVOLTAGE; 297 else if (v & BD70528_MASK_CHG_BAT_TIMER) 298 *val = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; 299 else 300 *val = POWER_SUPPLY_HEALTH_GOOD; 301 302 return 0; 303} 304 305static int bd70528_get_online(struct bd70528_psy *bdpsy, int *val) 306{ 307 int ret; 308 unsigned int v; 309 310 ret = regmap_read(bdpsy->regmap, BD70528_REG_CHG_IN_STAT, &v); 311 if (ret) { 312 dev_err(bdpsy->dev, "DC1 IN state read failure %d\n", 313 ret); 314 return ret; 315 } 316 317 *val = (v & BD70528_MASK_CHG_DCIN1_UVLO) ? 1 : 0; 318 319 return 0; 320} 321 322static int bd70528_get_present(struct bd70528_psy *bdpsy, int *val) 323{ 324 int ret; 325 unsigned int v; 326 327 ret = regmap_read(bdpsy->regmap, BD70528_REG_CHG_BAT_STAT, &v); 328 if (ret) { 329 dev_err(bdpsy->dev, "Battery state read failure %d\n", 330 ret); 331 return ret; 332 } 333 334 *val = (v & BD70528_MASK_CHG_BAT_DETECT) ? 1 : 0; 335 336 return 0; 337} 338 339static const struct linear_range current_limit_ranges[] = { 340 { 341 .min = 5, 342 .step = 1, 343 .min_sel = 0, 344 .max_sel = 0x22, 345 }, 346 { 347 .min = 40, 348 .step = 5, 349 .min_sel = 0x23, 350 .max_sel = 0x26, 351 }, 352 { 353 .min = 60, 354 .step = 20, 355 .min_sel = 0x27, 356 .max_sel = 0x2d, 357 }, 358 { 359 .min = 200, 360 .step = 50, 361 .min_sel = 0x2e, 362 .max_sel = 0x34, 363 }, 364 { 365 .min = 500, 366 .step = 0, 367 .min_sel = 0x35, 368 .max_sel = 0x3f, 369 }, 370}; 371 372/* 373 * BD70528 would support setting and getting own charge current/ 374 * voltage for low temperatures. The driver currently only reads 375 * the charge current at room temperature. We do set both though. 376 */ 377static const struct linear_range warm_charge_curr[] = { 378 { 379 .min = 10, 380 .step = 10, 381 .min_sel = 0, 382 .max_sel = 0x12, 383 }, 384 { 385 .min = 200, 386 .step = 25, 387 .min_sel = 0x13, 388 .max_sel = 0x1f, 389 }, 390}; 391 392/* 393 * Cold charge current selectors are identical to warm charge current 394 * selectors. The difference is that only smaller currents are available 395 * at cold charge range. 396 */ 397#define MAX_COLD_CHG_CURR_SEL 0x15 398#define MAX_WARM_CHG_CURR_SEL 0x1f 399#define MIN_CHG_CURR_SEL 0x0 400 401static int get_charge_current(struct bd70528_psy *bdpsy, int *ma) 402{ 403 unsigned int sel; 404 int ret; 405 406 ret = regmap_read(bdpsy->regmap, BD70528_REG_CHG_CHG_CURR_WARM, 407 &sel); 408 if (ret) { 409 dev_err(bdpsy->dev, 410 "Charge current reading failed (%d)\n", ret); 411 return ret; 412 } 413 414 sel &= BD70528_MASK_CHG_CHG_CURR; 415 416 ret = linear_range_get_value_array(&warm_charge_curr[0], 417 ARRAY_SIZE(warm_charge_curr), 418 sel, ma); 419 if (ret) { 420 dev_err(bdpsy->dev, 421 "Unknown charge current value 0x%x\n", 422 sel); 423 } 424 425 return ret; 426} 427 428static int get_current_limit(struct bd70528_psy *bdpsy, int *ma) 429{ 430 unsigned int sel; 431 int ret; 432 433 ret = regmap_read(bdpsy->regmap, BD70528_REG_CHG_DCIN_ILIM, 434 &sel); 435 436 if (ret) { 437 dev_err(bdpsy->dev, 438 "Input current limit reading failed (%d)\n", ret); 439 return ret; 440 } 441 442 sel &= BD70528_MASK_CHG_DCIN_ILIM; 443 444 ret = linear_range_get_value_array(¤t_limit_ranges[0], 445 ARRAY_SIZE(current_limit_ranges), 446 sel, ma); 447 if (ret) { 448 /* Unspecified values mean 500 mA */ 449 *ma = 500; 450 } 451 return 0; 452} 453 454static enum power_supply_property bd70528_charger_props[] = { 455 POWER_SUPPLY_PROP_STATUS, 456 POWER_SUPPLY_PROP_CHARGE_TYPE, 457 POWER_SUPPLY_PROP_HEALTH, 458 POWER_SUPPLY_PROP_PRESENT, 459 POWER_SUPPLY_PROP_ONLINE, 460 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 461 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, 462 POWER_SUPPLY_PROP_MODEL_NAME, 463 POWER_SUPPLY_PROP_MANUFACTURER, 464}; 465 466static int bd70528_charger_get_property(struct power_supply *psy, 467 enum power_supply_property psp, 468 union power_supply_propval *val) 469{ 470 struct bd70528_psy *bdpsy = power_supply_get_drvdata(psy); 471 int ret = 0; 472 473 switch (psp) { 474 case POWER_SUPPLY_PROP_STATUS: 475 return bd70528_get_charger_status(bdpsy, &val->intval); 476 case POWER_SUPPLY_PROP_CHARGE_TYPE: 477 return bd70528_get_charge_type(bdpsy, &val->intval); 478 case POWER_SUPPLY_PROP_HEALTH: 479 return bd70528_get_battery_health(bdpsy, &val->intval); 480 case POWER_SUPPLY_PROP_PRESENT: 481 return bd70528_get_present(bdpsy, &val->intval); 482 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 483 ret = get_current_limit(bdpsy, &val->intval); 484 val->intval *= 1000; 485 return ret; 486 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 487 ret = get_charge_current(bdpsy, &val->intval); 488 val->intval *= 1000; 489 return ret; 490 case POWER_SUPPLY_PROP_ONLINE: 491 return bd70528_get_online(bdpsy, &val->intval); 492 case POWER_SUPPLY_PROP_MODEL_NAME: 493 val->strval = bd70528_charger_model; 494 return 0; 495 case POWER_SUPPLY_PROP_MANUFACTURER: 496 val->strval = bd70528_charger_manufacturer; 497 return 0; 498 default: 499 break; 500 } 501 502 return -EINVAL; 503} 504 505static int bd70528_prop_is_writable(struct power_supply *psy, 506 enum power_supply_property psp) 507{ 508 switch (psp) { 509 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 510 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 511 return 1; 512 default: 513 break; 514 } 515 return 0; 516} 517 518static int set_charge_current(struct bd70528_psy *bdpsy, int ma) 519{ 520 unsigned int reg; 521 int ret = 0, tmpret; 522 bool found; 523 524 if (ma > 500) { 525 dev_warn(bdpsy->dev, 526 "Requested charge current %u exceed maximum (500mA)\n", 527 ma); 528 reg = MAX_WARM_CHG_CURR_SEL; 529 goto set; 530 } 531 if (ma < 10) { 532 dev_err(bdpsy->dev, 533 "Requested charge current %u smaller than min (10mA)\n", 534 ma); 535 reg = MIN_CHG_CURR_SEL; 536 ret = -EINVAL; 537 goto set; 538 } 539 540/* 541 * For BD70528 voltage/current limits we happily accept any value which 542 * belongs the range. We could check if value matching the selector is 543 * desired by computing the range min + (sel - sel_low) * range step - but 544 * I guess it is enough if we use voltage/current which is closest (below) 545 * the requested? 546 */ 547 548 ret = linear_range_get_selector_low_array(warm_charge_curr, 549 ARRAY_SIZE(warm_charge_curr), 550 ma, ®, &found); 551 if (ret) { 552 dev_err(bdpsy->dev, 553 "Unsupported charge current %u mA\n", ma); 554 reg = MIN_CHG_CURR_SEL; 555 goto set; 556 } 557 if (!found) { 558 /* 559 * There was a gap in supported values and we hit it. 560 * Yet a smaller value was found so we use it. 561 */ 562 dev_warn(bdpsy->dev, 563 "Unsupported charge current %u mA\n", ma); 564 } 565set: 566 567 tmpret = regmap_update_bits(bdpsy->regmap, 568 BD70528_REG_CHG_CHG_CURR_WARM, 569 BD70528_MASK_CHG_CHG_CURR, reg); 570 if (tmpret) 571 dev_err(bdpsy->dev, 572 "Charge current write failure (%d)\n", tmpret); 573 574 if (reg > MAX_COLD_CHG_CURR_SEL) 575 reg = MAX_COLD_CHG_CURR_SEL; 576 577 if (!tmpret) 578 tmpret = regmap_update_bits(bdpsy->regmap, 579 BD70528_REG_CHG_CHG_CURR_COLD, 580 BD70528_MASK_CHG_CHG_CURR, reg); 581 582 if (!ret) 583 ret = tmpret; 584 585 return ret; 586} 587 588#define MAX_CURR_LIMIT_SEL 0x34 589#define MIN_CURR_LIMIT_SEL 0x0 590 591static int set_current_limit(struct bd70528_psy *bdpsy, int ma) 592{ 593 unsigned int reg; 594 int ret = 0, tmpret; 595 bool found; 596 597 if (ma > 500) { 598 dev_warn(bdpsy->dev, 599 "Requested current limit %u exceed maximum (500mA)\n", 600 ma); 601 reg = MAX_CURR_LIMIT_SEL; 602 goto set; 603 } 604 if (ma < 5) { 605 dev_err(bdpsy->dev, 606 "Requested current limit %u smaller than min (5mA)\n", 607 ma); 608 reg = MIN_CURR_LIMIT_SEL; 609 ret = -EINVAL; 610 goto set; 611 } 612 613 ret = linear_range_get_selector_low_array(current_limit_ranges, 614 ARRAY_SIZE(current_limit_ranges), 615 ma, ®, &found); 616 if (ret) { 617 dev_err(bdpsy->dev, "Unsupported current limit %umA\n", ma); 618 reg = MIN_CURR_LIMIT_SEL; 619 goto set; 620 } 621 if (!found) { 622 /* 623 * There was a gap in supported values and we hit it. 624 * We found a smaller value from ranges and use it. 625 * Warn user though. 626 */ 627 dev_warn(bdpsy->dev, "Unsupported current limit %umA\n", ma); 628 } 629 630set: 631 tmpret = regmap_update_bits(bdpsy->regmap, 632 BD70528_REG_CHG_DCIN_ILIM, 633 BD70528_MASK_CHG_DCIN_ILIM, reg); 634 635 if (!ret) 636 ret = tmpret; 637 638 return ret; 639} 640 641static int bd70528_charger_set_property(struct power_supply *psy, 642 enum power_supply_property psp, 643 const union power_supply_propval *val) 644{ 645 struct bd70528_psy *bdpsy = power_supply_get_drvdata(psy); 646 647 switch (psp) { 648 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 649 return set_current_limit(bdpsy, val->intval / 1000); 650 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: 651 return set_charge_current(bdpsy, val->intval / 1000); 652 default: 653 break; 654 } 655 return -EINVAL; 656} 657 658static const struct power_supply_desc bd70528_charger_desc = { 659 .name = "bd70528-charger", 660 .type = POWER_SUPPLY_TYPE_MAINS, 661 .properties = bd70528_charger_props, 662 .num_properties = ARRAY_SIZE(bd70528_charger_props), 663 .get_property = bd70528_charger_get_property, 664 .set_property = bd70528_charger_set_property, 665 .property_is_writeable = bd70528_prop_is_writable, 666}; 667 668static int bd70528_power_probe(struct platform_device *pdev) 669{ 670 struct bd70528_psy *bdpsy; 671 struct power_supply_config cfg = {}; 672 673 bdpsy = devm_kzalloc(&pdev->dev, sizeof(*bdpsy), GFP_KERNEL); 674 if (!bdpsy) 675 return -ENOMEM; 676 677 bdpsy->regmap = dev_get_regmap(pdev->dev.parent, NULL); 678 if (!bdpsy->regmap) { 679 dev_err(&pdev->dev, "No regmap found for chip\n"); 680 return -EINVAL; 681 } 682 bdpsy->dev = &pdev->dev; 683 684 platform_set_drvdata(pdev, bdpsy); 685 cfg.drv_data = bdpsy; 686 cfg.of_node = pdev->dev.parent->of_node; 687 688 bdpsy->psy = devm_power_supply_register(&pdev->dev, 689 &bd70528_charger_desc, &cfg); 690 if (IS_ERR(bdpsy->psy)) { 691 dev_err(&pdev->dev, "failed: power supply register\n"); 692 return PTR_ERR(bdpsy->psy); 693 } 694 695 return bd70528_get_irqs(pdev, bdpsy); 696} 697 698static struct platform_driver bd70528_power = { 699 .driver = { 700 .name = "bd70528-power" 701 }, 702 .probe = bd70528_power_probe, 703}; 704 705module_platform_driver(bd70528_power); 706 707MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 708MODULE_DESCRIPTION("BD70528 power-supply driver"); 709MODULE_LICENSE("GPL"); 710MODULE_ALIAS("platform:bd70528-power"); 711