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