1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved. 4 * Copyright (c) 2022, Linaro Ltd 5 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 6 */ 7 #include <linux/auxiliary_bus.h> 8 #include <linux/module.h> 9 #include <linux/mutex.h> 10 #include <linux/nvmem-consumer.h> 11 #include <linux/of_device.h> 12 #include <linux/power_supply.h> 13 #include <linux/property.h> 14 #include <linux/soc/qcom/pdr.h> 15 #include <linux/soc/qcom/pmic_glink.h> 16 #include <linux/math.h> 17 #include <linux/units.h> 18 19 #define BATTMGR_CHEMISTRY_LEN 4 20 #define BATTMGR_STRING_LEN 128 21 22 enum qcom_battmgr_variant { 23 QCOM_BATTMGR_SC8280XP, 24 QCOM_BATTMGR_SM8350, 25 QCOM_BATTMGR_SM8550, 26 QCOM_BATTMGR_X1E80100, 27 }; 28 29 #define BATTMGR_BAT_STATUS 0x1 30 31 #define BATTMGR_REQUEST_NOTIFICATION 0x4 32 33 #define BATTMGR_NOTIFICATION 0x7 34 #define NOTIF_BAT_PROPERTY 0x30 35 #define NOTIF_USB_PROPERTY 0x32 36 #define NOTIF_WLS_PROPERTY 0x34 37 #define NOTIF_BAT_STATUS 0x80 38 #define NOTIF_BAT_INFO 0x81 39 #define NOTIF_BAT_CHARGING_STATE 0x83 40 41 #define BATTMGR_BAT_INFO 0x9 42 43 #define BATTMGR_BAT_DISCHARGE_TIME 0xc 44 45 #define BATTMGR_BAT_CHARGE_TIME 0xd 46 47 #define BATTMGR_BAT_PROPERTY_GET 0x30 48 #define BATTMGR_BAT_PROPERTY_SET 0x31 49 #define BATT_STATUS 0 50 #define BATT_HEALTH 1 51 #define BATT_PRESENT 2 52 #define BATT_CHG_TYPE 3 53 #define BATT_CAPACITY 4 54 #define BATT_SOH 5 55 #define BATT_VOLT_OCV 6 56 #define BATT_VOLT_NOW 7 57 #define BATT_VOLT_MAX 8 58 #define BATT_CURR_NOW 9 59 #define BATT_CHG_CTRL_LIM 10 60 #define BATT_CHG_CTRL_LIM_MAX 11 61 #define BATT_TEMP 12 62 #define BATT_TECHNOLOGY 13 63 #define BATT_CHG_COUNTER 14 64 #define BATT_CYCLE_COUNT 15 65 #define BATT_CHG_FULL_DESIGN 16 66 #define BATT_CHG_FULL 17 67 #define BATT_MODEL_NAME 18 68 #define BATT_TTF_AVG 19 69 #define BATT_TTE_AVG 20 70 #define BATT_RESISTANCE 21 71 #define BATT_POWER_NOW 22 72 #define BATT_POWER_AVG 23 73 #define BATT_CHG_CTRL_EN 24 74 #define BATT_CHG_CTRL_START_THR 25 75 #define BATT_CHG_CTRL_END_THR 26 76 77 #define BATTMGR_USB_PROPERTY_GET 0x32 78 #define BATTMGR_USB_PROPERTY_SET 0x33 79 #define USB_ONLINE 0 80 #define USB_VOLT_NOW 1 81 #define USB_VOLT_MAX 2 82 #define USB_CURR_NOW 3 83 #define USB_CURR_MAX 4 84 #define USB_INPUT_CURR_LIMIT 5 85 #define USB_TYPE 6 86 #define USB_ADAP_TYPE 7 87 #define USB_MOISTURE_DET_EN 8 88 #define USB_MOISTURE_DET_STS 9 89 90 #define BATTMGR_WLS_PROPERTY_GET 0x34 91 #define BATTMGR_WLS_PROPERTY_SET 0x35 92 #define WLS_ONLINE 0 93 #define WLS_VOLT_NOW 1 94 #define WLS_VOLT_MAX 2 95 #define WLS_CURR_NOW 3 96 #define WLS_CURR_MAX 4 97 #define WLS_TYPE 5 98 #define WLS_BOOST_EN 6 99 100 #define BATTMGR_CHG_CTRL_LIMIT_EN 0x48 101 #define CHARGE_CTRL_START_THR_MIN 50 102 #define CHARGE_CTRL_START_THR_MAX 95 103 #define CHARGE_CTRL_END_THR_MIN 55 104 #define CHARGE_CTRL_END_THR_MAX 100 105 #define CHARGE_CTRL_DELTA_SOC 5 106 107 struct qcom_battmgr_enable_request { 108 struct pmic_glink_hdr hdr; 109 __le32 battery_id; 110 __le32 power_state; 111 __le32 low_capacity; 112 __le32 high_capacity; 113 }; 114 115 struct qcom_battmgr_property_request { 116 struct pmic_glink_hdr hdr; 117 __le32 battery; 118 __le32 property; 119 __le32 value; 120 }; 121 122 struct qcom_battmgr_update_request { 123 struct pmic_glink_hdr hdr; 124 __le32 battery_id; 125 }; 126 127 struct qcom_battmgr_charge_time_request { 128 struct pmic_glink_hdr hdr; 129 __le32 battery_id; 130 __le32 percent; 131 __le32 reserved; 132 }; 133 134 struct qcom_battmgr_discharge_time_request { 135 struct pmic_glink_hdr hdr; 136 __le32 battery_id; 137 __le32 rate; /* 0 for current rate */ 138 __le32 reserved; 139 }; 140 141 struct qcom_battmgr_charge_ctrl_request { 142 struct pmic_glink_hdr hdr; 143 __le32 enable; 144 __le32 target_soc; 145 __le32 delta_soc; 146 }; 147 148 struct qcom_battmgr_message { 149 struct pmic_glink_hdr hdr; 150 union { 151 struct { 152 __le32 property; 153 __le32 value; 154 __le32 result; 155 } intval; 156 struct { 157 __le32 property; 158 char model[BATTMGR_STRING_LEN]; 159 } strval; 160 struct { 161 /* 162 * 0: mWh 163 * 1: mAh 164 */ 165 __le32 power_unit; 166 __le32 design_capacity; 167 __le32 last_full_capacity; 168 /* 169 * 0 nonrechargable 170 * 1 rechargable 171 */ 172 __le32 battery_tech; 173 __le32 design_voltage; /* mV */ 174 __le32 capacity_low; 175 __le32 capacity_warning; 176 __le32 cycle_count; 177 /* thousandth of percent */ 178 __le32 accuracy; 179 __le32 max_sample_time_ms; 180 __le32 min_sample_time_ms; 181 __le32 max_average_interval_ms; 182 __le32 min_average_interval_ms; 183 /* granularity between low and warning */ 184 __le32 capacity_granularity1; 185 /* granularity between warning and full */ 186 __le32 capacity_granularity2; 187 /* 188 * 0: no 189 * 1: cold 190 * 2: hot 191 */ 192 __le32 swappable; 193 __le32 capabilities; 194 char model_number[BATTMGR_STRING_LEN]; 195 char serial_number[BATTMGR_STRING_LEN]; 196 char battery_type[BATTMGR_STRING_LEN]; 197 char oem_info[BATTMGR_STRING_LEN]; 198 char battery_chemistry[BATTMGR_CHEMISTRY_LEN]; 199 char uid[BATTMGR_STRING_LEN]; 200 __le32 critical_bias; 201 u8 day; 202 u8 month; 203 __le16 year; 204 __le32 battery_id; 205 } info; 206 struct { 207 /* 208 * BIT(0) discharging 209 * BIT(1) charging 210 * BIT(2) critical low 211 */ 212 __le32 battery_state; 213 /* mWh or mAh, based on info->power_unit */ 214 __le32 capacity; 215 __le32 rate; 216 /* mv */ 217 __le32 battery_voltage; 218 /* 219 * BIT(0) power online 220 * BIT(1) discharging 221 * BIT(2) charging 222 * BIT(3) battery critical 223 */ 224 __le32 power_state; 225 /* 226 * 1: AC 227 * 2: USB 228 * 3: Wireless 229 */ 230 __le32 charging_source; 231 __le32 temperature; 232 } status; 233 __le32 time; 234 __le32 notification; 235 }; 236 }; 237 238 #define BATTMGR_CHARGING_SOURCE_AC 1 239 #define BATTMGR_CHARGING_SOURCE_USB 2 240 #define BATTMGR_CHARGING_SOURCE_WIRELESS 3 241 242 enum qcom_battmgr_unit { 243 QCOM_BATTMGR_UNIT_mWh = 0, 244 QCOM_BATTMGR_UNIT_mAh = 1 245 }; 246 247 struct qcom_battmgr_info { 248 bool valid; 249 250 bool present; 251 unsigned int charge_type; 252 unsigned int design_capacity; 253 unsigned int last_full_capacity; 254 unsigned int voltage_max_design; 255 unsigned int voltage_max; 256 unsigned int capacity_low; 257 unsigned int capacity_warning; 258 unsigned int cycle_count; 259 unsigned int charge_count; 260 unsigned int charge_ctrl_start; 261 unsigned int charge_ctrl_end; 262 char model_number[BATTMGR_STRING_LEN]; 263 char serial_number[BATTMGR_STRING_LEN]; 264 char oem_info[BATTMGR_STRING_LEN]; 265 unsigned char technology; 266 unsigned char day; 267 unsigned char month; 268 unsigned short year; 269 }; 270 271 struct qcom_battmgr_status { 272 unsigned int status; 273 unsigned int health; 274 unsigned int capacity; 275 unsigned int percent; 276 int current_now; 277 int power_now; 278 unsigned int voltage_now; 279 unsigned int voltage_ocv; 280 unsigned int temperature; 281 unsigned int resistance; 282 unsigned int soh_percent; 283 284 unsigned int discharge_time; 285 unsigned int charge_time; 286 }; 287 288 struct qcom_battmgr_ac { 289 bool online; 290 }; 291 292 struct qcom_battmgr_usb { 293 bool online; 294 unsigned int voltage_now; 295 unsigned int voltage_max; 296 unsigned int current_now; 297 unsigned int current_max; 298 unsigned int current_limit; 299 unsigned int usb_type; 300 }; 301 302 struct qcom_battmgr_wireless { 303 bool online; 304 unsigned int voltage_now; 305 unsigned int voltage_max; 306 unsigned int current_now; 307 unsigned int current_max; 308 }; 309 310 struct qcom_battmgr { 311 struct device *dev; 312 struct pmic_glink_client *client; 313 314 enum qcom_battmgr_variant variant; 315 316 struct power_supply *ac_psy; 317 struct power_supply *bat_psy; 318 struct power_supply *usb_psy; 319 struct power_supply *wls_psy; 320 321 enum qcom_battmgr_unit unit; 322 323 int error; 324 struct completion ack; 325 326 bool service_up; 327 328 struct qcom_battmgr_info info; 329 struct qcom_battmgr_status status; 330 struct qcom_battmgr_ac ac; 331 struct qcom_battmgr_usb usb; 332 struct qcom_battmgr_wireless wireless; 333 334 struct work_struct enable_work; 335 336 /* 337 * @lock is used to prevent concurrent power supply requests to the 338 * firmware, as it then stops responding. 339 */ 340 struct mutex lock; 341 }; 342 343 static int qcom_battmgr_request(struct qcom_battmgr *battmgr, void *data, size_t len) 344 { 345 unsigned long left; 346 int ret; 347 348 reinit_completion(&battmgr->ack); 349 350 battmgr->error = 0; 351 352 ret = pmic_glink_send(battmgr->client, data, len); 353 if (ret < 0) 354 return ret; 355 356 left = wait_for_completion_timeout(&battmgr->ack, HZ); 357 if (!left) 358 return -ETIMEDOUT; 359 360 return battmgr->error; 361 } 362 363 static int qcom_battmgr_request_property(struct qcom_battmgr *battmgr, int opcode, 364 int property, u32 value) 365 { 366 struct qcom_battmgr_property_request request = { 367 .hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR), 368 .hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP), 369 .hdr.opcode = cpu_to_le32(opcode), 370 .battery = cpu_to_le32(0), 371 .property = cpu_to_le32(property), 372 .value = cpu_to_le32(value), 373 }; 374 375 return qcom_battmgr_request(battmgr, &request, sizeof(request)); 376 } 377 378 static int qcom_battmgr_update_status(struct qcom_battmgr *battmgr) 379 { 380 struct qcom_battmgr_update_request request = { 381 .hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR), 382 .hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP), 383 .hdr.opcode = cpu_to_le32(BATTMGR_BAT_STATUS), 384 .battery_id = cpu_to_le32(0), 385 }; 386 387 return qcom_battmgr_request(battmgr, &request, sizeof(request)); 388 } 389 390 static int qcom_battmgr_update_info(struct qcom_battmgr *battmgr) 391 { 392 struct qcom_battmgr_update_request request = { 393 .hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR), 394 .hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP), 395 .hdr.opcode = cpu_to_le32(BATTMGR_BAT_INFO), 396 .battery_id = cpu_to_le32(0), 397 }; 398 399 return qcom_battmgr_request(battmgr, &request, sizeof(request)); 400 } 401 402 static int qcom_battmgr_update_charge_time(struct qcom_battmgr *battmgr) 403 { 404 struct qcom_battmgr_charge_time_request request = { 405 .hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR), 406 .hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP), 407 .hdr.opcode = cpu_to_le32(BATTMGR_BAT_CHARGE_TIME), 408 .battery_id = cpu_to_le32(0), 409 .percent = cpu_to_le32(100), 410 }; 411 412 return qcom_battmgr_request(battmgr, &request, sizeof(request)); 413 } 414 415 static int qcom_battmgr_update_discharge_time(struct qcom_battmgr *battmgr) 416 { 417 struct qcom_battmgr_discharge_time_request request = { 418 .hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR), 419 .hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP), 420 .hdr.opcode = cpu_to_le32(BATTMGR_BAT_DISCHARGE_TIME), 421 .battery_id = cpu_to_le32(0), 422 .rate = cpu_to_le32(0), 423 }; 424 425 return qcom_battmgr_request(battmgr, &request, sizeof(request)); 426 } 427 428 static const u8 sm8350_bat_prop_map[] = { 429 [POWER_SUPPLY_PROP_STATUS] = BATT_STATUS, 430 [POWER_SUPPLY_PROP_HEALTH] = BATT_HEALTH, 431 [POWER_SUPPLY_PROP_PRESENT] = BATT_PRESENT, 432 [POWER_SUPPLY_PROP_CHARGE_TYPE] = BATT_CHG_TYPE, 433 [POWER_SUPPLY_PROP_CAPACITY] = BATT_CAPACITY, 434 [POWER_SUPPLY_PROP_VOLTAGE_OCV] = BATT_VOLT_OCV, 435 [POWER_SUPPLY_PROP_VOLTAGE_NOW] = BATT_VOLT_NOW, 436 [POWER_SUPPLY_PROP_VOLTAGE_MAX] = BATT_VOLT_MAX, 437 [POWER_SUPPLY_PROP_CURRENT_NOW] = BATT_CURR_NOW, 438 [POWER_SUPPLY_PROP_TEMP] = BATT_TEMP, 439 [POWER_SUPPLY_PROP_TECHNOLOGY] = BATT_TECHNOLOGY, 440 [POWER_SUPPLY_PROP_CHARGE_COUNTER] = BATT_CHG_COUNTER, 441 [POWER_SUPPLY_PROP_CYCLE_COUNT] = BATT_CYCLE_COUNT, 442 [POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN] = BATT_CHG_FULL_DESIGN, 443 [POWER_SUPPLY_PROP_CHARGE_FULL] = BATT_CHG_FULL, 444 [POWER_SUPPLY_PROP_MODEL_NAME] = BATT_MODEL_NAME, 445 [POWER_SUPPLY_PROP_TIME_TO_FULL_AVG] = BATT_TTF_AVG, 446 [POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG] = BATT_TTE_AVG, 447 [POWER_SUPPLY_PROP_INTERNAL_RESISTANCE] = BATT_RESISTANCE, 448 [POWER_SUPPLY_PROP_STATE_OF_HEALTH] = BATT_SOH, 449 [POWER_SUPPLY_PROP_POWER_NOW] = BATT_POWER_NOW, 450 [POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD] = BATT_CHG_CTRL_START_THR, 451 [POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD] = BATT_CHG_CTRL_END_THR, 452 }; 453 454 static int qcom_battmgr_bat_sm8350_update(struct qcom_battmgr *battmgr, 455 enum power_supply_property psp) 456 { 457 unsigned int prop; 458 int ret; 459 460 if (psp >= ARRAY_SIZE(sm8350_bat_prop_map)) 461 return -EINVAL; 462 463 prop = sm8350_bat_prop_map[psp]; 464 465 mutex_lock(&battmgr->lock); 466 ret = qcom_battmgr_request_property(battmgr, BATTMGR_BAT_PROPERTY_GET, prop, 0); 467 mutex_unlock(&battmgr->lock); 468 469 return ret; 470 } 471 472 static int qcom_battmgr_bat_sc8280xp_update(struct qcom_battmgr *battmgr, 473 enum power_supply_property psp) 474 { 475 int ret; 476 477 mutex_lock(&battmgr->lock); 478 479 if (!battmgr->info.valid) { 480 ret = qcom_battmgr_update_info(battmgr); 481 if (ret < 0) 482 goto out_unlock; 483 battmgr->info.valid = true; 484 } 485 486 ret = qcom_battmgr_update_status(battmgr); 487 if (ret < 0) 488 goto out_unlock; 489 490 if (psp == POWER_SUPPLY_PROP_TIME_TO_FULL_AVG) { 491 ret = qcom_battmgr_update_charge_time(battmgr); 492 if (ret < 0) { 493 ret = -ENODATA; 494 goto out_unlock; 495 } 496 } 497 498 if (psp == POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG) { 499 ret = qcom_battmgr_update_discharge_time(battmgr); 500 if (ret < 0) { 501 ret = -ENODATA; 502 goto out_unlock; 503 } 504 } 505 506 out_unlock: 507 mutex_unlock(&battmgr->lock); 508 return ret; 509 } 510 511 static int qcom_battmgr_bat_get_property(struct power_supply *psy, 512 enum power_supply_property psp, 513 union power_supply_propval *val) 514 { 515 struct qcom_battmgr *battmgr = power_supply_get_drvdata(psy); 516 enum qcom_battmgr_unit unit = battmgr->unit; 517 int ret; 518 519 if (!battmgr->service_up) 520 return -EAGAIN; 521 522 if (battmgr->variant == QCOM_BATTMGR_SC8280XP || 523 battmgr->variant == QCOM_BATTMGR_X1E80100) 524 ret = qcom_battmgr_bat_sc8280xp_update(battmgr, psp); 525 else 526 ret = qcom_battmgr_bat_sm8350_update(battmgr, psp); 527 if (ret < 0) 528 return ret; 529 530 switch (psp) { 531 case POWER_SUPPLY_PROP_STATUS: 532 val->intval = battmgr->status.status; 533 break; 534 case POWER_SUPPLY_PROP_CHARGE_TYPE: 535 val->intval = battmgr->info.charge_type; 536 break; 537 case POWER_SUPPLY_PROP_HEALTH: 538 val->intval = battmgr->status.health; 539 break; 540 case POWER_SUPPLY_PROP_PRESENT: 541 val->intval = battmgr->info.present; 542 break; 543 case POWER_SUPPLY_PROP_TECHNOLOGY: 544 val->intval = battmgr->info.technology; 545 break; 546 case POWER_SUPPLY_PROP_CYCLE_COUNT: 547 val->intval = battmgr->info.cycle_count; 548 break; 549 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: 550 val->intval = battmgr->info.voltage_max_design; 551 break; 552 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 553 val->intval = battmgr->info.voltage_max; 554 break; 555 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 556 val->intval = battmgr->status.voltage_now; 557 break; 558 case POWER_SUPPLY_PROP_VOLTAGE_OCV: 559 val->intval = battmgr->status.voltage_ocv; 560 break; 561 case POWER_SUPPLY_PROP_CURRENT_NOW: 562 val->intval = battmgr->status.current_now; 563 break; 564 case POWER_SUPPLY_PROP_POWER_NOW: 565 val->intval = battmgr->status.power_now; 566 break; 567 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 568 if (unit != QCOM_BATTMGR_UNIT_mAh) 569 return -ENODATA; 570 val->intval = battmgr->info.design_capacity; 571 break; 572 case POWER_SUPPLY_PROP_CHARGE_FULL: 573 if (unit != QCOM_BATTMGR_UNIT_mAh) 574 return -ENODATA; 575 val->intval = battmgr->info.last_full_capacity; 576 break; 577 case POWER_SUPPLY_PROP_CHARGE_EMPTY: 578 if (unit != QCOM_BATTMGR_UNIT_mAh) 579 return -ENODATA; 580 val->intval = battmgr->info.capacity_low; 581 break; 582 case POWER_SUPPLY_PROP_CHARGE_NOW: 583 if (unit != QCOM_BATTMGR_UNIT_mAh) 584 return -ENODATA; 585 val->intval = battmgr->status.capacity; 586 break; 587 case POWER_SUPPLY_PROP_CHARGE_COUNTER: 588 val->intval = battmgr->info.charge_count; 589 break; 590 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN: 591 if (unit != QCOM_BATTMGR_UNIT_mWh) 592 return -ENODATA; 593 val->intval = battmgr->info.design_capacity; 594 break; 595 case POWER_SUPPLY_PROP_ENERGY_FULL: 596 if (unit != QCOM_BATTMGR_UNIT_mWh) 597 return -ENODATA; 598 val->intval = battmgr->info.last_full_capacity; 599 break; 600 case POWER_SUPPLY_PROP_ENERGY_EMPTY: 601 if (unit != QCOM_BATTMGR_UNIT_mWh) 602 return -ENODATA; 603 val->intval = battmgr->info.capacity_low; 604 break; 605 case POWER_SUPPLY_PROP_ENERGY_NOW: 606 if (unit != QCOM_BATTMGR_UNIT_mWh) 607 return -ENODATA; 608 val->intval = battmgr->status.capacity; 609 break; 610 case POWER_SUPPLY_PROP_CAPACITY: 611 if (battmgr->status.percent == (unsigned int)-1) 612 return -ENODATA; 613 val->intval = battmgr->status.percent; 614 break; 615 case POWER_SUPPLY_PROP_TEMP: 616 val->intval = battmgr->status.temperature; 617 break; 618 case POWER_SUPPLY_PROP_INTERNAL_RESISTANCE: 619 val->intval = battmgr->status.resistance; 620 break; 621 case POWER_SUPPLY_PROP_STATE_OF_HEALTH: 622 val->intval = battmgr->status.soh_percent; 623 break; 624 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 625 val->intval = battmgr->status.discharge_time; 626 break; 627 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG: 628 val->intval = battmgr->status.charge_time; 629 break; 630 case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD: 631 val->intval = battmgr->info.charge_ctrl_start; 632 break; 633 case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD: 634 val->intval = battmgr->info.charge_ctrl_end; 635 break; 636 case POWER_SUPPLY_PROP_MANUFACTURE_YEAR: 637 val->intval = battmgr->info.year; 638 break; 639 case POWER_SUPPLY_PROP_MANUFACTURE_MONTH: 640 val->intval = battmgr->info.month; 641 break; 642 case POWER_SUPPLY_PROP_MANUFACTURE_DAY: 643 val->intval = battmgr->info.day; 644 break; 645 case POWER_SUPPLY_PROP_MODEL_NAME: 646 val->strval = battmgr->info.model_number; 647 break; 648 case POWER_SUPPLY_PROP_MANUFACTURER: 649 val->strval = battmgr->info.oem_info; 650 break; 651 case POWER_SUPPLY_PROP_SERIAL_NUMBER: 652 val->strval = battmgr->info.serial_number; 653 break; 654 default: 655 return -EINVAL; 656 } 657 658 return 0; 659 } 660 661 static int qcom_battmgr_set_charge_control(struct qcom_battmgr *battmgr, 662 u32 target_soc, u32 delta_soc) 663 { 664 struct qcom_battmgr_charge_ctrl_request request = { 665 .hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR), 666 .hdr.type = cpu_to_le32(PMIC_GLINK_REQ_RESP), 667 .hdr.opcode = cpu_to_le32(BATTMGR_CHG_CTRL_LIMIT_EN), 668 .enable = cpu_to_le32(1), 669 .target_soc = cpu_to_le32(target_soc), 670 .delta_soc = cpu_to_le32(delta_soc), 671 }; 672 673 return qcom_battmgr_request(battmgr, &request, sizeof(request)); 674 } 675 676 static int qcom_battmgr_set_charge_start_threshold(struct qcom_battmgr *battmgr, int start_soc) 677 { 678 u32 target_soc, delta_soc; 679 int ret; 680 681 if (start_soc < CHARGE_CTRL_START_THR_MIN || 682 start_soc > CHARGE_CTRL_START_THR_MAX) { 683 dev_err(battmgr->dev, "charge control start threshold exceed range: [%u - %u]\n", 684 CHARGE_CTRL_START_THR_MIN, CHARGE_CTRL_START_THR_MAX); 685 return -EINVAL; 686 } 687 688 /* 689 * If the new start threshold is larger than the old end threshold, 690 * move the end threshold one step (DELTA_SOC) after the new start 691 * threshold. 692 */ 693 if (start_soc > battmgr->info.charge_ctrl_end) { 694 target_soc = start_soc + CHARGE_CTRL_DELTA_SOC; 695 target_soc = min_t(u32, target_soc, CHARGE_CTRL_END_THR_MAX); 696 delta_soc = target_soc - start_soc; 697 delta_soc = min_t(u32, delta_soc, CHARGE_CTRL_DELTA_SOC); 698 } else { 699 target_soc = battmgr->info.charge_ctrl_end; 700 delta_soc = battmgr->info.charge_ctrl_end - start_soc; 701 } 702 703 mutex_lock(&battmgr->lock); 704 ret = qcom_battmgr_set_charge_control(battmgr, target_soc, delta_soc); 705 mutex_unlock(&battmgr->lock); 706 if (!ret) { 707 battmgr->info.charge_ctrl_start = start_soc; 708 battmgr->info.charge_ctrl_end = target_soc; 709 } 710 711 return 0; 712 } 713 714 static int qcom_battmgr_set_charge_end_threshold(struct qcom_battmgr *battmgr, int end_soc) 715 { 716 u32 delta_soc = CHARGE_CTRL_DELTA_SOC; 717 int ret; 718 719 if (end_soc < CHARGE_CTRL_END_THR_MIN || 720 end_soc > CHARGE_CTRL_END_THR_MAX) { 721 dev_err(battmgr->dev, "charge control end threshold exceed range: [%u - %u]\n", 722 CHARGE_CTRL_END_THR_MIN, CHARGE_CTRL_END_THR_MAX); 723 return -EINVAL; 724 } 725 726 if (battmgr->info.charge_ctrl_start && end_soc > battmgr->info.charge_ctrl_start) 727 delta_soc = end_soc - battmgr->info.charge_ctrl_start; 728 729 mutex_lock(&battmgr->lock); 730 ret = qcom_battmgr_set_charge_control(battmgr, end_soc, delta_soc); 731 mutex_unlock(&battmgr->lock); 732 if (!ret) { 733 battmgr->info.charge_ctrl_start = end_soc - delta_soc; 734 battmgr->info.charge_ctrl_end = end_soc; 735 } 736 737 return 0; 738 } 739 740 static int qcom_battmgr_charge_control_thresholds_init(struct qcom_battmgr *battmgr) 741 { 742 int ret; 743 u8 en, end_soc, start_soc, delta_soc; 744 745 ret = nvmem_cell_read_u8(battmgr->dev->parent, "charge_limit_en", &en); 746 if (!ret && en != 0) { 747 ret = nvmem_cell_read_u8(battmgr->dev->parent, "charge_limit_end", &end_soc); 748 if (ret < 0) 749 return ret; 750 751 ret = nvmem_cell_read_u8(battmgr->dev->parent, "charge_limit_delta", &delta_soc); 752 if (ret < 0) 753 return ret; 754 755 if (delta_soc >= end_soc) 756 return -EINVAL; 757 758 start_soc = end_soc - delta_soc; 759 end_soc = clamp(end_soc, CHARGE_CTRL_END_THR_MIN, CHARGE_CTRL_END_THR_MAX); 760 start_soc = clamp(start_soc, CHARGE_CTRL_START_THR_MIN, CHARGE_CTRL_START_THR_MAX); 761 762 battmgr->info.charge_ctrl_start = start_soc; 763 battmgr->info.charge_ctrl_end = end_soc; 764 } 765 766 return 0; 767 } 768 769 static int qcom_battmgr_bat_is_writeable(struct power_supply *psy, 770 enum power_supply_property psp) 771 { 772 switch (psp) { 773 case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD: 774 case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD: 775 return 1; 776 default: 777 return 0; 778 } 779 780 return 0; 781 } 782 783 static int qcom_battmgr_bat_set_property(struct power_supply *psy, 784 enum power_supply_property psp, 785 const union power_supply_propval *pval) 786 { 787 struct qcom_battmgr *battmgr = power_supply_get_drvdata(psy); 788 789 if (!battmgr->service_up) 790 return -EAGAIN; 791 792 switch (psp) { 793 case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD: 794 return qcom_battmgr_set_charge_start_threshold(battmgr, pval->intval); 795 case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD: 796 return qcom_battmgr_set_charge_end_threshold(battmgr, pval->intval); 797 default: 798 return -EINVAL; 799 } 800 801 return 0; 802 } 803 804 static const enum power_supply_property sc8280xp_bat_props[] = { 805 POWER_SUPPLY_PROP_STATUS, 806 POWER_SUPPLY_PROP_PRESENT, 807 POWER_SUPPLY_PROP_TECHNOLOGY, 808 POWER_SUPPLY_PROP_CAPACITY, 809 POWER_SUPPLY_PROP_CYCLE_COUNT, 810 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 811 POWER_SUPPLY_PROP_VOLTAGE_NOW, 812 POWER_SUPPLY_PROP_POWER_NOW, 813 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 814 POWER_SUPPLY_PROP_CHARGE_FULL, 815 POWER_SUPPLY_PROP_CHARGE_EMPTY, 816 POWER_SUPPLY_PROP_CHARGE_NOW, 817 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 818 POWER_SUPPLY_PROP_ENERGY_FULL, 819 POWER_SUPPLY_PROP_ENERGY_EMPTY, 820 POWER_SUPPLY_PROP_ENERGY_NOW, 821 POWER_SUPPLY_PROP_TEMP, 822 POWER_SUPPLY_PROP_MANUFACTURE_YEAR, 823 POWER_SUPPLY_PROP_MANUFACTURE_MONTH, 824 POWER_SUPPLY_PROP_MANUFACTURE_DAY, 825 POWER_SUPPLY_PROP_MODEL_NAME, 826 POWER_SUPPLY_PROP_MANUFACTURER, 827 POWER_SUPPLY_PROP_SERIAL_NUMBER, 828 }; 829 830 static const struct power_supply_desc sc8280xp_bat_psy_desc = { 831 .name = "qcom-battmgr-bat", 832 .type = POWER_SUPPLY_TYPE_BATTERY, 833 .properties = sc8280xp_bat_props, 834 .num_properties = ARRAY_SIZE(sc8280xp_bat_props), 835 .get_property = qcom_battmgr_bat_get_property, 836 }; 837 838 static const enum power_supply_property x1e80100_bat_props[] = { 839 POWER_SUPPLY_PROP_STATUS, 840 POWER_SUPPLY_PROP_PRESENT, 841 POWER_SUPPLY_PROP_TECHNOLOGY, 842 POWER_SUPPLY_PROP_CYCLE_COUNT, 843 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 844 POWER_SUPPLY_PROP_VOLTAGE_NOW, 845 POWER_SUPPLY_PROP_POWER_NOW, 846 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 847 POWER_SUPPLY_PROP_CHARGE_FULL, 848 POWER_SUPPLY_PROP_CHARGE_EMPTY, 849 POWER_SUPPLY_PROP_CHARGE_NOW, 850 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 851 POWER_SUPPLY_PROP_ENERGY_FULL, 852 POWER_SUPPLY_PROP_ENERGY_EMPTY, 853 POWER_SUPPLY_PROP_ENERGY_NOW, 854 POWER_SUPPLY_PROP_TEMP, 855 POWER_SUPPLY_PROP_MANUFACTURE_YEAR, 856 POWER_SUPPLY_PROP_MANUFACTURE_MONTH, 857 POWER_SUPPLY_PROP_MANUFACTURE_DAY, 858 POWER_SUPPLY_PROP_MODEL_NAME, 859 POWER_SUPPLY_PROP_MANUFACTURER, 860 POWER_SUPPLY_PROP_SERIAL_NUMBER, 861 POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD, 862 POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD, 863 }; 864 865 static const struct power_supply_desc x1e80100_bat_psy_desc = { 866 .name = "qcom-battmgr-bat", 867 .type = POWER_SUPPLY_TYPE_BATTERY, 868 .properties = x1e80100_bat_props, 869 .num_properties = ARRAY_SIZE(x1e80100_bat_props), 870 .get_property = qcom_battmgr_bat_get_property, 871 .set_property = qcom_battmgr_bat_set_property, 872 .property_is_writeable = qcom_battmgr_bat_is_writeable, 873 }; 874 875 static const enum power_supply_property sm8350_bat_props[] = { 876 POWER_SUPPLY_PROP_STATUS, 877 POWER_SUPPLY_PROP_HEALTH, 878 POWER_SUPPLY_PROP_PRESENT, 879 POWER_SUPPLY_PROP_CHARGE_TYPE, 880 POWER_SUPPLY_PROP_CAPACITY, 881 POWER_SUPPLY_PROP_VOLTAGE_OCV, 882 POWER_SUPPLY_PROP_VOLTAGE_NOW, 883 POWER_SUPPLY_PROP_VOLTAGE_MAX, 884 POWER_SUPPLY_PROP_CURRENT_NOW, 885 POWER_SUPPLY_PROP_TEMP, 886 POWER_SUPPLY_PROP_TECHNOLOGY, 887 POWER_SUPPLY_PROP_CHARGE_COUNTER, 888 POWER_SUPPLY_PROP_CYCLE_COUNT, 889 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 890 POWER_SUPPLY_PROP_CHARGE_FULL, 891 POWER_SUPPLY_PROP_MODEL_NAME, 892 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 893 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 894 POWER_SUPPLY_PROP_INTERNAL_RESISTANCE, 895 POWER_SUPPLY_PROP_STATE_OF_HEALTH, 896 POWER_SUPPLY_PROP_POWER_NOW, 897 }; 898 899 static const struct power_supply_desc sm8350_bat_psy_desc = { 900 .name = "qcom-battmgr-bat", 901 .type = POWER_SUPPLY_TYPE_BATTERY, 902 .properties = sm8350_bat_props, 903 .num_properties = ARRAY_SIZE(sm8350_bat_props), 904 .get_property = qcom_battmgr_bat_get_property, 905 }; 906 907 static const enum power_supply_property sm8550_bat_props[] = { 908 POWER_SUPPLY_PROP_STATUS, 909 POWER_SUPPLY_PROP_HEALTH, 910 POWER_SUPPLY_PROP_PRESENT, 911 POWER_SUPPLY_PROP_CHARGE_TYPE, 912 POWER_SUPPLY_PROP_CAPACITY, 913 POWER_SUPPLY_PROP_VOLTAGE_OCV, 914 POWER_SUPPLY_PROP_VOLTAGE_NOW, 915 POWER_SUPPLY_PROP_VOLTAGE_MAX, 916 POWER_SUPPLY_PROP_CURRENT_NOW, 917 POWER_SUPPLY_PROP_TEMP, 918 POWER_SUPPLY_PROP_TECHNOLOGY, 919 POWER_SUPPLY_PROP_CHARGE_COUNTER, 920 POWER_SUPPLY_PROP_CYCLE_COUNT, 921 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 922 POWER_SUPPLY_PROP_CHARGE_FULL, 923 POWER_SUPPLY_PROP_MODEL_NAME, 924 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 925 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 926 POWER_SUPPLY_PROP_INTERNAL_RESISTANCE, 927 POWER_SUPPLY_PROP_STATE_OF_HEALTH, 928 POWER_SUPPLY_PROP_POWER_NOW, 929 POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD, 930 POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD, 931 }; 932 933 static const struct power_supply_desc sm8550_bat_psy_desc = { 934 .name = "qcom-battmgr-bat", 935 .type = POWER_SUPPLY_TYPE_BATTERY, 936 .properties = sm8550_bat_props, 937 .num_properties = ARRAY_SIZE(sm8550_bat_props), 938 .get_property = qcom_battmgr_bat_get_property, 939 .set_property = qcom_battmgr_bat_set_property, 940 .property_is_writeable = qcom_battmgr_bat_is_writeable, 941 }; 942 943 static int qcom_battmgr_ac_get_property(struct power_supply *psy, 944 enum power_supply_property psp, 945 union power_supply_propval *val) 946 { 947 struct qcom_battmgr *battmgr = power_supply_get_drvdata(psy); 948 int ret; 949 950 if (!battmgr->service_up) 951 return -EAGAIN; 952 953 ret = qcom_battmgr_bat_sc8280xp_update(battmgr, psp); 954 if (ret) 955 return ret; 956 957 switch (psp) { 958 case POWER_SUPPLY_PROP_ONLINE: 959 val->intval = battmgr->ac.online; 960 break; 961 default: 962 return -EINVAL; 963 } 964 965 return 0; 966 } 967 968 static const enum power_supply_property sc8280xp_ac_props[] = { 969 POWER_SUPPLY_PROP_ONLINE, 970 }; 971 972 static const struct power_supply_desc sc8280xp_ac_psy_desc = { 973 .name = "qcom-battmgr-ac", 974 .type = POWER_SUPPLY_TYPE_MAINS, 975 .properties = sc8280xp_ac_props, 976 .num_properties = ARRAY_SIZE(sc8280xp_ac_props), 977 .get_property = qcom_battmgr_ac_get_property, 978 }; 979 980 static const u8 sm8350_usb_prop_map[] = { 981 [POWER_SUPPLY_PROP_ONLINE] = USB_ONLINE, 982 [POWER_SUPPLY_PROP_VOLTAGE_NOW] = USB_VOLT_NOW, 983 [POWER_SUPPLY_PROP_VOLTAGE_MAX] = USB_VOLT_MAX, 984 [POWER_SUPPLY_PROP_CURRENT_NOW] = USB_CURR_NOW, 985 [POWER_SUPPLY_PROP_CURRENT_MAX] = USB_CURR_MAX, 986 [POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT] = USB_INPUT_CURR_LIMIT, 987 [POWER_SUPPLY_PROP_USB_TYPE] = USB_TYPE, 988 }; 989 990 static int qcom_battmgr_usb_sm8350_update(struct qcom_battmgr *battmgr, 991 enum power_supply_property psp) 992 { 993 unsigned int prop; 994 int ret; 995 996 if (psp >= ARRAY_SIZE(sm8350_usb_prop_map)) 997 return -EINVAL; 998 999 prop = sm8350_usb_prop_map[psp]; 1000 1001 mutex_lock(&battmgr->lock); 1002 ret = qcom_battmgr_request_property(battmgr, BATTMGR_USB_PROPERTY_GET, prop, 0); 1003 mutex_unlock(&battmgr->lock); 1004 1005 return ret; 1006 } 1007 1008 static int qcom_battmgr_usb_get_property(struct power_supply *psy, 1009 enum power_supply_property psp, 1010 union power_supply_propval *val) 1011 { 1012 struct qcom_battmgr *battmgr = power_supply_get_drvdata(psy); 1013 int ret; 1014 1015 if (!battmgr->service_up) 1016 return -EAGAIN; 1017 1018 if (battmgr->variant == QCOM_BATTMGR_SC8280XP || 1019 battmgr->variant == QCOM_BATTMGR_X1E80100) 1020 ret = qcom_battmgr_bat_sc8280xp_update(battmgr, psp); 1021 else 1022 ret = qcom_battmgr_usb_sm8350_update(battmgr, psp); 1023 if (ret) 1024 return ret; 1025 1026 switch (psp) { 1027 case POWER_SUPPLY_PROP_ONLINE: 1028 val->intval = battmgr->usb.online; 1029 break; 1030 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 1031 val->intval = battmgr->usb.voltage_now; 1032 break; 1033 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 1034 val->intval = battmgr->usb.voltage_max; 1035 break; 1036 case POWER_SUPPLY_PROP_CURRENT_NOW: 1037 val->intval = battmgr->usb.current_now; 1038 break; 1039 case POWER_SUPPLY_PROP_CURRENT_MAX: 1040 val->intval = battmgr->usb.current_max; 1041 break; 1042 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: 1043 val->intval = battmgr->usb.current_limit; 1044 break; 1045 case POWER_SUPPLY_PROP_USB_TYPE: 1046 val->intval = battmgr->usb.usb_type; 1047 break; 1048 default: 1049 return -EINVAL; 1050 } 1051 1052 return 0; 1053 } 1054 1055 static const enum power_supply_property sc8280xp_usb_props[] = { 1056 POWER_SUPPLY_PROP_ONLINE, 1057 }; 1058 1059 static const struct power_supply_desc sc8280xp_usb_psy_desc = { 1060 .name = "qcom-battmgr-usb", 1061 .type = POWER_SUPPLY_TYPE_USB, 1062 .properties = sc8280xp_usb_props, 1063 .num_properties = ARRAY_SIZE(sc8280xp_usb_props), 1064 .get_property = qcom_battmgr_usb_get_property, 1065 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) | 1066 BIT(POWER_SUPPLY_USB_TYPE_SDP) | 1067 BIT(POWER_SUPPLY_USB_TYPE_DCP) | 1068 BIT(POWER_SUPPLY_USB_TYPE_CDP) | 1069 BIT(POWER_SUPPLY_USB_TYPE_ACA) | 1070 BIT(POWER_SUPPLY_USB_TYPE_C) | 1071 BIT(POWER_SUPPLY_USB_TYPE_PD) | 1072 BIT(POWER_SUPPLY_USB_TYPE_PD_DRP) | 1073 BIT(POWER_SUPPLY_USB_TYPE_PD_PPS) | 1074 BIT(POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID), 1075 }; 1076 1077 static const enum power_supply_property sm8350_usb_props[] = { 1078 POWER_SUPPLY_PROP_ONLINE, 1079 POWER_SUPPLY_PROP_VOLTAGE_NOW, 1080 POWER_SUPPLY_PROP_VOLTAGE_MAX, 1081 POWER_SUPPLY_PROP_CURRENT_NOW, 1082 POWER_SUPPLY_PROP_CURRENT_MAX, 1083 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, 1084 POWER_SUPPLY_PROP_USB_TYPE, 1085 }; 1086 1087 static const struct power_supply_desc sm8350_usb_psy_desc = { 1088 .name = "qcom-battmgr-usb", 1089 .type = POWER_SUPPLY_TYPE_USB, 1090 .properties = sm8350_usb_props, 1091 .num_properties = ARRAY_SIZE(sm8350_usb_props), 1092 .get_property = qcom_battmgr_usb_get_property, 1093 .usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) | 1094 BIT(POWER_SUPPLY_USB_TYPE_SDP) | 1095 BIT(POWER_SUPPLY_USB_TYPE_DCP) | 1096 BIT(POWER_SUPPLY_USB_TYPE_CDP) | 1097 BIT(POWER_SUPPLY_USB_TYPE_ACA) | 1098 BIT(POWER_SUPPLY_USB_TYPE_C) | 1099 BIT(POWER_SUPPLY_USB_TYPE_PD) | 1100 BIT(POWER_SUPPLY_USB_TYPE_PD_DRP) | 1101 BIT(POWER_SUPPLY_USB_TYPE_PD_PPS) | 1102 BIT(POWER_SUPPLY_USB_TYPE_APPLE_BRICK_ID), 1103 }; 1104 1105 static const u8 sm8350_wls_prop_map[] = { 1106 [POWER_SUPPLY_PROP_ONLINE] = WLS_ONLINE, 1107 [POWER_SUPPLY_PROP_VOLTAGE_NOW] = WLS_VOLT_NOW, 1108 [POWER_SUPPLY_PROP_VOLTAGE_MAX] = WLS_VOLT_MAX, 1109 [POWER_SUPPLY_PROP_CURRENT_NOW] = WLS_CURR_NOW, 1110 [POWER_SUPPLY_PROP_CURRENT_MAX] = WLS_CURR_MAX, 1111 }; 1112 1113 static int qcom_battmgr_wls_sm8350_update(struct qcom_battmgr *battmgr, 1114 enum power_supply_property psp) 1115 { 1116 unsigned int prop; 1117 int ret; 1118 1119 if (psp >= ARRAY_SIZE(sm8350_wls_prop_map)) 1120 return -EINVAL; 1121 1122 prop = sm8350_wls_prop_map[psp]; 1123 1124 mutex_lock(&battmgr->lock); 1125 ret = qcom_battmgr_request_property(battmgr, BATTMGR_WLS_PROPERTY_GET, prop, 0); 1126 mutex_unlock(&battmgr->lock); 1127 1128 return ret; 1129 } 1130 1131 static int qcom_battmgr_wls_get_property(struct power_supply *psy, 1132 enum power_supply_property psp, 1133 union power_supply_propval *val) 1134 { 1135 struct qcom_battmgr *battmgr = power_supply_get_drvdata(psy); 1136 int ret; 1137 1138 if (!battmgr->service_up) 1139 return -EAGAIN; 1140 1141 if (battmgr->variant == QCOM_BATTMGR_SC8280XP || 1142 battmgr->variant == QCOM_BATTMGR_X1E80100) 1143 ret = qcom_battmgr_bat_sc8280xp_update(battmgr, psp); 1144 else 1145 ret = qcom_battmgr_wls_sm8350_update(battmgr, psp); 1146 if (ret < 0) 1147 return ret; 1148 1149 switch (psp) { 1150 case POWER_SUPPLY_PROP_ONLINE: 1151 val->intval = battmgr->wireless.online; 1152 break; 1153 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 1154 val->intval = battmgr->wireless.voltage_now; 1155 break; 1156 case POWER_SUPPLY_PROP_VOLTAGE_MAX: 1157 val->intval = battmgr->wireless.voltage_max; 1158 break; 1159 case POWER_SUPPLY_PROP_CURRENT_NOW: 1160 val->intval = battmgr->wireless.current_now; 1161 break; 1162 case POWER_SUPPLY_PROP_CURRENT_MAX: 1163 val->intval = battmgr->wireless.current_max; 1164 break; 1165 default: 1166 return -EINVAL; 1167 } 1168 1169 return 0; 1170 } 1171 1172 static const enum power_supply_property sc8280xp_wls_props[] = { 1173 POWER_SUPPLY_PROP_ONLINE, 1174 }; 1175 1176 static const struct power_supply_desc sc8280xp_wls_psy_desc = { 1177 .name = "qcom-battmgr-wls", 1178 .type = POWER_SUPPLY_TYPE_WIRELESS, 1179 .properties = sc8280xp_wls_props, 1180 .num_properties = ARRAY_SIZE(sc8280xp_wls_props), 1181 .get_property = qcom_battmgr_wls_get_property, 1182 }; 1183 1184 static const enum power_supply_property sm8350_wls_props[] = { 1185 POWER_SUPPLY_PROP_ONLINE, 1186 POWER_SUPPLY_PROP_VOLTAGE_NOW, 1187 POWER_SUPPLY_PROP_VOLTAGE_MAX, 1188 POWER_SUPPLY_PROP_CURRENT_NOW, 1189 POWER_SUPPLY_PROP_CURRENT_MAX, 1190 }; 1191 1192 static const struct power_supply_desc sm8350_wls_psy_desc = { 1193 .name = "qcom-battmgr-wls", 1194 .type = POWER_SUPPLY_TYPE_WIRELESS, 1195 .properties = sm8350_wls_props, 1196 .num_properties = ARRAY_SIZE(sm8350_wls_props), 1197 .get_property = qcom_battmgr_wls_get_property, 1198 }; 1199 1200 static void qcom_battmgr_notification(struct qcom_battmgr *battmgr, 1201 const struct qcom_battmgr_message *msg, 1202 int len) 1203 { 1204 size_t payload_len = len - sizeof(struct pmic_glink_hdr); 1205 unsigned int notification; 1206 1207 if (payload_len != sizeof(msg->notification)) { 1208 dev_warn(battmgr->dev, "ignoring notification with invalid length\n"); 1209 return; 1210 } 1211 1212 notification = le32_to_cpu(msg->notification); 1213 notification &= 0xff; 1214 switch (notification) { 1215 case NOTIF_BAT_INFO: 1216 battmgr->info.valid = false; 1217 fallthrough; 1218 case NOTIF_BAT_STATUS: 1219 case NOTIF_BAT_PROPERTY: 1220 case NOTIF_BAT_CHARGING_STATE: 1221 power_supply_changed(battmgr->bat_psy); 1222 break; 1223 case NOTIF_USB_PROPERTY: 1224 power_supply_changed(battmgr->usb_psy); 1225 break; 1226 case NOTIF_WLS_PROPERTY: 1227 power_supply_changed(battmgr->wls_psy); 1228 break; 1229 default: 1230 dev_err(battmgr->dev, "unknown notification: %#x\n", notification); 1231 break; 1232 } 1233 } 1234 1235 static void qcom_battmgr_sc8280xp_strcpy(char *dest, const char *src) 1236 { 1237 size_t len = src[0]; 1238 1239 /* Some firmware versions return Pascal-style strings */ 1240 if (len < BATTMGR_STRING_LEN && len == strnlen(src + 1, BATTMGR_STRING_LEN - 1)) { 1241 memcpy(dest, src + 1, len); 1242 dest[len] = '\0'; 1243 } else { 1244 memcpy(dest, src, BATTMGR_STRING_LEN); 1245 } 1246 } 1247 1248 static unsigned int qcom_battmgr_sc8280xp_parse_technology(const char *chemistry) 1249 { 1250 if ((!strncmp(chemistry, "LIO", BATTMGR_CHEMISTRY_LEN)) || 1251 (!strncmp(chemistry, "OOI", BATTMGR_CHEMISTRY_LEN))) 1252 return POWER_SUPPLY_TECHNOLOGY_LION; 1253 if (!strncmp(chemistry, "LIP", BATTMGR_CHEMISTRY_LEN)) 1254 return POWER_SUPPLY_TECHNOLOGY_LIPO; 1255 1256 pr_err("Unknown battery technology '%s'\n", chemistry); 1257 return POWER_SUPPLY_TECHNOLOGY_UNKNOWN; 1258 } 1259 1260 static unsigned int qcom_battmgr_sc8280xp_convert_temp(unsigned int temperature) 1261 { 1262 return DIV_ROUND_CLOSEST(temperature, 10); 1263 } 1264 1265 static void qcom_battmgr_sc8280xp_callback(struct qcom_battmgr *battmgr, 1266 const struct qcom_battmgr_message *resp, 1267 size_t len) 1268 { 1269 unsigned int opcode = le32_to_cpu(resp->hdr.opcode); 1270 unsigned int source; 1271 unsigned int state; 1272 size_t payload_len = len - sizeof(struct pmic_glink_hdr); 1273 1274 if (payload_len < sizeof(__le32)) { 1275 dev_warn(battmgr->dev, "invalid payload length for %#x: %zd\n", 1276 opcode, len); 1277 return; 1278 } 1279 1280 switch (opcode) { 1281 case BATTMGR_REQUEST_NOTIFICATION: 1282 battmgr->error = 0; 1283 break; 1284 case BATTMGR_BAT_INFO: 1285 /* some firmware versions report an extra __le32 at the end of the payload */ 1286 if (payload_len != sizeof(resp->info) && 1287 payload_len != (sizeof(resp->info) + sizeof(__le32))) { 1288 dev_warn(battmgr->dev, 1289 "invalid payload length for battery information request: %zd\n", 1290 payload_len); 1291 battmgr->error = -ENODATA; 1292 return; 1293 } 1294 1295 battmgr->unit = le32_to_cpu(resp->info.power_unit); 1296 1297 battmgr->info.present = true; 1298 battmgr->info.design_capacity = le32_to_cpu(resp->info.design_capacity) * 1000; 1299 battmgr->info.last_full_capacity = le32_to_cpu(resp->info.last_full_capacity) * 1000; 1300 battmgr->info.voltage_max_design = le32_to_cpu(resp->info.design_voltage) * 1000; 1301 battmgr->info.capacity_low = le32_to_cpu(resp->info.capacity_low) * 1000; 1302 battmgr->info.cycle_count = le32_to_cpu(resp->info.cycle_count); 1303 qcom_battmgr_sc8280xp_strcpy(battmgr->info.model_number, resp->info.model_number); 1304 qcom_battmgr_sc8280xp_strcpy(battmgr->info.serial_number, resp->info.serial_number); 1305 battmgr->info.technology = qcom_battmgr_sc8280xp_parse_technology(resp->info.battery_chemistry); 1306 qcom_battmgr_sc8280xp_strcpy(battmgr->info.oem_info, resp->info.oem_info); 1307 battmgr->info.day = resp->info.day; 1308 battmgr->info.month = resp->info.month; 1309 battmgr->info.year = le16_to_cpu(resp->info.year); 1310 break; 1311 case BATTMGR_BAT_STATUS: 1312 if (payload_len != sizeof(resp->status)) { 1313 dev_warn(battmgr->dev, 1314 "invalid payload length for battery status request: %zd\n", 1315 payload_len); 1316 battmgr->error = -ENODATA; 1317 return; 1318 } 1319 1320 state = le32_to_cpu(resp->status.battery_state); 1321 if (state & BIT(0)) 1322 battmgr->status.status = POWER_SUPPLY_STATUS_DISCHARGING; 1323 else if (state & BIT(1)) 1324 battmgr->status.status = POWER_SUPPLY_STATUS_CHARGING; 1325 else 1326 battmgr->status.status = POWER_SUPPLY_STATUS_NOT_CHARGING; 1327 1328 battmgr->status.capacity = le32_to_cpu(resp->status.capacity) * 1000; 1329 battmgr->status.power_now = le32_to_cpu(resp->status.rate) * 1000; 1330 battmgr->status.voltage_now = le32_to_cpu(resp->status.battery_voltage) * 1000; 1331 battmgr->status.temperature = qcom_battmgr_sc8280xp_convert_temp(le32_to_cpu(resp->status.temperature)); 1332 1333 source = le32_to_cpu(resp->status.charging_source); 1334 battmgr->ac.online = source == BATTMGR_CHARGING_SOURCE_AC; 1335 battmgr->usb.online = source == BATTMGR_CHARGING_SOURCE_USB; 1336 battmgr->wireless.online = source == BATTMGR_CHARGING_SOURCE_WIRELESS; 1337 if (battmgr->info.last_full_capacity != 0) { 1338 /* 1339 * 100 * battmgr->status.capacity can overflow a 32bit 1340 * unsigned integer. FW readings are in m{W/A}h, which 1341 * are multiplied by 1000 converting them to u{W/A}h, 1342 * the format the power_supply API expects. 1343 * To avoid overflow use the original value for dividend 1344 * and convert the divider back to m{W/A}h, which can be 1345 * done without any loss of precision. 1346 */ 1347 battmgr->status.percent = 1348 (100 * le32_to_cpu(resp->status.capacity)) / 1349 (battmgr->info.last_full_capacity / 1000); 1350 } else { 1351 /* 1352 * Let the sysfs handler know no data is available at 1353 * this time. 1354 */ 1355 battmgr->status.percent = (unsigned int)-1; 1356 } 1357 break; 1358 case BATTMGR_BAT_DISCHARGE_TIME: 1359 battmgr->status.discharge_time = le32_to_cpu(resp->time); 1360 break; 1361 case BATTMGR_BAT_CHARGE_TIME: 1362 battmgr->status.charge_time = le32_to_cpu(resp->time); 1363 break; 1364 case BATTMGR_CHG_CTRL_LIMIT_EN: 1365 battmgr->error = 0; 1366 break; 1367 default: 1368 dev_warn(battmgr->dev, "unknown message %#x\n", opcode); 1369 break; 1370 } 1371 1372 complete(&battmgr->ack); 1373 } 1374 1375 static void qcom_battmgr_sm8350_callback(struct qcom_battmgr *battmgr, 1376 const struct qcom_battmgr_message *resp, 1377 size_t len) 1378 { 1379 unsigned int property; 1380 unsigned int opcode = le32_to_cpu(resp->hdr.opcode); 1381 size_t payload_len = len - sizeof(struct pmic_glink_hdr); 1382 unsigned int val; 1383 1384 if (payload_len < sizeof(__le32)) { 1385 dev_warn(battmgr->dev, "invalid payload length for %#x: %zd\n", 1386 opcode, len); 1387 return; 1388 } 1389 1390 switch (opcode) { 1391 case BATTMGR_BAT_PROPERTY_GET: 1392 property = le32_to_cpu(resp->intval.property); 1393 if (property == BATT_MODEL_NAME) { 1394 if (payload_len != sizeof(resp->strval)) { 1395 dev_warn(battmgr->dev, 1396 "invalid payload length for BATT_MODEL_NAME request: %zd\n", 1397 payload_len); 1398 battmgr->error = -ENODATA; 1399 return; 1400 } 1401 } else { 1402 if (payload_len != sizeof(resp->intval)) { 1403 dev_warn(battmgr->dev, 1404 "invalid payload length for %#x request: %zd\n", 1405 property, payload_len); 1406 battmgr->error = -ENODATA; 1407 return; 1408 } 1409 1410 battmgr->error = le32_to_cpu(resp->intval.result); 1411 if (battmgr->error) 1412 goto out_complete; 1413 } 1414 1415 switch (property) { 1416 case BATT_STATUS: 1417 battmgr->status.status = le32_to_cpu(resp->intval.value); 1418 break; 1419 case BATT_HEALTH: 1420 battmgr->status.health = le32_to_cpu(resp->intval.value); 1421 break; 1422 case BATT_PRESENT: 1423 battmgr->info.present = le32_to_cpu(resp->intval.value); 1424 break; 1425 case BATT_CHG_TYPE: 1426 battmgr->info.charge_type = le32_to_cpu(resp->intval.value); 1427 break; 1428 case BATT_CAPACITY: 1429 battmgr->status.percent = le32_to_cpu(resp->intval.value) / 100; 1430 break; 1431 case BATT_SOH: 1432 battmgr->status.soh_percent = le32_to_cpu(resp->intval.value); 1433 break; 1434 case BATT_VOLT_OCV: 1435 battmgr->status.voltage_ocv = le32_to_cpu(resp->intval.value); 1436 break; 1437 case BATT_VOLT_NOW: 1438 battmgr->status.voltage_now = le32_to_cpu(resp->intval.value); 1439 break; 1440 case BATT_VOLT_MAX: 1441 battmgr->info.voltage_max = le32_to_cpu(resp->intval.value); 1442 break; 1443 case BATT_CURR_NOW: 1444 battmgr->status.current_now = le32_to_cpu(resp->intval.value); 1445 break; 1446 case BATT_TEMP: 1447 val = le32_to_cpu(resp->intval.value); 1448 battmgr->status.temperature = DIV_ROUND_CLOSEST(val, 10); 1449 break; 1450 case BATT_TECHNOLOGY: 1451 battmgr->info.technology = le32_to_cpu(resp->intval.value); 1452 break; 1453 case BATT_CHG_COUNTER: 1454 battmgr->info.charge_count = le32_to_cpu(resp->intval.value); 1455 break; 1456 case BATT_CYCLE_COUNT: 1457 battmgr->info.cycle_count = le32_to_cpu(resp->intval.value); 1458 break; 1459 case BATT_CHG_FULL_DESIGN: 1460 battmgr->info.design_capacity = le32_to_cpu(resp->intval.value); 1461 break; 1462 case BATT_CHG_FULL: 1463 battmgr->info.last_full_capacity = le32_to_cpu(resp->intval.value); 1464 break; 1465 case BATT_MODEL_NAME: 1466 strscpy(battmgr->info.model_number, resp->strval.model, BATTMGR_STRING_LEN); 1467 break; 1468 case BATT_TTF_AVG: 1469 battmgr->status.charge_time = le32_to_cpu(resp->intval.value); 1470 break; 1471 case BATT_TTE_AVG: 1472 battmgr->status.discharge_time = le32_to_cpu(resp->intval.value); 1473 break; 1474 case BATT_RESISTANCE: 1475 battmgr->status.resistance = le32_to_cpu(resp->intval.value); 1476 break; 1477 case BATT_POWER_NOW: 1478 battmgr->status.power_now = le32_to_cpu(resp->intval.value); 1479 break; 1480 case BATT_CHG_CTRL_START_THR: 1481 battmgr->info.charge_ctrl_start = le32_to_cpu(resp->intval.value); 1482 break; 1483 case BATT_CHG_CTRL_END_THR: 1484 battmgr->info.charge_ctrl_end = le32_to_cpu(resp->intval.value); 1485 break; 1486 default: 1487 dev_warn(battmgr->dev, "unknown property %#x\n", property); 1488 break; 1489 } 1490 break; 1491 case BATTMGR_USB_PROPERTY_GET: 1492 property = le32_to_cpu(resp->intval.property); 1493 if (payload_len != sizeof(resp->intval)) { 1494 dev_warn(battmgr->dev, 1495 "invalid payload length for %#x request: %zd\n", 1496 property, payload_len); 1497 battmgr->error = -ENODATA; 1498 return; 1499 } 1500 1501 battmgr->error = le32_to_cpu(resp->intval.result); 1502 if (battmgr->error) 1503 goto out_complete; 1504 1505 switch (property) { 1506 case USB_ONLINE: 1507 battmgr->usb.online = le32_to_cpu(resp->intval.value); 1508 break; 1509 case USB_VOLT_NOW: 1510 battmgr->usb.voltage_now = le32_to_cpu(resp->intval.value); 1511 break; 1512 case USB_VOLT_MAX: 1513 battmgr->usb.voltage_max = le32_to_cpu(resp->intval.value); 1514 break; 1515 case USB_CURR_NOW: 1516 battmgr->usb.current_now = le32_to_cpu(resp->intval.value); 1517 break; 1518 case USB_CURR_MAX: 1519 battmgr->usb.current_max = le32_to_cpu(resp->intval.value); 1520 break; 1521 case USB_INPUT_CURR_LIMIT: 1522 battmgr->usb.current_limit = le32_to_cpu(resp->intval.value); 1523 break; 1524 case USB_TYPE: 1525 battmgr->usb.usb_type = le32_to_cpu(resp->intval.value); 1526 break; 1527 default: 1528 dev_warn(battmgr->dev, "unknown property %#x\n", property); 1529 break; 1530 } 1531 break; 1532 case BATTMGR_WLS_PROPERTY_GET: 1533 property = le32_to_cpu(resp->intval.property); 1534 if (payload_len != sizeof(resp->intval)) { 1535 dev_warn(battmgr->dev, 1536 "invalid payload length for %#x request: %zd\n", 1537 property, payload_len); 1538 battmgr->error = -ENODATA; 1539 return; 1540 } 1541 1542 battmgr->error = le32_to_cpu(resp->intval.result); 1543 if (battmgr->error) 1544 goto out_complete; 1545 1546 switch (property) { 1547 case WLS_ONLINE: 1548 battmgr->wireless.online = le32_to_cpu(resp->intval.value); 1549 break; 1550 case WLS_VOLT_NOW: 1551 battmgr->wireless.voltage_now = le32_to_cpu(resp->intval.value); 1552 break; 1553 case WLS_VOLT_MAX: 1554 battmgr->wireless.voltage_max = le32_to_cpu(resp->intval.value); 1555 break; 1556 case WLS_CURR_NOW: 1557 battmgr->wireless.current_now = le32_to_cpu(resp->intval.value); 1558 break; 1559 case WLS_CURR_MAX: 1560 battmgr->wireless.current_max = le32_to_cpu(resp->intval.value); 1561 break; 1562 default: 1563 dev_warn(battmgr->dev, "unknown property %#x\n", property); 1564 break; 1565 } 1566 break; 1567 case BATTMGR_REQUEST_NOTIFICATION: 1568 case BATTMGR_CHG_CTRL_LIMIT_EN: 1569 battmgr->error = 0; 1570 break; 1571 default: 1572 dev_warn(battmgr->dev, "unknown message %#x\n", opcode); 1573 break; 1574 } 1575 1576 out_complete: 1577 complete(&battmgr->ack); 1578 } 1579 1580 static void qcom_battmgr_callback(const void *data, size_t len, void *priv) 1581 { 1582 const struct pmic_glink_hdr *hdr = data; 1583 struct qcom_battmgr *battmgr = priv; 1584 unsigned int opcode = le32_to_cpu(hdr->opcode); 1585 1586 if (opcode == BATTMGR_NOTIFICATION) 1587 qcom_battmgr_notification(battmgr, data, len); 1588 else if (battmgr->variant == QCOM_BATTMGR_SC8280XP || 1589 battmgr->variant == QCOM_BATTMGR_X1E80100) 1590 qcom_battmgr_sc8280xp_callback(battmgr, data, len); 1591 else 1592 qcom_battmgr_sm8350_callback(battmgr, data, len); 1593 } 1594 1595 static void qcom_battmgr_enable_worker(struct work_struct *work) 1596 { 1597 struct qcom_battmgr *battmgr = container_of(work, struct qcom_battmgr, enable_work); 1598 struct qcom_battmgr_enable_request req = { 1599 .hdr.owner = cpu_to_le32(PMIC_GLINK_OWNER_BATTMGR), 1600 .hdr.type = cpu_to_le32(PMIC_GLINK_NOTIFY), 1601 .hdr.opcode = cpu_to_le32(BATTMGR_REQUEST_NOTIFICATION), 1602 }; 1603 int ret; 1604 1605 ret = qcom_battmgr_request(battmgr, &req, sizeof(req)); 1606 if (ret) 1607 dev_err(battmgr->dev, "failed to request power notifications\n"); 1608 } 1609 1610 static void qcom_battmgr_pdr_notify(void *priv, int state) 1611 { 1612 struct qcom_battmgr *battmgr = priv; 1613 1614 if (state == SERVREG_SERVICE_STATE_UP) { 1615 battmgr->service_up = true; 1616 schedule_work(&battmgr->enable_work); 1617 } else { 1618 battmgr->service_up = false; 1619 } 1620 } 1621 1622 static const struct of_device_id qcom_battmgr_of_variants[] = { 1623 { .compatible = "qcom,sc8180x-pmic-glink", .data = (void *)QCOM_BATTMGR_SC8280XP }, 1624 { .compatible = "qcom,sc8280xp-pmic-glink", .data = (void *)QCOM_BATTMGR_SC8280XP }, 1625 { .compatible = "qcom,sm8550-pmic-glink", .data = (void *)QCOM_BATTMGR_SM8550 }, 1626 { .compatible = "qcom,x1e80100-pmic-glink", .data = (void *)QCOM_BATTMGR_X1E80100 }, 1627 /* Unmatched devices falls back to QCOM_BATTMGR_SM8350 */ 1628 {} 1629 }; 1630 1631 static char *qcom_battmgr_battery[] = { "battery" }; 1632 1633 static int qcom_battmgr_probe(struct auxiliary_device *adev, 1634 const struct auxiliary_device_id *id) 1635 { 1636 const struct power_supply_desc *psy_desc; 1637 struct power_supply_config psy_cfg_supply = {}; 1638 struct power_supply_config psy_cfg = {}; 1639 const struct of_device_id *match; 1640 struct qcom_battmgr *battmgr; 1641 struct device *dev = &adev->dev; 1642 int ret; 1643 1644 battmgr = devm_kzalloc(dev, sizeof(*battmgr), GFP_KERNEL); 1645 if (!battmgr) 1646 return -ENOMEM; 1647 1648 battmgr->dev = dev; 1649 1650 psy_cfg.drv_data = battmgr; 1651 psy_cfg.fwnode = dev_fwnode(&adev->dev); 1652 1653 psy_cfg_supply.drv_data = battmgr; 1654 psy_cfg_supply.fwnode = dev_fwnode(&adev->dev); 1655 psy_cfg_supply.supplied_to = qcom_battmgr_battery; 1656 psy_cfg_supply.num_supplicants = 1; 1657 1658 INIT_WORK(&battmgr->enable_work, qcom_battmgr_enable_worker); 1659 mutex_init(&battmgr->lock); 1660 init_completion(&battmgr->ack); 1661 1662 match = of_match_device(qcom_battmgr_of_variants, dev->parent); 1663 if (match) 1664 battmgr->variant = (unsigned long)match->data; 1665 else 1666 battmgr->variant = QCOM_BATTMGR_SM8350; 1667 1668 ret = qcom_battmgr_charge_control_thresholds_init(battmgr); 1669 if (ret < 0) 1670 return dev_err_probe(dev, ret, 1671 "failed to init battery charge control thresholds\n"); 1672 1673 if (battmgr->variant == QCOM_BATTMGR_SC8280XP || 1674 battmgr->variant == QCOM_BATTMGR_X1E80100) { 1675 if (battmgr->variant == QCOM_BATTMGR_X1E80100) 1676 psy_desc = &x1e80100_bat_psy_desc; 1677 else 1678 psy_desc = &sc8280xp_bat_psy_desc; 1679 1680 battmgr->bat_psy = devm_power_supply_register(dev, psy_desc, &psy_cfg); 1681 if (IS_ERR(battmgr->bat_psy)) 1682 return dev_err_probe(dev, PTR_ERR(battmgr->bat_psy), 1683 "failed to register battery power supply\n"); 1684 1685 battmgr->ac_psy = devm_power_supply_register(dev, &sc8280xp_ac_psy_desc, &psy_cfg_supply); 1686 if (IS_ERR(battmgr->ac_psy)) 1687 return dev_err_probe(dev, PTR_ERR(battmgr->ac_psy), 1688 "failed to register AC power supply\n"); 1689 1690 battmgr->usb_psy = devm_power_supply_register(dev, &sc8280xp_usb_psy_desc, &psy_cfg_supply); 1691 if (IS_ERR(battmgr->usb_psy)) 1692 return dev_err_probe(dev, PTR_ERR(battmgr->usb_psy), 1693 "failed to register USB power supply\n"); 1694 1695 battmgr->wls_psy = devm_power_supply_register(dev, &sc8280xp_wls_psy_desc, &psy_cfg_supply); 1696 if (IS_ERR(battmgr->wls_psy)) 1697 return dev_err_probe(dev, PTR_ERR(battmgr->wls_psy), 1698 "failed to register wireless charing power supply\n"); 1699 } else { 1700 if (battmgr->variant == QCOM_BATTMGR_SM8550) 1701 psy_desc = &sm8550_bat_psy_desc; 1702 else 1703 psy_desc = &sm8350_bat_psy_desc; 1704 1705 battmgr->bat_psy = devm_power_supply_register(dev, psy_desc, &psy_cfg); 1706 if (IS_ERR(battmgr->bat_psy)) 1707 return dev_err_probe(dev, PTR_ERR(battmgr->bat_psy), 1708 "failed to register battery power supply\n"); 1709 1710 battmgr->usb_psy = devm_power_supply_register(dev, &sm8350_usb_psy_desc, &psy_cfg_supply); 1711 if (IS_ERR(battmgr->usb_psy)) 1712 return dev_err_probe(dev, PTR_ERR(battmgr->usb_psy), 1713 "failed to register USB power supply\n"); 1714 1715 battmgr->wls_psy = devm_power_supply_register(dev, &sm8350_wls_psy_desc, &psy_cfg_supply); 1716 if (IS_ERR(battmgr->wls_psy)) 1717 return dev_err_probe(dev, PTR_ERR(battmgr->wls_psy), 1718 "failed to register wireless charing power supply\n"); 1719 } 1720 1721 battmgr->client = devm_pmic_glink_client_alloc(dev, PMIC_GLINK_OWNER_BATTMGR, 1722 qcom_battmgr_callback, 1723 qcom_battmgr_pdr_notify, 1724 battmgr); 1725 if (IS_ERR(battmgr->client)) 1726 return PTR_ERR(battmgr->client); 1727 1728 pmic_glink_client_register(battmgr->client); 1729 1730 return 0; 1731 } 1732 1733 static const struct auxiliary_device_id qcom_battmgr_id_table[] = { 1734 { .name = "pmic_glink.power-supply", }, 1735 {}, 1736 }; 1737 MODULE_DEVICE_TABLE(auxiliary, qcom_battmgr_id_table); 1738 1739 static struct auxiliary_driver qcom_battmgr_driver = { 1740 .name = "pmic_glink_power_supply", 1741 .probe = qcom_battmgr_probe, 1742 .id_table = qcom_battmgr_id_table, 1743 }; 1744 1745 module_auxiliary_driver(qcom_battmgr_driver); 1746 1747 MODULE_DESCRIPTION("Qualcomm PMIC GLINK battery manager driver"); 1748 MODULE_LICENSE("GPL"); 1749