* [PATCH v3 0/6] platform: arm64: Huawei Matebook E Go embedded controller @ 2025-01-13 17:49 Pengyu Luo 2025-01-13 17:50 ` [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Pengyu Luo 0 siblings, 2 replies; 20+ messages in thread From: Pengyu Luo @ 2025-01-13 17:49 UTC (permalink / raw) To: Rob Herring, Krzysztof Kozlowski, Conor Dooley, Bjorn Andersson, Konrad Dybcio, Hans de Goede, Ilpo Järvinen, Bryan O'Donoghue, Sebastian Reichel, Heikki Krogerus, Greg Kroah-Hartman, Jean Delvare, Guenter Roeck Cc: devicetree, linux-kernel, linux-arm-msm, platform-driver-x86, linux-pm, linux-usb, linux-hwmon, Pengyu Luo This adds binding, drivers and the DT support for the Huawei Matebook E Go (sc8280xp-based) Embedded Controller which is also found in Huawei Matebook E Go LTE (sc8180x-based), but I don't have the sc8180x one to perform tests, so this series enable support for sc8280xp variant only, this series provides the following features: - battery and charger information report - charging thresholds control - FN lock (An alternative method) - LID switch detection - Temperature sensors - USB Type-C altmode - USB Type-C PD(high power) Thanks to the work of Bjorn and Dmitry([1]), the work of Nikita([2]), writing a EC driver won't be suffering. This work refers a lot to their work, also, many other works. I mentioned them in the source file. Depends: https://lore.kernel.org/linux-arm-msm/20241220160530.444864-1-mitltlatltl@gmail.com [1] https://lore.kernel.org/all/20240614-yoga-ec-driver-v7-0-9f0b9b40ae76@linaro.org/ [2] https://lore.kernel.org/all/20240315-aspire1-ec-v5-0-f93381deff39@trvn.ru/ base-commit: 37136bf5c3a6f6b686d74f41837a6406bec6b7bc Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> --- Changes in v3: - Link to v2: https://lore.kernel.org/linux-arm-msm/20250105174159.227831-1-mitltlatltl@gmail.com dt-binding: - drop generic compatibles. (Krzysztof) - remove '+' to use literal block style. (Krzysztof) ec: - take struct gaokun_ucsi_reg as parameter (Heikki) - add almost all kernel doc comments (Krzysztof, Heikki) ucsi: - drop unnecessary ucsi quirks (Dmitry) - add UCSI v1.0 to ucsi.h (Heikki) - use gaokun_ucsi_read_cci() to read cci directly (Heikki) - drop unnecessary gaokun_ucsi_get_port_num (Heikki) - rename member port_num => num_ports (Heikki) - fix completion, forgot to signal threads in previous version dt: - fix indentation (Konrad) - add a link between role switch and connector Changes in v2: - Link to v1: https://lore.kernel.org/linux-arm-msm/20241227171353.404432-1-mitltlatltl@gmail.com global: - drop qcom's products(i.e. sc8180x, sx8280xp) everywhere, use 'product'-based instead(Krzysztof, Bryan) - drop Cc Nikita Travkin, we had discussed the device in PM. - add myself to MAINTAINERS dt-binding: - fix building (Rob Herring (Arm)) - remove unnecessary code (Krzysztof) - add bugzilla documentation, insights of gaokun(see [1] or patch[1/5]) (Krzysztof, Aiqun(Maria)) - explain the difference between PMIC GLink and gaokun EC (Aiqun(Maria)) ec: - use Linux style comments (Krzysztof) - add a comment for mutex lock (Krzysztof) - add more kerneldoc for exported functions (Krzysztof) - eliminate unnecessary conditions (Bryan) - add a macro for check thresholds (Bryan) - improve English (Bryan) - use existing sysfs interface(hwmon, psy) whenever possible (Krzysztof) - use __le16 and related endianess conversion function for temp data (Ilpo) - drop alias for packet headers (Ilpo) - avoid hardcoding i2c msgs size (Aiqun(Maria)) - add a comment for the sleep in critial region (Bryan, Aiqun(Maria)) - use macro to construct packet (Bryan, Aiqun(Maria)) wmi: - dropped ucsi: - reorder headers (Bryan) - a comment for the orientation map macro (Bryan) - make mux mode map more explicit(minus six is very clear now) (Bryan, Dmitry) - handle port update exceptions return (Bryan) - a comment for the UCSI quirks (Dmitry) - use the inline hint for the short register function (Dmitry) - use the API with delay to handle register instead of a direct sleep (Bryan) - handle unfinished initialization early psy: - add charging related sysfs to here (Krzysztof, Dmitry) - document ABI for power_supply sysfs (Krzysztof) - drop charging threshold, use smart charging instead dts: - correct indentation, properties' order. (Konrad) Pengyu Luo (6): dt-bindings: platform: Add Huawei Matebook E Go EC platform: arm64: add Huawei Matebook E Go EC driver usb: typec: ucsi: Add a macro definition for UCSI v1.0 usb: typec: ucsi: add Huawei Matebook E Go ucsi driver power: supply: add Huawei Matebook E Go psy driver arm64: dts: qcom: gaokun3: Add Embedded Controller node .../ABI/testing/sysfs-class-power-gaokun | 47 + .../bindings/platform/huawei,gaokun-ec.yaml | 124 +++ MAINTAINERS | 9 + .../boot/dts/qcom/sc8280xp-huawei-gaokun3.dts | 163 ++++ drivers/platform/arm64/Kconfig | 21 + drivers/platform/arm64/Makefile | 1 + drivers/platform/arm64/huawei-gaokun-ec.c | 841 ++++++++++++++++++ drivers/power/supply/Kconfig | 10 + drivers/power/supply/Makefile | 1 + drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++ drivers/usb/typec/ucsi/Kconfig | 11 + drivers/usb/typec/ucsi/Makefile | 1 + drivers/usb/typec/ucsi/ucsi.h | 1 + drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c | 524 +++++++++++ .../linux/platform_data/huawei-gaokun-ec.h | 80 ++ 15 files changed, 2382 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun create mode 100644 Documentation/devicetree/bindings/platform/huawei,gaokun-ec.yaml create mode 100644 drivers/platform/arm64/huawei-gaokun-ec.c create mode 100644 drivers/power/supply/huawei-gaokun-battery.c create mode 100644 drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c create mode 100644 include/linux/platform_data/huawei-gaokun-ec.h -- 2.47.1 ^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver @ 2025-01-13 17:50 ` Pengyu Luo 2025-01-13 18:34 ` Guenter Roeck ` (2 more replies) 0 siblings, 3 replies; 20+ messages in thread From: Pengyu Luo @ 2025-01-13 17:50 UTC (permalink / raw) To: Rob Herring, Krzysztof Kozlowski, Conor Dooley, Bjorn Andersson, Konrad Dybcio, Hans de Goede, Ilpo Järvinen, Bryan O'Donoghue, Sebastian Reichel, Heikki Krogerus, Greg Kroah-Hartman, Jean Delvare, Guenter Roeck Cc: devicetree, linux-kernel, linux-arm-msm, platform-driver-x86, linux-pm, linux-usb, linux-hwmon, Pengyu Luo There are three variants of which Huawei released the first two simultaneously. Huawei Matebook E Go LTE(sc8180x), codename seems to be gaokun2. Huawei Matebook E Go(sc8280xp@3.0GHz), codename must be gaokun3. (see [1]) Huawei Matebook E Go 2023(sc8280xp@2.69GHz), codename should be also gaokun3. Adding support for the latter two variants for now, this driver should also work for the sc8180x variant according to acpi table files, but I don't have the device to test yet. Different from other Qualcomm Snapdragon sc8280xp based machines, the Huawei Matebook E Go uses an embedded controller while others use a system called PMIC GLink. This embedded controller can be used to perform a set of various functions, including, but not limited to: - Battery and charger monitoring; - Charge control and smart charge; - Fn_lock settings; - Tablet lid status; - Temperature sensors; - USB Type-C notifications (ports orientation, DP alt mode HPD); - USB Type-C PD (according to observation, up to 48w). Add a driver for the EC which creates devices for UCSI and power supply devices. [1] https://bugzilla.kernel.org/show_bug.cgi?id=219645 Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> --- MAINTAINERS | 9 + drivers/platform/arm64/Kconfig | 21 + drivers/platform/arm64/Makefile | 1 + drivers/platform/arm64/huawei-gaokun-ec.c | 841 ++++++++++++++++++ .../linux/platform_data/huawei-gaokun-ec.h | 80 ++ 5 files changed, 952 insertions(+) create mode 100644 drivers/platform/arm64/huawei-gaokun-ec.c create mode 100644 include/linux/platform_data/huawei-gaokun-ec.h diff --git a/MAINTAINERS b/MAINTAINERS index 520612b3d..0f9e0390a 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -10691,6 +10691,15 @@ S: Maintained F: Documentation/networking/device_drivers/ethernet/huawei/hinic.rst F: drivers/net/ethernet/huawei/hinic/ +HUAWEI MATEBOOK E GO EMBEDDED CONTROLLER DRIVER +M: Pengyu Luo <mitltlatltl@gmail.com> +S: Maintained +F: Documentation/devicetree/bindings/platform/huawei,gaokun-ec.yaml +F: drivers/platform/arm64/huawei-gaokun-ec.c +F: drivers/power/supply/huawei-gaokun-battery.c +F: drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c +F: include/linux/platform_data/huawei-gaokun-ec.h + HUGETLB SUBSYSTEM M: Muchun Song <muchun.song@linux.dev> L: linux-mm@kvack.org diff --git a/drivers/platform/arm64/Kconfig b/drivers/platform/arm64/Kconfig index f88395ea3..67dc7aa95 100644 --- a/drivers/platform/arm64/Kconfig +++ b/drivers/platform/arm64/Kconfig @@ -33,6 +33,27 @@ config EC_ACER_ASPIRE1 laptop where this information is not properly exposed via the standard ACPI devices. +config EC_HUAWEI_GAOKUN + tristate "Huawei Matebook E Go Embedded Controller driver" + depends on ARCH_QCOM || COMPILE_TEST + depends on I2C + depends on DRM + depends on POWER_SUPPLY + depends on INPUT + help + Say Y here to enable the EC driver for the Huawei Matebook E Go + which is a sc8280xp-based 2-in-1 tablet. The driver handles battery + (information, charge control) and USB Type-C DP HPD events as well + as some misc functions like the lid sensor and temperature sensors, + etc. + + This driver provides battery and AC status support for the mentioned + laptop where this information is not properly exposed via the + standard ACPI devices. + + Say M or Y here to include this support. + + config EC_LENOVO_YOGA_C630 tristate "Lenovo Yoga C630 Embedded Controller driver" depends on ARCH_QCOM || COMPILE_TEST diff --git a/drivers/platform/arm64/Makefile b/drivers/platform/arm64/Makefile index b2ae9114f..46a99eba3 100644 --- a/drivers/platform/arm64/Makefile +++ b/drivers/platform/arm64/Makefile @@ -6,4 +6,5 @@ # obj-$(CONFIG_EC_ACER_ASPIRE1) += acer-aspire1-ec.o +obj-$(CONFIG_EC_HUAWEI_GAOKUN) += huawei-gaokun-ec.o obj-$(CONFIG_EC_LENOVO_YOGA_C630) += lenovo-yoga-c630.o diff --git a/drivers/platform/arm64/huawei-gaokun-ec.c b/drivers/platform/arm64/huawei-gaokun-ec.c new file mode 100644 index 000000000..3cbecc81e --- /dev/null +++ b/drivers/platform/arm64/huawei-gaokun-ec.c @@ -0,0 +1,841 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * huawei-gaokun-ec - An EC driver for HUAWEI Matebook E Go + * + * reference: drivers/platform/arm64/acer-aspire1-ec.c + * drivers/platform/arm64/lenovo-yoga-c630.c + * drivers/platform/x86/huawei-wmi.c + * + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> + */ + +#include <linux/auxiliary_bus.h> +#include <linux/delay.h> +#include <linux/device.h> +#include <linux/hwmon.h> +#include <linux/hwmon-sysfs.h> +#include <linux/i2c.h> +#include <linux/input.h> +#include <linux/notifier.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/platform_data/huawei-gaokun-ec.h> +#include <linux/version.h> + +#define EC_EVENT 0x06 + +/* Also can be found in ACPI specification 12.3 */ +#define EC_READ 0x80 +#define EC_WRITE 0x81 +#define EC_BURST 0x82 +#define EC_QUERY 0x84 + +#define EC_FN_LOCK_ON 0x5A +#define EC_FN_LOCK_OFF 0x55 + +#define EC_EVENT_LID 0x81 + +#define EC_LID_STATE 0x80 +#define EC_LID_OPEN BIT(1) + +#define UCSI_REG_SIZE 7 + +/* + * for tx, command sequences are arranged as + * {master_cmd, slave_cmd, data_len, data_seq} + */ +#define REQ_HDR_SIZE 3 +#define INPUT_SIZE_OFFSET 2 +#define REQ_LEN(req) (REQ_HDR_SIZE + req[INPUT_SIZE_OFFSET]) + +/* + * for rx, data sequences are arranged as + * {status, data_len(unreliable), data_seq} + */ +#define RESP_HDR_SIZE 2 + +#define MKREQ(REG0, REG1, SIZE, ...) \ +{ \ + REG0, REG1, SIZE, \ + /* ## will remove comma when SIZE is 0 */ \ + ## __VA_ARGS__, \ + /* make sure len(pkt[3:]) >= SIZE */ \ + [3 + SIZE] = 0, \ +} + +#define MKRESP(SIZE) \ +{ \ + [RESP_HDR_SIZE + SIZE - 1] = 0, \ +} + +static inline void refill_req(u8 *dest, const u8 *src, size_t size) +{ + memcpy(dest + REQ_HDR_SIZE, src, size); +} + +static inline void extr_resp(u8 *dest, const u8 *src, size_t size) +{ + memcpy(dest, src + RESP_HDR_SIZE, size); +} + +struct gaokun_ec { + struct i2c_client *client; + struct mutex lock; /* EC transaction lock */ + struct blocking_notifier_head notifier_list; + struct device *hwmon_dev; + struct input_dev *idev; + bool suspended; +}; + +static int gaokun_ec_request(struct gaokun_ec *ec, const u8 *req, + size_t resp_len, u8 *resp) +{ + struct i2c_client *client = ec->client; + struct i2c_msg msgs[2] = { + { + .addr = client->addr, + .flags = client->flags, + .len = REQ_LEN(req), + .buf = req, + }, { + .addr = client->addr, + .flags = client->flags | I2C_M_RD, + .len = resp_len, + .buf = resp, + }, + }; + + mutex_lock(&ec->lock); + + i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); + usleep_range(2000, 2500); /* have a break, acpi did this */ + + mutex_unlock(&ec->lock); + + return *resp ? -EIO : 0; +} + +/* -------------------------------------------------------------------------- */ +/* Common API */ + +/** + * gaokun_ec_read - Read from EC + * @ec: The gaokun_ec + * @req: The sequence to request + * @resp_len: The size to read + * @resp: Where the data are read to + * + * Return: 0 on success or negative error code. + * + * This function is used to read data after writing a magic sequence to EC. + * All EC operations depend on this function. + * + * Huawei uses magic sequences everywhere to complete various functions, all + * these sequences are passed to ECCD(a ACPI method which is quiet similar + * to gaokun_ec_request), there is no good abstraction to generalize these + * sequences, so just wrap it for now. Almost all magic sequences are kept + * in this file. + */ +int gaokun_ec_read(struct gaokun_ec *ec, const u8 *req, + size_t resp_len, u8 *resp) +{ + return gaokun_ec_request(ec, req, resp_len, resp); +} +EXPORT_SYMBOL_GPL(gaokun_ec_read); + +/** + * gaokun_ec_write - Write to EC + * @ec: The gaokun_ec + * @req: The sequence to request + * + * Return: 0 on success or negative error code. + * + * This function has no big difference from gaokun_ec_read. When caller care + * only write status and no actual data are returned, then use it. + */ +int gaokun_ec_write(struct gaokun_ec *ec, u8 *req) +{ + u8 resp[] = MKRESP(0); + + return gaokun_ec_request(ec, req, sizeof(resp), resp); +} +EXPORT_SYMBOL_GPL(gaokun_ec_write); + +int gaokun_ec_read_byte(struct gaokun_ec *ec, u8 *req, u8 *byte) +{ + int ret; + u8 resp[] = MKRESP(sizeof(*byte)); + + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); + extr_resp(byte, resp, sizeof(*byte)); + + return ret; +} +EXPORT_SYMBOL_GPL(gaokun_ec_read_byte); + +/** + * gaokun_ec_register_notify - Register a notifier callback for EC events. + * @ec: The gaokun_ec + * @nb: Notifier block pointer to register + * + * Return: 0 on success or negative error code. + */ +int gaokun_ec_register_notify(struct gaokun_ec *ec, struct notifier_block *nb) +{ + return blocking_notifier_chain_register(&ec->notifier_list, nb); +} +EXPORT_SYMBOL_GPL(gaokun_ec_register_notify); + +/** + * gaokun_ec_unregister_notify - Unregister notifier callback for EC events. + * @ec: The gaokun_ec + * @nb: Notifier block pointer to unregister + * + * Unregister a notifier callback that was previously registered with + * gaokun_ec_register_notify(). + */ +void gaokun_ec_unregister_notify(struct gaokun_ec *ec, struct notifier_block *nb) +{ + blocking_notifier_chain_unregister(&ec->notifier_list, nb); +} +EXPORT_SYMBOL_GPL(gaokun_ec_unregister_notify); + +/* -------------------------------------------------------------------------- */ +/* API For PSY */ + +/** + * gaokun_ec_psy_multi_read - Read contiguous registers + * @ec: The gaokun_ec + * @reg: The start register + * @resp_len: The number of registers to be read + * @resp: Where the data are read to + * + * Return: 0 on success or negative error code. + */ +int gaokun_ec_psy_multi_read(struct gaokun_ec *ec, u8 reg, + size_t resp_len, u8 *resp) +{ + int i, ret; + u8 _resp[] = MKRESP(1); + u8 req[] = MKREQ(0x02, EC_READ, 1, 0); + + for (i = 0; i < resp_len; ++i, reg++) { + refill_req(req, ®, 1); + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); + if (ret) + return ret; + extr_resp(&resp[i], _resp, 1); + } + + return 0; +} +EXPORT_SYMBOL_GPL(gaokun_ec_psy_multi_read); + +/* Smart charge */ +#define are_thresholds_valid(start, end) ((end != 0) && (start <= end) && (end <= 100)) + +/** + * gaokun_ec_psy_get_smart_charge - read smart charge data from EC + * @ec: The gaokun_ec + * @data: Where the data are read to, (mode, delay, start, end) + * + * Return: 0 on success or negative error code. + */ +int gaokun_ec_psy_get_smart_charge(struct gaokun_ec *ec, + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]) +{ + /* GBCM */ + u8 req[] = MKREQ(0x02, 0xE4, 0); + u8 resp[] = MKRESP(GAOKUN_SMART_CHARGE_DATA_SIZE); + int ret; + + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); + if (ret) + return ret; + + extr_resp(data, resp, GAOKUN_SMART_CHARGE_DATA_SIZE); + + return 0; +} +EXPORT_SYMBOL_GPL(gaokun_ec_psy_get_smart_charge); + +/** + * gaokun_ec_psy_set_smart_charge - set smart charge data + * @ec: The gaokun_ec + * @data: The data are to be set + * + * Return: 0 on success or negative error code. + */ +int gaokun_ec_psy_set_smart_charge(struct gaokun_ec *ec, + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]) +{ + /* SBCM */ + u8 req[] = MKREQ(0x02, 0XE3, GAOKUN_SMART_CHARGE_DATA_SIZE); + + if (!are_thresholds_valid(data[2], data[3])) + return -EINVAL; + + refill_req(req, data, GAOKUN_SMART_CHARGE_DATA_SIZE); + + return gaokun_ec_write(ec, req); +} +EXPORT_SYMBOL_GPL(gaokun_ec_psy_set_smart_charge); + +/* Smart charge enable */ +/** + * gaokun_ec_psy_get_smart_charge_enable - check if smart charge is enabled + * @ec: The gaokun_ec + * @on: The state + * + * Return: 0 on success or negative error code. + */ +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on) +{ + /* GBAC */ + *on = 0; /* clear other 3 Bytes */ + return gaokun_ec_read_byte(ec, (u8 [])MKREQ(0x02, 0xE6, 0), (u8 *)on); +} +EXPORT_SYMBOL_GPL(gaokun_ec_psy_get_smart_charge_enable); + +/** + * gaokun_ec_psy_set_smart_charge_enable - set smart charge state + * @ec: The gaokun_ec + * @on: The state + * + * Return: 0 on success or negative error code. + */ +int gaokun_ec_psy_set_smart_charge_enable(struct gaokun_ec *ec, bool on) +{ + /* SBAC */ + return gaokun_ec_write(ec, (u8 [])MKREQ(0x02, 0xE5, 1, on)); +} +EXPORT_SYMBOL_GPL(gaokun_ec_psy_set_smart_charge_enable); + +/* -------------------------------------------------------------------------- */ +/* API For UCSI */ + +/** + * gaokun_ec_ucsi_read - read ucsi data from EC, like CCI, MSGI + * @ec: The gaokun_ec + * @resp: Where the data are read to + * + * Return: 0 on success or negative error code. + * + * UCSI subdriver uses this function to read CCI and MSGI. + */ +int gaokun_ec_ucsi_read(struct gaokun_ec *ec, + u8 resp[GAOKUN_UCSI_READ_SIZE]) +{ + u8 req[] = MKREQ(0x03, 0xD5, 0); + u8 _resp[] = MKRESP(GAOKUN_UCSI_READ_SIZE); + int ret; + + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); + if (ret) + return ret; + + extr_resp(resp, _resp, GAOKUN_UCSI_READ_SIZE); + return 0; +} +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_read); + +/** + * gaokun_ec_ucsi_write - write ucsi data to EC + * @ec: The gaokun_ec + * @req: The command + * + * Return: 0 on success or negative error code. + * + * UCSI subdriver uses this function to write control command. + */ +int gaokun_ec_ucsi_write(struct gaokun_ec *ec, + const u8 req[GAOKUN_UCSI_WRITE_SIZE]) +{ + u8 _req[] = MKREQ(0x03, 0xD4, GAOKUN_UCSI_WRITE_SIZE); + + refill_req(_req, req, GAOKUN_UCSI_WRITE_SIZE); + + return gaokun_ec_write(ec, _req); +} +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_write); + +/** + * gaokun_ec_ucsi_get_reg - get ucsi register from EC + * @ec: The gaokun_ec + * @ureg: The gaokun ucsi register + * + * Return: 0 on success or negative error code. + * + * UCSI subdriver uses this function to get ucsi register from EC. + */ +int gaokun_ec_ucsi_get_reg(struct gaokun_ec *ec, + struct gaokun_ucsi_reg *ureg) +{ + u8 req[] = MKREQ(0x03, 0xD3, 0); + u8 _resp[] = MKRESP(UCSI_REG_SIZE); + int ret; + + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); + if (ret) + return ret; + + extr_resp((u8 *)ureg, _resp, UCSI_REG_SIZE); + + return 0; +} +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_get_reg); + +/** + * gaokun_ec_ucsi_pan_ack - ack pin assignment notifications from EC + * @ec: The gaokun_ec + * @port_id: The id of port which just received and handled the notifications + * + * Return: 0 on success or negative error code. + * + * UCSI subdriver uses this function to ack PANs from EC. + */ +int gaokun_ec_ucsi_pan_ack(struct gaokun_ec *ec, int port_id) +{ + u8 req[] = MKREQ(0x03, 0xD2, 1); + u8 data = 1 << port_id; + + if (port_id == GAOKUN_UCSI_NO_PORT_UPDATE) + data = 0; + + refill_req(req, &data, 1); + + return gaokun_ec_write(ec, req); +} +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_pan_ack); + +/* -------------------------------------------------------------------------- */ +/* EC Sysfs */ + +/* Fn lock */ +static int gaokun_ec_get_fn_lock(struct gaokun_ec *ec, bool *on) +{ + /* GFRS */ + u8 req[] = MKREQ(0x02, 0x6B, 0); + int ret; + u8 val; + + ret = gaokun_ec_read_byte(ec, req, &val); + if (ret) + return ret; + + if (val == EC_FN_LOCK_ON) + *on = true; + else if (val == EC_FN_LOCK_OFF) + *on = false; + else + return -EIO; + + return 0; +} + +static int gaokun_ec_set_fn_lock(struct gaokun_ec *ec, bool on) +{ + /* SFRS */ + u8 req[] = MKREQ(0x02, 0x6C, 1); + u8 data; + + if (on) + data = EC_FN_LOCK_ON; + else + data = EC_FN_LOCK_OFF; + + refill_req(req, &data, 1); + + return gaokun_ec_write(ec, req); +} + +static ssize_t fn_lock_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct gaokun_ec *ec = dev_get_drvdata(dev); + bool on; + int ret; + + ret = gaokun_ec_get_fn_lock(ec, &on); + if (ret) + return ret; + + return sysfs_emit(buf, "%d\n", on); +} + +static ssize_t fn_lock_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t size) +{ + struct gaokun_ec *ec = dev_get_drvdata(dev); + bool on; + int ret; + + if (kstrtobool(buf, &on)) + return -EINVAL; + + ret = gaokun_ec_set_fn_lock(ec, on); + if (ret) + return ret; + + return size; +} + +static DEVICE_ATTR_RW(fn_lock); + +static struct attribute *gaokun_ec_attrs[] = { + &dev_attr_fn_lock.attr, + NULL, +}; +ATTRIBUTE_GROUPS(gaokun_ec); + +/* Thermal Zone HwMon */ +/* Range from 0 to 0x2C, partial valid */ +static const u8 temp_reg[20] = {0x05, 0x07, 0x08, 0x0E, 0x0F, 0x12, 0x15, 0x1E, + 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, + 0x27, 0x28, 0x29, 0x2A}; + +static int gaokun_ec_get_temp(struct gaokun_ec *ec, u8 idx, int *temp) +{ + /* GTMP */ + u8 req[] = MKREQ(0x02, 0x61, 1, temp_reg[idx]); + u8 resp[] = MKRESP(sizeof(__le16)); + __le16 tmp; + int ret; + + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); + if (ret) + return ret; + + extr_resp((u8 *)&tmp, resp, sizeof(tmp)); + *temp = le16_to_cpu(tmp) * 100; /* convert to HwMon's unit */ + + return 0; +} + +static ssize_t get_ec_tz_temp(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct gaokun_ec *ec = dev_get_drvdata(dev); + int idx, ret, temp; + + idx = (to_sensor_dev_attr(attr))->index - 1; + ret = gaokun_ec_get_temp(ec, idx, &temp); + if (ret) + return ret; + + return sysfs_emit(buf, "%d\n", temp); +} + +static ssize_t ec_tz_temp_label(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + int idx = (to_sensor_dev_attr(attr))->index - 1; + + return sysfs_emit(buf, "EC Thermal Zone %2d Temperature\n", idx); +} + +static SENSOR_DEVICE_ATTR(temp1_input, 0444, get_ec_tz_temp, NULL, 1); +static SENSOR_DEVICE_ATTR(temp1_label, 0444, ec_tz_temp_label, NULL, 1); +static SENSOR_DEVICE_ATTR(temp2_input, 0444, get_ec_tz_temp, NULL, 2); +static SENSOR_DEVICE_ATTR(temp2_label, 0444, ec_tz_temp_label, NULL, 2); +static SENSOR_DEVICE_ATTR(temp3_input, 0444, get_ec_tz_temp, NULL, 3); +static SENSOR_DEVICE_ATTR(temp3_label, 0444, ec_tz_temp_label, NULL, 3); +static SENSOR_DEVICE_ATTR(temp4_input, 0444, get_ec_tz_temp, NULL, 4); +static SENSOR_DEVICE_ATTR(temp4_label, 0444, ec_tz_temp_label, NULL, 4); +static SENSOR_DEVICE_ATTR(temp5_input, 0444, get_ec_tz_temp, NULL, 5); +static SENSOR_DEVICE_ATTR(temp5_label, 0444, ec_tz_temp_label, NULL, 5); +static SENSOR_DEVICE_ATTR(temp6_input, 0444, get_ec_tz_temp, NULL, 6); +static SENSOR_DEVICE_ATTR(temp6_label, 0444, ec_tz_temp_label, NULL, 6); +static SENSOR_DEVICE_ATTR(temp7_input, 0444, get_ec_tz_temp, NULL, 7); +static SENSOR_DEVICE_ATTR(temp7_label, 0444, ec_tz_temp_label, NULL, 7); +static SENSOR_DEVICE_ATTR(temp8_input, 0444, get_ec_tz_temp, NULL, 8); +static SENSOR_DEVICE_ATTR(temp8_label, 0444, ec_tz_temp_label, NULL, 8); +static SENSOR_DEVICE_ATTR(temp9_input, 0444, get_ec_tz_temp, NULL, 9); +static SENSOR_DEVICE_ATTR(temp9_label, 0444, ec_tz_temp_label, NULL, 9); +static SENSOR_DEVICE_ATTR(temp10_input, 0444, get_ec_tz_temp, NULL, 10); +static SENSOR_DEVICE_ATTR(temp10_label, 0444, ec_tz_temp_label, NULL, 10); +static SENSOR_DEVICE_ATTR(temp11_input, 0444, get_ec_tz_temp, NULL, 11); +static SENSOR_DEVICE_ATTR(temp11_label, 0444, ec_tz_temp_label, NULL, 11); +static SENSOR_DEVICE_ATTR(temp12_input, 0444, get_ec_tz_temp, NULL, 12); +static SENSOR_DEVICE_ATTR(temp12_label, 0444, ec_tz_temp_label, NULL, 12); +static SENSOR_DEVICE_ATTR(temp13_input, 0444, get_ec_tz_temp, NULL, 13); +static SENSOR_DEVICE_ATTR(temp13_label, 0444, ec_tz_temp_label, NULL, 13); +static SENSOR_DEVICE_ATTR(temp14_input, 0444, get_ec_tz_temp, NULL, 14); +static SENSOR_DEVICE_ATTR(temp14_label, 0444, ec_tz_temp_label, NULL, 14); +static SENSOR_DEVICE_ATTR(temp15_input, 0444, get_ec_tz_temp, NULL, 15); +static SENSOR_DEVICE_ATTR(temp15_label, 0444, ec_tz_temp_label, NULL, 15); +static SENSOR_DEVICE_ATTR(temp16_input, 0444, get_ec_tz_temp, NULL, 16); +static SENSOR_DEVICE_ATTR(temp16_label, 0444, ec_tz_temp_label, NULL, 16); +static SENSOR_DEVICE_ATTR(temp17_input, 0444, get_ec_tz_temp, NULL, 17); +static SENSOR_DEVICE_ATTR(temp17_label, 0444, ec_tz_temp_label, NULL, 17); +static SENSOR_DEVICE_ATTR(temp18_input, 0444, get_ec_tz_temp, NULL, 18); +static SENSOR_DEVICE_ATTR(temp18_label, 0444, ec_tz_temp_label, NULL, 18); +static SENSOR_DEVICE_ATTR(temp19_input, 0444, get_ec_tz_temp, NULL, 19); +static SENSOR_DEVICE_ATTR(temp19_label, 0444, ec_tz_temp_label, NULL, 19); +static SENSOR_DEVICE_ATTR(temp20_input, 0444, get_ec_tz_temp, NULL, 20); +static SENSOR_DEVICE_ATTR(temp20_label, 0444, ec_tz_temp_label, NULL, 20); + +static struct attribute *gaokun_ec_hwmon_attrs[] = { + &sensor_dev_attr_temp1_input.dev_attr.attr, + &sensor_dev_attr_temp1_label.dev_attr.attr, + &sensor_dev_attr_temp2_input.dev_attr.attr, + &sensor_dev_attr_temp2_label.dev_attr.attr, + &sensor_dev_attr_temp3_input.dev_attr.attr, + &sensor_dev_attr_temp3_label.dev_attr.attr, + &sensor_dev_attr_temp4_input.dev_attr.attr, + &sensor_dev_attr_temp4_label.dev_attr.attr, + &sensor_dev_attr_temp5_input.dev_attr.attr, + &sensor_dev_attr_temp5_label.dev_attr.attr, + &sensor_dev_attr_temp6_input.dev_attr.attr, + &sensor_dev_attr_temp6_label.dev_attr.attr, + &sensor_dev_attr_temp7_input.dev_attr.attr, + &sensor_dev_attr_temp7_label.dev_attr.attr, + &sensor_dev_attr_temp8_input.dev_attr.attr, + &sensor_dev_attr_temp8_label.dev_attr.attr, + &sensor_dev_attr_temp9_input.dev_attr.attr, + &sensor_dev_attr_temp9_label.dev_attr.attr, + &sensor_dev_attr_temp10_input.dev_attr.attr, + &sensor_dev_attr_temp10_label.dev_attr.attr, + &sensor_dev_attr_temp11_input.dev_attr.attr, + &sensor_dev_attr_temp11_label.dev_attr.attr, + &sensor_dev_attr_temp12_input.dev_attr.attr, + &sensor_dev_attr_temp12_label.dev_attr.attr, + &sensor_dev_attr_temp13_input.dev_attr.attr, + &sensor_dev_attr_temp13_label.dev_attr.attr, + &sensor_dev_attr_temp14_input.dev_attr.attr, + &sensor_dev_attr_temp14_label.dev_attr.attr, + &sensor_dev_attr_temp15_input.dev_attr.attr, + &sensor_dev_attr_temp15_label.dev_attr.attr, + &sensor_dev_attr_temp16_input.dev_attr.attr, + &sensor_dev_attr_temp16_label.dev_attr.attr, + &sensor_dev_attr_temp17_input.dev_attr.attr, + &sensor_dev_attr_temp17_label.dev_attr.attr, + &sensor_dev_attr_temp18_input.dev_attr.attr, + &sensor_dev_attr_temp18_label.dev_attr.attr, + &sensor_dev_attr_temp19_input.dev_attr.attr, + &sensor_dev_attr_temp19_label.dev_attr.attr, + &sensor_dev_attr_temp20_input.dev_attr.attr, + &sensor_dev_attr_temp20_label.dev_attr.attr, + NULL +}; +ATTRIBUTE_GROUPS(gaokun_ec_hwmon); + +/* -------------------------------------------------------------------------- */ +/* Modern Standby */ + +static int gaokun_ec_suspend(struct device *dev) +{ + struct gaokun_ec *ec = dev_get_drvdata(dev); + u8 req[] = MKREQ(0x02, 0xB2, 1, 0xDB); + int ret; + + if (ec->suspended) + return 0; + + ret = gaokun_ec_write(ec, req); + + if (ret) + return ret; + + ec->suspended = true; + + return 0; +} + +static int gaokun_ec_resume(struct device *dev) +{ + struct gaokun_ec *ec = dev_get_drvdata(dev); + u8 req[] = MKREQ(0x02, 0xB2, 1, 0xEB); + int ret; + int i; + + if (!ec->suspended) + return 0; + + for (i = 0; i < 3; ++i) { + ret = gaokun_ec_write(ec, req); + if (ret == 0) + break; + + msleep(100); /* EC need time to resume */ + }; + + ec->suspended = false; + + return 0; +} + +static void gaokun_aux_release(struct device *dev) +{ + struct auxiliary_device *adev = to_auxiliary_dev(dev); + + kfree(adev); +} + +static void gaokun_aux_remove(void *data) +{ + struct auxiliary_device *adev = data; + + auxiliary_device_delete(adev); + auxiliary_device_uninit(adev); +} + +static int gaokun_aux_init(struct device *parent, const char *name, + struct gaokun_ec *ec) +{ + struct auxiliary_device *adev; + int ret; + + adev = kzalloc(sizeof(*adev), GFP_KERNEL); + if (!adev) + return -ENOMEM; + + adev->name = name; + adev->id = 0; + adev->dev.parent = parent; + adev->dev.release = gaokun_aux_release; + adev->dev.platform_data = ec; + /* Allow aux devices to access parent's DT nodes directly */ + device_set_of_node_from_dev(&adev->dev, parent); + + ret = auxiliary_device_init(adev); + if (ret) { + kfree(adev); + return ret; + } + + ret = auxiliary_device_add(adev); + if (ret) { + auxiliary_device_uninit(adev); + return ret; + } + + return devm_add_action_or_reset(parent, gaokun_aux_remove, adev); +} + +/* -------------------------------------------------------------------------- */ +/* EC */ + +static irqreturn_t gaokun_ec_irq_handler(int irq, void *data) +{ + struct gaokun_ec *ec = data; + u8 req[] = MKREQ(EC_EVENT, EC_QUERY, 0); + u8 status, id; + int ret; + + ret = gaokun_ec_read_byte(ec, req, &id); + if (ret) + return IRQ_HANDLED; + + switch (id) { + case 0x0: /* No event */ + break; + + case EC_EVENT_LID: + gaokun_ec_psy_read_byte(ec, EC_LID_STATE, &status); + status = EC_LID_OPEN & status; + input_report_switch(ec->idev, SW_LID, !status); + input_sync(ec->idev); + break; + + default: + blocking_notifier_call_chain(&ec->notifier_list, id, ec); + } + + return IRQ_HANDLED; +} + +static int gaokun_ec_probe(struct i2c_client *client) +{ + struct device *dev = &client->dev; + struct gaokun_ec *ec; + int ret; + + ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL); + if (!ec) + return -ENOMEM; + + mutex_init(&ec->lock); + ec->client = client; + i2c_set_clientdata(client, ec); + BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list); + + /* Lid switch */ + ec->idev = devm_input_allocate_device(dev); + if (!ec->idev) + return -ENOMEM; + + ec->idev->name = "LID"; + ec->idev->phys = "gaokun-ec/input0"; + input_set_capability(ec->idev, EV_SW, SW_LID); + + ret = input_register_device(ec->idev); + if (ret) + return dev_err_probe(dev, ret, "Failed to register input device\n"); + + ret = gaokun_aux_init(dev, "psy", ec); + if (ret) + return ret; + + ret = gaokun_aux_init(dev, "ucsi", ec); + if (ret) + return ret; + + ret = devm_request_threaded_irq(dev, client->irq, NULL, + gaokun_ec_irq_handler, IRQF_ONESHOT, + dev_name(dev), ec); + if (ret) + return dev_err_probe(dev, ret, "Failed to request irq\n"); + + ec->hwmon_dev = hwmon_device_register_with_groups(dev, "gaokun_ec_hwmon", + ec, gaokun_ec_hwmon_groups); + if (IS_ERR(ec->hwmon_dev)) { + dev_err(dev, "Failed to register hwmon device\n"); + return PTR_ERR(ec->hwmon_dev); + } + + return 0; +} + +static void gaokun_ec_remove(struct i2c_client *client) +{ + struct gaokun_ec *ec = i2c_get_clientdata(client); + hwmon_device_unregister(ec->hwmon_dev); +} + +static const struct i2c_device_id gaokun_ec_id[] = { + { "gaokun-ec", }, + { } +}; +MODULE_DEVICE_TABLE(i2c, gaokun_ec_id); + +static const struct of_device_id gaokun_ec_of_match[] = { + { .compatible = "huawei,gaokun3-ec", }, + { } +}; +MODULE_DEVICE_TABLE(of, gaokun_ec_of_match); + +static const struct dev_pm_ops gaokun_ec_pm_ops = { + NOIRQ_SYSTEM_SLEEP_PM_OPS(gaokun_ec_suspend, gaokun_ec_resume) +}; + +static struct i2c_driver gaokun_ec_driver = { + .driver = { + .name = "gaokun-ec", + .of_match_table = gaokun_ec_of_match, + .pm = &gaokun_ec_pm_ops, + .dev_groups = gaokun_ec_groups, + }, + .probe = gaokun_ec_probe, + .remove = gaokun_ec_remove, + .id_table = gaokun_ec_id, +}; +module_i2c_driver(gaokun_ec_driver); + +MODULE_DESCRIPTION("HUAWEI Matebook E Go EC driver"); +MODULE_AUTHOR("Pengyu Luo <mitltlatltl@gmail.com>"); +MODULE_LICENSE("GPL"); diff --git a/include/linux/platform_data/huawei-gaokun-ec.h b/include/linux/platform_data/huawei-gaokun-ec.h new file mode 100644 index 000000000..dfd177bd9 --- /dev/null +++ b/include/linux/platform_data/huawei-gaokun-ec.h @@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Huawei Matebook E Go Embedded Controller + * + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> + */ + +#ifndef __HUAWEI_GAOKUN_EC_H__ +#define __HUAWEI_GAOKUN_EC_H__ + +#define GAOKUN_UCSI_CCI_SIZE 4 +#define GAOKUN_UCSI_DATA_SIZE 16 +#define GAOKUN_UCSI_READ_SIZE (GAOKUN_UCSI_CCI_SIZE + GAOKUN_UCSI_DATA_SIZE) +#define GAOKUN_UCSI_WRITE_SIZE 0x18 + +#define GAOKUN_UCSI_NO_PORT_UPDATE (-1) + +#define GAOKUN_SMART_CHARGE_DATA_SIZE 4 /* mode, delay, start, end */ + +/* -------------------------------------------------------------------------- */ + +struct gaokun_ec; +struct gaokun_ucsi_reg; +struct notifier_block; + +#define GAOKUN_MOD_NAME "huawei_gaokun_ec" +#define GAOKUN_DEV_PSY "psy" +#define GAOKUN_DEV_UCSI "ucsi" + +/* -------------------------------------------------------------------------- */ +/* Common API */ + +int gaokun_ec_register_notify(struct gaokun_ec *ec, + struct notifier_block *nb); +void gaokun_ec_unregister_notify(struct gaokun_ec *ec, + struct notifier_block *nb); + +int gaokun_ec_read(struct gaokun_ec *ec, const u8 *req, + size_t resp_len, u8 *resp); +int gaokun_ec_write(struct gaokun_ec *ec, u8 *req); +int gaokun_ec_read_byte(struct gaokun_ec *ec, u8 *req, u8 *byte); + +/* -------------------------------------------------------------------------- */ +/* API For PSY */ + +int gaokun_ec_psy_multi_read(struct gaokun_ec *ec, u8 reg, + size_t resp_len, u8 *resp); + +static inline int gaokun_ec_psy_read_byte(struct gaokun_ec *ec, + u8 reg, u8 *byte) +{ + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*byte), byte); +} + +static inline int gaokun_ec_psy_read_word(struct gaokun_ec *ec, + u8 reg, u16 *word) +{ + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*word), (u8 *)word); +} + +int gaokun_ec_psy_get_smart_charge(struct gaokun_ec *ec, + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); +int gaokun_ec_psy_set_smart_charge(struct gaokun_ec *ec, + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); + +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on); +int gaokun_ec_psy_set_smart_charge_enable(struct gaokun_ec *ec, bool on); + +/* -------------------------------------------------------------------------- */ +/* API For UCSI */ + +int gaokun_ec_ucsi_read(struct gaokun_ec *ec, u8 resp[GAOKUN_UCSI_READ_SIZE]); +int gaokun_ec_ucsi_write(struct gaokun_ec *ec, + const u8 req[GAOKUN_UCSI_WRITE_SIZE]); + +int gaokun_ec_ucsi_get_reg(struct gaokun_ec *ec, struct gaokun_ucsi_reg *ureg); +int gaokun_ec_ucsi_pan_ack(struct gaokun_ec *ec, int port_id); + + +#endif /* __HUAWEI_GAOKUN_EC_H__ */ -- 2.47.1 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver 2025-01-13 17:50 ` [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver Pengyu Luo @ 2025-01-13 18:34 ` Guenter Roeck 2025-01-13 18:56 ` Ilpo Järvinen 2025-01-16 12:02 ` Heikki Krogerus 2 siblings, 0 replies; 20+ messages in thread From: Guenter Roeck @ 2025-01-13 18:34 UTC (permalink / raw) To: Pengyu Luo, Rob Herring, Krzysztof Kozlowski, Conor Dooley, Bjorn Andersson, Konrad Dybcio, Hans de Goede, Ilpo Järvinen, Bryan O'Donoghue, Sebastian Reichel, Heikki Krogerus, Greg Kroah-Hartman, Jean Delvare Cc: devicetree, linux-kernel, linux-arm-msm, platform-driver-x86, linux-pm, linux-usb, linux-hwmon On 1/13/25 09:50, Pengyu Luo wrote: > There are three variants of which Huawei released the first two > simultaneously. > > Huawei Matebook E Go LTE(sc8180x), codename seems to be gaokun2. > Huawei Matebook E Go(sc8280xp@3.0GHz), codename must be gaokun3. (see [1]) > Huawei Matebook E Go 2023(sc8280xp@2.69GHz), codename should be also gaokun3. > > Adding support for the latter two variants for now, this driver should > also work for the sc8180x variant according to acpi table files, but I > don't have the device to test yet. > > Different from other Qualcomm Snapdragon sc8280xp based machines, the > Huawei Matebook E Go uses an embedded controller while others use > a system called PMIC GLink. This embedded controller can be used to > perform a set of various functions, including, but not limited to: > > - Battery and charger monitoring; > - Charge control and smart charge; > - Fn_lock settings; > - Tablet lid status; > - Temperature sensors; > - USB Type-C notifications (ports orientation, DP alt mode HPD); > - USB Type-C PD (according to observation, up to 48w). > > Add a driver for the EC which creates devices for UCSI and power supply > devices. > > [1] https://bugzilla.kernel.org/show_bug.cgi?id=219645 > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > --- ... > + ec->hwmon_dev = hwmon_device_register_with_groups(dev, "gaokun_ec_hwmon", > + ec, gaokun_ec_hwmon_groups); This API function is deprecated. Guenter ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver 2025-01-13 17:50 ` [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver Pengyu Luo 2025-01-13 18:34 ` Guenter Roeck @ 2025-01-13 18:56 ` Ilpo Järvinen 2025-01-14 8:31 ` Pengyu Luo 2025-01-16 12:02 ` Heikki Krogerus 2 siblings, 1 reply; 20+ messages in thread From: Ilpo Järvinen @ 2025-01-13 18:56 UTC (permalink / raw) To: Pengyu Luo Cc: Rob Herring, Krzysztof Kozlowski, Conor Dooley, Bjorn Andersson, Konrad Dybcio, Hans de Goede, Bryan O'Donoghue, Sebastian Reichel, Heikki Krogerus, Greg Kroah-Hartman, Jean Delvare, Guenter Roeck, devicetree, LKML, linux-arm-msm, platform-driver-x86, linux-pm, linux-usb, linux-hwmon On Tue, 14 Jan 2025, Pengyu Luo wrote: > There are three variants of which Huawei released the first two > simultaneously. > > Huawei Matebook E Go LTE(sc8180x), codename seems to be gaokun2. > Huawei Matebook E Go(sc8280xp@3.0GHz), codename must be gaokun3. (see [1]) > Huawei Matebook E Go 2023(sc8280xp@2.69GHz), codename should be also gaokun3. > > Adding support for the latter two variants for now, this driver should > also work for the sc8180x variant according to acpi table files, but I > don't have the device to test yet. > > Different from other Qualcomm Snapdragon sc8280xp based machines, the > Huawei Matebook E Go uses an embedded controller while others use > a system called PMIC GLink. This embedded controller can be used to > perform a set of various functions, including, but not limited to: > > - Battery and charger monitoring; > - Charge control and smart charge; > - Fn_lock settings; > - Tablet lid status; > - Temperature sensors; > - USB Type-C notifications (ports orientation, DP alt mode HPD); > - USB Type-C PD (according to observation, up to 48w). > > Add a driver for the EC which creates devices for UCSI and power supply > devices. > > [1] https://bugzilla.kernel.org/show_bug.cgi?id=219645 > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > --- > MAINTAINERS | 9 + > drivers/platform/arm64/Kconfig | 21 + > drivers/platform/arm64/Makefile | 1 + > drivers/platform/arm64/huawei-gaokun-ec.c | 841 ++++++++++++++++++ > .../linux/platform_data/huawei-gaokun-ec.h | 80 ++ > 5 files changed, 952 insertions(+) > create mode 100644 drivers/platform/arm64/huawei-gaokun-ec.c > create mode 100644 include/linux/platform_data/huawei-gaokun-ec.h > > diff --git a/MAINTAINERS b/MAINTAINERS > index 520612b3d..0f9e0390a 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -10691,6 +10691,15 @@ S: Maintained > F: Documentation/networking/device_drivers/ethernet/huawei/hinic.rst > F: drivers/net/ethernet/huawei/hinic/ > > +HUAWEI MATEBOOK E GO EMBEDDED CONTROLLER DRIVER > +M: Pengyu Luo <mitltlatltl@gmail.com> > +S: Maintained > +F: Documentation/devicetree/bindings/platform/huawei,gaokun-ec.yaml > +F: drivers/platform/arm64/huawei-gaokun-ec.c > +F: drivers/power/supply/huawei-gaokun-battery.c > +F: drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > +F: include/linux/platform_data/huawei-gaokun-ec.h > + > HUGETLB SUBSYSTEM > M: Muchun Song <muchun.song@linux.dev> > L: linux-mm@kvack.org > diff --git a/drivers/platform/arm64/Kconfig b/drivers/platform/arm64/Kconfig > index f88395ea3..67dc7aa95 100644 > --- a/drivers/platform/arm64/Kconfig > +++ b/drivers/platform/arm64/Kconfig > @@ -33,6 +33,27 @@ config EC_ACER_ASPIRE1 > laptop where this information is not properly exposed via the > standard ACPI devices. > > +config EC_HUAWEI_GAOKUN > + tristate "Huawei Matebook E Go Embedded Controller driver" > + depends on ARCH_QCOM || COMPILE_TEST > + depends on I2C > + depends on DRM > + depends on POWER_SUPPLY > + depends on INPUT > + help > + Say Y here to enable the EC driver for the Huawei Matebook E Go > + which is a sc8280xp-based 2-in-1 tablet. The driver handles battery > + (information, charge control) and USB Type-C DP HPD events as well > + as some misc functions like the lid sensor and temperature sensors, > + etc. > + > + This driver provides battery and AC status support for the mentioned > + laptop where this information is not properly exposed via the > + standard ACPI devices. > + > + Say M or Y here to include this support. > + > + > config EC_LENOVO_YOGA_C630 > tristate "Lenovo Yoga C630 Embedded Controller driver" > depends on ARCH_QCOM || COMPILE_TEST > diff --git a/drivers/platform/arm64/Makefile b/drivers/platform/arm64/Makefile > index b2ae9114f..46a99eba3 100644 > --- a/drivers/platform/arm64/Makefile > +++ b/drivers/platform/arm64/Makefile > @@ -6,4 +6,5 @@ > # > > obj-$(CONFIG_EC_ACER_ASPIRE1) += acer-aspire1-ec.o > +obj-$(CONFIG_EC_HUAWEI_GAOKUN) += huawei-gaokun-ec.o > obj-$(CONFIG_EC_LENOVO_YOGA_C630) += lenovo-yoga-c630.o > diff --git a/drivers/platform/arm64/huawei-gaokun-ec.c b/drivers/platform/arm64/huawei-gaokun-ec.c > new file mode 100644 > index 000000000..3cbecc81e > --- /dev/null > +++ b/drivers/platform/arm64/huawei-gaokun-ec.c > @@ -0,0 +1,841 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * huawei-gaokun-ec - An EC driver for HUAWEI Matebook E Go > + * > + * reference: drivers/platform/arm64/acer-aspire1-ec.c > + * drivers/platform/arm64/lenovo-yoga-c630.c > + * drivers/platform/x86/huawei-wmi.c What's the purpose of these? Should they rather be e.g. in the commit message? > + * > + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> -2025? > + */ > + > +#include <linux/auxiliary_bus.h> > +#include <linux/delay.h> > +#include <linux/device.h> > +#include <linux/hwmon.h> > +#include <linux/hwmon-sysfs.h> > +#include <linux/i2c.h> > +#include <linux/input.h> > +#include <linux/notifier.h> > +#include <linux/module.h> > +#include <linux/mutex.h> > +#include <linux/platform_data/huawei-gaokun-ec.h> > +#include <linux/version.h> Why is version.h needed? > + > +#define EC_EVENT 0x06 > + > +/* Also can be found in ACPI specification 12.3 */ > +#define EC_READ 0x80 > +#define EC_WRITE 0x81 > +#define EC_BURST 0x82 > +#define EC_QUERY 0x84 > + > +#define EC_FN_LOCK_ON 0x5A > +#define EC_FN_LOCK_OFF 0x55 > + > +#define EC_EVENT_LID 0x81 > + > +#define EC_LID_STATE 0x80 > +#define EC_LID_OPEN BIT(1) > + > +#define UCSI_REG_SIZE 7 > + > +/* > + * for tx, command sequences are arranged as For > + * {master_cmd, slave_cmd, data_len, data_seq} > + */ > +#define REQ_HDR_SIZE 3 > +#define INPUT_SIZE_OFFSET 2 > +#define REQ_LEN(req) (REQ_HDR_SIZE + req[INPUT_SIZE_OFFSET]) > + > +/* > + * for rx, data sequences are arranged as For > + * {status, data_len(unreliable), data_seq} > + */ > +#define RESP_HDR_SIZE 2 > + > +#define MKREQ(REG0, REG1, SIZE, ...) \ > +{ \ > + REG0, REG1, SIZE, \ > + /* ## will remove comma when SIZE is 0 */ \ > + ## __VA_ARGS__, \ > + /* make sure len(pkt[3:]) >= SIZE */ \ > + [3 + SIZE] = 0, \ > +} > + > +#define MKRESP(SIZE) \ > +{ \ > + [RESP_HDR_SIZE + SIZE - 1] = 0, \ > +} > + > +static inline void refill_req(u8 *dest, const u8 *src, size_t size) > +{ > + memcpy(dest + REQ_HDR_SIZE, src, size); > +} > + > +static inline void extr_resp(u8 *dest, const u8 *src, size_t size) > +{ > + memcpy(dest, src + RESP_HDR_SIZE, size); > +} > + > +struct gaokun_ec { > + struct i2c_client *client; > + struct mutex lock; /* EC transaction lock */ > + struct blocking_notifier_head notifier_list; > + struct device *hwmon_dev; > + struct input_dev *idev; > + bool suspended; > +}; > + > +static int gaokun_ec_request(struct gaokun_ec *ec, const u8 *req, > + size_t resp_len, u8 *resp) > +{ > + struct i2c_client *client = ec->client; > + struct i2c_msg msgs[2] = { > + { > + .addr = client->addr, > + .flags = client->flags, > + .len = REQ_LEN(req), > + .buf = req, > + }, { > + .addr = client->addr, > + .flags = client->flags | I2C_M_RD, > + .len = resp_len, > + .buf = resp, > + }, > + }; > + > + mutex_lock(&ec->lock); Use guard(). > + > + i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); > + usleep_range(2000, 2500); /* have a break, acpi did this */ ACPI > + > + mutex_unlock(&ec->lock); > + > + return *resp ? -EIO : 0; > +} > + > +/* -------------------------------------------------------------------------- */ > +/* Common API */ > + > +/** > + * gaokun_ec_read - Read from EC > + * @ec: The gaokun_ec > + * @req: The sequence to request > + * @resp_len: The size to read > + * @resp: Where the data are read to > + * > + * Return: 0 on success or negative error code. > + * > + * This function is used to read data after writing a magic sequence to EC. > + * All EC operations depend on this function. > + * > + * Huawei uses magic sequences everywhere to complete various functions, all > + * these sequences are passed to ECCD(a ACPI method which is quiet similar > + * to gaokun_ec_request), there is no good abstraction to generalize these > + * sequences, so just wrap it for now. Almost all magic sequences are kept > + * in this file. > + */ > +int gaokun_ec_read(struct gaokun_ec *ec, const u8 *req, > + size_t resp_len, u8 *resp) > +{ > + return gaokun_ec_request(ec, req, resp_len, resp); > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_read); > + > +/** > + * gaokun_ec_write - Write to EC > + * @ec: The gaokun_ec > + * @req: The sequence to request > + * > + * Return: 0 on success or negative error code. > + * > + * This function has no big difference from gaokun_ec_read. When caller care > + * only write status and no actual data are returned, then use it. > + */ > +int gaokun_ec_write(struct gaokun_ec *ec, u8 *req) > +{ > + u8 resp[] = MKRESP(0); > + > + return gaokun_ec_request(ec, req, sizeof(resp), resp); > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_write); > + > +int gaokun_ec_read_byte(struct gaokun_ec *ec, u8 *req, u8 *byte) > +{ > + int ret; > + u8 resp[] = MKRESP(sizeof(*byte)); > + > + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); > + extr_resp(byte, resp, sizeof(*byte)); > + > + return ret; > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_read_byte); > + > +/** > + * gaokun_ec_register_notify - Register a notifier callback for EC events. > + * @ec: The gaokun_ec > + * @nb: Notifier block pointer to register > + * > + * Return: 0 on success or negative error code. > + */ > +int gaokun_ec_register_notify(struct gaokun_ec *ec, struct notifier_block *nb) > +{ > + return blocking_notifier_chain_register(&ec->notifier_list, nb); > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_register_notify); > + > +/** > + * gaokun_ec_unregister_notify - Unregister notifier callback for EC events. > + * @ec: The gaokun_ec > + * @nb: Notifier block pointer to unregister > + * > + * Unregister a notifier callback that was previously registered with > + * gaokun_ec_register_notify(). > + */ > +void gaokun_ec_unregister_notify(struct gaokun_ec *ec, struct notifier_block *nb) > +{ > + blocking_notifier_chain_unregister(&ec->notifier_list, nb); > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_unregister_notify); > + > +/* -------------------------------------------------------------------------- */ > +/* API For PSY */ > + > +/** > + * gaokun_ec_psy_multi_read - Read contiguous registers > + * @ec: The gaokun_ec > + * @reg: The start register > + * @resp_len: The number of registers to be read > + * @resp: Where the data are read to > + * > + * Return: 0 on success or negative error code. > + */ > +int gaokun_ec_psy_multi_read(struct gaokun_ec *ec, u8 reg, > + size_t resp_len, u8 *resp) > +{ > + int i, ret; > + u8 _resp[] = MKRESP(1); > + u8 req[] = MKREQ(0x02, EC_READ, 1, 0); > + > + for (i = 0; i < resp_len; ++i, reg++) { > + refill_req(req, ®, 1); > + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); > + if (ret) > + return ret; > + extr_resp(&resp[i], _resp, 1); I'm not a big fan of having resp and _resp named variables. > + } > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_multi_read); > + > +/* Smart charge */ > +#define are_thresholds_valid(start, end) ((end != 0) && (start <= end) && (end <= 100)) Why this cannot be a static function? > + > +/** > + * gaokun_ec_psy_get_smart_charge - read smart charge data from EC > + * @ec: The gaokun_ec > + * @data: Where the data are read to, (mode, delay, start, end) > + * > + * Return: 0 on success or negative error code. > + */ > +int gaokun_ec_psy_get_smart_charge(struct gaokun_ec *ec, > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]) > +{ > + /* GBCM */ > + u8 req[] = MKREQ(0x02, 0xE4, 0); > + u8 resp[] = MKRESP(GAOKUN_SMART_CHARGE_DATA_SIZE); > + int ret; > + > + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); > + if (ret) > + return ret; > + > + extr_resp(data, resp, GAOKUN_SMART_CHARGE_DATA_SIZE); So in the previous func you used _resp and resp as names, and here you have resp and data. Any chance of being consistent in variable naming? > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_get_smart_charge); > + > +/** > + * gaokun_ec_psy_set_smart_charge - set smart charge data > + * @ec: The gaokun_ec > + * @data: The data are to be set > + * > + * Return: 0 on success or negative error code. > + */ > +int gaokun_ec_psy_set_smart_charge(struct gaokun_ec *ec, > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]) > +{ > + /* SBCM */ > + u8 req[] = MKREQ(0x02, 0XE3, GAOKUN_SMART_CHARGE_DATA_SIZE); X -> x > + > + if (!are_thresholds_valid(data[2], data[3])) > + return -EINVAL; > + > + refill_req(req, data, GAOKUN_SMART_CHARGE_DATA_SIZE); > + > + return gaokun_ec_write(ec, req); > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_set_smart_charge); > + > +/* Smart charge enable */ > +/** > + * gaokun_ec_psy_get_smart_charge_enable - check if smart charge is enabled > + * @ec: The gaokun_ec > + * @on: The state > + * > + * Return: 0 on success or negative error code. > + */ > +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on) > +{ > + /* GBAC */ > + *on = 0; /* clear other 3 Bytes */ = false (as it's bool) What that comment means??? The type is bool so what "3 Bytes" ??? > + return gaokun_ec_read_byte(ec, (u8 [])MKREQ(0x02, 0xE6, 0), (u8 *)on); Don't cast bool * to u8 *. Please cleanup the MKREQ mess out of this call like in the other functions above. > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_get_smart_charge_enable); > + > +/** > + * gaokun_ec_psy_set_smart_charge_enable - set smart charge state > + * @ec: The gaokun_ec > + * @on: The state > + * > + * Return: 0 on success or negative error code. > + */ > +int gaokun_ec_psy_set_smart_charge_enable(struct gaokun_ec *ec, bool on) > +{ > + /* SBAC */ > + return gaokun_ec_write(ec, (u8 [])MKREQ(0x02, 0xE5, 1, on)); Ditto. > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_set_smart_charge_enable); > + > +/* -------------------------------------------------------------------------- */ > +/* API For UCSI */ > + > +/** > + * gaokun_ec_ucsi_read - read ucsi data from EC, like CCI, MSGI > + * @ec: The gaokun_ec The gaokun_ec structure > + * @resp: Where the data are read to Not a very good kernel doc parameter description. > + * > + * Return: 0 on success or negative error code. > + * > + * UCSI subdriver uses this function to read CCI and MSGI. > + */ > +int gaokun_ec_ucsi_read(struct gaokun_ec *ec, > + u8 resp[GAOKUN_UCSI_READ_SIZE]) > +{ > + u8 req[] = MKREQ(0x03, 0xD5, 0); > + u8 _resp[] = MKRESP(GAOKUN_UCSI_READ_SIZE); > + int ret; > + > + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); > + if (ret) > + return ret; > + > + extr_resp(resp, _resp, GAOKUN_UCSI_READ_SIZE); > + return 0; > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_read); > + > +/** > + * gaokun_ec_ucsi_write - write ucsi data to EC > + * @ec: The gaokun_ec > + * @req: The command If you'd call it cmd, then you don't have req & req_ problem. > + * > + * Return: 0 on success or negative error code. > + * > + * UCSI subdriver uses this function to write control command. This should be before Return: and perhaps it could be reworded such that it describes what the function does, eg.: Write control command (used by UCSI subdriver). > + */ > +int gaokun_ec_ucsi_write(struct gaokun_ec *ec, > + const u8 req[GAOKUN_UCSI_WRITE_SIZE]) > +{ > + u8 _req[] = MKREQ(0x03, 0xD4, GAOKUN_UCSI_WRITE_SIZE); > + > + refill_req(_req, req, GAOKUN_UCSI_WRITE_SIZE); > + return gaokun_ec_write(ec, _req); > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_write); > + > +/** > + * gaokun_ec_ucsi_get_reg - get ucsi register from EC > + * @ec: The gaokun_ec > + * @ureg: The gaokun ucsi register > + * > + * Return: 0 on success or negative error code. > + * > + * UCSI subdriver uses this function to get ucsi register from EC. > + */ > +int gaokun_ec_ucsi_get_reg(struct gaokun_ec *ec, > + struct gaokun_ucsi_reg *ureg) Fits to one line. > +{ > + u8 req[] = MKREQ(0x03, 0xD3, 0); > + u8 _resp[] = MKRESP(UCSI_REG_SIZE); > + int ret; > + > + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); > + if (ret) > + return ret; > + > + extr_resp((u8 *)ureg, _resp, UCSI_REG_SIZE); > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_get_reg); > + > +/** > + * gaokun_ec_ucsi_pan_ack - ack pin assignment notifications from EC > + * @ec: The gaokun_ec > + * @port_id: The id of port which just received and handled the notifications @port_id: The port id receiving and handling the notifications > + * > + * Return: 0 on success or negative error code. > + * > + * UCSI subdriver uses this function to ack PANs from EC. Place before Return, I suggest similar rephrasing as mentioned above. > + */ > +int gaokun_ec_ucsi_pan_ack(struct gaokun_ec *ec, int port_id) > +{ > + u8 req[] = MKREQ(0x03, 0xD2, 1); > + u8 data = 1 << port_id; > + > + if (port_id == GAOKUN_UCSI_NO_PORT_UPDATE) > + data = 0; > + > + refill_req(req, &data, 1); > + > + return gaokun_ec_write(ec, req); > +} > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_pan_ack); > + > +/* -------------------------------------------------------------------------- */ > +/* EC Sysfs */ > + > +/* Fn lock */ > +static int gaokun_ec_get_fn_lock(struct gaokun_ec *ec, bool *on) > +{ > + /* GFRS */ > + u8 req[] = MKREQ(0x02, 0x6B, 0); Does that random acronym map to one of the literal? In which case a define would be more useful than a comment. (You seem to have a few similar comments preceeding the req definitions) > + int ret; > + u8 val; > + > + ret = gaokun_ec_read_byte(ec, req, &val); > + if (ret) > + return ret; > + > + if (val == EC_FN_LOCK_ON) > + *on = true; > + else if (val == EC_FN_LOCK_OFF) > + *on = false; > + else > + return -EIO; > + > + return 0; > +} > + > +static int gaokun_ec_set_fn_lock(struct gaokun_ec *ec, bool on) > +{ > + /* SFRS */ > + u8 req[] = MKREQ(0x02, 0x6C, 1); > + u8 data; > + > + if (on) > + data = EC_FN_LOCK_ON; > + else > + data = EC_FN_LOCK_OFF; You could do: u8 req[] = MKREQ(0x02, 0x6C, 1, on ? EC_FN_LOCK_ON : EC_FN_LOCK_OFF); > + > + refill_req(req, &data, 1); > + > + return gaokun_ec_write(ec, req); > +} > + > +static ssize_t fn_lock_show(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct gaokun_ec *ec = dev_get_drvdata(dev); > + bool on; > + int ret; > + > + ret = gaokun_ec_get_fn_lock(ec, &on); > + if (ret) > + return ret; > + > + return sysfs_emit(buf, "%d\n", on); > +} > + > +static ssize_t fn_lock_store(struct device *dev, > + struct device_attribute *attr, > + const char *buf, size_t size) > +{ > + struct gaokun_ec *ec = dev_get_drvdata(dev); > + bool on; > + int ret; > + > + if (kstrtobool(buf, &on)) > + return -EINVAL; > + > + ret = gaokun_ec_set_fn_lock(ec, on); > + if (ret) > + return ret; > + > + return size; > +} > + > +static DEVICE_ATTR_RW(fn_lock); > + > +static struct attribute *gaokun_ec_attrs[] = { > + &dev_attr_fn_lock.attr, > + NULL, > +}; > +ATTRIBUTE_GROUPS(gaokun_ec); > + > +/* Thermal Zone HwMon */ > +/* Range from 0 to 0x2C, partial valid */ partially? > +static const u8 temp_reg[20] = {0x05, 0x07, 0x08, 0x0E, 0x0F, 0x12, 0x15, 0x1E, > + 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, > + 0x27, 0x28, 0x29, 0x2A}; > + > +static int gaokun_ec_get_temp(struct gaokun_ec *ec, u8 idx, int *temp) > +{ > + /* GTMP */ > + u8 req[] = MKREQ(0x02, 0x61, 1, temp_reg[idx]); > + u8 resp[] = MKRESP(sizeof(__le16)); > + __le16 tmp; > + int ret; > + > + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); > + if (ret) > + return ret; > + > + extr_resp((u8 *)&tmp, resp, sizeof(tmp)); > + *temp = le16_to_cpu(tmp) * 100; /* convert to HwMon's unit */ extr_resp() does memcpy() but there should be no need to copy anything here. You just want to have __le16 pointer of the response data data. > + return 0; > +} > + > +static ssize_t get_ec_tz_temp(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + struct gaokun_ec *ec = dev_get_drvdata(dev); > + int idx, ret, temp; > + > + idx = (to_sensor_dev_attr(attr))->index - 1; Extra parenthesis. > + ret = gaokun_ec_get_temp(ec, idx, &temp); > + if (ret) > + return ret; > + > + return sysfs_emit(buf, "%d\n", temp); > +} > + > +static ssize_t ec_tz_temp_label(struct device *dev, > + struct device_attribute *attr, > + char *buf) > +{ > + int idx = (to_sensor_dev_attr(attr))->index - 1; Ditto. > + > + return sysfs_emit(buf, "EC Thermal Zone %2d Temperature\n", idx); > +} > + > +static SENSOR_DEVICE_ATTR(temp1_input, 0444, get_ec_tz_temp, NULL, 1); > +static SENSOR_DEVICE_ATTR(temp1_label, 0444, ec_tz_temp_label, NULL, 1); > +static SENSOR_DEVICE_ATTR(temp2_input, 0444, get_ec_tz_temp, NULL, 2); > +static SENSOR_DEVICE_ATTR(temp2_label, 0444, ec_tz_temp_label, NULL, 2); > +static SENSOR_DEVICE_ATTR(temp3_input, 0444, get_ec_tz_temp, NULL, 3); > +static SENSOR_DEVICE_ATTR(temp3_label, 0444, ec_tz_temp_label, NULL, 3); > +static SENSOR_DEVICE_ATTR(temp4_input, 0444, get_ec_tz_temp, NULL, 4); > +static SENSOR_DEVICE_ATTR(temp4_label, 0444, ec_tz_temp_label, NULL, 4); > +static SENSOR_DEVICE_ATTR(temp5_input, 0444, get_ec_tz_temp, NULL, 5); > +static SENSOR_DEVICE_ATTR(temp5_label, 0444, ec_tz_temp_label, NULL, 5); > +static SENSOR_DEVICE_ATTR(temp6_input, 0444, get_ec_tz_temp, NULL, 6); > +static SENSOR_DEVICE_ATTR(temp6_label, 0444, ec_tz_temp_label, NULL, 6); > +static SENSOR_DEVICE_ATTR(temp7_input, 0444, get_ec_tz_temp, NULL, 7); > +static SENSOR_DEVICE_ATTR(temp7_label, 0444, ec_tz_temp_label, NULL, 7); > +static SENSOR_DEVICE_ATTR(temp8_input, 0444, get_ec_tz_temp, NULL, 8); > +static SENSOR_DEVICE_ATTR(temp8_label, 0444, ec_tz_temp_label, NULL, 8); > +static SENSOR_DEVICE_ATTR(temp9_input, 0444, get_ec_tz_temp, NULL, 9); > +static SENSOR_DEVICE_ATTR(temp9_label, 0444, ec_tz_temp_label, NULL, 9); > +static SENSOR_DEVICE_ATTR(temp10_input, 0444, get_ec_tz_temp, NULL, 10); > +static SENSOR_DEVICE_ATTR(temp10_label, 0444, ec_tz_temp_label, NULL, 10); > +static SENSOR_DEVICE_ATTR(temp11_input, 0444, get_ec_tz_temp, NULL, 11); > +static SENSOR_DEVICE_ATTR(temp11_label, 0444, ec_tz_temp_label, NULL, 11); > +static SENSOR_DEVICE_ATTR(temp12_input, 0444, get_ec_tz_temp, NULL, 12); > +static SENSOR_DEVICE_ATTR(temp12_label, 0444, ec_tz_temp_label, NULL, 12); > +static SENSOR_DEVICE_ATTR(temp13_input, 0444, get_ec_tz_temp, NULL, 13); > +static SENSOR_DEVICE_ATTR(temp13_label, 0444, ec_tz_temp_label, NULL, 13); > +static SENSOR_DEVICE_ATTR(temp14_input, 0444, get_ec_tz_temp, NULL, 14); > +static SENSOR_DEVICE_ATTR(temp14_label, 0444, ec_tz_temp_label, NULL, 14); > +static SENSOR_DEVICE_ATTR(temp15_input, 0444, get_ec_tz_temp, NULL, 15); > +static SENSOR_DEVICE_ATTR(temp15_label, 0444, ec_tz_temp_label, NULL, 15); > +static SENSOR_DEVICE_ATTR(temp16_input, 0444, get_ec_tz_temp, NULL, 16); > +static SENSOR_DEVICE_ATTR(temp16_label, 0444, ec_tz_temp_label, NULL, 16); > +static SENSOR_DEVICE_ATTR(temp17_input, 0444, get_ec_tz_temp, NULL, 17); > +static SENSOR_DEVICE_ATTR(temp17_label, 0444, ec_tz_temp_label, NULL, 17); > +static SENSOR_DEVICE_ATTR(temp18_input, 0444, get_ec_tz_temp, NULL, 18); > +static SENSOR_DEVICE_ATTR(temp18_label, 0444, ec_tz_temp_label, NULL, 18); > +static SENSOR_DEVICE_ATTR(temp19_input, 0444, get_ec_tz_temp, NULL, 19); > +static SENSOR_DEVICE_ATTR(temp19_label, 0444, ec_tz_temp_label, NULL, 19); > +static SENSOR_DEVICE_ATTR(temp20_input, 0444, get_ec_tz_temp, NULL, 20); > +static SENSOR_DEVICE_ATTR(temp20_label, 0444, ec_tz_temp_label, NULL, 20); > + > +static struct attribute *gaokun_ec_hwmon_attrs[] = { > + &sensor_dev_attr_temp1_input.dev_attr.attr, > + &sensor_dev_attr_temp1_label.dev_attr.attr, > + &sensor_dev_attr_temp2_input.dev_attr.attr, > + &sensor_dev_attr_temp2_label.dev_attr.attr, > + &sensor_dev_attr_temp3_input.dev_attr.attr, > + &sensor_dev_attr_temp3_label.dev_attr.attr, > + &sensor_dev_attr_temp4_input.dev_attr.attr, > + &sensor_dev_attr_temp4_label.dev_attr.attr, > + &sensor_dev_attr_temp5_input.dev_attr.attr, > + &sensor_dev_attr_temp5_label.dev_attr.attr, > + &sensor_dev_attr_temp6_input.dev_attr.attr, > + &sensor_dev_attr_temp6_label.dev_attr.attr, > + &sensor_dev_attr_temp7_input.dev_attr.attr, > + &sensor_dev_attr_temp7_label.dev_attr.attr, > + &sensor_dev_attr_temp8_input.dev_attr.attr, > + &sensor_dev_attr_temp8_label.dev_attr.attr, > + &sensor_dev_attr_temp9_input.dev_attr.attr, > + &sensor_dev_attr_temp9_label.dev_attr.attr, > + &sensor_dev_attr_temp10_input.dev_attr.attr, > + &sensor_dev_attr_temp10_label.dev_attr.attr, > + &sensor_dev_attr_temp11_input.dev_attr.attr, > + &sensor_dev_attr_temp11_label.dev_attr.attr, > + &sensor_dev_attr_temp12_input.dev_attr.attr, > + &sensor_dev_attr_temp12_label.dev_attr.attr, > + &sensor_dev_attr_temp13_input.dev_attr.attr, > + &sensor_dev_attr_temp13_label.dev_attr.attr, > + &sensor_dev_attr_temp14_input.dev_attr.attr, > + &sensor_dev_attr_temp14_label.dev_attr.attr, > + &sensor_dev_attr_temp15_input.dev_attr.attr, > + &sensor_dev_attr_temp15_label.dev_attr.attr, > + &sensor_dev_attr_temp16_input.dev_attr.attr, > + &sensor_dev_attr_temp16_label.dev_attr.attr, > + &sensor_dev_attr_temp17_input.dev_attr.attr, > + &sensor_dev_attr_temp17_label.dev_attr.attr, > + &sensor_dev_attr_temp18_input.dev_attr.attr, > + &sensor_dev_attr_temp18_label.dev_attr.attr, > + &sensor_dev_attr_temp19_input.dev_attr.attr, > + &sensor_dev_attr_temp19_label.dev_attr.attr, > + &sensor_dev_attr_temp20_input.dev_attr.attr, > + &sensor_dev_attr_temp20_label.dev_attr.attr, > + NULL > +}; > +ATTRIBUTE_GROUPS(gaokun_ec_hwmon); > + > +/* -------------------------------------------------------------------------- */ > +/* Modern Standby */ > + > +static int gaokun_ec_suspend(struct device *dev) > +{ > + struct gaokun_ec *ec = dev_get_drvdata(dev); > + u8 req[] = MKREQ(0x02, 0xB2, 1, 0xDB); > + int ret; > + > + if (ec->suspended) > + return 0; > + > + ret = gaokun_ec_write(ec, req); > + > + if (ret) Don't put empty line between call and its error handling. > + return ret; > + > + ec->suspended = true; > + > + return 0; > +} > + > +static int gaokun_ec_resume(struct device *dev) > +{ > + struct gaokun_ec *ec = dev_get_drvdata(dev); > + u8 req[] = MKREQ(0x02, 0xB2, 1, 0xEB); > + int ret; > + int i; > + > + if (!ec->suspended) > + return 0; > + > + for (i = 0; i < 3; ++i) { > + ret = gaokun_ec_write(ec, req); > + if (ret == 0) > + break; > + > + msleep(100); /* EC need time to resume */ So you are stacking delays in gaokun_ec_request() and another here. > + }; > + > + ec->suspended = false; > + > + return 0; > +} > + > +static void gaokun_aux_release(struct device *dev) > +{ > + struct auxiliary_device *adev = to_auxiliary_dev(dev); > + > + kfree(adev); > +} > + > +static void gaokun_aux_remove(void *data) > +{ > + struct auxiliary_device *adev = data; > + > + auxiliary_device_delete(adev); > + auxiliary_device_uninit(adev); > +} > + > +static int gaokun_aux_init(struct device *parent, const char *name, > + struct gaokun_ec *ec) > +{ > + struct auxiliary_device *adev; > + int ret; > + > + adev = kzalloc(sizeof(*adev), GFP_KERNEL); > + if (!adev) > + return -ENOMEM; > + > + adev->name = name; > + adev->id = 0; > + adev->dev.parent = parent; > + adev->dev.release = gaokun_aux_release; > + adev->dev.platform_data = ec; > + /* Allow aux devices to access parent's DT nodes directly */ > + device_set_of_node_from_dev(&adev->dev, parent); > + > + ret = auxiliary_device_init(adev); > + if (ret) { > + kfree(adev); > + return ret; > + } > + > + ret = auxiliary_device_add(adev); > + if (ret) { > + auxiliary_device_uninit(adev); > + return ret; > + } > + > + return devm_add_action_or_reset(parent, gaokun_aux_remove, adev); > +} > + > +/* -------------------------------------------------------------------------- */ > +/* EC */ > + > +static irqreturn_t gaokun_ec_irq_handler(int irq, void *data) > +{ > + struct gaokun_ec *ec = data; > + u8 req[] = MKREQ(EC_EVENT, EC_QUERY, 0); Great, here you have named them. Could you name all of the other literals too, please. > + u8 status, id; > + int ret; > + > + ret = gaokun_ec_read_byte(ec, req, &id); > + if (ret) > + return IRQ_HANDLED; > + > + switch (id) { > + case 0x0: /* No event */ > + break; > + > + case EC_EVENT_LID: > + gaokun_ec_psy_read_byte(ec, EC_LID_STATE, &status); > + status = EC_LID_OPEN & status; > + input_report_switch(ec->idev, SW_LID, !status); > + input_sync(ec->idev); > + break; > + > + default: > + blocking_notifier_call_chain(&ec->notifier_list, id, ec); > + } > + > + return IRQ_HANDLED; > +} > + > +static int gaokun_ec_probe(struct i2c_client *client) > +{ > + struct device *dev = &client->dev; > + struct gaokun_ec *ec; > + int ret; > + > + ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL); > + if (!ec) > + return -ENOMEM; > + > + mutex_init(&ec->lock); > + ec->client = client; > + i2c_set_clientdata(client, ec); > + BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list); > + > + /* Lid switch */ > + ec->idev = devm_input_allocate_device(dev); > + if (!ec->idev) > + return -ENOMEM; > + > + ec->idev->name = "LID"; > + ec->idev->phys = "gaokun-ec/input0"; > + input_set_capability(ec->idev, EV_SW, SW_LID); > + > + ret = input_register_device(ec->idev); > + if (ret) > + return dev_err_probe(dev, ret, "Failed to register input device\n"); > + > + ret = gaokun_aux_init(dev, "psy", ec); > + if (ret) > + return ret; > + > + ret = gaokun_aux_init(dev, "ucsi", ec); > + if (ret) > + return ret; > + > + ret = devm_request_threaded_irq(dev, client->irq, NULL, > + gaokun_ec_irq_handler, IRQF_ONESHOT, > + dev_name(dev), ec); > + if (ret) > + return dev_err_probe(dev, ret, "Failed to request irq\n"); IRQ > + > + ec->hwmon_dev = hwmon_device_register_with_groups(dev, "gaokun_ec_hwmon", > + ec, gaokun_ec_hwmon_groups); > + if (IS_ERR(ec->hwmon_dev)) { > + dev_err(dev, "Failed to register hwmon device\n"); > + return PTR_ERR(ec->hwmon_dev); > + } > + > + return 0; > +} > + > +static void gaokun_ec_remove(struct i2c_client *client) > +{ > + struct gaokun_ec *ec = i2c_get_clientdata(client); > + hwmon_device_unregister(ec->hwmon_dev); > +} > + > +static const struct i2c_device_id gaokun_ec_id[] = { > + { "gaokun-ec", }, > + { } > +}; > +MODULE_DEVICE_TABLE(i2c, gaokun_ec_id); > + > +static const struct of_device_id gaokun_ec_of_match[] = { > + { .compatible = "huawei,gaokun3-ec", }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, gaokun_ec_of_match); > + > +static const struct dev_pm_ops gaokun_ec_pm_ops = { > + NOIRQ_SYSTEM_SLEEP_PM_OPS(gaokun_ec_suspend, gaokun_ec_resume) > +}; > + > +static struct i2c_driver gaokun_ec_driver = { > + .driver = { > + .name = "gaokun-ec", > + .of_match_table = gaokun_ec_of_match, > + .pm = &gaokun_ec_pm_ops, > + .dev_groups = gaokun_ec_groups, > + }, > + .probe = gaokun_ec_probe, > + .remove = gaokun_ec_remove, > + .id_table = gaokun_ec_id, > +}; > +module_i2c_driver(gaokun_ec_driver); > + > +MODULE_DESCRIPTION("HUAWEI Matebook E Go EC driver"); > +MODULE_AUTHOR("Pengyu Luo <mitltlatltl@gmail.com>"); > +MODULE_LICENSE("GPL"); > diff --git a/include/linux/platform_data/huawei-gaokun-ec.h b/include/linux/platform_data/huawei-gaokun-ec.h > new file mode 100644 > index 000000000..dfd177bd9 > --- /dev/null > +++ b/include/linux/platform_data/huawei-gaokun-ec.h > @@ -0,0 +1,80 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Huawei Matebook E Go Embedded Controller > + * > + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> -2025 ? > + */ > + > +#ifndef __HUAWEI_GAOKUN_EC_H__ > +#define __HUAWEI_GAOKUN_EC_H__ > + > +#define GAOKUN_UCSI_CCI_SIZE 4 > +#define GAOKUN_UCSI_DATA_SIZE 16 > +#define GAOKUN_UCSI_READ_SIZE (GAOKUN_UCSI_CCI_SIZE + GAOKUN_UCSI_DATA_SIZE) > +#define GAOKUN_UCSI_WRITE_SIZE 0x18 > + > +#define GAOKUN_UCSI_NO_PORT_UPDATE (-1) > + > +#define GAOKUN_SMART_CHARGE_DATA_SIZE 4 /* mode, delay, start, end */ > + > +/* -------------------------------------------------------------------------- */ > + > +struct gaokun_ec; > +struct gaokun_ucsi_reg; > +struct notifier_block; > + > +#define GAOKUN_MOD_NAME "huawei_gaokun_ec" > +#define GAOKUN_DEV_PSY "psy" > +#define GAOKUN_DEV_UCSI "ucsi" So you defined these here but used literal strings for aux dev init calls? > +/* -------------------------------------------------------------------------- */ > +/* Common API */ > + > +int gaokun_ec_register_notify(struct gaokun_ec *ec, > + struct notifier_block *nb); > +void gaokun_ec_unregister_notify(struct gaokun_ec *ec, > + struct notifier_block *nb); > + > +int gaokun_ec_read(struct gaokun_ec *ec, const u8 *req, > + size_t resp_len, u8 *resp); > +int gaokun_ec_write(struct gaokun_ec *ec, u8 *req); > +int gaokun_ec_read_byte(struct gaokun_ec *ec, u8 *req, u8 *byte); > + > +/* -------------------------------------------------------------------------- */ > +/* API For PSY */ for > + > +int gaokun_ec_psy_multi_read(struct gaokun_ec *ec, u8 reg, > + size_t resp_len, u8 *resp); > + > +static inline int gaokun_ec_psy_read_byte(struct gaokun_ec *ec, > + u8 reg, u8 *byte) > +{ > + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*byte), byte); > +} > + > +static inline int gaokun_ec_psy_read_word(struct gaokun_ec *ec, > + u8 reg, u16 *word) > +{ > + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*word), (u8 *)word); > +} > + > +int gaokun_ec_psy_get_smart_charge(struct gaokun_ec *ec, > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); > +int gaokun_ec_psy_set_smart_charge(struct gaokun_ec *ec, > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); > + > +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on); > +int gaokun_ec_psy_set_smart_charge_enable(struct gaokun_ec *ec, bool on); > + > +/* -------------------------------------------------------------------------- */ > +/* API For UCSI */ for > + > +int gaokun_ec_ucsi_read(struct gaokun_ec *ec, u8 resp[GAOKUN_UCSI_READ_SIZE]); > +int gaokun_ec_ucsi_write(struct gaokun_ec *ec, > + const u8 req[GAOKUN_UCSI_WRITE_SIZE]); > + > +int gaokun_ec_ucsi_get_reg(struct gaokun_ec *ec, struct gaokun_ucsi_reg *ureg); > +int gaokun_ec_ucsi_pan_ack(struct gaokun_ec *ec, int port_id); > + > + > +#endif /* __HUAWEI_GAOKUN_EC_H__ */ > -- i. ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver 2025-01-13 18:56 ` Ilpo Järvinen @ 2025-01-14 8:31 ` Pengyu Luo 2025-01-14 15:40 ` Ilpo Järvinen 0 siblings, 1 reply; 20+ messages in thread From: Pengyu Luo @ 2025-01-14 8:31 UTC (permalink / raw) To: ilpo.jarvinen Cc: andersson, bryan.odonoghue, conor+dt, devicetree, gregkh, hdegoede, heikki.krogerus, jdelvare, konradybcio, krzk+dt, linux-arm-msm, linux-hwmon, linux-kernel, linux-pm, linux-usb, linux, mitltlatltl, platform-driver-x86, robh, sre On Tue, Jan 14, 2025 at 2:56 AM Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> wrote: > On Tue, 14 Jan 2025, Pengyu Luo wrote: > > > There are three variants of which Huawei released the first two > > simultaneously. > > > > Huawei Matebook E Go LTE(sc8180x), codename seems to be gaokun2. > > Huawei Matebook E Go(sc8280xp@3.0GHz), codename must be gaokun3. (see [1]) > > Huawei Matebook E Go 2023(sc8280xp@2.69GHz), codename should be also gaokun3. > > > > Adding support for the latter two variants for now, this driver should > > also work for the sc8180x variant according to acpi table files, but I > > don't have the device to test yet. > > > > Different from other Qualcomm Snapdragon sc8280xp based machines, the > > Huawei Matebook E Go uses an embedded controller while others use > > a system called PMIC GLink. This embedded controller can be used to > > perform a set of various functions, including, but not limited to: > > > > - Battery and charger monitoring; > > - Charge control and smart charge; > > - Fn_lock settings; > > - Tablet lid status; > > - Temperature sensors; > > - USB Type-C notifications (ports orientation, DP alt mode HPD); > > - USB Type-C PD (according to observation, up to 48w). > > > > Add a driver for the EC which creates devices for UCSI and power supply > > devices. > > > > [1] https://bugzilla.kernel.org/show_bug.cgi?id=219645 > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > --- > > MAINTAINERS | 9 + > > drivers/platform/arm64/Kconfig | 21 + > > drivers/platform/arm64/Makefile | 1 + > > drivers/platform/arm64/huawei-gaokun-ec.c | 841 ++++++++++++++++++ > > .../linux/platform_data/huawei-gaokun-ec.h | 80 ++ > > 5 files changed, 952 insertions(+) > > create mode 100644 drivers/platform/arm64/huawei-gaokun-ec.c > > create mode 100644 include/linux/platform_data/huawei-gaokun-ec.h > > > > diff --git a/MAINTAINERS b/MAINTAINERS > > index 520612b3d..0f9e0390a 100644 > > --- a/MAINTAINERS > > +++ b/MAINTAINERS > > @@ -10691,6 +10691,15 @@ S: Maintained > > F: Documentation/networking/device_drivers/ethernet/huawei/hinic.rst > > F: drivers/net/ethernet/huawei/hinic/ > > > > +HUAWEI MATEBOOK E GO EMBEDDED CONTROLLER DRIVER > > +M: Pengyu Luo <mitltlatltl@gmail.com> > > +S: Maintained > > +F: Documentation/devicetree/bindings/platform/huawei,gaokun-ec.yaml > > +F: drivers/platform/arm64/huawei-gaokun-ec.c > > +F: drivers/power/supply/huawei-gaokun-battery.c > > +F: drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > > +F: include/linux/platform_data/huawei-gaokun-ec.h > > + > > HUGETLB SUBSYSTEM > > M: Muchun Song <muchun.song@linux.dev> > > L: linux-mm@kvack.org > > diff --git a/drivers/platform/arm64/Kconfig b/drivers/platform/arm64/Kconfig > > index f88395ea3..67dc7aa95 100644 > > --- a/drivers/platform/arm64/Kconfig > > +++ b/drivers/platform/arm64/Kconfig > > @@ -33,6 +33,27 @@ config EC_ACER_ASPIRE1 > > laptop where this information is not properly exposed via the > > standard ACPI devices. > > > > +config EC_HUAWEI_GAOKUN > > + tristate "Huawei Matebook E Go Embedded Controller driver" > > + depends on ARCH_QCOM || COMPILE_TEST > > + depends on I2C > > + depends on DRM > > + depends on POWER_SUPPLY > > + depends on INPUT > > + help > > + Say Y here to enable the EC driver for the Huawei Matebook E Go > > + which is a sc8280xp-based 2-in-1 tablet. The driver handles battery > > + (information, charge control) and USB Type-C DP HPD events as well > > + as some misc functions like the lid sensor and temperature sensors, > > + etc. > > + > > + This driver provides battery and AC status support for the mentioned > > + laptop where this information is not properly exposed via the > > + standard ACPI devices. > > + > > + Say M or Y here to include this support. > > + > > + > > config EC_LENOVO_YOGA_C630 > > tristate "Lenovo Yoga C630 Embedded Controller driver" > > depends on ARCH_QCOM || COMPILE_TEST > > diff --git a/drivers/platform/arm64/Makefile b/drivers/platform/arm64/Makefile > > index b2ae9114f..46a99eba3 100644 > > --- a/drivers/platform/arm64/Makefile > > +++ b/drivers/platform/arm64/Makefile > > @@ -6,4 +6,5 @@ > > # > > > > obj-$(CONFIG_EC_ACER_ASPIRE1) += acer-aspire1-ec.o > > +obj-$(CONFIG_EC_HUAWEI_GAOKUN) += huawei-gaokun-ec.o > > obj-$(CONFIG_EC_LENOVO_YOGA_C630) += lenovo-yoga-c630.o > > diff --git a/drivers/platform/arm64/huawei-gaokun-ec.c b/drivers/platform/arm64/huawei-gaokun-ec.c > > new file mode 100644 > > index 000000000..3cbecc81e > > --- /dev/null > > +++ b/drivers/platform/arm64/huawei-gaokun-ec.c > > @@ -0,0 +1,841 @@ > > +// SPDX-License-Identifier: GPL-2.0-only > > +/* > > + * huawei-gaokun-ec - An EC driver for HUAWEI Matebook E Go > > + * > > + * reference: drivers/platform/arm64/acer-aspire1-ec.c > > + * drivers/platform/arm64/lenovo-yoga-c630.c > > + * drivers/platform/x86/huawei-wmi.c > > What's the purpose of these? Should they rather be e.g. in the commit > message? > I have seen some drivers state that "This driver is based on xxxx", I would like to highlight that this driver is inspired by their work. Mentioning this in the commit message is also fine for me. > > + * > > + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> > > -2025? > Agree > > + */ > > + > > +#include <linux/auxiliary_bus.h> > > +#include <linux/delay.h> > > +#include <linux/device.h> > > +#include <linux/hwmon.h> > > +#include <linux/hwmon-sysfs.h> > > +#include <linux/i2c.h> > > +#include <linux/input.h> > > +#include <linux/notifier.h> > > +#include <linux/module.h> > > +#include <linux/mutex.h> > > +#include <linux/platform_data/huawei-gaokun-ec.h> > > +#include <linux/version.h> > > Why is version.h needed? > You are right, I started from a template, I forgot to remove it. > > + > > +#define EC_EVENT 0x06 > > + > > +/* Also can be found in ACPI specification 12.3 */ > > +#define EC_READ 0x80 > > +#define EC_WRITE 0x81 > > +#define EC_BURST 0x82 > > +#define EC_QUERY 0x84 > > + > > +#define EC_FN_LOCK_ON 0x5A > > +#define EC_FN_LOCK_OFF 0x55 > > + > > +#define EC_EVENT_LID 0x81 > > + > > +#define EC_LID_STATE 0x80 > > +#define EC_LID_OPEN BIT(1) > > + > > +#define UCSI_REG_SIZE 7 > > + > > +/* > > + * for tx, command sequences are arranged as > > For > > > + * {master_cmd, slave_cmd, data_len, data_seq} > > + */ > > +#define REQ_HDR_SIZE 3 > > +#define INPUT_SIZE_OFFSET 2 > > +#define REQ_LEN(req) (REQ_HDR_SIZE + req[INPUT_SIZE_OFFSET]) > > + > > +/* > > + * for rx, data sequences are arranged as > > For > Agree > > + * {status, data_len(unreliable), data_seq} > > + */ > > +#define RESP_HDR_SIZE 2 > > + > > +#define MKREQ(REG0, REG1, SIZE, ...) \ > > +{ \ > > + REG0, REG1, SIZE, \ > > + /* ## will remove comma when SIZE is 0 */ \ > > + ## __VA_ARGS__, \ > > + /* make sure len(pkt[3:]) >= SIZE */ \ > > + [3 + SIZE] = 0, \ > > +} > > + > > +#define MKRESP(SIZE) \ > > +{ \ > > + [RESP_HDR_SIZE + SIZE - 1] = 0, \ > > +} > > + > > +static inline void refill_req(u8 *dest, const u8 *src, size_t size) > > +{ > > + memcpy(dest + REQ_HDR_SIZE, src, size); > > +} > > + > > +static inline void extr_resp(u8 *dest, const u8 *src, size_t size) > > +{ > > + memcpy(dest, src + RESP_HDR_SIZE, size); > > +} > > + > > +struct gaokun_ec { > > + struct i2c_client *client; > > + struct mutex lock; /* EC transaction lock */ > > + struct blocking_notifier_head notifier_list; > > + struct device *hwmon_dev; > > + struct input_dev *idev; > > + bool suspended; > > +}; > > + > > +static int gaokun_ec_request(struct gaokun_ec *ec, const u8 *req, > > + size_t resp_len, u8 *resp) > > +{ > > + struct i2c_client *client = ec->client; > > + struct i2c_msg msgs[2] = { > > + { > > + .addr = client->addr, > > + .flags = client->flags, > > + .len = REQ_LEN(req), > > + .buf = req, > > + }, { > > + .addr = client->addr, > > + .flags = client->flags | I2C_M_RD, > > + .len = resp_len, > > + .buf = resp, > > + }, > > + }; > > + > > + mutex_lock(&ec->lock); > > Use guard(). > Agree > > + > > + i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); > > + usleep_range(2000, 2500); /* have a break, acpi did this */ > > ACPI > Agree > > + > > + mutex_unlock(&ec->lock); > > + > > + return *resp ? -EIO : 0; > > +} > > + > > +/* -------------------------------------------------------------------------- */ > > +/* Common API */ > > + > > +/** > > + * gaokun_ec_read - Read from EC > > + * @ec: The gaokun_ec > > + * @req: The sequence to request > > + * @resp_len: The size to read > > + * @resp: Where the data are read to > > + * > > + * Return: 0 on success or negative error code. > > + * > > + * This function is used to read data after writing a magic sequence to EC. > > + * All EC operations depend on this function. > > + * > > + * Huawei uses magic sequences everywhere to complete various functions, all > > + * these sequences are passed to ECCD(a ACPI method which is quiet similar > > + * to gaokun_ec_request), there is no good abstraction to generalize these > > + * sequences, so just wrap it for now. Almost all magic sequences are kept > > + * in this file. > > + */ > > +int gaokun_ec_read(struct gaokun_ec *ec, const u8 *req, > > + size_t resp_len, u8 *resp) > > +{ > > + return gaokun_ec_request(ec, req, resp_len, resp); > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_read); > > + > > +/** > > + * gaokun_ec_write - Write to EC > > + * @ec: The gaokun_ec > > + * @req: The sequence to request > > + * > > + * Return: 0 on success or negative error code. > > + * > > + * This function has no big difference from gaokun_ec_read. When caller care > > + * only write status and no actual data are returned, then use it. > > + */ > > +int gaokun_ec_write(struct gaokun_ec *ec, u8 *req) > > +{ > > + u8 resp[] = MKRESP(0); > > + > > + return gaokun_ec_request(ec, req, sizeof(resp), resp); > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_write); > > + > > +int gaokun_ec_read_byte(struct gaokun_ec *ec, u8 *req, u8 *byte) > > +{ > > + int ret; > > + u8 resp[] = MKRESP(sizeof(*byte)); > > + > > + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); > > + extr_resp(byte, resp, sizeof(*byte)); > > + > > + return ret; > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_read_byte); > > + > > +/** > > + * gaokun_ec_register_notify - Register a notifier callback for EC events. > > + * @ec: The gaokun_ec > > + * @nb: Notifier block pointer to register > > + * > > + * Return: 0 on success or negative error code. > > + */ > > +int gaokun_ec_register_notify(struct gaokun_ec *ec, struct notifier_block *nb) > > +{ > > + return blocking_notifier_chain_register(&ec->notifier_list, nb); > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_register_notify); > > + > > +/** > > + * gaokun_ec_unregister_notify - Unregister notifier callback for EC events. > > + * @ec: The gaokun_ec > > + * @nb: Notifier block pointer to unregister > > + * > > + * Unregister a notifier callback that was previously registered with > > + * gaokun_ec_register_notify(). > > + */ > > +void gaokun_ec_unregister_notify(struct gaokun_ec *ec, struct notifier_block *nb) > > +{ > > + blocking_notifier_chain_unregister(&ec->notifier_list, nb); > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_unregister_notify); > > + > > +/* -------------------------------------------------------------------------- */ > > +/* API For PSY */ > > + > > +/** > > + * gaokun_ec_psy_multi_read - Read contiguous registers > > + * @ec: The gaokun_ec > > + * @reg: The start register > > + * @resp_len: The number of registers to be read > > + * @resp: Where the data are read to > > + * > > + * Return: 0 on success or negative error code. > > + */ > > +int gaokun_ec_psy_multi_read(struct gaokun_ec *ec, u8 reg, > > + size_t resp_len, u8 *resp) > > +{ > > + int i, ret; > > + u8 _resp[] = MKRESP(1); > > + u8 req[] = MKREQ(0x02, EC_READ, 1, 0); > > + > > + for (i = 0; i < resp_len; ++i, reg++) { > > + refill_req(req, ®, 1); > > + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); > > + if (ret) > > + return ret; > > + extr_resp(&resp[i], _resp, 1); > > I'm not a big fan of having resp and _resp named variables. > Got it, I will rename it. > > + } > > + > > + return 0; > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_multi_read); > > + > > +/* Smart charge */ > > +#define are_thresholds_valid(start, end) ((end != 0) && (start <= end) && (end <= 100)) > > Why this cannot be a static function? > Agree > > + > > +/** > > + * gaokun_ec_psy_get_smart_charge - read smart charge data from EC > > + * @ec: The gaokun_ec > > + * @data: Where the data are read to, (mode, delay, start, end) > > + * > > + * Return: 0 on success or negative error code. > > + */ > > +int gaokun_ec_psy_get_smart_charge(struct gaokun_ec *ec, > > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]) > > +{ > > + /* GBCM */ > > + u8 req[] = MKREQ(0x02, 0xE4, 0); > > + u8 resp[] = MKRESP(GAOKUN_SMART_CHARGE_DATA_SIZE); > > + int ret; > > + > > + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); > > + if (ret) > > + return ret; > > + > > + extr_resp(data, resp, GAOKUN_SMART_CHARGE_DATA_SIZE); > > So in the previous func you used _resp and resp as names, and here you > have resp and data. Any chance of being consistent in variable naming? > Agree > > + > > + return 0; > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_get_smart_charge); > > + > > +/** > > + * gaokun_ec_psy_set_smart_charge - set smart charge data > > + * @ec: The gaokun_ec > > + * @data: The data are to be set > > + * > > + * Return: 0 on success or negative error code. > > + */ > > +int gaokun_ec_psy_set_smart_charge(struct gaokun_ec *ec, > > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]) > > +{ > > + /* SBCM */ > > + u8 req[] = MKREQ(0x02, 0XE3, GAOKUN_SMART_CHARGE_DATA_SIZE); > > X -> x > Agree > > + > > + if (!are_thresholds_valid(data[2], data[3])) > > + return -EINVAL; > > + > > + refill_req(req, data, GAOKUN_SMART_CHARGE_DATA_SIZE); > > + > > + return gaokun_ec_write(ec, req); > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_set_smart_charge); > > + > > +/* Smart charge enable */ > > +/** > > + * gaokun_ec_psy_get_smart_charge_enable - check if smart charge is enabled > > + * @ec: The gaokun_ec > > + * @on: The state > > + * > > + * Return: 0 on success or negative error code. > > + */ > > +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on) > > +{ > > + /* GBAC */ > > + *on = 0; /* clear other 3 Bytes */ > > = false (as it's bool) > > What that comment means??? The type is bool so what "3 Bytes" ??? > We will write to the lowest Byte, the higher 3 Bytes are dirty, so clear it. We can also implememnt it like this int ret; u8 resp; ret = gaokun_ec_read_byte(.., &resp); if (ret) return ret; *on = !!resp; return 0; > > + return gaokun_ec_read_byte(ec, (u8 [])MKREQ(0x02, 0xE6, 0), (u8 *)on); > > Don't cast bool * to u8 *. > > Please cleanup the MKREQ mess out of this call like in the other > functions above. > Agree > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_get_smart_charge_enable); > > + > > +/** > > + * gaokun_ec_psy_set_smart_charge_enable - set smart charge state > > + * @ec: The gaokun_ec > > + * @on: The state > > + * > > + * Return: 0 on success or negative error code. > > + */ > > +int gaokun_ec_psy_set_smart_charge_enable(struct gaokun_ec *ec, bool on) > > +{ > > + /* SBAC */ > > + return gaokun_ec_write(ec, (u8 [])MKREQ(0x02, 0xE5, 1, on)); > > Ditto. > > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_psy_set_smart_charge_enable); > > + > > +/* -------------------------------------------------------------------------- */ > > +/* API For UCSI */ > > + > > +/** > > + * gaokun_ec_ucsi_read - read ucsi data from EC, like CCI, MSGI > > + * @ec: The gaokun_ec > > The gaokun_ec structure > > > > + * @resp: Where the data are read to > > Not a very good kernel doc parameter description. > I am not a good writer, I use English less IRL. I will try to improve it with AI. ;) > > + * > > + * Return: 0 on success or negative error code. > > + * > > + * UCSI subdriver uses this function to read CCI and MSGI. > > + */ > > +int gaokun_ec_ucsi_read(struct gaokun_ec *ec, > > + u8 resp[GAOKUN_UCSI_READ_SIZE]) > > +{ > > + u8 req[] = MKREQ(0x03, 0xD5, 0); > > + u8 _resp[] = MKRESP(GAOKUN_UCSI_READ_SIZE); > > + int ret; > > + > > + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); > > + if (ret) > > + return ret; > > + > > + extr_resp(resp, _resp, GAOKUN_UCSI_READ_SIZE); > > + return 0; > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_read); > > + > > +/** > > + * gaokun_ec_ucsi_write - write ucsi data to EC > > + * @ec: The gaokun_ec > > + * @req: The command > > If you'd call it cmd, then you don't have req & req_ problem. > Agree > > + * > > + * Return: 0 on success or negative error code. > > + * > > + * UCSI subdriver uses this function to write control command. > > This should be before Return: and perhaps it could be reworded such that > it describes what the function does, eg.: > > Write control command (used by UCSI subdriver). > Agree > > + */ > > +int gaokun_ec_ucsi_write(struct gaokun_ec *ec, > > + const u8 req[GAOKUN_UCSI_WRITE_SIZE]) > > +{ > > + u8 _req[] = MKREQ(0x03, 0xD4, GAOKUN_UCSI_WRITE_SIZE); > > + > > + refill_req(_req, req, GAOKUN_UCSI_WRITE_SIZE); > > + return gaokun_ec_write(ec, _req); > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_write); > > + > > +/** > > + * gaokun_ec_ucsi_get_reg - get ucsi register from EC > > + * @ec: The gaokun_ec > > + * @ureg: The gaokun ucsi register > > + * > > + * Return: 0 on success or negative error code. > > + * > > + * UCSI subdriver uses this function to get ucsi register from EC. > > + */ > > +int gaokun_ec_ucsi_get_reg(struct gaokun_ec *ec, > > + struct gaokun_ucsi_reg *ureg) > > Fits to one line. > Got it > > +{ > > + u8 req[] = MKREQ(0x03, 0xD3, 0); > > + u8 _resp[] = MKRESP(UCSI_REG_SIZE); > > + int ret; > > + > > + ret = gaokun_ec_read(ec, req, sizeof(_resp), _resp); > > + if (ret) > > + return ret; > > + > > + extr_resp((u8 *)ureg, _resp, UCSI_REG_SIZE); > > + > > + return 0; > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_get_reg); > > + > > +/** > > + * gaokun_ec_ucsi_pan_ack - ack pin assignment notifications from EC > > + * @ec: The gaokun_ec > > + * @port_id: The id of port which just received and handled the notifications > > @port_id: The port id receiving and handling the notifications > Agree > > + * > > + * Return: 0 on success or negative error code. > > + * > > + * UCSI subdriver uses this function to ack PANs from EC. > > Place before Return, I suggest similar rephrasing as mentioned above. > Agree > > + */ > > +int gaokun_ec_ucsi_pan_ack(struct gaokun_ec *ec, int port_id) > > +{ > > + u8 req[] = MKREQ(0x03, 0xD2, 1); > > + u8 data = 1 << port_id; > > + > > + if (port_id == GAOKUN_UCSI_NO_PORT_UPDATE) > > + data = 0; > > + > > + refill_req(req, &data, 1); > > + > > + return gaokun_ec_write(ec, req); > > +} > > +EXPORT_SYMBOL_GPL(gaokun_ec_ucsi_pan_ack); > > + > > +/* -------------------------------------------------------------------------- */ > > +/* EC Sysfs */ > > + > > +/* Fn lock */ > > +static int gaokun_ec_get_fn_lock(struct gaokun_ec *ec, bool *on) > > +{ > > + /* GFRS */ > > + u8 req[] = MKREQ(0x02, 0x6B, 0); > > Does that random acronym map to one of the literal? In which case a define > would be more useful than a comment. (You seem to have a few similar > comments preceeding the req definitions) > They are ACPI method names/identifiers, it will be useful if someone want to locate ACPI's implementations. > > + int ret; > > + u8 val; > > + > > + ret = gaokun_ec_read_byte(ec, req, &val); > > + if (ret) > > + return ret; > > + > > + if (val == EC_FN_LOCK_ON) > > + *on = true; > > + else if (val == EC_FN_LOCK_OFF) > > + *on = false; > > + else > > + return -EIO; > > + > > + return 0; > > +} > > + > > +static int gaokun_ec_set_fn_lock(struct gaokun_ec *ec, bool on) > > +{ > > + /* SFRS */ > > + u8 req[] = MKREQ(0x02, 0x6C, 1); > > + u8 data; > > + > > + if (on) > > + data = EC_FN_LOCK_ON; > > + else > > + data = EC_FN_LOCK_OFF; > > You could do: > u8 req[] = MKREQ(0x02, 0x6C, 1, on ? EC_FN_LOCK_ON : EC_FN_LOCK_OFF); > Agree > > + > > + refill_req(req, &data, 1); > > + > > + return gaokun_ec_write(ec, req); > > +} > > + > > +static ssize_t fn_lock_show(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + struct gaokun_ec *ec = dev_get_drvdata(dev); > > + bool on; > > + int ret; > > + > > + ret = gaokun_ec_get_fn_lock(ec, &on); > > + if (ret) > > + return ret; > > + > > + return sysfs_emit(buf, "%d\n", on); > > +} > > + > > +static ssize_t fn_lock_store(struct device *dev, > > + struct device_attribute *attr, > > + const char *buf, size_t size) > > +{ > > + struct gaokun_ec *ec = dev_get_drvdata(dev); > > + bool on; > > + int ret; > > + > > + if (kstrtobool(buf, &on)) > > + return -EINVAL; > > + > > + ret = gaokun_ec_set_fn_lock(ec, on); > > + if (ret) > > + return ret; > > + > > + return size; > > +} > > + > > +static DEVICE_ATTR_RW(fn_lock); > > + > > +static struct attribute *gaokun_ec_attrs[] = { > > + &dev_attr_fn_lock.attr, > > + NULL, > > +}; > > +ATTRIBUTE_GROUPS(gaokun_ec); > > + > > +/* Thermal Zone HwMon */ > > +/* Range from 0 to 0x2C, partial valid */ > > partially? > Agree > > +static const u8 temp_reg[20] = {0x05, 0x07, 0x08, 0x0E, 0x0F, 0x12, 0x15, 0x1E, > > + 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, > > + 0x27, 0x28, 0x29, 0x2A}; > > + > > +static int gaokun_ec_get_temp(struct gaokun_ec *ec, u8 idx, int *temp) > > +{ > > + /* GTMP */ > > + u8 req[] = MKREQ(0x02, 0x61, 1, temp_reg[idx]); > > + u8 resp[] = MKRESP(sizeof(__le16)); > > + __le16 tmp; > > + int ret; > > + > > + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); > > + if (ret) > > + return ret; > > + > > + extr_resp((u8 *)&tmp, resp, sizeof(tmp)); > > + *temp = le16_to_cpu(tmp) * 100; /* convert to HwMon's unit */ > > extr_resp() does memcpy() but there should be no need to copy anything > here. You just want to have __le16 pointer of the response data data. > I think this would break abstraction, recently, these data are accessed by extr_resp() and refill_req() only. > > + return 0; > > +} > > + > > +static ssize_t get_ec_tz_temp(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + struct gaokun_ec *ec = dev_get_drvdata(dev); > > + int idx, ret, temp; > > + > > + idx = (to_sensor_dev_attr(attr))->index - 1; > > Extra parenthesis. > Agree, I will remove it. > > + ret = gaokun_ec_get_temp(ec, idx, &temp); > > + if (ret) > > + return ret; > > + > > + return sysfs_emit(buf, "%d\n", temp); > > +} > > + > > +static ssize_t ec_tz_temp_label(struct device *dev, > > + struct device_attribute *attr, > > + char *buf) > > +{ > > + int idx = (to_sensor_dev_attr(attr))->index - 1; > > Ditto. > > > + > > + return sysfs_emit(buf, "EC Thermal Zone %2d Temperature\n", idx); > > +} > > + > > +static SENSOR_DEVICE_ATTR(temp1_input, 0444, get_ec_tz_temp, NULL, 1); > > +static SENSOR_DEVICE_ATTR(temp1_label, 0444, ec_tz_temp_label, NULL, 1); > > +static SENSOR_DEVICE_ATTR(temp2_input, 0444, get_ec_tz_temp, NULL, 2); > > +static SENSOR_DEVICE_ATTR(temp2_label, 0444, ec_tz_temp_label, NULL, 2); > > +static SENSOR_DEVICE_ATTR(temp3_input, 0444, get_ec_tz_temp, NULL, 3); > > +static SENSOR_DEVICE_ATTR(temp3_label, 0444, ec_tz_temp_label, NULL, 3); > > +static SENSOR_DEVICE_ATTR(temp4_input, 0444, get_ec_tz_temp, NULL, 4); > > +static SENSOR_DEVICE_ATTR(temp4_label, 0444, ec_tz_temp_label, NULL, 4); > > +static SENSOR_DEVICE_ATTR(temp5_input, 0444, get_ec_tz_temp, NULL, 5); > > +static SENSOR_DEVICE_ATTR(temp5_label, 0444, ec_tz_temp_label, NULL, 5); > > +static SENSOR_DEVICE_ATTR(temp6_input, 0444, get_ec_tz_temp, NULL, 6); > > +static SENSOR_DEVICE_ATTR(temp6_label, 0444, ec_tz_temp_label, NULL, 6); > > +static SENSOR_DEVICE_ATTR(temp7_input, 0444, get_ec_tz_temp, NULL, 7); > > +static SENSOR_DEVICE_ATTR(temp7_label, 0444, ec_tz_temp_label, NULL, 7); > > +static SENSOR_DEVICE_ATTR(temp8_input, 0444, get_ec_tz_temp, NULL, 8); > > +static SENSOR_DEVICE_ATTR(temp8_label, 0444, ec_tz_temp_label, NULL, 8); > > +static SENSOR_DEVICE_ATTR(temp9_input, 0444, get_ec_tz_temp, NULL, 9); > > +static SENSOR_DEVICE_ATTR(temp9_label, 0444, ec_tz_temp_label, NULL, 9); > > +static SENSOR_DEVICE_ATTR(temp10_input, 0444, get_ec_tz_temp, NULL, 10); > > +static SENSOR_DEVICE_ATTR(temp10_label, 0444, ec_tz_temp_label, NULL, 10); > > +static SENSOR_DEVICE_ATTR(temp11_input, 0444, get_ec_tz_temp, NULL, 11); > > +static SENSOR_DEVICE_ATTR(temp11_label, 0444, ec_tz_temp_label, NULL, 11); > > +static SENSOR_DEVICE_ATTR(temp12_input, 0444, get_ec_tz_temp, NULL, 12); > > +static SENSOR_DEVICE_ATTR(temp12_label, 0444, ec_tz_temp_label, NULL, 12); > > +static SENSOR_DEVICE_ATTR(temp13_input, 0444, get_ec_tz_temp, NULL, 13); > > +static SENSOR_DEVICE_ATTR(temp13_label, 0444, ec_tz_temp_label, NULL, 13); > > +static SENSOR_DEVICE_ATTR(temp14_input, 0444, get_ec_tz_temp, NULL, 14); > > +static SENSOR_DEVICE_ATTR(temp14_label, 0444, ec_tz_temp_label, NULL, 14); > > +static SENSOR_DEVICE_ATTR(temp15_input, 0444, get_ec_tz_temp, NULL, 15); > > +static SENSOR_DEVICE_ATTR(temp15_label, 0444, ec_tz_temp_label, NULL, 15); > > +static SENSOR_DEVICE_ATTR(temp16_input, 0444, get_ec_tz_temp, NULL, 16); > > +static SENSOR_DEVICE_ATTR(temp16_label, 0444, ec_tz_temp_label, NULL, 16); > > +static SENSOR_DEVICE_ATTR(temp17_input, 0444, get_ec_tz_temp, NULL, 17); > > +static SENSOR_DEVICE_ATTR(temp17_label, 0444, ec_tz_temp_label, NULL, 17); > > +static SENSOR_DEVICE_ATTR(temp18_input, 0444, get_ec_tz_temp, NULL, 18); > > +static SENSOR_DEVICE_ATTR(temp18_label, 0444, ec_tz_temp_label, NULL, 18); > > +static SENSOR_DEVICE_ATTR(temp19_input, 0444, get_ec_tz_temp, NULL, 19); > > +static SENSOR_DEVICE_ATTR(temp19_label, 0444, ec_tz_temp_label, NULL, 19); > > +static SENSOR_DEVICE_ATTR(temp20_input, 0444, get_ec_tz_temp, NULL, 20); > > +static SENSOR_DEVICE_ATTR(temp20_label, 0444, ec_tz_temp_label, NULL, 20); > > + > > +static struct attribute *gaokun_ec_hwmon_attrs[] = { > > + &sensor_dev_attr_temp1_input.dev_attr.attr, > > + &sensor_dev_attr_temp1_label.dev_attr.attr, > > + &sensor_dev_attr_temp2_input.dev_attr.attr, > > + &sensor_dev_attr_temp2_label.dev_attr.attr, > > + &sensor_dev_attr_temp3_input.dev_attr.attr, > > + &sensor_dev_attr_temp3_label.dev_attr.attr, > > + &sensor_dev_attr_temp4_input.dev_attr.attr, > > + &sensor_dev_attr_temp4_label.dev_attr.attr, > > + &sensor_dev_attr_temp5_input.dev_attr.attr, > > + &sensor_dev_attr_temp5_label.dev_attr.attr, > > + &sensor_dev_attr_temp6_input.dev_attr.attr, > > + &sensor_dev_attr_temp6_label.dev_attr.attr, > > + &sensor_dev_attr_temp7_input.dev_attr.attr, > > + &sensor_dev_attr_temp7_label.dev_attr.attr, > > + &sensor_dev_attr_temp8_input.dev_attr.attr, > > + &sensor_dev_attr_temp8_label.dev_attr.attr, > > + &sensor_dev_attr_temp9_input.dev_attr.attr, > > + &sensor_dev_attr_temp9_label.dev_attr.attr, > > + &sensor_dev_attr_temp10_input.dev_attr.attr, > > + &sensor_dev_attr_temp10_label.dev_attr.attr, > > + &sensor_dev_attr_temp11_input.dev_attr.attr, > > + &sensor_dev_attr_temp11_label.dev_attr.attr, > > + &sensor_dev_attr_temp12_input.dev_attr.attr, > > + &sensor_dev_attr_temp12_label.dev_attr.attr, > > + &sensor_dev_attr_temp13_input.dev_attr.attr, > > + &sensor_dev_attr_temp13_label.dev_attr.attr, > > + &sensor_dev_attr_temp14_input.dev_attr.attr, > > + &sensor_dev_attr_temp14_label.dev_attr.attr, > > + &sensor_dev_attr_temp15_input.dev_attr.attr, > > + &sensor_dev_attr_temp15_label.dev_attr.attr, > > + &sensor_dev_attr_temp16_input.dev_attr.attr, > > + &sensor_dev_attr_temp16_label.dev_attr.attr, > > + &sensor_dev_attr_temp17_input.dev_attr.attr, > > + &sensor_dev_attr_temp17_label.dev_attr.attr, > > + &sensor_dev_attr_temp18_input.dev_attr.attr, > > + &sensor_dev_attr_temp18_label.dev_attr.attr, > > + &sensor_dev_attr_temp19_input.dev_attr.attr, > > + &sensor_dev_attr_temp19_label.dev_attr.attr, > > + &sensor_dev_attr_temp20_input.dev_attr.attr, > > + &sensor_dev_attr_temp20_label.dev_attr.attr, > > + NULL > > +}; > > +ATTRIBUTE_GROUPS(gaokun_ec_hwmon); > > + > > +/* -------------------------------------------------------------------------- */ > > +/* Modern Standby */ > > + > > +static int gaokun_ec_suspend(struct device *dev) > > +{ > > + struct gaokun_ec *ec = dev_get_drvdata(dev); > > + u8 req[] = MKREQ(0x02, 0xB2, 1, 0xDB); > > + int ret; > > + > > + if (ec->suspended) > > + return 0; > > + > > + ret = gaokun_ec_write(ec, req); > > + > > + if (ret) > > Don't put empty line between call and its error handling. > Agree > > + return ret; > > + > > + ec->suspended = true; > > + > > + return 0; > > +} > > + > > +static int gaokun_ec_resume(struct device *dev) > > +{ > > + struct gaokun_ec *ec = dev_get_drvdata(dev); > > + u8 req[] = MKREQ(0x02, 0xB2, 1, 0xEB); > > + int ret; > > + int i; > > + > > + if (!ec->suspended) > > + return 0; > > + > > + for (i = 0; i < 3; ++i) { > > + ret = gaokun_ec_write(ec, req); > > + if (ret == 0) > > + break; > > + > > + msleep(100); /* EC need time to resume */ > > So you are stacking delays in gaokun_ec_request() and another here. > I think so, gaokun_ec_request() sleep 20~25ms, it is not enough, here reuqires more time to resume from suspend. > > + }; > > + > > + ec->suspended = false; > > + > > + return 0; > > +} > > + > > +static void gaokun_aux_release(struct device *dev) > > +{ > > + struct auxiliary_device *adev = to_auxiliary_dev(dev); > > + > > + kfree(adev); > > +} > > + > > +static void gaokun_aux_remove(void *data) > > +{ > > + struct auxiliary_device *adev = data; > > + > > + auxiliary_device_delete(adev); > > + auxiliary_device_uninit(adev); > > +} > > + > > +static int gaokun_aux_init(struct device *parent, const char *name, > > + struct gaokun_ec *ec) > > +{ > > + struct auxiliary_device *adev; > > + int ret; > > + > > + adev = kzalloc(sizeof(*adev), GFP_KERNEL); > > + if (!adev) > > + return -ENOMEM; > > + > > + adev->name = name; > > + adev->id = 0; > > + adev->dev.parent = parent; > > + adev->dev.release = gaokun_aux_release; > > + adev->dev.platform_data = ec; > > + /* Allow aux devices to access parent's DT nodes directly */ > > + device_set_of_node_from_dev(&adev->dev, parent); > > + > > + ret = auxiliary_device_init(adev); > > + if (ret) { > > + kfree(adev); > > + return ret; > > + } > > + > > + ret = auxiliary_device_add(adev); > > + if (ret) { > > + auxiliary_device_uninit(adev); > > + return ret; > > + } > > + > > + return devm_add_action_or_reset(parent, gaokun_aux_remove, adev); > > +} > > + > > +/* -------------------------------------------------------------------------- */ > > +/* EC */ > > + > > +static irqreturn_t gaokun_ec_irq_handler(int irq, void *data) > > +{ > > + struct gaokun_ec *ec = data; > > + u8 req[] = MKREQ(EC_EVENT, EC_QUERY, 0); > > Great, here you have named them. Could you name all of the other literals > too, please. > I mentioned this in previous version. Most of them are magic, it is hard to generalize them. We could name partial scmd according to specific functions (sysfs functions), their function names have implied registers' meaning, and these registers would be never reused in other functions. > > + u8 status, id; > > + int ret; > > + > > + ret = gaokun_ec_read_byte(ec, req, &id); > > + if (ret) > > + return IRQ_HANDLED; > > + > > + switch (id) { > > + case 0x0: /* No event */ > > + break; > > + > > + case EC_EVENT_LID: > > + gaokun_ec_psy_read_byte(ec, EC_LID_STATE, &status); > > + status = EC_LID_OPEN & status; > > + input_report_switch(ec->idev, SW_LID, !status); > > + input_sync(ec->idev); > > + break; > > + > > + default: > > + blocking_notifier_call_chain(&ec->notifier_list, id, ec); > > + } > > + > > + return IRQ_HANDLED; > > +} > > + > > +static int gaokun_ec_probe(struct i2c_client *client) > > +{ > > + struct device *dev = &client->dev; > > + struct gaokun_ec *ec; > > + int ret; > > + > > + ec = devm_kzalloc(dev, sizeof(*ec), GFP_KERNEL); > > + if (!ec) > > + return -ENOMEM; > > + > > + mutex_init(&ec->lock); > > + ec->client = client; > > + i2c_set_clientdata(client, ec); > > + BLOCKING_INIT_NOTIFIER_HEAD(&ec->notifier_list); > > + > > + /* Lid switch */ > > + ec->idev = devm_input_allocate_device(dev); > > + if (!ec->idev) > > + return -ENOMEM; > > + > > + ec->idev->name = "LID"; > > + ec->idev->phys = "gaokun-ec/input0"; > > + input_set_capability(ec->idev, EV_SW, SW_LID); > > + > > + ret = input_register_device(ec->idev); > > + if (ret) > > + return dev_err_probe(dev, ret, "Failed to register input device\n"); > > + > > + ret = gaokun_aux_init(dev, "psy", ec); > > + if (ret) > > + return ret; > > + > > + ret = gaokun_aux_init(dev, "ucsi", ec); > > + if (ret) > > + return ret; > > + > > + ret = devm_request_threaded_irq(dev, client->irq, NULL, > > + gaokun_ec_irq_handler, IRQF_ONESHOT, > > + dev_name(dev), ec); > > + if (ret) > > + return dev_err_probe(dev, ret, "Failed to request irq\n"); > > IRQ > Agree > > + > > + ec->hwmon_dev = hwmon_device_register_with_groups(dev, "gaokun_ec_hwmon", > > + ec, gaokun_ec_hwmon_groups); > > + if (IS_ERR(ec->hwmon_dev)) { > > + dev_err(dev, "Failed to register hwmon device\n"); > > + return PTR_ERR(ec->hwmon_dev); > > + } > > + > > + return 0; > > +} > > + > > +static void gaokun_ec_remove(struct i2c_client *client) > > +{ > > + struct gaokun_ec *ec = i2c_get_clientdata(client); > > + hwmon_device_unregister(ec->hwmon_dev); > > +} > > + > > +static const struct i2c_device_id gaokun_ec_id[] = { > > + { "gaokun-ec", }, > > + { } > > +}; > > +MODULE_DEVICE_TABLE(i2c, gaokun_ec_id); > > + > > +static const struct of_device_id gaokun_ec_of_match[] = { > > + { .compatible = "huawei,gaokun3-ec", }, > > + { } > > +}; > > +MODULE_DEVICE_TABLE(of, gaokun_ec_of_match); > > + > > +static const struct dev_pm_ops gaokun_ec_pm_ops = { > > + NOIRQ_SYSTEM_SLEEP_PM_OPS(gaokun_ec_suspend, gaokun_ec_resume) > > +}; > > + > > +static struct i2c_driver gaokun_ec_driver = { > > + .driver = { > > + .name = "gaokun-ec", > > + .of_match_table = gaokun_ec_of_match, > > + .pm = &gaokun_ec_pm_ops, > > + .dev_groups = gaokun_ec_groups, > > + }, > > + .probe = gaokun_ec_probe, > > + .remove = gaokun_ec_remove, > > + .id_table = gaokun_ec_id, > > +}; > > +module_i2c_driver(gaokun_ec_driver); > > + > > +MODULE_DESCRIPTION("HUAWEI Matebook E Go EC driver"); > > +MODULE_AUTHOR("Pengyu Luo <mitltlatltl@gmail.com>"); > > +MODULE_LICENSE("GPL"); > > diff --git a/include/linux/platform_data/huawei-gaokun-ec.h b/include/linux/platform_data/huawei-gaokun-ec.h > > new file mode 100644 > > index 000000000..dfd177bd9 > > --- /dev/null > > +++ b/include/linux/platform_data/huawei-gaokun-ec.h > > @@ -0,0 +1,80 @@ > > +// SPDX-License-Identifier: GPL-2.0-only > > +/* > > + * Huawei Matebook E Go Embedded Controller > > + * > > + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> > > -2025 ? > Agree > > + */ > > + > > +#ifndef __HUAWEI_GAOKUN_EC_H__ > > +#define __HUAWEI_GAOKUN_EC_H__ > > + > > +#define GAOKUN_UCSI_CCI_SIZE 4 > > +#define GAOKUN_UCSI_DATA_SIZE 16 > > +#define GAOKUN_UCSI_READ_SIZE (GAOKUN_UCSI_CCI_SIZE + GAOKUN_UCSI_DATA_SIZE) > > +#define GAOKUN_UCSI_WRITE_SIZE 0x18 > > + > > +#define GAOKUN_UCSI_NO_PORT_UPDATE (-1) > > + > > +#define GAOKUN_SMART_CHARGE_DATA_SIZE 4 /* mode, delay, start, end */ > > + > > +/* -------------------------------------------------------------------------- */ > > + > > +struct gaokun_ec; > > +struct gaokun_ucsi_reg; > > +struct notifier_block; > > + > > +#define GAOKUN_MOD_NAME "huawei_gaokun_ec" > > +#define GAOKUN_DEV_PSY "psy" > > +#define GAOKUN_DEV_UCSI "ucsi" > > So you defined these here but used literal strings for aux dev init calls? > Agree > > +/* -------------------------------------------------------------------------- */ > > +/* Common API */ > > + > > +int gaokun_ec_register_notify(struct gaokun_ec *ec, > > + struct notifier_block *nb); > > +void gaokun_ec_unregister_notify(struct gaokun_ec *ec, > > + struct notifier_block *nb); > > + > > +int gaokun_ec_read(struct gaokun_ec *ec, const u8 *req, > > + size_t resp_len, u8 *resp); > > +int gaokun_ec_write(struct gaokun_ec *ec, u8 *req); > > +int gaokun_ec_read_byte(struct gaokun_ec *ec, u8 *req, u8 *byte); > > + > > +/* -------------------------------------------------------------------------- */ > > +/* API For PSY */ > > for > Agree > > + > > +int gaokun_ec_psy_multi_read(struct gaokun_ec *ec, u8 reg, > > + size_t resp_len, u8 *resp); > > + > > +static inline int gaokun_ec_psy_read_byte(struct gaokun_ec *ec, > > + u8 reg, u8 *byte) > > +{ > > + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*byte), byte); > > +} > > + > > +static inline int gaokun_ec_psy_read_word(struct gaokun_ec *ec, > > + u8 reg, u16 *word) > > +{ > > + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*word), (u8 *)word); > > +} > > + > > +int gaokun_ec_psy_get_smart_charge(struct gaokun_ec *ec, > > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); > > +int gaokun_ec_psy_set_smart_charge(struct gaokun_ec *ec, > > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); > > + > > +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on); > > +int gaokun_ec_psy_set_smart_charge_enable(struct gaokun_ec *ec, bool on); > > + > > +/* -------------------------------------------------------------------------- */ > > +/* API For UCSI */ > > for > Agree > > + > > +int gaokun_ec_ucsi_read(struct gaokun_ec *ec, u8 resp[GAOKUN_UCSI_READ_SIZE]); > > +int gaokun_ec_ucsi_write(struct gaokun_ec *ec, > > + const u8 req[GAOKUN_UCSI_WRITE_SIZE]); > > + > > +int gaokun_ec_ucsi_get_reg(struct gaokun_ec *ec, struct gaokun_ucsi_reg *ureg); > > +int gaokun_ec_ucsi_pan_ack(struct gaokun_ec *ec, int port_id); > > + > > + > > +#endif /* __HUAWEI_GAOKUN_EC_H__ */ > > > > -- > i. > Best wishes, Pengyu ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver 2025-01-14 8:31 ` Pengyu Luo @ 2025-01-14 15:40 ` Ilpo Järvinen 0 siblings, 0 replies; 20+ messages in thread From: Ilpo Järvinen @ 2025-01-14 15:40 UTC (permalink / raw) To: Pengyu Luo Cc: andersson, bryan.odonoghue, conor+dt, devicetree, Greg Kroah-Hartman, Hans de Goede, heikki.krogerus, jdelvare, konradybcio, krzk+dt, linux-arm-msm, linux-hwmon, LKML, linux-pm, linux-usb, linux, platform-driver-x86, robh, sre [-- Attachment #1: Type: text/plain, Size: 5290 bytes --] On Tue, 14 Jan 2025, Pengyu Luo wrote: > On Tue, Jan 14, 2025 at 2:56 AM Ilpo Järvinen <ilpo.jarvinen@linux.intel.com> wrote: > > On Tue, 14 Jan 2025, Pengyu Luo wrote: > > > > > There are three variants of which Huawei released the first two > > > simultaneously. > > > > > > Huawei Matebook E Go LTE(sc8180x), codename seems to be gaokun2. > > > Huawei Matebook E Go(sc8280xp@3.0GHz), codename must be gaokun3. (see [1]) > > > Huawei Matebook E Go 2023(sc8280xp@2.69GHz), codename should be also gaokun3. > > > > > > Adding support for the latter two variants for now, this driver should > > > also work for the sc8180x variant according to acpi table files, but I > > > don't have the device to test yet. > > > > > > Different from other Qualcomm Snapdragon sc8280xp based machines, the > > > Huawei Matebook E Go uses an embedded controller while others use > > > a system called PMIC GLink. This embedded controller can be used to > > > perform a set of various functions, including, but not limited to: > > > > > > - Battery and charger monitoring; > > > - Charge control and smart charge; > > > - Fn_lock settings; > > > - Tablet lid status; > > > - Temperature sensors; > > > - USB Type-C notifications (ports orientation, DP alt mode HPD); > > > - USB Type-C PD (according to observation, up to 48w). > > > > > > Add a driver for the EC which creates devices for UCSI and power supply > > > devices. > > > > > > [1] https://bugzilla.kernel.org/show_bug.cgi?id=219645 > > > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > > +/** > > > + * gaokun_ec_psy_get_smart_charge_enable - check if smart charge is enabled > > > + * @ec: The gaokun_ec > > > + * @on: The state > > > + * > > > + * Return: 0 on success or negative error code. > > > + */ > > > +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on) > > > +{ > > > + /* GBAC */ > > > + *on = 0; /* clear other 3 Bytes */ > > > > = false (as it's bool) > > > > What that comment means??? The type is bool so what "3 Bytes" ??? > > > > We will write to the lowest Byte, the higher 3 Bytes are dirty, so clear it. Are you saying you assume bool is 4 bytes long? I'd be cautious on making assumptions on sizeof(bool). > We can also implememnt it like this > > int ret; > u8 resp; > > ret = gaokun_ec_read_byte(.., &resp); > if (ret) > return ret; > > *on = !!resp; Yes, I prefer explicit u8 -> bool conversion like this. > > > +/* Fn lock */ > > > +static int gaokun_ec_get_fn_lock(struct gaokun_ec *ec, bool *on) > > > +{ > > > + /* GFRS */ > > > + u8 req[] = MKREQ(0x02, 0x6B, 0); > > > > Does that random acronym map to one of the literal? In which case a define > > would be more useful than a comment. (You seem to have a few similar > > comments preceeding the req definitions) > > > > They are ACPI method names/identifiers, it will be useful if someone want > to locate ACPI's implementations. Okay, I guess it's fine as is then. > > > +static int gaokun_ec_get_temp(struct gaokun_ec *ec, u8 idx, int *temp) > > > +{ > > > + /* GTMP */ > > > + u8 req[] = MKREQ(0x02, 0x61, 1, temp_reg[idx]); > > > + u8 resp[] = MKRESP(sizeof(__le16)); > > > + __le16 tmp; > > > + int ret; > > > + > > > + ret = gaokun_ec_read(ec, req, sizeof(resp), resp); > > > + if (ret) > > > + return ret; > > > + > > > + extr_resp((u8 *)&tmp, resp, sizeof(tmp)); > > > + *temp = le16_to_cpu(tmp) * 100; /* convert to HwMon's unit */ > > > > extr_resp() does memcpy() but there should be no need to copy anything > > here. You just want to have __le16 pointer of the response data data. > > > > I think this would break abstraction, recently, these data are accessed by > extr_resp() and refill_req() only. If you want to keep doing it like that, not a big deal for me. There are different ways to do the abstraction though, and not all require memcpy() when changing a layer (e.g., a pointer advancing to the other layer). > > > +/* -------------------------------------------------------------------------- */ > > > +/* EC */ > > > + > > > +static irqreturn_t gaokun_ec_irq_handler(int irq, void *data) > > > +{ > > > + struct gaokun_ec *ec = data; > > > + u8 req[] = MKREQ(EC_EVENT, EC_QUERY, 0); > > > > Great, here you have named them. Could you name all of the other literals > > too, please. > > I mentioned this in previous version. Most of them are magic, it is hard to > generalize them. We could name partial scmd according to specific functions > (sysfs functions), their function names have implied registers' meaning, and > these registers would be never reused in other functions. Fair (I didn't read every comment made to the previous version). > > > +/* -------------------------------------------------------------------------- */ > > > +/* API For UCSI */ > > > > for > > > > Agree For me, you don't need to reply "Agree", "Ack" or something along those lines if you're going to act on the feedback. Just make sure you don't forget them :-). It'll save us both some time when we focus on points that need further discussion. -- i. ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver 2025-01-13 17:50 ` [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver Pengyu Luo 2025-01-13 18:34 ` Guenter Roeck 2025-01-13 18:56 ` Ilpo Järvinen @ 2025-01-16 12:02 ` Heikki Krogerus 2 siblings, 0 replies; 20+ messages in thread From: Heikki Krogerus @ 2025-01-16 12:02 UTC (permalink / raw) To: Pengyu Luo Cc: Rob Herring, Krzysztof Kozlowski, Conor Dooley, Bjorn Andersson, Konrad Dybcio, Hans de Goede, Ilpo Järvinen, Bryan O'Donoghue, Sebastian Reichel, Greg Kroah-Hartman, Jean Delvare, Guenter Roeck, devicetree, linux-kernel, linux-arm-msm, platform-driver-x86, linux-pm, linux-usb, linux-hwmon Hi, > +static void gaokun_ec_remove(struct i2c_client *client) > +{ > + struct gaokun_ec *ec = i2c_get_clientdata(client); > + hwmon_device_unregister(ec->hwmon_dev); > +} You are missing black line after the declaration. > +static const struct i2c_device_id gaokun_ec_id[] = { > + { "gaokun-ec", }, > + { } > +}; > +MODULE_DEVICE_TABLE(i2c, gaokun_ec_id); > + > +static const struct of_device_id gaokun_ec_of_match[] = { > + { .compatible = "huawei,gaokun3-ec", }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, gaokun_ec_of_match); > + > +static const struct dev_pm_ops gaokun_ec_pm_ops = { > + NOIRQ_SYSTEM_SLEEP_PM_OPS(gaokun_ec_suspend, gaokun_ec_resume) > +}; > + > +static struct i2c_driver gaokun_ec_driver = { > + .driver = { > + .name = "gaokun-ec", > + .of_match_table = gaokun_ec_of_match, > + .pm = &gaokun_ec_pm_ops, > + .dev_groups = gaokun_ec_groups, > + }, > + .probe = gaokun_ec_probe, > + .remove = gaokun_ec_remove, > + .id_table = gaokun_ec_id, > +}; > +module_i2c_driver(gaokun_ec_driver); > + > +MODULE_DESCRIPTION("HUAWEI Matebook E Go EC driver"); > +MODULE_AUTHOR("Pengyu Luo <mitltlatltl@gmail.com>"); > +MODULE_LICENSE("GPL"); > diff --git a/include/linux/platform_data/huawei-gaokun-ec.h b/include/linux/platform_data/huawei-gaokun-ec.h > new file mode 100644 > index 000000000..dfd177bd9 > --- /dev/null > +++ b/include/linux/platform_data/huawei-gaokun-ec.h > @@ -0,0 +1,80 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * Huawei Matebook E Go Embedded Controller > + * > + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> > + */ > + > +#ifndef __HUAWEI_GAOKUN_EC_H__ > +#define __HUAWEI_GAOKUN_EC_H__ > + > +#define GAOKUN_UCSI_CCI_SIZE 4 > +#define GAOKUN_UCSI_DATA_SIZE 16 > +#define GAOKUN_UCSI_READ_SIZE (GAOKUN_UCSI_CCI_SIZE + GAOKUN_UCSI_DATA_SIZE) > +#define GAOKUN_UCSI_WRITE_SIZE 0x18 > + > +#define GAOKUN_UCSI_NO_PORT_UPDATE (-1) > + > +#define GAOKUN_SMART_CHARGE_DATA_SIZE 4 /* mode, delay, start, end */ > + > +/* -------------------------------------------------------------------------- */ > + > +struct gaokun_ec; > +struct gaokun_ucsi_reg; > +struct notifier_block; > + > +#define GAOKUN_MOD_NAME "huawei_gaokun_ec" > +#define GAOKUN_DEV_PSY "psy" > +#define GAOKUN_DEV_UCSI "ucsi" > + > +/* -------------------------------------------------------------------------- */ > +/* Common API */ > + > +int gaokun_ec_register_notify(struct gaokun_ec *ec, > + struct notifier_block *nb); > +void gaokun_ec_unregister_notify(struct gaokun_ec *ec, > + struct notifier_block *nb); > + > +int gaokun_ec_read(struct gaokun_ec *ec, const u8 *req, > + size_t resp_len, u8 *resp); > +int gaokun_ec_write(struct gaokun_ec *ec, u8 *req); > +int gaokun_ec_read_byte(struct gaokun_ec *ec, u8 *req, u8 *byte); > + > +/* -------------------------------------------------------------------------- */ > +/* API For PSY */ > + > +int gaokun_ec_psy_multi_read(struct gaokun_ec *ec, u8 reg, > + size_t resp_len, u8 *resp); > + > +static inline int gaokun_ec_psy_read_byte(struct gaokun_ec *ec, > + u8 reg, u8 *byte) > +{ > + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*byte), byte); > +} > + > +static inline int gaokun_ec_psy_read_word(struct gaokun_ec *ec, > + u8 reg, u16 *word) > +{ > + return gaokun_ec_psy_multi_read(ec, reg, sizeof(*word), (u8 *)word); > +} > + > +int gaokun_ec_psy_get_smart_charge(struct gaokun_ec *ec, > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); > +int gaokun_ec_psy_set_smart_charge(struct gaokun_ec *ec, > + u8 data[GAOKUN_SMART_CHARGE_DATA_SIZE]); > + > +int gaokun_ec_psy_get_smart_charge_enable(struct gaokun_ec *ec, bool *on); > +int gaokun_ec_psy_set_smart_charge_enable(struct gaokun_ec *ec, bool on); > + > +/* -------------------------------------------------------------------------- */ > +/* API For UCSI */ > + > +int gaokun_ec_ucsi_read(struct gaokun_ec *ec, u8 resp[GAOKUN_UCSI_READ_SIZE]); > +int gaokun_ec_ucsi_write(struct gaokun_ec *ec, > + const u8 req[GAOKUN_UCSI_WRITE_SIZE]); > + > +int gaokun_ec_ucsi_get_reg(struct gaokun_ec *ec, struct gaokun_ucsi_reg *ureg); > +int gaokun_ec_ucsi_pan_ack(struct gaokun_ec *ec, int port_id); > + > + Here you have extra line. scripts/checkpatch.pl should find this kind issues for you. Br, -- heikki ^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 @ 2025-01-13 17:51 ` Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver Pengyu Luo ` (3 more replies) 0 siblings, 4 replies; 20+ messages in thread From: Pengyu Luo @ 2025-01-13 17:51 UTC (permalink / raw) To: Heikki Krogerus, Greg Kroah-Hartman; +Cc: Pengyu Luo, linux-usb, linux-kernel Many platforms from Qualcomm(before X elite) still use UCSI v1.0, part of them hardcoded the version number to dsdt, add this for them. Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> --- drivers/usb/typec/ucsi/ucsi.h | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/usb/typec/ucsi/ucsi.h b/drivers/usb/typec/ucsi/ucsi.h index 5ff369c24..82735eb34 100644 --- a/drivers/usb/typec/ucsi/ucsi.h +++ b/drivers/usb/typec/ucsi/ucsi.h @@ -30,6 +30,7 @@ struct dentry; #define UCSIv2_MESSAGE_OUT 272 /* UCSI versions */ +#define UCSI_VERSION_1_0 0x0100 #define UCSI_VERSION_1_1 0x0110 #define UCSI_VERSION_1_2 0x0120 #define UCSI_VERSION_2_0 0x0200 -- 2.47.1 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver 2025-01-13 17:51 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Pengyu Luo @ 2025-01-13 17:51 ` Pengyu Luo 2025-01-16 11:55 ` Heikki Krogerus 2025-01-13 17:51 ` [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver Pengyu Luo ` (2 subsequent siblings) 3 siblings, 1 reply; 20+ messages in thread From: Pengyu Luo @ 2025-01-13 17:51 UTC (permalink / raw) To: Heikki Krogerus, Greg Kroah-Hartman, Pengyu Luo; +Cc: linux-kernel, linux-usb The Huawei Matebook E Go tablet implements the UCSI interface in the onboard EC. Add the glue driver to interface with the platform's UCSI implementation. Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> --- drivers/usb/typec/ucsi/Kconfig | 11 + drivers/usb/typec/ucsi/Makefile | 1 + drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c | 526 ++++++++++++++++++++ 3 files changed, 538 insertions(+) create mode 100644 drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c diff --git a/drivers/usb/typec/ucsi/Kconfig b/drivers/usb/typec/ucsi/Kconfig index 75559601f..e94956d27 100644 --- a/drivers/usb/typec/ucsi/Kconfig +++ b/drivers/usb/typec/ucsi/Kconfig @@ -91,4 +91,15 @@ config UCSI_LENOVO_YOGA_C630 To compile the driver as a module, choose M here: the module will be called ucsi_yoga_c630. +config UCSI_HUAWEI_GAOKUN + tristate "UCSI Interface Driver for Huawei Matebook E Go" + depends on EC_HUAWEI_GAOKUN + select DRM_AUX_HPD_BRIDGE + help + This driver enables UCSI support on the Huawei Matebook E Go tablet, + which is a sc8280xp-based 2-in-1 tablet. + + To compile the driver as a module, choose M here: the module will be + called ucsi_huawei_gaokun. + endif diff --git a/drivers/usb/typec/ucsi/Makefile b/drivers/usb/typec/ucsi/Makefile index be98a8791..dbc571763 100644 --- a/drivers/usb/typec/ucsi/Makefile +++ b/drivers/usb/typec/ucsi/Makefile @@ -23,3 +23,4 @@ obj-$(CONFIG_UCSI_STM32G0) += ucsi_stm32g0.o obj-$(CONFIG_UCSI_PMIC_GLINK) += ucsi_glink.o obj-$(CONFIG_CROS_EC_UCSI) += cros_ec_ucsi.o obj-$(CONFIG_UCSI_LENOVO_YOGA_C630) += ucsi_yoga_c630.o +obj-$(CONFIG_UCSI_HUAWEI_GAOKUN) += ucsi_huawei_gaokun.o diff --git a/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c b/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c new file mode 100644 index 000000000..da1993805 --- /dev/null +++ b/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c @@ -0,0 +1,527 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * ucsi-huawei-gaokun - A UCSI driver for HUAWEI Matebook E Go + * + * reference: drivers/usb/typec/ucsi/ucsi_yoga_c630.c + * drivers/usb/typec/ucsi/ucsi_glink.c + * drivers/soc/qcom/pmic_glink_altmode.c + * + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> + */ + +#include <drm/bridge/aux-bridge.h> +#include <linux/auxiliary_bus.h> +#include <linux/bitops.h> +#include <linux/completion.h> +#include <linux/container_of.h> +#include <linux/module.h> +#include <linux/notifier.h> +#include <linux/of.h> +#include <linux/platform_data/huawei-gaokun-ec.h> +#include <linux/string.h> +#include <linux/usb/pd_vdo.h> +#include <linux/usb/typec_altmode.h> +#include <linux/usb/typec_dp.h> +#include <linux/workqueue_types.h> + +#include "ucsi.h" + +#define EC_EVENT_UCSI 0x21 +#define EC_EVENT_USB 0x22 + +#define GAOKUN_CCX_MASK GENMASK(1, 0) +#define GAOKUN_MUX_MASK GENMASK(3, 2) + +#define GAOKUN_DPAM_MASK GENMASK(3, 0) +#define GAOKUN_HPD_STATE_MASK BIT(4) +#define GAOKUN_HPD_IRQ_MASK BIT(5) + +#define GET_IDX(updt) (ffs(updt) - 1) + +#define CCX_TO_ORI(ccx) (++ccx % 3) /* convert ccx to enum typec_orientation */ + +/* Configuration Channel Extension */ +enum gaokun_ucsi_ccx { + USBC_CCX_NORMAL, + USBC_CCX_REVERSE, + USBC_CCX_NONE, +}; + +enum gaokun_ucsi_mux { + USBC_MUX_NONE, + USBC_MUX_USB_2L, + USBC_MUX_DP_4L, + USBC_MUX_USB_DP, +}; +/* based on pmic_glink_altmode_pin_assignment */ +enum gaokun_ucsi_dpam_pan { /* DP Alt Mode Pin Assignments */ + USBC_DPAM_PAN_NONE, + USBC_DPAM_PAN_A, /* Not supported after USB Type-C Standard v1.0b */ + USBC_DPAM_PAN_B, /* Not supported after USB Type-C Standard v1.0b */ + USBC_DPAM_PAN_C, /* USBC_DPAM_PAN_C_REVERSE - 6 */ + USBC_DPAM_PAN_D, + USBC_DPAM_PAN_E, + USBC_DPAM_PAN_F, /* Not supported after USB Type-C Standard v1.0b */ + USBC_DPAM_PAN_A_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ + USBC_DPAM_PAN_B_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ + USBC_DPAM_PAN_C_REVERSE, + USBC_DPAM_PAN_D_REVERSE, + USBC_DPAM_PAN_E_REVERSE, + USBC_DPAM_PAN_F_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ +}; + +struct gaokun_ucsi_reg { + u8 num_ports; + u8 port_updt; + u8 port_data[4]; + u8 checksum; + u8 reserved; +} __packed; + +struct gaokun_ucsi_port { + struct completion usb_ack; + spinlock_t lock; + + struct gaokun_ucsi *ucsi; + struct auxiliary_device *bridge; + + int idx; + enum gaokun_ucsi_ccx ccx; + enum gaokun_ucsi_mux mux; + u8 mode; + u16 svid; + u8 hpd_state; + u8 hpd_irq; +}; + +struct gaokun_ucsi { + struct gaokun_ec *ec; + struct ucsi *ucsi; + struct gaokun_ucsi_port *ports; + struct device *dev; + struct delayed_work work; + struct notifier_block nb; + u16 version; + u8 num_ports; +}; + +/* -------------------------------------------------------------------------- */ +/* For UCSI */ + +static int gaokun_ucsi_read_version(struct ucsi *ucsi, u16 *version) +{ + struct gaokun_ucsi *uec = ucsi_get_drvdata(ucsi); + + *version = uec->version; + + return 0; +} + +static int gaokun_ucsi_read_cci(struct ucsi *ucsi, u32 *cci) +{ + struct gaokun_ucsi *uec = ucsi_get_drvdata(ucsi); + u8 buf[GAOKUN_UCSI_READ_SIZE]; + int ret; + + ret = gaokun_ec_ucsi_read(uec->ec, buf); + if (ret) + return ret; + + memcpy(cci, buf, sizeof(*cci)); + + return 0; +} + +static int gaokun_ucsi_read_message_in(struct ucsi *ucsi, + void *val, size_t val_len) +{ + struct gaokun_ucsi *uec = ucsi_get_drvdata(ucsi); + u8 buf[GAOKUN_UCSI_READ_SIZE]; + int ret; + + ret = gaokun_ec_ucsi_read(uec->ec, buf); + if (ret) + return ret; + + memcpy(val, buf + GAOKUN_UCSI_CCI_SIZE, + min(val_len, GAOKUN_UCSI_DATA_SIZE)); + + return 0; +} + +static int gaokun_ucsi_async_control(struct ucsi *ucsi, u64 command) +{ + struct gaokun_ucsi *uec = ucsi_get_drvdata(ucsi); + u8 buf[GAOKUN_UCSI_WRITE_SIZE] = {}; + + memcpy(buf, &command, sizeof(command)); + + return gaokun_ec_ucsi_write(uec->ec, buf); +} + +static void gaokun_ucsi_update_connector(struct ucsi_connector *con) +{ + struct gaokun_ucsi *uec = ucsi_get_drvdata(con->ucsi); + + if (con->num > uec->num_ports) + return; + + con->typec_cap.orientation_aware = true; +} + +static void gaokun_set_orientation(struct ucsi_connector *con, + struct gaokun_ucsi_port *port) +{ + enum gaokun_ucsi_ccx ccx; + unsigned long flags; + + spin_lock_irqsave(&port->lock, flags); + ccx = port->ccx; + spin_unlock_irqrestore(&port->lock, flags); + + typec_set_orientation(con->port, CCX_TO_ORI(ccx)); +} + +static void gaokun_ucsi_connector_status(struct ucsi_connector *con) +{ + struct gaokun_ucsi *uec = ucsi_get_drvdata(con->ucsi); + int idx; + + idx = con->num - 1; + if (con->num > uec->num_ports) { + dev_warn(uec->dev, "set orientation out of range: con%d\n", idx); + return; + } + + gaokun_set_orientation(con, &uec->ports[idx]); +} + +const struct ucsi_operations gaokun_ucsi_ops = { + .read_version = gaokun_ucsi_read_version, + .read_cci = gaokun_ucsi_read_cci, + .read_message_in = gaokun_ucsi_read_message_in, + .sync_control = ucsi_sync_control_common, + .async_control = gaokun_ucsi_async_control, + .update_connector = gaokun_ucsi_update_connector, + .connector_status = gaokun_ucsi_connector_status, +}; + +/* -------------------------------------------------------------------------- */ +/* For Altmode */ + +static void gaokun_ucsi_port_update(struct gaokun_ucsi_port *port, + const u8 *port_data) +{ + struct gaokun_ucsi *uec = port->ucsi; + int offset = port->idx * 2; /* every port has 2 Bytes data */ + unsigned long flags; + u8 dcc, ddi; + + dcc = port_data[offset]; + ddi = port_data[offset + 1]; + + spin_lock_irqsave(&port->lock, flags); + + port->ccx = FIELD_GET(GAOKUN_CCX_MASK, dcc); + port->mux = FIELD_GET(GAOKUN_MUX_MASK, dcc); + port->mode = FIELD_GET(GAOKUN_DPAM_MASK, ddi); + port->hpd_state = FIELD_GET(GAOKUN_HPD_STATE_MASK, ddi); + port->hpd_irq = FIELD_GET(GAOKUN_HPD_IRQ_MASK, ddi); + + /* Mode and SVID are unused; keeping them to make things clearer */ + switch (port->mode) { + case USBC_DPAM_PAN_C: + case USBC_DPAM_PAN_C_REVERSE: + port->mode = DP_PIN_ASSIGN_C; /* correct it for usb later */ + break; + case USBC_DPAM_PAN_D: + case USBC_DPAM_PAN_D_REVERSE: + port->mode = DP_PIN_ASSIGN_D; + break; + case USBC_DPAM_PAN_E: + case USBC_DPAM_PAN_E_REVERSE: + port->mode = DP_PIN_ASSIGN_E; + break; + case USBC_DPAM_PAN_NONE: + port->mode = TYPEC_STATE_SAFE; + break; + default: + dev_warn(uec->dev, "unknown mode %d\n", port->mode); + break; + } + + switch (port->mux) { + case USBC_MUX_NONE: + port->svid = 0; + break; + case USBC_MUX_USB_2L: + port->svid = USB_SID_PD; + port->mode = TYPEC_STATE_USB; /* same as PAN_C, correct it */ + break; + case USBC_MUX_DP_4L: + case USBC_MUX_USB_DP: + port->svid = USB_SID_DISPLAYPORT; + break; + default: + dev_warn(uec->dev, "unknown mux state %d\n", port->mux); + break; + } + + spin_unlock_irqrestore(&port->lock, flags); +} + +static int gaokun_ucsi_refresh(struct gaokun_ucsi *uec) +{ + struct gaokun_ucsi_reg ureg; + int ret, idx; + + ret = gaokun_ec_ucsi_get_reg(uec->ec, &ureg); + if (ret) + return GAOKUN_UCSI_NO_PORT_UPDATE; + + uec->num_ports = ureg.num_ports; + idx = GET_IDX(ureg.port_updt); + + if (idx < 0 || idx >= ureg.num_ports) + return GAOKUN_UCSI_NO_PORT_UPDATE; + + gaokun_ucsi_port_update(&uec->ports[idx], ureg.port_data); + return idx; +} + +static void gaokun_ucsi_handle_altmode(struct gaokun_ucsi_port *port) +{ + struct gaokun_ucsi *uec = port->ucsi; + int idx = port->idx; + + if (idx >= uec->ucsi->cap.num_connectors) { + dev_warn(uec->dev, "altmode port out of range: %d\n", idx); + return; + } + + /* UCSI callback .connector_status() have set orientation */ + if (port->bridge) + drm_aux_hpd_bridge_notify(&port->bridge->dev, + port->hpd_state ? + connector_status_connected : + connector_status_disconnected); + + gaokun_ec_ucsi_pan_ack(uec->ec, port->idx); +} + +static void gaokun_ucsi_altmode_notify_ind(struct gaokun_ucsi *uec) +{ + int idx; + + if (!uec->ucsi->connector) { /* slow to register */ + dev_err(uec->dev, "ucsi connector is not initialized yet\n"); + return; + } + + idx = gaokun_ucsi_refresh(uec); + if (idx == GAOKUN_UCSI_NO_PORT_UPDATE) + gaokun_ec_ucsi_pan_ack(uec->ec, idx); /* ack directly if no update */ + else + gaokun_ucsi_handle_altmode(&uec->ports[idx]); +} + +/* + * When inserting, 2 UCSI events(connector change) are followed by USB events. + * If we received one USB event, that means USB events are not blocked, so we + * can complelte for all ports, and we should signal all events. + */ +static void gaokun_ucsi_complete_usb_ack(struct gaokun_ucsi *uec) +{ + struct gaokun_ucsi_port *port; + int idx = 0; + + while (idx < uec->num_ports) { + port = &uec->ports[idx++]; + if (!completion_done(&port->usb_ack)) + complete_all(&port->usb_ack); + } +} + +/* + * USB event is necessary for enabling altmode, the event should follow + * UCSI event, if not after timeout(this notify may be disabled somehow), + * then force to enable altmode. + */ +static void gaokun_ucsi_handle_no_usb_event(struct gaokun_ucsi *uec, int idx) +{ + struct gaokun_ucsi_port *port; + + port = &uec->ports[idx]; + if (!wait_for_completion_timeout(&port->usb_ack, 2 * HZ)) { + dev_warn(uec->dev, "No USB EVENT, triggered by UCSI EVENT"); + gaokun_ucsi_altmode_notify_ind(uec); + } +} + +static int gaokun_ucsi_notify(struct notifier_block *nb, + unsigned long action, void *data) +{ + u32 cci; + struct gaokun_ucsi *uec = container_of(nb, struct gaokun_ucsi, nb); + + switch (action) { + case EC_EVENT_USB: + gaokun_ucsi_complete_usb_ack(uec); + gaokun_ucsi_altmode_notify_ind(uec); + return NOTIFY_OK; + + case EC_EVENT_UCSI: + gaokun_ucsi_read_cci(uec->ucsi, &cci); + ucsi_notify_common(uec->ucsi, cci); + if (UCSI_CCI_CONNECTOR(cci)) + gaokun_ucsi_handle_no_usb_event(uec, UCSI_CCI_CONNECTOR(cci) - 1); + + return NOTIFY_OK; + + default: + return NOTIFY_DONE; + } +} + +static int gaokun_ucsi_ports_init(struct gaokun_ucsi *uec) +{ + struct gaokun_ucsi_port *ucsi_port; + struct gaokun_ucsi_reg ureg = {}; + struct device *dev = uec->dev; + struct fwnode_handle *fwnode; + int i, ret, num_ports; + u32 port; + + gaokun_ec_ucsi_get_reg(uec->ec, &ureg); + num_ports = ureg.num_ports; + uec->num_ports = num_ports; + + uec->ports = devm_kcalloc(dev, num_ports, sizeof(*(uec->ports)), + GFP_KERNEL); + if (!uec->ports) + return -ENOMEM; + + for (i = 0; i < num_ports; ++i) { + ucsi_port = &uec->ports[i]; + ucsi_port->ccx = USBC_CCX_NONE; + ucsi_port->idx = i; + ucsi_port->ucsi = uec; + init_completion(&ucsi_port->usb_ack); + spin_lock_init(&ucsi_port->lock); + } + + device_for_each_child_node(dev, fwnode) { + ret = fwnode_property_read_u32(fwnode, "reg", &port); + if (ret < 0) { + dev_err(dev, "missing reg property of %pOFn\n", fwnode); + fwnode_handle_put(fwnode); + return ret; + } + + if (port >= num_ports) { + dev_warn(dev, "invalid connector number %d, ignoring\n", port); + continue; + } + + ucsi_port = &uec->ports[port]; + ucsi_port->bridge = devm_drm_dp_hpd_bridge_alloc(dev, to_of_node(fwnode)); + if (IS_ERR(ucsi_port->bridge)) { + fwnode_handle_put(fwnode); + return PTR_ERR(ucsi_port->bridge); + } + } + + for (i = 0; i < num_ports; i++) { + if (!uec->ports[i].bridge) + continue; + + ret = devm_drm_dp_hpd_bridge_add(dev, uec->ports[i].bridge); + if (ret) + return ret; + } + + return 0; +} + +static void gaokun_ucsi_register_worker(struct work_struct *work) +{ + struct gaokun_ucsi *uec; + struct ucsi *ucsi; + int ret; + + uec = container_of(work, struct gaokun_ucsi, work.work); + ucsi = uec->ucsi; + + ret = gaokun_ec_register_notify(uec->ec, &uec->nb); + if (ret) { + dev_err_probe(ucsi->dev, ret, "notifier register failed\n"); + return; + } + + ret = ucsi_register(ucsi); + if (ret) + dev_err_probe(ucsi->dev, ret, "ucsi register failed\n"); +} + +static int gaokun_ucsi_probe(struct auxiliary_device *adev, + const struct auxiliary_device_id *id) +{ + struct gaokun_ec *ec = adev->dev.platform_data; + struct device *dev = &adev->dev; + struct gaokun_ucsi *uec; + int ret; + + uec = devm_kzalloc(dev, sizeof(*uec), GFP_KERNEL); + if (!uec) + return -ENOMEM; + + uec->ec = ec; + uec->dev = dev; + uec->version = UCSI_VERSION_1_0; + uec->nb.notifier_call = gaokun_ucsi_notify; + + INIT_DELAYED_WORK(&uec->work, gaokun_ucsi_register_worker); + + ret = gaokun_ucsi_ports_init(uec); + if (ret) + return ret; + + uec->ucsi = ucsi_create(dev, &gaokun_ucsi_ops); + if (IS_ERR(uec->ucsi)) + return PTR_ERR(uec->ucsi); + + ucsi_set_drvdata(uec->ucsi, uec); + auxiliary_set_drvdata(adev, uec); + + /* EC can't handle UCSI properly in the early stage */ + schedule_delayed_work(&uec->work, 3 * HZ); + + return 0; +} + +static void gaokun_ucsi_remove(struct auxiliary_device *adev) +{ + struct gaokun_ucsi *uec = auxiliary_get_drvdata(adev); + + gaokun_ec_unregister_notify(uec->ec, &uec->nb); + ucsi_unregister(uec->ucsi); + ucsi_destroy(uec->ucsi); +} + +static const struct auxiliary_device_id gaokun_ucsi_id_table[] = { + { .name = GAOKUN_MOD_NAME "." GAOKUN_DEV_UCSI, }, + {} +}; +MODULE_DEVICE_TABLE(auxiliary, gaokun_ucsi_id_table); + +static struct auxiliary_driver gaokun_ucsi_driver = { + .name = GAOKUN_DEV_UCSI, + .id_table = gaokun_ucsi_id_table, + .probe = gaokun_ucsi_probe, + .remove = gaokun_ucsi_remove, +}; + +module_auxiliary_driver(gaokun_ucsi_driver); + +MODULE_DESCRIPTION("HUAWEI Matebook E Go UCSI driver"); +MODULE_LICENSE("GPL"); -- 2.47.1 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver 2025-01-13 17:51 ` [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver Pengyu Luo @ 2025-01-16 11:55 ` Heikki Krogerus 2025-01-16 18:26 ` Pengyu Luo 0 siblings, 1 reply; 20+ messages in thread From: Heikki Krogerus @ 2025-01-16 11:55 UTC (permalink / raw) To: Pengyu Luo; +Cc: Greg Kroah-Hartman, linux-kernel, linux-usb Hi, On Tue, Jan 14, 2025 at 01:51:26AM +0800, Pengyu Luo wrote: > The Huawei Matebook E Go tablet implements the UCSI interface in the > onboard EC. Add the glue driver to interface with the platform's UCSI > implementation. > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > --- > drivers/usb/typec/ucsi/Kconfig | 11 + > drivers/usb/typec/ucsi/Makefile | 1 + > drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c | 526 ++++++++++++++++++++ > 3 files changed, 538 insertions(+) > create mode 100644 drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > > diff --git a/drivers/usb/typec/ucsi/Kconfig b/drivers/usb/typec/ucsi/Kconfig > index 75559601f..e94956d27 100644 > --- a/drivers/usb/typec/ucsi/Kconfig > +++ b/drivers/usb/typec/ucsi/Kconfig > @@ -91,4 +91,15 @@ config UCSI_LENOVO_YOGA_C630 > To compile the driver as a module, choose M here: the module will be > called ucsi_yoga_c630. > > +config UCSI_HUAWEI_GAOKUN > + tristate "UCSI Interface Driver for Huawei Matebook E Go" > + depends on EC_HUAWEI_GAOKUN > + select DRM_AUX_HPD_BRIDGE > + help > + This driver enables UCSI support on the Huawei Matebook E Go tablet, > + which is a sc8280xp-based 2-in-1 tablet. > + > + To compile the driver as a module, choose M here: the module will be > + called ucsi_huawei_gaokun. > + > endif > diff --git a/drivers/usb/typec/ucsi/Makefile b/drivers/usb/typec/ucsi/Makefile > index be98a8791..dbc571763 100644 > --- a/drivers/usb/typec/ucsi/Makefile > +++ b/drivers/usb/typec/ucsi/Makefile > @@ -23,3 +23,4 @@ obj-$(CONFIG_UCSI_STM32G0) += ucsi_stm32g0.o > obj-$(CONFIG_UCSI_PMIC_GLINK) += ucsi_glink.o > obj-$(CONFIG_CROS_EC_UCSI) += cros_ec_ucsi.o > obj-$(CONFIG_UCSI_LENOVO_YOGA_C630) += ucsi_yoga_c630.o > +obj-$(CONFIG_UCSI_HUAWEI_GAOKUN) += ucsi_huawei_gaokun.o > diff --git a/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c b/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > new file mode 100644 > index 000000000..da1993805 > --- /dev/null > +++ b/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > @@ -0,0 +1,527 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * ucsi-huawei-gaokun - A UCSI driver for HUAWEI Matebook E Go > + * > + * reference: drivers/usb/typec/ucsi/ucsi_yoga_c630.c > + * drivers/usb/typec/ucsi/ucsi_glink.c > + * drivers/soc/qcom/pmic_glink_altmode.c > + * > + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> > + */ > + > +#include <drm/bridge/aux-bridge.h> > +#include <linux/auxiliary_bus.h> > +#include <linux/bitops.h> > +#include <linux/completion.h> > +#include <linux/container_of.h> > +#include <linux/module.h> > +#include <linux/notifier.h> > +#include <linux/of.h> > +#include <linux/platform_data/huawei-gaokun-ec.h> > +#include <linux/string.h> > +#include <linux/usb/pd_vdo.h> > +#include <linux/usb/typec_altmode.h> > +#include <linux/usb/typec_dp.h> > +#include <linux/workqueue_types.h> > + > +#include "ucsi.h" > + > +#define EC_EVENT_UCSI 0x21 > +#define EC_EVENT_USB 0x22 > + > +#define GAOKUN_CCX_MASK GENMASK(1, 0) > +#define GAOKUN_MUX_MASK GENMASK(3, 2) > + > +#define GAOKUN_DPAM_MASK GENMASK(3, 0) > +#define GAOKUN_HPD_STATE_MASK BIT(4) > +#define GAOKUN_HPD_IRQ_MASK BIT(5) > + > +#define GET_IDX(updt) (ffs(updt) - 1) > + > +#define CCX_TO_ORI(ccx) (++ccx % 3) /* convert ccx to enum typec_orientation */ > + > +/* Configuration Channel Extension */ > +enum gaokun_ucsi_ccx { > + USBC_CCX_NORMAL, > + USBC_CCX_REVERSE, > + USBC_CCX_NONE, > +}; > + > +enum gaokun_ucsi_mux { > + USBC_MUX_NONE, > + USBC_MUX_USB_2L, > + USBC_MUX_DP_4L, > + USBC_MUX_USB_DP, > +}; Missing newline. > +/* based on pmic_glink_altmode_pin_assignment */ > +enum gaokun_ucsi_dpam_pan { /* DP Alt Mode Pin Assignments */ > + USBC_DPAM_PAN_NONE, > + USBC_DPAM_PAN_A, /* Not supported after USB Type-C Standard v1.0b */ > + USBC_DPAM_PAN_B, /* Not supported after USB Type-C Standard v1.0b */ > + USBC_DPAM_PAN_C, /* USBC_DPAM_PAN_C_REVERSE - 6 */ > + USBC_DPAM_PAN_D, > + USBC_DPAM_PAN_E, > + USBC_DPAM_PAN_F, /* Not supported after USB Type-C Standard v1.0b */ > + USBC_DPAM_PAN_A_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ > + USBC_DPAM_PAN_B_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ > + USBC_DPAM_PAN_C_REVERSE, > + USBC_DPAM_PAN_D_REVERSE, > + USBC_DPAM_PAN_E_REVERSE, > + USBC_DPAM_PAN_F_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ > +}; > + > +struct gaokun_ucsi_reg { > + u8 num_ports; > + u8 port_updt; > + u8 port_data[4]; > + u8 checksum; > + u8 reserved; > +} __packed; > + > +struct gaokun_ucsi_port { > + struct completion usb_ack; > + spinlock_t lock; Locks need to be commented. Did you run checkpatch.pl on this? > + struct gaokun_ucsi *ucsi; > + struct auxiliary_device *bridge; > + > + int idx; > + enum gaokun_ucsi_ccx ccx; > + enum gaokun_ucsi_mux mux; > + u8 mode; > + u16 svid; > + u8 hpd_state; > + u8 hpd_irq; > +}; > + > +struct gaokun_ucsi { > + struct gaokun_ec *ec; > + struct ucsi *ucsi; > + struct gaokun_ucsi_port *ports; > + struct device *dev; > + struct delayed_work work; > + struct notifier_block nb; > + u16 version; > + u8 num_ports; > +}; thanks, -- heikki ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver 2025-01-16 11:55 ` Heikki Krogerus @ 2025-01-16 18:26 ` Pengyu Luo 0 siblings, 0 replies; 20+ messages in thread From: Pengyu Luo @ 2025-01-16 18:26 UTC (permalink / raw) To: heikki.krogerus; +Cc: gregkh, linux-kernel, linux-usb, mitltlatltl On Thu, Jan 16, 2025 at 7:55 PM Heikki Krogerus <heikki.krogerus@linux.intel.com> wrote: > Hi, > > On Tue, Jan 14, 2025 at 01:51:26AM +0800, Pengyu Luo wrote: > > The Huawei Matebook E Go tablet implements the UCSI interface in the > > onboard EC. Add the glue driver to interface with the platform's UCSI > > implementation. > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > --- > > drivers/usb/typec/ucsi/Kconfig | 11 + > > drivers/usb/typec/ucsi/Makefile | 1 + > > drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c | 526 ++++++++++++++++++++ > > 3 files changed, 538 insertions(+) > > create mode 100644 drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > > > > diff --git a/drivers/usb/typec/ucsi/Kconfig b/drivers/usb/typec/ucsi/Kconfig > > index 75559601f..e94956d27 100644 > > --- a/drivers/usb/typec/ucsi/Kconfig > > +++ b/drivers/usb/typec/ucsi/Kconfig > > @@ -91,4 +91,15 @@ config UCSI_LENOVO_YOGA_C630 > > To compile the driver as a module, choose M here: the module will be > > called ucsi_yoga_c630. > > > > +config UCSI_HUAWEI_GAOKUN > > + tristate "UCSI Interface Driver for Huawei Matebook E Go" > > + depends on EC_HUAWEI_GAOKUN > > + select DRM_AUX_HPD_BRIDGE > > + help > > + This driver enables UCSI support on the Huawei Matebook E Go tablet, > > + which is a sc8280xp-based 2-in-1 tablet. > > + > > + To compile the driver as a module, choose M here: the module will be > > + called ucsi_huawei_gaokun. > > + > > endif > > diff --git a/drivers/usb/typec/ucsi/Makefile b/drivers/usb/typec/ucsi/Makefile > > index be98a8791..dbc571763 100644 > > --- a/drivers/usb/typec/ucsi/Makefile > > +++ b/drivers/usb/typec/ucsi/Makefile > > @@ -23,3 +23,4 @@ obj-$(CONFIG_UCSI_STM32G0) += ucsi_stm32g0.o > > obj-$(CONFIG_UCSI_PMIC_GLINK) += ucsi_glink.o > > obj-$(CONFIG_CROS_EC_UCSI) += cros_ec_ucsi.o > > obj-$(CONFIG_UCSI_LENOVO_YOGA_C630) += ucsi_yoga_c630.o > > +obj-$(CONFIG_UCSI_HUAWEI_GAOKUN) += ucsi_huawei_gaokun.o > > diff --git a/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c b/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > > new file mode 100644 > > index 000000000..da1993805 > > --- /dev/null > > +++ b/drivers/usb/typec/ucsi/ucsi_huawei_gaokun.c > > @@ -0,0 +1,527 @@ > > +// SPDX-License-Identifier: GPL-2.0-only > > +/* > > + * ucsi-huawei-gaokun - A UCSI driver for HUAWEI Matebook E Go > > + * > > + * reference: drivers/usb/typec/ucsi/ucsi_yoga_c630.c > > + * drivers/usb/typec/ucsi/ucsi_glink.c > > + * drivers/soc/qcom/pmic_glink_altmode.c > > + * > > + * Copyright (C) 2024 Pengyu Luo <mitltlatltl@gmail.com> > > + */ > > + > > +#include <drm/bridge/aux-bridge.h> > > +#include <linux/auxiliary_bus.h> > > +#include <linux/bitops.h> > > +#include <linux/completion.h> > > +#include <linux/container_of.h> > > +#include <linux/module.h> > > +#include <linux/notifier.h> > > +#include <linux/of.h> > > +#include <linux/platform_data/huawei-gaokun-ec.h> > > +#include <linux/string.h> > > +#include <linux/usb/pd_vdo.h> > > +#include <linux/usb/typec_altmode.h> > > +#include <linux/usb/typec_dp.h> > > +#include <linux/workqueue_types.h> > > + > > +#include "ucsi.h" > > + > > +#define EC_EVENT_UCSI 0x21 > > +#define EC_EVENT_USB 0x22 > > + > > +#define GAOKUN_CCX_MASK GENMASK(1, 0) > > +#define GAOKUN_MUX_MASK GENMASK(3, 2) > > + > > +#define GAOKUN_DPAM_MASK GENMASK(3, 0) > > +#define GAOKUN_HPD_STATE_MASK BIT(4) > > +#define GAOKUN_HPD_IRQ_MASK BIT(5) > > + > > +#define GET_IDX(updt) (ffs(updt) - 1) > > + > > +#define CCX_TO_ORI(ccx) (++ccx % 3) /* convert ccx to enum typec_orientation */ > > + > > +/* Configuration Channel Extension */ > > +enum gaokun_ucsi_ccx { > > + USBC_CCX_NORMAL, > > + USBC_CCX_REVERSE, > > + USBC_CCX_NONE, > > +}; > > + > > +enum gaokun_ucsi_mux { > > + USBC_MUX_NONE, > > + USBC_MUX_USB_2L, > > + USBC_MUX_DP_4L, > > + USBC_MUX_USB_DP, > > +}; > > Missing newline. > > > +/* based on pmic_glink_altmode_pin_assignment */ > > +enum gaokun_ucsi_dpam_pan { /* DP Alt Mode Pin Assignments */ > > + USBC_DPAM_PAN_NONE, > > + USBC_DPAM_PAN_A, /* Not supported after USB Type-C Standard v1.0b */ > > + USBC_DPAM_PAN_B, /* Not supported after USB Type-C Standard v1.0b */ > > + USBC_DPAM_PAN_C, /* USBC_DPAM_PAN_C_REVERSE - 6 */ > > + USBC_DPAM_PAN_D, > > + USBC_DPAM_PAN_E, > > + USBC_DPAM_PAN_F, /* Not supported after USB Type-C Standard v1.0b */ > > + USBC_DPAM_PAN_A_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ > > + USBC_DPAM_PAN_B_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ > > + USBC_DPAM_PAN_C_REVERSE, > > + USBC_DPAM_PAN_D_REVERSE, > > + USBC_DPAM_PAN_E_REVERSE, > > + USBC_DPAM_PAN_F_REVERSE,/* Not supported after USB Type-C Standard v1.0b */ > > +}; > > + > > +struct gaokun_ucsi_reg { > > + u8 num_ports; > > + u8 port_updt; > > + u8 port_data[4]; > > + u8 checksum; > > + u8 reserved; > > +} __packed; > > + > > +struct gaokun_ucsi_port { > > + struct completion usb_ack; > > + spinlock_t lock; > > Locks need to be commented. Did you run checkpatch.pl on this? > I ran, without `--strict` though. I got it, I will do it. > > + struct gaokun_ucsi *ucsi; > > + struct auxiliary_device *bridge; > > + > > + int idx; > > + enum gaokun_ucsi_ccx ccx; > > + enum gaokun_ucsi_mux mux; > > + u8 mode; > > + u16 svid; > > + u8 hpd_state; > > + u8 hpd_irq; > > +}; > > + > > +struct gaokun_ucsi { > > + struct gaokun_ec *ec; > > + struct ucsi *ucsi; > > + struct gaokun_ucsi_port *ports; > > + struct device *dev; > > + struct delayed_work work; > > + struct notifier_block nb; > > + u16 version; > > + u8 num_ports; > > +}; > > thanks, > > -- > heikki Best wishes, Pengyu ^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver 2025-01-13 17:51 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver Pengyu Luo @ 2025-01-13 17:51 ` Pengyu Luo 2025-02-20 0:24 ` Sebastian Reichel 2025-01-13 17:51 ` [PATCH v3 6/6] arm64: dts: qcom: gaokun3: Add Embedded Controller node Pengyu Luo 2025-01-16 11:26 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Heikki Krogerus 3 siblings, 1 reply; 20+ messages in thread From: Pengyu Luo @ 2025-01-13 17:51 UTC (permalink / raw) To: Sebastian Reichel, Pengyu Luo; +Cc: linux-pm, linux-kernel On the Huawei Matebook E Go tablet the EC provides access to the adapter and battery status. Add the driver to read power supply status on the tablet. Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> --- .../ABI/testing/sysfs-class-power-gaokun | 47 ++ drivers/power/supply/Kconfig | 10 + drivers/power/supply/Makefile | 1 + drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++++++++ 4 files changed, 606 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun create mode 100644 drivers/power/supply/huawei-gaokun-battery.c diff --git a/Documentation/ABI/testing/sysfs-class-power-gaokun b/Documentation/ABI/testing/sysfs-class-power-gaokun new file mode 100644 index 000000000..b1eb9e8d7 --- /dev/null +++ b/Documentation/ABI/testing/sysfs-class-power-gaokun @@ -0,0 +1,47 @@ +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge +Date: January 2025 +KernelVersion: 6.12 +Contact: Pengyu Luo <mitltlatltl@gmail.com> +Description: + This entry allows configuration of smart charging behavior with + four parameters. The format is: <mode> <delay> <start> <stop>. + + - mode: Defines the charging mode (1 or 4). Mode 4 enables delay, + while mode 1 does not. + - delay: Specifies the delay in hours (non-negative). This is + only used when 'mode' is set to 4. + - start: The battery percentage at which charging starts (0-100). + - stop: The battery percentage at which charging stops (1-100). + + When the laptop is connected to a power adapter, it starts + charging if the battery level is below the 'start' value. It + continues charging until the battery reaches the 'stop' level. + If the battery is already above the 'stop' level, charging is + paused. + + When the power adapter is always connected, charging will + begin if the battery level falls below 'start', and charging + will stop once the battery reaches 'stop'. + + If mode is set to 4, the above charging mode will only occur + after the specified delay in hours. If mode is 1, there is + no delay. + + Access: Read, Write + + Valid values: + - mode: integer value (1 or 4) + - delay: integer value, delay in hours (non-negative) + - start: integer value, battery percentage (0-100) + - stop: integer value, battery percentage (1-100) + +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge_enable +Date: January 2025 +KernelVersion: 6.12 +Contact: Pengyu Luo <mitltlatltl@gmail.com> +Description: + This entry allows enabling smart charging. + + Access: Read, Write + + Valid values: 0 (disabled) or 1 (enabled) diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig index 7b18358f1..556bda9ad 100644 --- a/drivers/power/supply/Kconfig +++ b/drivers/power/supply/Kconfig @@ -161,6 +161,16 @@ config BATTERY_DS2782 Say Y here to enable support for the DS2782/DS2786 standalone battery gas-gauge. +config BATTERY_HUAWEI_GAOKUN + tristate "Huawei Matebook E Go power supply" + depends on EC_HUAWEI_GAOKUN + help + This driver enables battery and adapter support on the Huawei Matebook + E Go, which is a sc8280xp-based 2-in-1 tablet. + + To compile the driver as a module, choose M here: the module will be + called huawei-gaokun-battery. + config BATTERY_LEGO_EV3 tristate "LEGO MINDSTORMS EV3 battery" depends on OF && IIO && GPIOLIB && (ARCH_DAVINCI_DA850 || COMPILE_TEST) diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile index b55cc48a4..796570e7f 100644 --- a/drivers/power/supply/Makefile +++ b/drivers/power/supply/Makefile @@ -31,6 +31,7 @@ obj-$(CONFIG_BATTERY_DS2781) += ds2781_battery.o obj-$(CONFIG_BATTERY_DS2782) += ds2782_battery.o obj-$(CONFIG_BATTERY_GAUGE_LTC2941) += ltc2941-battery-gauge.o obj-$(CONFIG_BATTERY_GOLDFISH) += goldfish_battery.o +obj-$(CONFIG_BATTERY_HUAWEI_GAOKUN) += huawei-gaokun-battery.o obj-$(CONFIG_BATTERY_LEGO_EV3) += lego_ev3_battery.o obj-$(CONFIG_BATTERY_LENOVO_YOGA_C630) += lenovo_yoga_c630_battery.o obj-$(CONFIG_BATTERY_PMU) += pmu_battery.o diff --git a/drivers/power/supply/huawei-gaokun-battery.c b/drivers/power/supply/huawei-gaokun-battery.c new file mode 100644 index 000000000..65b617aea --- /dev/null +++ b/drivers/power/supply/huawei-gaokun-battery.c @@ -0,0 +1,548 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * huawei-gaokun-battery - A power supply driver for HUAWEI Matebook E Go + * + * reference: drivers/power/supply/lenovo_yoga_c630_battery.c + * drivers/platform/arm64/acer-aspire1-ec.c + * drivers/acpi/battery.c + * drivers/acpi/ac.c + * + * 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 3000 /* cache time in milliseconds */ + +#define MILLI_TO_MICRO 1000 + +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; + + default: + return -EINVAL; + } + + return 0; +} + +static enum power_supply_property gaokun_psy_adp_props[] = { + POWER_SUPPLY_PROP_ONLINE, +}; + +static const struct power_supply_desc gaokun_psy_adp_desc = { + .name = "gaokun-ec-adapter", + .type = POWER_SUPPLY_TYPE_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); + + 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_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 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_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, + .properties = gaokun_psy_bat_props, + .num_properties = ARRAY_SIZE(gaokun_psy_bat_props), +}; + +/* -------------------------------------------------------------------------- */ +/* Sysfs */ + +/* Smart charge enable */ +static ssize_t smart_charge_enable_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 smart_charge_enable_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(smart_charge_enable); + +/* Smart charge */ +static ssize_t smart_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); + 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 %d %d %d\n", + bf[0], bf[1], bf[2], bf[3]); +} + +static ssize_t smart_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); + u8 bf[GAOKUN_SMART_CHARGE_DATA_SIZE]; + int ret; + + if (sscanf(buf, "%hhd %hhd %hhd %hhd", bf, bf + 1, bf + 2, bf + 3) != 4) + return -EINVAL; + + if (bf[0] != 1 && bf[0] != 4) + return -EINVAL; + + ret = gaokun_ec_psy_set_smart_charge(ecbat->ec, bf); + if (ret) + return ret; + + return size; +} + +static DEVICE_ATTR_RW(smart_charge); + +static struct attribute *gaokun_psy_features_attrs[] = { + &dev_attr_smart_charge_enable.attr, + &dev_attr_smart_charge.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"); -- 2.47.1 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver 2025-01-13 17:51 ` [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver Pengyu Luo @ 2025-02-20 0:24 ` Sebastian Reichel 2025-02-20 6:43 ` Pengyu Luo 0 siblings, 1 reply; 20+ messages in thread From: Sebastian Reichel @ 2025-02-20 0:24 UTC (permalink / raw) To: Pengyu Luo; +Cc: linux-pm, linux-kernel Hi, On Tue, Jan 14, 2025 at 01:51:27AM +0800, Pengyu Luo wrote: > On the Huawei Matebook E Go tablet the EC provides access to the adapter > and battery status. Add the driver to read power supply status on the > tablet. > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > --- > .../ABI/testing/sysfs-class-power-gaokun | 47 ++ > drivers/power/supply/Kconfig | 10 + > drivers/power/supply/Makefile | 1 + > drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++++++++ > 4 files changed, 606 insertions(+) > create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun > create mode 100644 drivers/power/supply/huawei-gaokun-battery.c > > diff --git a/Documentation/ABI/testing/sysfs-class-power-gaokun b/Documentation/ABI/testing/sysfs-class-power-gaokun > new file mode 100644 > index 000000000..b1eb9e8d7 > --- /dev/null > +++ b/Documentation/ABI/testing/sysfs-class-power-gaokun > @@ -0,0 +1,47 @@ > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge > +Date: January 2025 > +KernelVersion: 6.12 > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > +Description: > + This entry allows configuration of smart charging behavior with > + four parameters. The format is: <mode> <delay> <start> <stop>. > + > + - mode: Defines the charging mode (1 or 4). Mode 4 enables delay, > + while mode 1 does not. > + - delay: Specifies the delay in hours (non-negative). This is > + only used when 'mode' is set to 4. > + - start: The battery percentage at which charging starts (0-100). > + - stop: The battery percentage at which charging stops (1-100). > + > + When the laptop is connected to a power adapter, it starts > + charging if the battery level is below the 'start' value. It > + continues charging until the battery reaches the 'stop' level. > + If the battery is already above the 'stop' level, charging is > + paused. > + > + When the power adapter is always connected, charging will > + begin if the battery level falls below 'start', and charging > + will stop once the battery reaches 'stop'. > + > + If mode is set to 4, the above charging mode will only occur > + after the specified delay in hours. If mode is 1, there is > + no delay. > + > + Access: Read, Write > + > + Valid values: > + - mode: integer value (1 or 4) > + - delay: integer value, delay in hours (non-negative) > + - start: integer value, battery percentage (0-100) > + - stop: integer value, battery percentage (1-100) There are common properties for start and stop charging percentage, which should be used: * POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD * POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD For the charge mode it seems there is no need to expose anything. You can have a single property for the charge delay in hours. If '0' is written to it there is no delay, so you can use mode 1 and otherwise you can use mode 4. There is no need for this multi-value mess. The delay thing seems to be quite specific to this EC, so a custom property for that is fine. > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge_enable > +Date: January 2025 > +KernelVersion: 6.12 > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > +Description: > + This entry allows enabling smart charging. > + > + Access: Read, Write > + > + Valid values: 0 (disabled) or 1 (enabled) > diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig > index 7b18358f1..556bda9ad 100644 > --- a/drivers/power/supply/Kconfig > +++ b/drivers/power/supply/Kconfig > @@ -161,6 +161,16 @@ config BATTERY_DS2782 > Say Y here to enable support for the DS2782/DS2786 standalone battery > gas-gauge. > > +config BATTERY_HUAWEI_GAOKUN > + tristate "Huawei Matebook E Go power supply" > + depends on EC_HUAWEI_GAOKUN > + help > + This driver enables battery and adapter support on the Huawei Matebook > + E Go, which is a sc8280xp-based 2-in-1 tablet. > + > + To compile the driver as a module, choose M here: the module will be > + called huawei-gaokun-battery. > + > config BATTERY_LEGO_EV3 > tristate "LEGO MINDSTORMS EV3 battery" > depends on OF && IIO && GPIOLIB && (ARCH_DAVINCI_DA850 || COMPILE_TEST) > diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile > index b55cc48a4..796570e7f 100644 > --- a/drivers/power/supply/Makefile > +++ b/drivers/power/supply/Makefile > @@ -31,6 +31,7 @@ obj-$(CONFIG_BATTERY_DS2781) += ds2781_battery.o > obj-$(CONFIG_BATTERY_DS2782) += ds2782_battery.o > obj-$(CONFIG_BATTERY_GAUGE_LTC2941) += ltc2941-battery-gauge.o > obj-$(CONFIG_BATTERY_GOLDFISH) += goldfish_battery.o > +obj-$(CONFIG_BATTERY_HUAWEI_GAOKUN) += huawei-gaokun-battery.o > obj-$(CONFIG_BATTERY_LEGO_EV3) += lego_ev3_battery.o > obj-$(CONFIG_BATTERY_LENOVO_YOGA_C630) += lenovo_yoga_c630_battery.o > obj-$(CONFIG_BATTERY_PMU) += pmu_battery.o > diff --git a/drivers/power/supply/huawei-gaokun-battery.c b/drivers/power/supply/huawei-gaokun-battery.c > new file mode 100644 > index 000000000..65b617aea > --- /dev/null > +++ b/drivers/power/supply/huawei-gaokun-battery.c > @@ -0,0 +1,548 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * huawei-gaokun-battery - A power supply driver for HUAWEI Matebook E Go > + * > + * reference: drivers/power/supply/lenovo_yoga_c630_battery.c > + * drivers/platform/arm64/acer-aspire1-ec.c > + * drivers/acpi/battery.c > + * drivers/acpi/ac.c > + * > + * 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 3000 /* cache time in milliseconds */ > + > +#define MILLI_TO_MICRO 1000 > + > +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; > + > + default: > + return -EINVAL; > + } > + > + return 0; > +} > + > +static enum power_supply_property gaokun_psy_adp_props[] = { > + POWER_SUPPLY_PROP_ONLINE, > +}; > + > +static const struct power_supply_desc gaokun_psy_adp_desc = { > + .name = "gaokun-ec-adapter", > + .type = POWER_SUPPLY_TYPE_USB_TYPE_C, That's deprecated and should not be used. Use POWER_SUPPLY_TYPE_USB and POWER_SUPPLY_PROP_USB_TYPE for the exact type. > + .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); why? > + if (!gaokun_psy_bat_present(ecbat)) > + return; You only call it in your probe function, so the following will remain uninitialized if the battery was not present at boot time. Greetings, -- Sebastian > + 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); > + > + 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_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 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_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, > + .properties = gaokun_psy_bat_props, > + .num_properties = ARRAY_SIZE(gaokun_psy_bat_props), > +}; > + > +/* -------------------------------------------------------------------------- */ > +/* Sysfs */ > + > +/* Smart charge enable */ > +static ssize_t smart_charge_enable_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 smart_charge_enable_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(smart_charge_enable); > + > +/* Smart charge */ > +static ssize_t smart_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); > + 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 %d %d %d\n", > + bf[0], bf[1], bf[2], bf[3]); > +} > + > +static ssize_t smart_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); > + u8 bf[GAOKUN_SMART_CHARGE_DATA_SIZE]; > + int ret; > + > + if (sscanf(buf, "%hhd %hhd %hhd %hhd", bf, bf + 1, bf + 2, bf + 3) != 4) > + return -EINVAL; > + > + if (bf[0] != 1 && bf[0] != 4) > + return -EINVAL; > + > + ret = gaokun_ec_psy_set_smart_charge(ecbat->ec, bf); > + if (ret) > + return ret; > + > + return size; > +} > + > +static DEVICE_ATTR_RW(smart_charge); > + > +static struct attribute *gaokun_psy_features_attrs[] = { > + &dev_attr_smart_charge_enable.attr, > + &dev_attr_smart_charge.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"); > -- > 2.47.1 > ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver 2025-02-20 0:24 ` Sebastian Reichel @ 2025-02-20 6:43 ` Pengyu Luo 2025-02-21 1:33 ` Sebastian Reichel 0 siblings, 1 reply; 20+ messages in thread From: Pengyu Luo @ 2025-02-20 6:43 UTC (permalink / raw) To: sebastian.reichel; +Cc: linux-kernel, linux-pm, mitltlatltl On Thu, Feb 20, 2025 at 8:24 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > Hi, > > On Tue, Jan 14, 2025 at 01:51:27AM +0800, Pengyu Luo wrote: > > On the Huawei Matebook E Go tablet the EC provides access to the adapter > > and battery status. Add the driver to read power supply status on the > > tablet. > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > --- > > .../ABI/testing/sysfs-class-power-gaokun | 47 ++ > > drivers/power/supply/Kconfig | 10 + > > drivers/power/supply/Makefile | 1 + > > drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++++++++ > > 4 files changed, 606 insertions(+) > > create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun > > create mode 100644 drivers/power/supply/huawei-gaokun-battery.c > > > > diff --git a/Documentation/ABI/testing/sysfs-class-power-gaokun b/Documentation/ABI/testing/sysfs-class-power-gaokun > > new file mode 100644 > > index 000000000..b1eb9e8d7 > > --- /dev/null > > +++ b/Documentation/ABI/testing/sysfs-class-power-gaokun > > @@ -0,0 +1,47 @@ > > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge > > +Date: January 2025 > > +KernelVersion: 6.12 > > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > > +Description: > > + This entry allows configuration of smart charging behavior with > > + four parameters. The format is: <mode> <delay> <start> <stop>. > > + > > + - mode: Defines the charging mode (1 or 4). Mode 4 enables delay, > > + while mode 1 does not. > > + - delay: Specifies the delay in hours (non-negative). This is > > + only used when 'mode' is set to 4. > > + - start: The battery percentage at which charging starts (0-100). > > + - stop: The battery percentage at which charging stops (1-100). > > + > > + When the laptop is connected to a power adapter, it starts > > + charging if the battery level is below the 'start' value. It > > + continues charging until the battery reaches the 'stop' level. > > + If the battery is already above the 'stop' level, charging is > > + paused. > > + > > + When the power adapter is always connected, charging will > > + begin if the battery level falls below 'start', and charging > > + will stop once the battery reaches 'stop'. > > + > > + If mode is set to 4, the above charging mode will only occur > > + after the specified delay in hours. If mode is 1, there is > > + no delay. > > + > > + Access: Read, Write > > + > > + Valid values: > > + - mode: integer value (1 or 4) > > + - delay: integer value, delay in hours (non-negative) > > + - start: integer value, battery percentage (0-100) > > + - stop: integer value, battery percentage (1-100) > > There are common properties for start and stop charging percentage, > which should be used: > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD > * POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD > Agree, but at least, we should pass delay, start, end. EC only providedone interface to set mode and delay, that requires 4 arguments, we can handle it with 3 arguments, as you suggested below. but if we treat start and end separated, then if we want to set smart charge, we set start, set end, set delay(read start read end, then set them again). It is a bit redundant. > For the charge mode it seems there is no need to expose anything. > You can have a single property for the charge delay in hours. If > '0' is written to it there is no delay, so you can use mode 1 and > otherwise you can use mode 4. There is no need for this multi-value > mess. The delay thing seems to be quite specific to this EC, so a > custom property for that is fine. > Agree, mentioned above > > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge_enable > > +Date: January 2025 > > +KernelVersion: 6.12 > > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > > +Description: > > + This entry allows enabling smart charging. > > + > > + Access: Read, Write > > + > > + Valid values: 0 (disabled) or 1 (enabled) > > diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig > > index 7b18358f1..556bda9ad 100644 > > --- a/drivers/power/supply/Kconfig > > +++ b/drivers/power/supply/Kconfig > > @@ -161,6 +161,16 @@ config BATTERY_DS2782 > > Say Y here to enable support for the DS2782/DS2786 standalone battery > > gas-gauge. > > > > +config BATTERY_HUAWEI_GAOKUN > > + tristate "Huawei Matebook E Go power supply" > > + depends on EC_HUAWEI_GAOKUN > > + help > > + This driver enables battery and adapter support on the Huawei Matebook > > + E Go, which is a sc8280xp-based 2-in-1 tablet. > > + > > + To compile the driver as a module, choose M here: the module will be > > + called huawei-gaokun-battery. > > + > > config BATTERY_LEGO_EV3 > > tristate "LEGO MINDSTORMS EV3 battery" > > depends on OF && IIO && GPIOLIB && (ARCH_DAVINCI_DA850 || COMPILE_TEST) > > diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile > > index b55cc48a4..796570e7f 100644 > > --- a/drivers/power/supply/Makefile > > +++ b/drivers/power/supply/Makefile > > @@ -31,6 +31,7 @@ obj-$(CONFIG_BATTERY_DS2781) += ds2781_battery.o > > obj-$(CONFIG_BATTERY_DS2782) += ds2782_battery.o > > obj-$(CONFIG_BATTERY_GAUGE_LTC2941) += ltc2941-battery-gauge.o > > obj-$(CONFIG_BATTERY_GOLDFISH) += goldfish_battery.o > > +obj-$(CONFIG_BATTERY_HUAWEI_GAOKUN) += huawei-gaokun-battery.o > > obj-$(CONFIG_BATTERY_LEGO_EV3) += lego_ev3_battery.o > > obj-$(CONFIG_BATTERY_LENOVO_YOGA_C630) += lenovo_yoga_c630_battery.o > > obj-$(CONFIG_BATTERY_PMU) += pmu_battery.o > > diff --git a/drivers/power/supply/huawei-gaokun-battery.c b/drivers/power/supply/huawei-gaokun-battery.c > > new file mode 100644 > > index 000000000..65b617aea > > --- /dev/null > > +++ b/drivers/power/supply/huawei-gaokun-battery.c > > @@ -0,0 +1,548 @@ > > +// SPDX-License-Identifier: GPL-2.0-only > > +/* > > + * huawei-gaokun-battery - A power supply driver for HUAWEI Matebook E Go > > + * > > + * reference: drivers/power/supply/lenovo_yoga_c630_battery.c > > + * drivers/platform/arm64/acer-aspire1-ec.c > > + * drivers/acpi/battery.c > > + * drivers/acpi/ac.c > > + * > > + * 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 3000 /* cache time in milliseconds */ > > + > > +#define MILLI_TO_MICRO 1000 > > + > > +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; > > + > > + default: > > + return -EINVAL; > > + } > > + > > + return 0; > > +} > > + > > +static enum power_supply_property gaokun_psy_adp_props[] = { > > + POWER_SUPPLY_PROP_ONLINE, > > +}; > > + > > +static const struct power_supply_desc gaokun_psy_adp_desc = { > > + .name = "gaokun-ec-adapter", > > + .type = POWER_SUPPLY_TYPE_USB_TYPE_C, > > That's deprecated and should not be used. Use POWER_SUPPLY_TYPE_USB > and POWER_SUPPLY_PROP_USB_TYPE for the exact type. > Agree > > + .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); > > why? > EC provided a way to check if battery is presented, if there is no battery, then we don't fetch battery info, but other info (i.e. adapter) is still available. > > + if (!gaokun_psy_bat_present(ecbat)) > > + return; > > You only call it in your probe function, so the following will > remain uninitialized if the battery was not present at boot time. > mentioned above, keep them uninitialized is unharmful. Best wishes, Pengyu ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver 2025-02-20 6:43 ` Pengyu Luo @ 2025-02-21 1:33 ` Sebastian Reichel 2025-02-21 6:01 ` Pengyu Luo 0 siblings, 1 reply; 20+ messages in thread From: Sebastian Reichel @ 2025-02-21 1:33 UTC (permalink / raw) To: Pengyu Luo; +Cc: linux-kernel, linux-pm [-- Attachment #1: Type: text/plain, Size: 5369 bytes --] Hi, On Thu, Feb 20, 2025 at 02:43:20PM +0800, Pengyu Luo wrote: > On Thu, Feb 20, 2025 at 8:24 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > > On Tue, Jan 14, 2025 at 01:51:27AM +0800, Pengyu Luo wrote: > > > On the Huawei Matebook E Go tablet the EC provides access to the adapter > > > and battery status. Add the driver to read power supply status on the > > > tablet. > > > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > > --- > > > .../ABI/testing/sysfs-class-power-gaokun | 47 ++ > > > drivers/power/supply/Kconfig | 10 + > > > drivers/power/supply/Makefile | 1 + > > > drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++++++++ > > > 4 files changed, 606 insertions(+) > > > create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun > > > create mode 100644 drivers/power/supply/huawei-gaokun-battery.c > > > > > > diff --git a/Documentation/ABI/testing/sysfs-class-power-gaokun b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > new file mode 100644 > > > index 000000000..b1eb9e8d7 > > > --- /dev/null > > > +++ b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > @@ -0,0 +1,47 @@ > > > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge > > > +Date: January 2025 > > > +KernelVersion: 6.12 > > > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > > > +Description: > > > + This entry allows configuration of smart charging behavior with > > > + four parameters. The format is: <mode> <delay> <start> <stop>. > > > + > > > + - mode: Defines the charging mode (1 or 4). Mode 4 enables delay, > > > + while mode 1 does not. > > > + - delay: Specifies the delay in hours (non-negative). This is > > > + only used when 'mode' is set to 4. > > > + - start: The battery percentage at which charging starts (0-100). > > > + - stop: The battery percentage at which charging stops (1-100). > > > + > > > + When the laptop is connected to a power adapter, it starts > > > + charging if the battery level is below the 'start' value. It > > > + continues charging until the battery reaches the 'stop' level. > > > + If the battery is already above the 'stop' level, charging is > > > + paused. > > > + > > > + When the power adapter is always connected, charging will > > > + begin if the battery level falls below 'start', and charging > > > + will stop once the battery reaches 'stop'. > > > + > > > + If mode is set to 4, the above charging mode will only occur > > > + after the specified delay in hours. If mode is 1, there is > > > + no delay. > > > + > > > + Access: Read, Write > > > + > > > + Valid values: > > > + - mode: integer value (1 or 4) > > > + - delay: integer value, delay in hours (non-negative) > > > + - start: integer value, battery percentage (0-100) > > > + - stop: integer value, battery percentage (1-100) > > > > There are common properties for start and stop charging percentage, > > which should be used: > > > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD > > > > Agree, but at least, we should pass delay, start, end. EC only > providedone interface to set mode and delay, that requires 4 > arguments, we can handle it with 3 arguments, as you suggested > below. but if we treat start and end separated, then if we want > to set smart charge, we set start, set end, set delay(read start > read end, then set them again). It is a bit redundant. Yes, if these are separate properties you won't get atomic updates. But is that really a problem? Using the standard properties means that you get UI support in the future. I know at least the GNOME people are working on this. > > For the charge mode it seems there is no need to expose anything. > > You can have a single property for the charge delay in hours. If > > '0' is written to it there is no delay, so you can use mode 1 and > > otherwise you can use mode 4. There is no need for this multi-value > > mess. The delay thing seems to be quite specific to this EC, so a > > custom property for that is fine. > > > > Agree, mentioned above [...] > > > +static void gaokun_psy_init(struct gaokun_psy *ecbat) > > > +{ > > > + gaokun_psy_get_bat_present(ecbat); > > > > why? > > > > EC provided a way to check if battery is presented, if there is no > battery, then we don't fetch battery info, but other info > (i.e. adapter) is still available. nevermind, I miss-read and wondered why gaokun_psy_bat_present is being called twice. > > > + if (!gaokun_psy_bat_present(ecbat)) > > > + return; > > > > You only call it in your probe function, so the following will > > remain uninitialized if the battery was not present at boot time. > > mentioned above, keep them uninitialized is unharmful. Does the battery not support hot-plug? -- Sebastian [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 833 bytes --] ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver 2025-02-21 1:33 ` Sebastian Reichel @ 2025-02-21 6:01 ` Pengyu Luo 2025-02-21 22:22 ` Sebastian Reichel 0 siblings, 1 reply; 20+ messages in thread From: Pengyu Luo @ 2025-02-21 6:01 UTC (permalink / raw) To: sebastian.reichel; +Cc: linux-kernel, linux-pm, mitltlatltl On Fri, Feb 21, 2025 at 9:33 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > On Thu, Feb 20, 2025 at 02:43:20PM +0800, Pengyu Luo wrote: > > On Thu, Feb 20, 2025 at 8:24 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > > > On Tue, Jan 14, 2025 at 01:51:27AM +0800, Pengyu Luo wrote: > > > > On the Huawei Matebook E Go tablet the EC provides access to the adapter > > > > and battery status. Add the driver to read power supply status on the > > > > tablet. > > > > > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > > > --- > > > > .../ABI/testing/sysfs-class-power-gaokun | 47 ++ > > > > drivers/power/supply/Kconfig | 10 + > > > > drivers/power/supply/Makefile | 1 + > > > > drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++++++++ > > > > 4 files changed, 606 insertions(+) > > > > create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun > > > > create mode 100644 drivers/power/supply/huawei-gaokun-battery.c > > > > > > > > diff --git a/Documentation/ABI/testing/sysfs-class-power-gaokun b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > > new file mode 100644 > > > > index 000000000..b1eb9e8d7 > > > > --- /dev/null > > > > +++ b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > > @@ -0,0 +1,47 @@ > > > > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge > > > > +Date: January 2025 > > > > +KernelVersion: 6.12 > > > > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > > > > +Description: > > > > + This entry allows configuration of smart charging behavior with > > > > + four parameters. The format is: <mode> <delay> <start> <stop>. > > > > + > > > > + - mode: Defines the charging mode (1 or 4). Mode 4 enables delay, > > > > + while mode 1 does not. > > > > + - delay: Specifies the delay in hours (non-negative). This is > > > > + only used when 'mode' is set to 4. > > > > + - start: The battery percentage at which charging starts (0-100). > > > > + - stop: The battery percentage at which charging stops (1-100). > > > > + > > > > + When the laptop is connected to a power adapter, it starts > > > > + charging if the battery level is below the 'start' value. It > > > > + continues charging until the battery reaches the 'stop' level. > > > > + If the battery is already above the 'stop' level, charging is > > > > + paused. > > > > + > > > > + When the power adapter is always connected, charging will > > > > + begin if the battery level falls below 'start', and charging > > > > + will stop once the battery reaches 'stop'. > > > > + > > > > + If mode is set to 4, the above charging mode will only occur > > > > + after the specified delay in hours. If mode is 1, there is > > > > + no delay. > > > > + > > > > + Access: Read, Write > > > > + > > > > + Valid values: > > > > + - mode: integer value (1 or 4) > > > > + - delay: integer value, delay in hours (non-negative) > > > > + - start: integer value, battery percentage (0-100) > > > > + - stop: integer value, battery percentage (1-100) > > > > > > There are common properties for start and stop charging percentage, > > > which should be used: > > > > > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD > > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD > > > > > > > Agree, but at least, we should pass delay, start, end. EC only > > providedone interface to set mode and delay, that requires 4 > > arguments, we can handle it with 3 arguments, as you suggested > > below. but if we treat start and end separated, then if we want > > to set smart charge, we set start, set end, set delay(read start > > read end, then set them again). It is a bit redundant. > > Yes, if these are separate properties you won't get atomic updates. > But is that really a problem? Using the standard properties means > that you get UI support in the future. I know at least the GNOME > people are working on this. > On my another x86_64 device with end threshold supported, KDE Plasma supports showing this as > Battery is configured to charge up to aproximately <value>% it doesn't support setting things. So, can I keep passing delay, start, end when setting, but also setting start and end as battery properties? > > > For the charge mode it seems there is no need to expose anything. > > > You can have a single property for the charge delay in hours. If > > > '0' is written to it there is no delay, so you can use mode 1 and > > > otherwise you can use mode 4. There is no need for this multi-value > > > mess. The delay thing seems to be quite specific to this EC, so a > > > custom property for that is fine. > > > > > > > Agree, mentioned above > > [...] > > > > > +static void gaokun_psy_init(struct gaokun_psy *ecbat) > > > > +{ > > > > + gaokun_psy_get_bat_present(ecbat); > > > > > > why? > > > > > > > EC provided a way to check if battery is presented, if there is no > > battery, then we don't fetch battery info, but other info > > (i.e. adapter) is still available. > > nevermind, I miss-read and wondered why gaokun_psy_bat_present is > being called twice. > > > > > + if (!gaokun_psy_bat_present(ecbat)) > > > > + return; > > > > > > You only call it in your probe function, so the following will > > > remain uninitialized if the battery was not present at boot time. > > > > mentioned above, keep them uninitialized is unharmful. > > Does the battery not support hot-plug? > I am not sure, this is a tablet shipped with a qualcomm chip, we can take it as an embedded device. I just took normal usage and using without battery into account. Best wishes, Pengyu ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver 2025-02-21 6:01 ` Pengyu Luo @ 2025-02-21 22:22 ` Sebastian Reichel 2025-02-22 11:27 ` Pengyu Luo 0 siblings, 1 reply; 20+ messages in thread From: Sebastian Reichel @ 2025-02-21 22:22 UTC (permalink / raw) To: Pengyu Luo; +Cc: linux-kernel, linux-pm [-- Attachment #1: Type: text/plain, Size: 5389 bytes --] Hi, On Fri, Feb 21, 2025 at 02:01:04PM +0800, Pengyu Luo wrote: > On Fri, Feb 21, 2025 at 9:33 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > > On Thu, Feb 20, 2025 at 02:43:20PM +0800, Pengyu Luo wrote: > > > On Thu, Feb 20, 2025 at 8:24 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > > > > On Tue, Jan 14, 2025 at 01:51:27AM +0800, Pengyu Luo wrote: > > > > > On the Huawei Matebook E Go tablet the EC provides access to the adapter > > > > > and battery status. Add the driver to read power supply status on the > > > > > tablet. > > > > > > > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > > > > --- > > > > > .../ABI/testing/sysfs-class-power-gaokun | 47 ++ > > > > > drivers/power/supply/Kconfig | 10 + > > > > > drivers/power/supply/Makefile | 1 + > > > > > drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++++++++ > > > > > 4 files changed, 606 insertions(+) > > > > > create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun > > > > > create mode 100644 drivers/power/supply/huawei-gaokun-battery.c > > > > > > > > > > diff --git a/Documentation/ABI/testing/sysfs-class-power-gaokun b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > > > new file mode 100644 > > > > > index 000000000..b1eb9e8d7 > > > > > --- /dev/null > > > > > +++ b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > > > @@ -0,0 +1,47 @@ > > > > > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge > > > > > +Date: January 2025 > > > > > +KernelVersion: 6.12 > > > > > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > > > > > +Description: > > > > > + This entry allows configuration of smart charging behavior with > > > > > + four parameters. The format is: <mode> <delay> <start> <stop>. > > > > > + > > > > > + - mode: Defines the charging mode (1 or 4). Mode 4 enables delay, > > > > > + while mode 1 does not. > > > > > + - delay: Specifies the delay in hours (non-negative). This is > > > > > + only used when 'mode' is set to 4. > > > > > + - start: The battery percentage at which charging starts (0-100). > > > > > + - stop: The battery percentage at which charging stops (1-100). > > > > > + > > > > > + When the laptop is connected to a power adapter, it starts > > > > > + charging if the battery level is below the 'start' value. It > > > > > + continues charging until the battery reaches the 'stop' level. > > > > > + If the battery is already above the 'stop' level, charging is > > > > > + paused. > > > > > + > > > > > + When the power adapter is always connected, charging will > > > > > + begin if the battery level falls below 'start', and charging > > > > > + will stop once the battery reaches 'stop'. > > > > > + > > > > > + If mode is set to 4, the above charging mode will only occur > > > > > + after the specified delay in hours. If mode is 1, there is > > > > > + no delay. > > > > > + > > > > > + Access: Read, Write > > > > > + > > > > > + Valid values: > > > > > + - mode: integer value (1 or 4) > > > > > + - delay: integer value, delay in hours (non-negative) > > > > > + - start: integer value, battery percentage (0-100) > > > > > + - stop: integer value, battery percentage (1-100) > > > > > > > > There are common properties for start and stop charging percentage, > > > > which should be used: > > > > > > > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD > > > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD > > > > > > > > > > Agree, but at least, we should pass delay, start, end. EC only > > > providedone interface to set mode and delay, that requires 4 > > > arguments, we can handle it with 3 arguments, as you suggested > > > below. but if we treat start and end separated, then if we want > > > to set smart charge, we set start, set end, set delay(read start > > > read end, then set them again). It is a bit redundant. > > > > Yes, if these are separate properties you won't get atomic updates. > > But is that really a problem? Using the standard properties means > > that you get UI support in the future. I know at least the GNOME > > people are working on this. > > > > On my another x86_64 device with end threshold supported, KDE Plasma > supports showing this as > > > Battery is configured to charge up to aproximately <value>% > > it doesn't support setting things. So, can I keep passing delay, start, > end when setting, but also setting start and end as battery properties? No? Why should we create a custom sysfs ABI (which also breaks the one value per file rule), if we already have a standard ABI? > > Does the battery not support hot-plug? > > I am not sure, this is a tablet shipped with a qualcomm chip, we can > take it as an embedded device. I just took normal usage and using > without battery into account. I see. Let's keep it that way for now then. -- Sebastian [-- Attachment #2: signature.asc --] [-- Type: application/pgp-signature, Size: 833 bytes --] ^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver 2025-02-21 22:22 ` Sebastian Reichel @ 2025-02-22 11:27 ` Pengyu Luo 0 siblings, 0 replies; 20+ messages in thread From: Pengyu Luo @ 2025-02-22 11:27 UTC (permalink / raw) To: sebastian.reichel; +Cc: linux-kernel, linux-pm, mitltlatltl On Sat, Feb 22, 2025 at 6:22 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > On Fri, Feb 21, 2025 at 02:01:04PM +0800, Pengyu Luo wrote: > > On Fri, Feb 21, 2025 at 9:33 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > > > On Thu, Feb 20, 2025 at 02:43:20PM +0800, Pengyu Luo wrote: > > > > On Thu, Feb 20, 2025 at 8:24 AM Sebastian Reichel <sebastian.reichel@collabora.com> wrote: > > > > > On Tue, Jan 14, 2025 at 01:51:27AM +0800, Pengyu Luo wrote: > > > > > > On the Huawei Matebook E Go tablet the EC provides access to the adapter > > > > > > and battery status. Add the driver to read power supply status on the > > > > > > tablet. > > > > > > > > > > > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> > > > > > > --- > > > > > > .../ABI/testing/sysfs-class-power-gaokun | 47 ++ > > > > > > drivers/power/supply/Kconfig | 10 + > > > > > > drivers/power/supply/Makefile | 1 + > > > > > > drivers/power/supply/huawei-gaokun-battery.c | 548 ++++++++++++++++++ > > > > > > 4 files changed, 606 insertions(+) > > > > > > create mode 100644 Documentation/ABI/testing/sysfs-class-power-gaokun > > > > > > create mode 100644 drivers/power/supply/huawei-gaokun-battery.c > > > > > > > > > > > > diff --git a/Documentation/ABI/testing/sysfs-class-power-gaokun b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > > > > new file mode 100644 > > > > > > index 000000000..b1eb9e8d7 > > > > > > --- /dev/null > > > > > > +++ b/Documentation/ABI/testing/sysfs-class-power-gaokun > > > > > > @@ -0,0 +1,47 @@ > > > > > > +What: /sys/class/power_supply/gaokun-ec-battery/smart_charge > > > > > > +Date: January 2025 > > > > > > +KernelVersion: 6.12 > > > > > > +Contact: Pengyu Luo <mitltlatltl@gmail.com> > > > > > > +Description: > > > > > > + This entry allows configuration of smart charging behavior with > > > > > > + four parameters. The format is: <mode> <delay> <start> <stop>. > > > > > > + > > > > > > + - mode: Defines the charging mode (1 or 4). Mode 4 enables delay, > > > > > > + while mode 1 does not. > > > > > > + - delay: Specifies the delay in hours (non-negative). This is > > > > > > + only used when 'mode' is set to 4. > > > > > > + - start: The battery percentage at which charging starts (0-100). > > > > > > + - stop: The battery percentage at which charging stops (1-100). > > > > > > + > > > > > > + When the laptop is connected to a power adapter, it starts > > > > > > + charging if the battery level is below the 'start' value. It > > > > > > + continues charging until the battery reaches the 'stop' level. > > > > > > + If the battery is already above the 'stop' level, charging is > > > > > > + paused. > > > > > > + > > > > > > + When the power adapter is always connected, charging will > > > > > > + begin if the battery level falls below 'start', and charging > > > > > > + will stop once the battery reaches 'stop'. > > > > > > + > > > > > > + If mode is set to 4, the above charging mode will only occur > > > > > > + after the specified delay in hours. If mode is 1, there is > > > > > > + no delay. > > > > > > + > > > > > > + Access: Read, Write > > > > > > + > > > > > > + Valid values: > > > > > > + - mode: integer value (1 or 4) > > > > > > + - delay: integer value, delay in hours (non-negative) > > > > > > + - start: integer value, battery percentage (0-100) > > > > > > + - stop: integer value, battery percentage (1-100) > > > > > > > > > > There are common properties for start and stop charging percentage, > > > > > which should be used: > > > > > > > > > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_START_THRESHOLD > > > > > * POWER_SUPPLY_PROP_CHARGE_CONTROL_END_THRESHOLD > > > > > > > > > > > > > Agree, but at least, we should pass delay, start, end. EC only > > > > providedone interface to set mode and delay, that requires 4 > > > > arguments, we can handle it with 3 arguments, as you suggested > > > > below. but if we treat start and end separated, then if we want > > > > to set smart charge, we set start, set end, set delay(read start > > > > read end, then set them again). It is a bit redundant. > > > > > > Yes, if these are separate properties you won't get atomic updates. > > > But is that really a problem? Using the standard properties means > > > that you get UI support in the future. I know at least the GNOME > > > people are working on this. > > > > > > > On my another x86_64 device with end threshold supported, KDE Plasma > > supports showing this as > > > > > Battery is configured to charge up to aproximately <value>% > > > > it doesn't support setting things. So, can I keep passing delay, start, > > end when setting, but also setting start and end as battery properties? > > No? Why should we create a custom sysfs ABI (which also breaks the > one value per file rule), if we already have a standard ABI? > I got it, I will follow it. Since V4, I had dropped this driver to focus on upstreaming the base EC driver, once the base driver is upstreamed, I will send the new version of battery driver. Best wishes, Pengyu ^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v3 6/6] arm64: dts: qcom: gaokun3: Add Embedded Controller node 2025-01-13 17:51 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver Pengyu Luo @ 2025-01-13 17:51 ` Pengyu Luo 2025-01-16 11:26 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Heikki Krogerus 3 siblings, 0 replies; 20+ messages in thread From: Pengyu Luo @ 2025-01-13 17:51 UTC (permalink / raw) To: Bjorn Andersson, Konrad Dybcio, Rob Herring, Krzysztof Kozlowski, Conor Dooley Cc: Pengyu Luo, linux-arm-msm, devicetree, linux-kernel The Embedded Controller in the Huawei Matebook E Go is accessible on &i2c15 and provides battery and adapter status, port orientation status, as well as HPD event notifications for two USB Type-C port, etc. Add the EC to the device tree and describe the relationship among the type-c connectors, role switches, orientation switches and the QMP combo PHY. Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> --- .../boot/dts/qcom/sc8280xp-huawei-gaokun3.dts | 163 ++++++++++++++++++ 1 file changed, 163 insertions(+) diff --git a/arch/arm64/boot/dts/qcom/sc8280xp-huawei-gaokun3.dts b/arch/arm64/boot/dts/qcom/sc8280xp-huawei-gaokun3.dts index 09b95f89e..1667c7157 100644 --- a/arch/arm64/boot/dts/qcom/sc8280xp-huawei-gaokun3.dts +++ b/arch/arm64/boot/dts/qcom/sc8280xp-huawei-gaokun3.dts @@ -28,6 +28,7 @@ / { aliases { i2c4 = &i2c4; + i2c15 = &i2c15; serial1 = &uart2; }; @@ -216,6 +217,40 @@ map1 { }; }; + usb0-sbu-mux { + compatible = "pericom,pi3usb102", "gpio-sbu-mux"; + + select-gpios = <&tlmm 164 GPIO_ACTIVE_HIGH>; + + pinctrl-0 = <&usb0_sbu_default>; + pinctrl-names = "default"; + + orientation-switch; + + port { + usb0_sbu_mux: endpoint { + remote-endpoint = <&ucsi0_sbu>; + }; + }; + }; + + usb1-sbu-mux { + compatible = "pericom,pi3usb102", "gpio-sbu-mux"; + + select-gpios = <&tlmm 47 GPIO_ACTIVE_HIGH>; + + pinctrl-0 = <&usb1_sbu_default>; + pinctrl-names = "default"; + + orientation-switch; + + port { + usb1_sbu_mux: endpoint { + remote-endpoint = <&ucsi1_sbu>; + }; + }; + }; + wcn6855-pmu { compatible = "qcom,wcn6855-pmu"; @@ -584,6 +619,97 @@ touchscreen@4f { }; +&i2c15 { + clock-frequency = <400000>; + + pinctrl-0 = <&i2c15_default>; + pinctrl-names = "default"; + + status = "okay"; + + embedded-controller@38 { + compatible = "huawei,gaokun3-ec"; + reg = <0x38>; + + interrupts-extended = <&tlmm 107 IRQ_TYPE_LEVEL_LOW>; + + #address-cells = <1>; + #size-cells = <0>; + + connector@0 { + compatible = "usb-c-connector"; + reg = <0>; + power-role = "dual"; + data-role = "dual"; + + ports { + #address-cells = <1>; + #size-cells = <0>; + + port@0 { + reg = <0>; + + ucsi0_hs_in: endpoint { + remote-endpoint = <&usb_0_dwc3_hs>; + }; + }; + + port@1 { + reg = <1>; + + ucsi0_ss_in: endpoint { + remote-endpoint = <&usb_0_qmpphy_out>; + }; + }; + + port@2 { + reg = <2>; + + ucsi0_sbu: endpoint { + remote-endpoint = <&usb0_sbu_mux>; + }; + }; + }; + }; + + connector@1 { + compatible = "usb-c-connector"; + reg = <1>; + power-role = "dual"; + data-role = "dual"; + + ports { + #address-cells = <1>; + #size-cells = <0>; + + port@0 { + reg = <0>; + + ucsi1_hs_in: endpoint { + remote-endpoint = <&usb_1_dwc3_hs>; + }; + }; + + port@1 { + reg = <1>; + + ucsi1_ss_in: endpoint { + remote-endpoint = <&usb_1_qmpphy_out>; + }; + }; + + port@2 { + reg = <2>; + + ucsi1_sbu: endpoint { + remote-endpoint = <&usb1_sbu_mux>; + }; + }; + }; + }; + }; +}; + &mdss0 { status = "okay"; }; @@ -1004,6 +1130,10 @@ &usb_0_dwc3 { dr_mode = "host"; }; +&usb_0_dwc3_hs { + remote-endpoint = <&ucsi0_hs_in>; +}; + &usb_0_hsphy { vdda-pll-supply = <&vreg_l9d>; vdda18-supply = <&vreg_l1c>; @@ -1025,6 +1155,10 @@ &usb_0_qmpphy_dp_in { remote-endpoint = <&mdss0_dp0_out>; }; +&usb_0_qmpphy_out { + remote-endpoint = <&ucsi0_ss_in>; +}; + &usb_1 { status = "okay"; }; @@ -1033,6 +1167,10 @@ &usb_1_dwc3 { dr_mode = "host"; }; +&usb_1_dwc3_hs { + remote-endpoint = <&ucsi1_hs_in>; +}; + &usb_1_hsphy { vdda-pll-supply = <&vreg_l4b>; vdda18-supply = <&vreg_l1c>; @@ -1054,6 +1192,10 @@ &usb_1_qmpphy_dp_in { remote-endpoint = <&mdss0_dp1_out>; }; +&usb_1_qmpphy_out { + remote-endpoint = <&ucsi1_ss_in>; +}; + &usb_2 { status = "okay"; }; @@ -1177,6 +1319,13 @@ i2c4_default: i2c4-default-state { bias-disable; }; + i2c15_default: i2c15-default-state { + pins = "gpio36", "gpio37"; + function = "qup15"; + drive-strength = <2>; + bias-pull-up; + }; + mode_pin_active: mode-pin-state { pins = "gpio26"; function = "gpio"; @@ -1301,6 +1450,20 @@ tx-pins { }; }; + usb0_sbu_default: usb0-sbu-state { + pins = "gpio164"; + function = "gpio"; + drive-strength = <16>; + bias-disable; + }; + + usb1_sbu_default: usb1-sbu-state { + pins = "gpio47"; + function = "gpio"; + drive-strength = <16>; + bias-disable; + }; + wcd_default: wcd-default-state { reset-pins { pins = "gpio106"; -- 2.47.1 ^ permalink raw reply related [flat|nested] 20+ messages in thread
* Re: [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 2025-01-13 17:51 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Pengyu Luo ` (2 preceding siblings ...) 2025-01-13 17:51 ` [PATCH v3 6/6] arm64: dts: qcom: gaokun3: Add Embedded Controller node Pengyu Luo @ 2025-01-16 11:26 ` Heikki Krogerus 3 siblings, 0 replies; 20+ messages in thread From: Heikki Krogerus @ 2025-01-16 11:26 UTC (permalink / raw) To: Pengyu Luo; +Cc: Greg Kroah-Hartman, linux-usb, linux-kernel On Tue, Jan 14, 2025 at 01:51:25AM +0800, Pengyu Luo wrote: > Many platforms from Qualcomm(before X elite) still use UCSI v1.0, > part of them hardcoded the version number to dsdt, add this for them. > > Signed-off-by: Pengyu Luo <mitltlatltl@gmail.com> Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com> > --- > drivers/usb/typec/ucsi/ucsi.h | 1 + > 1 file changed, 1 insertion(+) > > diff --git a/drivers/usb/typec/ucsi/ucsi.h b/drivers/usb/typec/ucsi/ucsi.h > index 5ff369c24..82735eb34 100644 > --- a/drivers/usb/typec/ucsi/ucsi.h > +++ b/drivers/usb/typec/ucsi/ucsi.h > @@ -30,6 +30,7 @@ struct dentry; > #define UCSIv2_MESSAGE_OUT 272 > > /* UCSI versions */ > +#define UCSI_VERSION_1_0 0x0100 > #define UCSI_VERSION_1_1 0x0110 > #define UCSI_VERSION_1_2 0x0120 > #define UCSI_VERSION_2_0 0x0200 > -- > 2.47.1 -- heikki ^ permalink raw reply [flat|nested] 20+ messages in thread
end of thread, other threads:[~2025-02-22 11:29 UTC | newest] Thread overview: 20+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2025-01-13 17:49 [PATCH v3 0/6] platform: arm64: Huawei Matebook E Go embedded controller Pengyu Luo 2025-01-13 17:50 ` [PATCH v3 2/6] platform: arm64: add Huawei Matebook E Go EC driver Pengyu Luo 2025-01-13 18:34 ` Guenter Roeck 2025-01-13 18:56 ` Ilpo Järvinen 2025-01-14 8:31 ` Pengyu Luo 2025-01-14 15:40 ` Ilpo Järvinen 2025-01-16 12:02 ` Heikki Krogerus 2025-01-13 17:51 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 4/6] usb: typec: ucsi: add Huawei Matebook E Go ucsi driver Pengyu Luo 2025-01-16 11:55 ` Heikki Krogerus 2025-01-16 18:26 ` Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 5/6] power: supply: add Huawei Matebook E Go psy driver Pengyu Luo 2025-02-20 0:24 ` Sebastian Reichel 2025-02-20 6:43 ` Pengyu Luo 2025-02-21 1:33 ` Sebastian Reichel 2025-02-21 6:01 ` Pengyu Luo 2025-02-21 22:22 ` Sebastian Reichel 2025-02-22 11:27 ` Pengyu Luo 2025-01-13 17:51 ` [PATCH v3 6/6] arm64: dts: qcom: gaokun3: Add Embedded Controller node Pengyu Luo 2025-01-16 11:26 ` [PATCH v3 3/6] usb: typec: ucsi: Add a macro definition for UCSI v1.0 Heikki Krogerus
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.