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