drivers/power/supply/huawei-gaokun-battery.c - linux/kernel/git/klassert/ipsec - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * huawei-gaokun-battery - A power supply driver for HUAWEI Matebook E Go
  *
  * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com>
  */

 #include <linux/auxiliary_bus.h>
 #include <linux/bits.h>
 #include <linux/delay.h>
 #include <linux/jiffies.h>
 #include <linux/module.h>
 #include <linux/notifier.h>
 #include <linux/platform_data/huawei-gaokun-ec.h>
 #include <linux/power_supply.h>
 #include <linux/sprintf.h>

 /* -------------------------------------------------------------------------- */
 /* String Data Reg */

 #define EC_BAT_VENDOR		0x01 /* from 0x01 to 0x0F, SUNWODA */
 #define EC_BAT_MODEL		0x11 /* from 0x11 to 0x1F, HB30A8P9ECW-22T */

 #define EC_ADP_STATUS		0x81
 #define EC_AC_STATUS		BIT(0)
 #define EC_BAT_PRESENT		BIT(1) /* BATC._STA */

 #define EC_BAT_STATUS		0x82 /* _BST */
 #define EC_BAT_DISCHARGING	BIT(0)
 #define EC_BAT_CHARGING		BIT(1)
 #define EC_BAT_CRITICAL		BIT(2) /* Low Battery Level */
 #define EC_BAT_FULL		BIT(3)

 /* -------------------------------------------------------------------------- */
 /* Word Data Reg */

 /* 0x5A: ?
  * 0x5C: ?
  * 0x5E: ?
  * 0X60: ?
  * 0x84: ?
  */

 #define EC_BAT_STATUS_START	0x90
 #define EC_BAT_PERCENTAGE	0x90
 #define EC_BAT_VOLTAGE		0x92
 #define EC_BAT_CAPACITY		0x94
 #define EC_BAT_FULL_CAPACITY	0x96
 /* 0x98: ? */
 #define EC_BAT_CURRENT		0x9A
 /* 0x9C: ? */

 #define EC_BAT_INFO_START	0xA0
 /* 0xA0: POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT? */
 #define EC_BAT_DESIGN_CAPACITY	0xA2
 #define EC_BAT_DESIGN_VOLTAGE	0xA4
 #define EC_BAT_SERIAL_NUMBER	0xA6
 #define EC_BAT_CYCLE_COUNT	0xAA

 /* -------------------------------------------------------------------------- */
 /* Battery Event ID */

 #define EC_EVENT_BAT_A0		0xA0
 #define EC_EVENT_BAT_A1		0xA1
 #define EC_EVENT_BAT_A2		0xA2
 #define EC_EVENT_BAT_A3		0xA3
 #define EC_EVENT_BAT_B1		0xB1
 /* EVENT B1 A0 A1 repeat about every 1s 2s 3s respectively */

 /* ACPI _BIX field, Min sampling time, the duration between two _BST */
 #define CACHE_TIME		2000 /* cache time in milliseconds */

 #define MILLI_TO_MICRO		1000

 #define SMART_CHARGE_MODE	0
 #define SMART_CHARGE_DELAY	1
 #define SMART_CHARGE_START	2
 #define SMART_CHARGE_END	3

 #define NO_DELAY_MODE	1
 #define DELAY_MODE	4

 struct gaokun_psy_bat_status {
 	__le16 percentage_now;	/* 0x90 */
 	__le16 voltage_now;
 	__le16 capacity_now;
 	__le16 full_capacity;
 	__le16 unknown1;
 	__le16 rate_now;
 	__le16 unknown2;	/* 0x9C */
 } __packed;

 struct gaokun_psy_bat_info {
 	__le16 unknown3;	/* 0xA0 */
 	__le16 design_capacity;
 	__le16 design_voltage;
 	__le16 serial_number;
 	__le16 padding2;
 	__le16 cycle_count;	/* 0xAA */
 } __packed;

 struct gaokun_psy {
 	struct gaokun_ec *ec;
 	struct device *dev;
 	struct notifier_block nb;

 	struct power_supply *bat_psy;
 	struct power_supply *adp_psy;

 	unsigned long update_time;
 	struct gaokun_psy_bat_status status;
 	struct gaokun_psy_bat_info info;

 	char battery_model[0x10]; /* HB30A8P9ECW-22T, the real one is XXX-22A */
 	char battery_serial[0x10];
 	char battery_vendor[0x10];

 	int charge_now;
 	int online;
 	int bat_present;
 };

 /* -------------------------------------------------------------------------- */
 /* Adapter */

 static int gaokun_psy_get_adp_status(struct gaokun_psy *ecbat)
 {
 	/* _PSR */
 	int ret;
 	u8 online;

 	ret = gaokun_ec_psy_read_byte(ecbat->ec, EC_ADP_STATUS, &online);
 	if (ret)
 		return ret;

 	ecbat->online = !!(online & EC_AC_STATUS);

 	return 0;
 }

 static int gaokun_psy_get_adp_property(struct power_supply *psy,
 				       enum power_supply_property psp,
 				       union power_supply_propval *val)
 {
 	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
 	int ret;

 	ret = gaokun_psy_get_adp_status(ecbat);
 	if (ret)
 		return ret;

 	switch (psp) {
 	case POWER_SUPPLY_PROP_ONLINE:
 		val->intval = ecbat->online;
 		break;
 	case POWER_SUPPLY_PROP_USB_TYPE:
 		val->intval = POWER_SUPPLY_USB_TYPE_C;
 		break;
 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static enum power_supply_property gaokun_psy_adp_props[] = {
 	POWER_SUPPLY_PROP_ONLINE,
 	POWER_SUPPLY_PROP_USB_TYPE,
 };

 static const struct power_supply_desc gaokun_psy_adp_desc = {
 	.name		= "gaokun-ec-adapter",
 	.type		= POWER_SUPPLY_TYPE_USB,
 	.usb_types	= BIT(POWER_SUPPLY_USB_TYPE_C),
 	.get_property	= gaokun_psy_get_adp_property,
 	.properties	= gaokun_psy_adp_props,
 	.num_properties	= ARRAY_SIZE(gaokun_psy_adp_props),
 };

 /* -------------------------------------------------------------------------- */
 /* Battery */

 static inline void gaokun_psy_get_bat_present(struct gaokun_psy *ecbat)
 {
 	int ret;
 	u8 present;

 	/* Some kind of initialization */
 	gaokun_ec_write(ecbat->ec, (u8 []){0x02, 0xB2, 1, 0x90});

 	ret = gaokun_ec_psy_read_byte(ecbat->ec, EC_ADP_STATUS, &present);

 	ecbat->bat_present = ret ? false : !!(present & EC_BAT_PRESENT);
 }

 static inline int gaokun_psy_bat_present(struct gaokun_psy *ecbat)
 {
 	return ecbat->bat_present;
 }

 static int gaokun_psy_get_bat_info(struct gaokun_psy *ecbat)
 {
 	/* _BIX */
 	if (!gaokun_psy_bat_present(ecbat))
 		return 0;

 	return gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_INFO_START,
 					sizeof(ecbat->info), (u8 *)&ecbat->info);
 }

 static void gaokun_psy_update_bat_charge(struct gaokun_psy *ecbat)
 {
 	u8 charge;

 	gaokun_ec_psy_read_byte(ecbat->ec, EC_BAT_STATUS, &charge);

 	switch (charge) {
 	case EC_BAT_CHARGING:
 		ecbat->charge_now = POWER_SUPPLY_STATUS_CHARGING;
 		break;
 	case EC_BAT_DISCHARGING:
 		ecbat->charge_now = POWER_SUPPLY_STATUS_DISCHARGING;
 		break;
 	case EC_BAT_FULL:
 		ecbat->charge_now = POWER_SUPPLY_STATUS_FULL;
 		break;
 	default:
 		dev_warn(ecbat->dev, "unknown charge state %d\n", charge);
 	}
 }

 static int gaokun_psy_get_bat_status(struct gaokun_psy *ecbat)
 {
 	/* _BST */
 	int ret;

 	if (time_before(jiffies, ecbat->update_time +
 			msecs_to_jiffies(CACHE_TIME)))
 		return 0;

 	gaokun_psy_update_bat_charge(ecbat);
 	ret = gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_STATUS_START,
 				       sizeof(ecbat->status), (u8 *)&ecbat->status);

 	ecbat->update_time = jiffies;

 	return ret;
 }

 static void gaokun_psy_init(struct gaokun_psy *ecbat)
 {
 	gaokun_psy_get_bat_present(ecbat);
 	if (!gaokun_psy_bat_present(ecbat))
 		return;

 	gaokun_psy_get_bat_info(ecbat);

 	snprintf(ecbat->battery_serial, sizeof(ecbat->battery_serial),
 		 "%d", le16_to_cpu(ecbat->info.serial_number));

 	gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_VENDOR,
 				 sizeof(ecbat->battery_vendor) - 1,
 				 ecbat->battery_vendor);

 	gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_MODEL,
 				 sizeof(ecbat->battery_model) - 1,
 				 ecbat->battery_model);

 	ecbat->battery_model[14] = 'A'; /* FIX UP */
 }

 static int gaokun_psy_get_bat_property(struct power_supply *psy,
 				       enum power_supply_property psp,
 				       union power_supply_propval *val)
 {
 	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
 	u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE];
 	int ret;

 	if (gaokun_psy_bat_present(ecbat))
 		gaokun_psy_get_bat_status(ecbat);
 	else if (psp != POWER_SUPPLY_PROP_PRESENT)
 		return -ENODEV;

 	switch (psp) {
 	case POWER_SUPPLY_PROP_STATUS:
 		val->intval = ecbat->charge_now;
 		break;

 	case POWER_SUPPLY_PROP_PRESENT:
 		val->intval = ecbat->bat_present;
 		break;

 	case POWER_SUPPLY_PROP_TECHNOLOGY:
 		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 		break;

 	case POWER_SUPPLY_PROP_CYCLE_COUNT:
 		val->intval = le16_to_cpu(ecbat->info.cycle_count);
 		break;

 	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 		val->intval = le16_to_cpu(ecbat->info.design_voltage) * MILLI_TO_MICRO;
 		break;

 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 		val->intval = le16_to_cpu(ecbat->status.voltage_now) * MILLI_TO_MICRO;
 		break;

 	case POWER_SUPPLY_PROP_CURRENT_NOW:
 		val->intval = (s16)le16_to_cpu(ecbat->status.rate_now) * MILLI_TO_MICRO;
 		break;

 	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
 		val->intval = le16_to_cpu(ecbat->info.design_capacity) * MILLI_TO_MICRO;
 		break;

 	case POWER_SUPPLY_PROP_CHARGE_FULL:
 		val->intval = le16_to_cpu(ecbat->status.full_capacity) * MILLI_TO_MICRO;
 		break;

 	case POWER_SUPPLY_PROP_CHARGE_NOW:
 		val->intval = le16_to_cpu(ecbat->status.capacity_now) * MILLI_TO_MICRO;
 		break;

 	case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD:
 	case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD:
 		ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, buf);
 		if (ret)
 			return ret;

 		if (psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD)
 			val->intval = buf[SMART_CHARGE_START];
 		else
 			val->intval = buf[SMART_CHARGE_END];
 		break;

 	case POWER_SUPPLY_PROP_CAPACITY:
 		val->intval = le16_to_cpu(ecbat->status.percentage_now);
 		break;

 	case POWER_SUPPLY_PROP_MODEL_NAME:
 		val->strval = ecbat->battery_model;
 		break;

 	case POWER_SUPPLY_PROP_MANUFACTURER:
 		val->strval = ecbat->battery_vendor;
 		break;

 	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
 		val->strval = ecbat->battery_serial;
 		break;

 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static int gaokun_psy_set_bat_property(struct power_supply *psy,
 				       enum power_supply_property psp,
 				       const union power_supply_propval *val)
 {
 	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
 	u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE];
 	int ret;

 	if (!gaokun_psy_bat_present(ecbat))
 		return -ENODEV;

 	ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, buf);
 	if (ret)
 		return ret;

 	switch (psp) {
 	/*
 	 * Resetting another thershold makes single thersold setting more likely
 	 * to succeed. But setting start = end makes thing strange(failure).
 	 */
 	case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD:
 		buf[SMART_CHARGE_START] = val->intval;
 		if (buf[SMART_CHARGE_START] > buf[SMART_CHARGE_END])
 			buf[SMART_CHARGE_END] = buf[SMART_CHARGE_START] + 1;
 		return gaokun_ec_psy_set_smart_charge(ecbat->ec, buf);

 	case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD:
 		buf[SMART_CHARGE_END] = val->intval;
 		if (buf[SMART_CHARGE_END] < buf[SMART_CHARGE_START])
 			buf[SMART_CHARGE_START] = buf[SMART_CHARGE_END] - 1;
 		return gaokun_ec_psy_set_smart_charge(ecbat->ec, buf);

 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 static int gaokun_psy_is_bat_property_writeable(struct power_supply *psy,
 						enum power_supply_property psp)
 {
 	return psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD ||
 	       psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD;
 }

 static enum power_supply_property gaokun_psy_bat_props[] = {
 	POWER_SUPPLY_PROP_STATUS,
 	POWER_SUPPLY_PROP_PRESENT,
 	POWER_SUPPLY_PROP_TECHNOLOGY,
 	POWER_SUPPLY_PROP_CYCLE_COUNT,
 	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
 	POWER_SUPPLY_PROP_CURRENT_NOW,
 	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
 	POWER_SUPPLY_PROP_CHARGE_FULL,
 	POWER_SUPPLY_PROP_CHARGE_NOW,
 	POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD,
 	POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD,
 	POWER_SUPPLY_PROP_CAPACITY,
 	POWER_SUPPLY_PROP_MODEL_NAME,
 	POWER_SUPPLY_PROP_MANUFACTURER,
 	POWER_SUPPLY_PROP_SERIAL_NUMBER,
 };

 static const struct power_supply_desc gaokun_psy_bat_desc = {
 	.name			= "gaokun-ec-battery",
 	.type			= POWER_SUPPLY_TYPE_BATTERY,
 	.get_property		= gaokun_psy_get_bat_property,
 	.set_property		= gaokun_psy_set_bat_property,
 	.property_is_writeable	= gaokun_psy_is_bat_property_writeable,
 	.properties		= gaokun_psy_bat_props,
 	.num_properties		= ARRAY_SIZE(gaokun_psy_bat_props),
 };

 /* -------------------------------------------------------------------------- */
 /* Sysfs */

 /*
  * Note that, HUAWEI calls them SBAC/GBAC and SBCM/GBCM in DSDT, they are likely
  * Set/Get Battery Adaptive Charging and Set/Get Battery Charging Mode.
  */

 /* battery adaptive charge */
 static ssize_t battery_adaptive_charge_show(struct device *dev,
 					    struct device_attribute *attr,
 					    char *buf)
 {
 	struct power_supply *psy = to_power_supply(dev);
 	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
 	int ret;
 	bool on;

 	ret = gaokun_ec_psy_get_smart_charge_enable(ecbat->ec, &on);
 	if (ret)
 		return ret;

 	return sysfs_emit(buf, "%d\n", on);
 }

 static ssize_t battery_adaptive_charge_store(struct device *dev,
 					     struct device_attribute *attr,
 					     const char *buf, size_t size)
 {
 	struct power_supply *psy = to_power_supply(dev);
 	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
 	int ret;
 	bool on;

 	if (kstrtobool(buf, &on))
 		return -EINVAL;

 	ret = gaokun_ec_psy_set_smart_charge_enable(ecbat->ec, on);
 	if (ret)
 		return ret;

 	return size;
 }

 static DEVICE_ATTR_RW(battery_adaptive_charge);

 static inline int get_charge_delay(u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE])
 {
 	return buf[SMART_CHARGE_MODE] == NO_DELAY_MODE ? 0 : buf[SMART_CHARGE_DELAY];
 }

 static inline void
 set_charge_delay(u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE], u8 delay)
 {
 	if (delay) {
 		buf[SMART_CHARGE_DELAY] = delay;
 		buf[SMART_CHARGE_MODE] = DELAY_MODE;
 	} else {
 		 /* No writing zero, there is a specific mode for it. */
 		buf[SMART_CHARGE_MODE] = NO_DELAY_MODE;
 	}
 }

 /* Smart charge */
 static ssize_t smart_charge_delay_show(struct device *dev,
 				       struct device_attribute *attr,
 				       char *buf)
 {
 	struct power_supply *psy = to_power_supply(dev);
 	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
 	u8 bf[GAOKUN_SMART_CHARGE_DATA_SIZE];
 	int ret;

 	ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, bf);
 	if (ret)
 		return ret;

 	return sysfs_emit(buf, "%d\n", get_charge_delay(bf));
 }

 static ssize_t smart_charge_delay_store(struct device *dev,
 					struct device_attribute *attr,
 					const char *buf, size_t size)
 {
 	struct power_supply *psy = to_power_supply(dev);
 	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
 	u8 bf[GAOKUN_SMART_CHARGE_DATA_SIZE];
 	u8 delay;
 	int ret;

 	if (kstrtou8(buf, 10, &delay))
 		return -EINVAL;

 	ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, bf);
 	if (ret)
 		return ret;

 	set_charge_delay(bf, delay);

 	ret = gaokun_ec_psy_set_smart_charge(ecbat->ec, bf);
 	if (ret)
 		return ret;

 	return size;
 }

 static DEVICE_ATTR_RW(smart_charge_delay);

 static struct attribute *gaokun_psy_features_attrs[] = {
 	&dev_attr_battery_adaptive_charge.attr,
 	&dev_attr_smart_charge_delay.attr,
 	NULL,
 };
 ATTRIBUTE_GROUPS(gaokun_psy_features);

 static int gaokun_psy_notify(struct notifier_block *nb,
 			     unsigned long action, void *data)
 {
 	struct gaokun_psy *ecbat = container_of(nb, struct gaokun_psy, nb);

 	switch (action) {
 	case EC_EVENT_BAT_A2:
 	case EC_EVENT_BAT_B1:
 		gaokun_psy_get_bat_info(ecbat);
 		return NOTIFY_OK;

 	case EC_EVENT_BAT_A0:
 		gaokun_psy_get_adp_status(ecbat);
 		power_supply_changed(ecbat->adp_psy);
 		msleep(10);
 		fallthrough;

 	case EC_EVENT_BAT_A1:
 	case EC_EVENT_BAT_A3:
 		if (action == EC_EVENT_BAT_A3) {
 			gaokun_psy_get_bat_info(ecbat);
 			msleep(100);
 		}
 		gaokun_psy_get_bat_status(ecbat);
 		power_supply_changed(ecbat->bat_psy);
 		return NOTIFY_OK;

 	default:
 		return NOTIFY_DONE;
 	}
 }

 static int gaokun_psy_probe(struct auxiliary_device *adev,
 			    const struct auxiliary_device_id *id)
 {
 	struct gaokun_ec *ec = adev->dev.platform_data;
 	struct power_supply_config psy_cfg = {};
 	struct device *dev = &adev->dev;
 	struct gaokun_psy *ecbat;

 	ecbat = devm_kzalloc(&adev->dev, sizeof(*ecbat), GFP_KERNEL);
 	if (!ecbat)
 		return -ENOMEM;

 	ecbat->ec = ec;
 	ecbat->dev = dev;
 	ecbat->nb.notifier_call = gaokun_psy_notify;

 	auxiliary_set_drvdata(adev, ecbat);

 	psy_cfg.drv_data = ecbat;
 	ecbat->adp_psy = devm_power_supply_register(dev, &gaokun_psy_adp_desc,
 						    &psy_cfg);
 	if (IS_ERR(ecbat->adp_psy))
 		return dev_err_probe(dev, PTR_ERR(ecbat->adp_psy),
 				     "Failed to register AC power supply\n");

 	psy_cfg.supplied_to = (char **)&gaokun_psy_bat_desc.name;
 	psy_cfg.num_supplicants = 1;
 	psy_cfg.no_wakeup_source = true;
 	psy_cfg.attr_grp = gaokun_psy_features_groups;
 	ecbat->bat_psy = devm_power_supply_register(dev, &gaokun_psy_bat_desc,
 						    &psy_cfg);
 	if (IS_ERR(ecbat->bat_psy))
 		return dev_err_probe(dev, PTR_ERR(ecbat->bat_psy),
 				     "Failed to register battery power supply\n");
 	gaokun_psy_init(ecbat);

 	return gaokun_ec_register_notify(ec, &ecbat->nb);
 }

 static void gaokun_psy_remove(struct auxiliary_device *adev)
 {
 	struct gaokun_psy *ecbat = auxiliary_get_drvdata(adev);

 	gaokun_ec_unregister_notify(ecbat->ec, &ecbat->nb);
 }

 static const struct auxiliary_device_id gaokun_psy_id_table[] = {
 	{ .name = GAOKUN_MOD_NAME "." GAOKUN_DEV_PSY, },
 	{}
 };
 MODULE_DEVICE_TABLE(auxiliary, gaokun_psy_id_table);

 static struct auxiliary_driver gaokun_psy_driver = {
 	.name = GAOKUN_DEV_PSY,
 	.id_table = gaokun_psy_id_table,
 	.probe = gaokun_psy_probe,
 	.remove = gaokun_psy_remove,
 };

 module_auxiliary_driver(gaokun_psy_driver);

 MODULE_DESCRIPTION("HUAWEI Matebook E Go psy driver");
 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* huawei-gaokun-battery - A power supply driver for HUAWEI Matebook E Go
	*
	* Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com>
	*/

	#include <linux/auxiliary_bus.h>
	#include <linux/bits.h>
	#include <linux/delay.h>
	#include <linux/jiffies.h>
	#include <linux/module.h>
	#include <linux/notifier.h>
	#include <linux/platform_data/huawei-gaokun-ec.h>
	#include <linux/power_supply.h>
	#include <linux/sprintf.h>

	/* -------------------------------------------------------------------------- */
	/* String Data Reg */

	#define EC_BAT_VENDOR 0x01 /* from 0x01 to 0x0F, SUNWODA */
	#define EC_BAT_MODEL 0x11 /* from 0x11 to 0x1F, HB30A8P9ECW-22T */

	#define EC_ADP_STATUS 0x81
	#define EC_AC_STATUS BIT(0)
	#define EC_BAT_PRESENT BIT(1) /* BATC._STA */

	#define EC_BAT_STATUS 0x82 /* _BST */
	#define EC_BAT_DISCHARGING BIT(0)
	#define EC_BAT_CHARGING BIT(1)
	#define EC_BAT_CRITICAL BIT(2) /* Low Battery Level */
	#define EC_BAT_FULL BIT(3)

	/* -------------------------------------------------------------------------- */
	/* Word Data Reg */

	/* 0x5A: ?
	* 0x5C: ?
	* 0x5E: ?
	* 0X60: ?
	* 0x84: ?
	*/

	#define EC_BAT_STATUS_START 0x90
	#define EC_BAT_PERCENTAGE 0x90
	#define EC_BAT_VOLTAGE 0x92
	#define EC_BAT_CAPACITY 0x94
	#define EC_BAT_FULL_CAPACITY 0x96
	/* 0x98: ? */
	#define EC_BAT_CURRENT 0x9A
	/* 0x9C: ? */

	#define EC_BAT_INFO_START 0xA0
	/* 0xA0: POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT? */
	#define EC_BAT_DESIGN_CAPACITY 0xA2
	#define EC_BAT_DESIGN_VOLTAGE 0xA4
	#define EC_BAT_SERIAL_NUMBER 0xA6
	#define EC_BAT_CYCLE_COUNT 0xAA

	/* -------------------------------------------------------------------------- */
	/* Battery Event ID */

	#define EC_EVENT_BAT_A0 0xA0
	#define EC_EVENT_BAT_A1 0xA1
	#define EC_EVENT_BAT_A2 0xA2
	#define EC_EVENT_BAT_A3 0xA3
	#define EC_EVENT_BAT_B1 0xB1
	/* EVENT B1 A0 A1 repeat about every 1s 2s 3s respectively */

	/* ACPI _BIX field, Min sampling time, the duration between two _BST */
	#define CACHE_TIME 2000 /* cache time in milliseconds */

	#define MILLI_TO_MICRO 1000

	#define SMART_CHARGE_MODE 0
	#define SMART_CHARGE_DELAY 1
	#define SMART_CHARGE_START 2
	#define SMART_CHARGE_END 3

	#define NO_DELAY_MODE 1
	#define DELAY_MODE 4

	struct gaokun_psy_bat_status {
	__le16 percentage_now; /* 0x90 */
	__le16 voltage_now;
	__le16 capacity_now;
	__le16 full_capacity;
	__le16 unknown1;
	__le16 rate_now;
	__le16 unknown2; /* 0x9C */
	} __packed;

	struct gaokun_psy_bat_info {
	__le16 unknown3; /* 0xA0 */
	__le16 design_capacity;
	__le16 design_voltage;
	__le16 serial_number;
	__le16 padding2;
	__le16 cycle_count; /* 0xAA */
	} __packed;

	struct gaokun_psy {
	struct gaokun_ec *ec;
	struct device *dev;
	struct notifier_block nb;

	struct power_supply *bat_psy;
	struct power_supply *adp_psy;

	unsigned long update_time;
	struct gaokun_psy_bat_status status;
	struct gaokun_psy_bat_info info;

	char battery_model[0x10]; /* HB30A8P9ECW-22T, the real one is XXX-22A */
	char battery_serial[0x10];
	char battery_vendor[0x10];

	int charge_now;
	int online;
	int bat_present;
	};

	/* -------------------------------------------------------------------------- */
	/* Adapter */

	static int gaokun_psy_get_adp_status(struct gaokun_psy *ecbat)
	{
	/* _PSR */
	int ret;
	u8 online;

	ret = gaokun_ec_psy_read_byte(ecbat->ec, EC_ADP_STATUS, &online);
	if (ret)
	return ret;

	ecbat->online = !!(online & EC_AC_STATUS);

	return 0;
	}

	static int gaokun_psy_get_adp_property(struct power_supply *psy,
	enum power_supply_property psp,
	union power_supply_propval *val)
	{
	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
	int ret;

	ret = gaokun_psy_get_adp_status(ecbat);
	if (ret)
	return ret;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
	val->intval = ecbat->online;
	break;
	case POWER_SUPPLY_PROP_USB_TYPE:
	val->intval = POWER_SUPPLY_USB_TYPE_C;
	break;
	default:
	return -EINVAL;
	}

	return 0;
	}

	static enum power_supply_property gaokun_psy_adp_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_USB_TYPE,
	};

	static const struct power_supply_desc gaokun_psy_adp_desc = {
	.name = "gaokun-ec-adapter",
	.type = POWER_SUPPLY_TYPE_USB,
	.usb_types = BIT(POWER_SUPPLY_USB_TYPE_C),
	.get_property = gaokun_psy_get_adp_property,
	.properties = gaokun_psy_adp_props,
	.num_properties = ARRAY_SIZE(gaokun_psy_adp_props),
	};

	/* -------------------------------------------------------------------------- */
	/* Battery */

	static inline void gaokun_psy_get_bat_present(struct gaokun_psy *ecbat)
	{
	int ret;
	u8 present;

	/* Some kind of initialization */
	gaokun_ec_write(ecbat->ec, (u8 []){0x02, 0xB2, 1, 0x90});

	ret = gaokun_ec_psy_read_byte(ecbat->ec, EC_ADP_STATUS, &present);

	ecbat->bat_present = ret ? false : !!(present & EC_BAT_PRESENT);
	}

	static inline int gaokun_psy_bat_present(struct gaokun_psy *ecbat)
	{
	return ecbat->bat_present;
	}

	static int gaokun_psy_get_bat_info(struct gaokun_psy *ecbat)
	{
	/* _BIX */
	if (!gaokun_psy_bat_present(ecbat))
	return 0;

	return gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_INFO_START,
	sizeof(ecbat->info), (u8 *)&ecbat->info);
	}

	static void gaokun_psy_update_bat_charge(struct gaokun_psy *ecbat)
	{
	u8 charge;

	gaokun_ec_psy_read_byte(ecbat->ec, EC_BAT_STATUS, &charge);

	switch (charge) {
	case EC_BAT_CHARGING:
	ecbat->charge_now = POWER_SUPPLY_STATUS_CHARGING;
	break;
	case EC_BAT_DISCHARGING:
	ecbat->charge_now = POWER_SUPPLY_STATUS_DISCHARGING;
	break;
	case EC_BAT_FULL:
	ecbat->charge_now = POWER_SUPPLY_STATUS_FULL;
	break;
	default:
	dev_warn(ecbat->dev, "unknown charge state %d\n", charge);
	}
	}

	static int gaokun_psy_get_bat_status(struct gaokun_psy *ecbat)
	{
	/* _BST */
	int ret;

	if (time_before(jiffies, ecbat->update_time +
	msecs_to_jiffies(CACHE_TIME)))
	return 0;

	gaokun_psy_update_bat_charge(ecbat);
	ret = gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_STATUS_START,
	sizeof(ecbat->status), (u8 *)&ecbat->status);

	ecbat->update_time = jiffies;

	return ret;
	}

	static void gaokun_psy_init(struct gaokun_psy *ecbat)
	{
	gaokun_psy_get_bat_present(ecbat);
	if (!gaokun_psy_bat_present(ecbat))
	return;

	gaokun_psy_get_bat_info(ecbat);

	snprintf(ecbat->battery_serial, sizeof(ecbat->battery_serial),
	"%d", le16_to_cpu(ecbat->info.serial_number));

	gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_VENDOR,
	sizeof(ecbat->battery_vendor) - 1,
	ecbat->battery_vendor);

	gaokun_ec_psy_multi_read(ecbat->ec, EC_BAT_MODEL,
	sizeof(ecbat->battery_model) - 1,
	ecbat->battery_model);

	ecbat->battery_model[14] = 'A'; /* FIX UP */
	}

	static int gaokun_psy_get_bat_property(struct power_supply *psy,
	enum power_supply_property psp,
	union power_supply_propval *val)
	{
	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
	u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE];
	int ret;

	if (gaokun_psy_bat_present(ecbat))
	gaokun_psy_get_bat_status(ecbat);
	else if (psp != POWER_SUPPLY_PROP_PRESENT)
	return -ENODEV;

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
	val->intval = ecbat->charge_now;
	break;

	case POWER_SUPPLY_PROP_PRESENT:
	val->intval = ecbat->bat_present;
	break;

	case POWER_SUPPLY_PROP_TECHNOLOGY:
	val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
	break;

	case POWER_SUPPLY_PROP_CYCLE_COUNT:
	val->intval = le16_to_cpu(ecbat->info.cycle_count);
	break;

	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
	val->intval = le16_to_cpu(ecbat->info.design_voltage) * MILLI_TO_MICRO;
	break;

	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
	val->intval = le16_to_cpu(ecbat->status.voltage_now) * MILLI_TO_MICRO;
	break;

	case POWER_SUPPLY_PROP_CURRENT_NOW:
	val->intval = (s16)le16_to_cpu(ecbat->status.rate_now) * MILLI_TO_MICRO;
	break;

	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
	val->intval = le16_to_cpu(ecbat->info.design_capacity) * MILLI_TO_MICRO;
	break;

	case POWER_SUPPLY_PROP_CHARGE_FULL:
	val->intval = le16_to_cpu(ecbat->status.full_capacity) * MILLI_TO_MICRO;
	break;

	case POWER_SUPPLY_PROP_CHARGE_NOW:
	val->intval = le16_to_cpu(ecbat->status.capacity_now) * MILLI_TO_MICRO;
	break;

	case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD:
	case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD:
	ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, buf);
	if (ret)
	return ret;

	if (psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD)
	val->intval = buf[SMART_CHARGE_START];
	else
	val->intval = buf[SMART_CHARGE_END];
	break;

	case POWER_SUPPLY_PROP_CAPACITY:
	val->intval = le16_to_cpu(ecbat->status.percentage_now);
	break;

	case POWER_SUPPLY_PROP_MODEL_NAME:
	val->strval = ecbat->battery_model;
	break;

	case POWER_SUPPLY_PROP_MANUFACTURER:
	val->strval = ecbat->battery_vendor;
	break;

	case POWER_SUPPLY_PROP_SERIAL_NUMBER:
	val->strval = ecbat->battery_serial;
	break;

	default:
	return -EINVAL;
	}

	return 0;
	}

	static int gaokun_psy_set_bat_property(struct power_supply *psy,
	enum power_supply_property psp,
	const union power_supply_propval *val)
	{
	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
	u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE];
	int ret;

	if (!gaokun_psy_bat_present(ecbat))
	return -ENODEV;

	ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, buf);
	if (ret)
	return ret;

	switch (psp) {
	/*
	* Resetting another thershold makes single thersold setting more likely
	* to succeed. But setting start = end makes thing strange(failure).
	*/
	case POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD:
	buf[SMART_CHARGE_START] = val->intval;
	if (buf[SMART_CHARGE_START] > buf[SMART_CHARGE_END])
	buf[SMART_CHARGE_END] = buf[SMART_CHARGE_START] + 1;
	return gaokun_ec_psy_set_smart_charge(ecbat->ec, buf);

	case POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD:
	buf[SMART_CHARGE_END] = val->intval;
	if (buf[SMART_CHARGE_END] < buf[SMART_CHARGE_START])
	buf[SMART_CHARGE_START] = buf[SMART_CHARGE_END] - 1;
	return gaokun_ec_psy_set_smart_charge(ecbat->ec, buf);

	default:
	return -EINVAL;
	}

	return 0;
	}

	static int gaokun_psy_is_bat_property_writeable(struct power_supply *psy,
	enum power_supply_property psp)
	{
	return psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD \|\|
	psp == POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD;
	}

	static enum power_supply_property gaokun_psy_bat_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_CYCLE_COUNT,
	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
	POWER_SUPPLY_PROP_VOLTAGE_NOW,
	POWER_SUPPLY_PROP_CURRENT_NOW,
	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
	POWER_SUPPLY_PROP_CHARGE_FULL,
	POWER_SUPPLY_PROP_CHARGE_NOW,
	POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD,
	POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD,
	POWER_SUPPLY_PROP_CAPACITY,
	POWER_SUPPLY_PROP_MODEL_NAME,
	POWER_SUPPLY_PROP_MANUFACTURER,
	POWER_SUPPLY_PROP_SERIAL_NUMBER,
	};

	static const struct power_supply_desc gaokun_psy_bat_desc = {
	.name = "gaokun-ec-battery",
	.type = POWER_SUPPLY_TYPE_BATTERY,
	.get_property = gaokun_psy_get_bat_property,
	.set_property = gaokun_psy_set_bat_property,
	.property_is_writeable = gaokun_psy_is_bat_property_writeable,
	.properties = gaokun_psy_bat_props,
	.num_properties = ARRAY_SIZE(gaokun_psy_bat_props),
	};

	/* -------------------------------------------------------------------------- */
	/* Sysfs */

	/*
	* Note that, HUAWEI calls them SBAC/GBAC and SBCM/GBCM in DSDT, they are likely
	* Set/Get Battery Adaptive Charging and Set/Get Battery Charging Mode.
	*/

	/* battery adaptive charge */
	static ssize_t battery_adaptive_charge_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct power_supply *psy = to_power_supply(dev);
	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
	int ret;
	bool on;

	ret = gaokun_ec_psy_get_smart_charge_enable(ecbat->ec, &on);
	if (ret)
	return ret;

	return sysfs_emit(buf, "%d\n", on);
	}

	static ssize_t battery_adaptive_charge_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t size)
	{
	struct power_supply *psy = to_power_supply(dev);
	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
	int ret;
	bool on;

	if (kstrtobool(buf, &on))
	return -EINVAL;

	ret = gaokun_ec_psy_set_smart_charge_enable(ecbat->ec, on);
	if (ret)
	return ret;

	return size;
	}

	static DEVICE_ATTR_RW(battery_adaptive_charge);

	static inline int get_charge_delay(u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE])
	{
	return buf[SMART_CHARGE_MODE] == NO_DELAY_MODE ? 0 : buf[SMART_CHARGE_DELAY];
	}

	static inline void
	set_charge_delay(u8 buf[GAOKUN_SMART_CHARGE_DATA_SIZE], u8 delay)
	{
	if (delay) {
	buf[SMART_CHARGE_DELAY] = delay;
	buf[SMART_CHARGE_MODE] = DELAY_MODE;
	} else {
	/* No writing zero, there is a specific mode for it. */
	buf[SMART_CHARGE_MODE] = NO_DELAY_MODE;
	}
	}

	/* Smart charge */
	static ssize_t smart_charge_delay_show(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct power_supply *psy = to_power_supply(dev);
	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
	u8 bf[GAOKUN_SMART_CHARGE_DATA_SIZE];
	int ret;

	ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, bf);
	if (ret)
	return ret;

	return sysfs_emit(buf, "%d\n", get_charge_delay(bf));
	}

	static ssize_t smart_charge_delay_store(struct device *dev,
	struct device_attribute *attr,
	const char *buf, size_t size)
	{
	struct power_supply *psy = to_power_supply(dev);
	struct gaokun_psy *ecbat = power_supply_get_drvdata(psy);
	u8 bf[GAOKUN_SMART_CHARGE_DATA_SIZE];
	u8 delay;
	int ret;

	if (kstrtou8(buf, 10, &delay))
	return -EINVAL;

	ret = gaokun_ec_psy_get_smart_charge(ecbat->ec, bf);
	if (ret)
	return ret;

	set_charge_delay(bf, delay);

	ret = gaokun_ec_psy_set_smart_charge(ecbat->ec, bf);
	if (ret)
	return ret;

	return size;
	}

	static DEVICE_ATTR_RW(smart_charge_delay);

	static struct attribute *gaokun_psy_features_attrs[] = {
	&dev_attr_battery_adaptive_charge.attr,
	&dev_attr_smart_charge_delay.attr,
	NULL,
	};
	ATTRIBUTE_GROUPS(gaokun_psy_features);

	static int gaokun_psy_notify(struct notifier_block *nb,
	unsigned long action, void *data)
	{
	struct gaokun_psy *ecbat = container_of(nb, struct gaokun_psy, nb);

	switch (action) {
	case EC_EVENT_BAT_A2:
	case EC_EVENT_BAT_B1:
	gaokun_psy_get_bat_info(ecbat);
	return NOTIFY_OK;

	case EC_EVENT_BAT_A0:
	gaokun_psy_get_adp_status(ecbat);
	power_supply_changed(ecbat->adp_psy);
	msleep(10);
	fallthrough;

	case EC_EVENT_BAT_A1:
	case EC_EVENT_BAT_A3:
	if (action == EC_EVENT_BAT_A3) {
	gaokun_psy_get_bat_info(ecbat);
	msleep(100);
	}
	gaokun_psy_get_bat_status(ecbat);
	power_supply_changed(ecbat->bat_psy);
	return NOTIFY_OK;

	default:
	return NOTIFY_DONE;
	}
	}

	static int gaokun_psy_probe(struct auxiliary_device *adev,
	const struct auxiliary_device_id *id)
	{
	struct gaokun_ec *ec = adev->dev.platform_data;
	struct power_supply_config psy_cfg = {};
	struct device *dev = &adev->dev;
	struct gaokun_psy *ecbat;

	ecbat = devm_kzalloc(&adev->dev, sizeof(*ecbat), GFP_KERNEL);
	if (!ecbat)
	return -ENOMEM;

	ecbat->ec = ec;
	ecbat->dev = dev;
	ecbat->nb.notifier_call = gaokun_psy_notify;

	auxiliary_set_drvdata(adev, ecbat);

	psy_cfg.drv_data = ecbat;
	ecbat->adp_psy = devm_power_supply_register(dev, &gaokun_psy_adp_desc,
	&psy_cfg);
	if (IS_ERR(ecbat->adp_psy))
	return dev_err_probe(dev, PTR_ERR(ecbat->adp_psy),
	"Failed to register AC power supply\n");

	psy_cfg.supplied_to = (char **)&gaokun_psy_bat_desc.name;
	psy_cfg.num_supplicants = 1;
	psy_cfg.no_wakeup_source = true;
	psy_cfg.attr_grp = gaokun_psy_features_groups;
	ecbat->bat_psy = devm_power_supply_register(dev, &gaokun_psy_bat_desc,
	&psy_cfg);
	if (IS_ERR(ecbat->bat_psy))
	return dev_err_probe(dev, PTR_ERR(ecbat->bat_psy),
	"Failed to register battery power supply\n");
	gaokun_psy_init(ecbat);

	return gaokun_ec_register_notify(ec, &ecbat->nb);
	}

	static void gaokun_psy_remove(struct auxiliary_device *adev)
	{
	struct gaokun_psy *ecbat = auxiliary_get_drvdata(adev);

	gaokun_ec_unregister_notify(ecbat->ec, &ecbat->nb);
	}

	static const struct auxiliary_device_id gaokun_psy_id_table[] = {
	{ .name = GAOKUN_MOD_NAME "." GAOKUN_DEV_PSY, },
	{}
	};
	MODULE_DEVICE_TABLE(auxiliary, gaokun_psy_id_table);

	static struct auxiliary_driver gaokun_psy_driver = {
	.name = GAOKUN_DEV_PSY,
	.id_table = gaokun_psy_id_table,
	.probe = gaokun_psy_probe,
	.remove = gaokun_psy_remove,
	};

	module_auxiliary_driver(gaokun_psy_driver);

	MODULE_DESCRIPTION("HUAWEI Matebook E Go psy driver");
	MODULE_LICENSE("GPL");