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