drivers/power/supply/qcom_battmgr.c

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