// SPDX-License-Identifier: GPL-2.0-or-later /* * Lenovo Other Mode WMI interface driver. * * This driver uses the fw_attributes class to expose the various WMI functions * provided by the "Other Mode" WMI interface. This enables CPU and GPU power * limit as well as various other attributes for devices that fall under the * "Gaming Series" of Lenovo laptop devices. Each attribute exposed by the * "Other Mode" interface has a corresponding Capability Data struct that * allows the driver to probe details about the attribute such as if it is * supported by the hardware, the default_value, max_value, min_value, and step * increment. * * These attributes typically don't fit anywhere else in the sysfs and are set * in Windows using one of Lenovo's multiple user applications. * * Copyright (C) 2025 Derek J. Clark */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "wmi-capdata01.h" #include "wmi-events.h" #include "wmi-gamezone.h" #include "wmi-helpers.h" #include "wmi-other.h" #include "../firmware_attributes_class.h" #define LENOVO_OTHER_MODE_GUID "DC2A8805-3A8C-41BA-A6F7-092E0089CD3B" #define LWMI_DEVICE_ID_CPU 0x01 #define LWMI_FEATURE_ID_CPU_SPPT 0x01 #define LWMI_FEATURE_ID_CPU_SPL 0x02 #define LWMI_FEATURE_ID_CPU_FPPT 0x03 #define LWMI_TYPE_ID_NONE 0x00 #define LWMI_FEATURE_VALUE_GET 17 #define LWMI_FEATURE_VALUE_SET 18 #define LWMI_ATTR_DEV_ID_MASK GENMASK(31, 24) #define LWMI_ATTR_FEAT_ID_MASK GENMASK(23, 16) #define LWMI_ATTR_MODE_ID_MASK GENMASK(15, 8) #define LWMI_ATTR_TYPE_ID_MASK GENMASK(7, 0) #define LWMI_OM_FW_ATTR_BASE_PATH "lenovo-wmi-other" static BLOCKING_NOTIFIER_HEAD(om_chain_head); static DEFINE_IDA(lwmi_om_ida); enum attribute_property { DEFAULT_VAL, MAX_VAL, MIN_VAL, STEP_VAL, SUPPORTED, }; struct lwmi_om_priv { struct component_master_ops *ops; struct cd01_list *cd01_list; /* only valid after capdata01 bind */ struct device *fw_attr_dev; struct kset *fw_attr_kset; struct notifier_block nb; struct wmi_device *wdev; int ida_id; }; struct tunable_attr_01 { struct capdata01 *capdata; struct device *dev; u32 feature_id; u32 device_id; u32 type_id; }; static struct tunable_attr_01 ppt_pl1_spl = { .device_id = LWMI_DEVICE_ID_CPU, .feature_id = LWMI_FEATURE_ID_CPU_SPL, .type_id = LWMI_TYPE_ID_NONE, }; static struct tunable_attr_01 ppt_pl2_sppt = { .device_id = LWMI_DEVICE_ID_CPU, .feature_id = LWMI_FEATURE_ID_CPU_SPPT, .type_id = LWMI_TYPE_ID_NONE, }; static struct tunable_attr_01 ppt_pl3_fppt = { .device_id = LWMI_DEVICE_ID_CPU, .feature_id = LWMI_FEATURE_ID_CPU_FPPT, .type_id = LWMI_TYPE_ID_NONE, }; struct capdata01_attr_group { const struct attribute_group *attr_group; struct tunable_attr_01 *tunable_attr; }; /** * lwmi_om_register_notifier() - Add a notifier to the blocking notifier chain * @nb: The notifier_block struct to register * * Call blocking_notifier_chain_register to register the notifier block to the * lenovo-wmi-other driver notifier chain. * * Return: 0 on success, %-EEXIST on error. */ int lwmi_om_register_notifier(struct notifier_block *nb) { return blocking_notifier_chain_register(&om_chain_head, nb); } EXPORT_SYMBOL_NS_GPL(lwmi_om_register_notifier, "LENOVO_WMI_OTHER"); /** * lwmi_om_unregister_notifier() - Remove a notifier from the blocking notifier * chain. * @nb: The notifier_block struct to register * * Call blocking_notifier_chain_unregister to unregister the notifier block from the * lenovo-wmi-other driver notifier chain. * * Return: 0 on success, %-ENOENT on error. */ int lwmi_om_unregister_notifier(struct notifier_block *nb) { return blocking_notifier_chain_unregister(&om_chain_head, nb); } EXPORT_SYMBOL_NS_GPL(lwmi_om_unregister_notifier, "LENOVO_WMI_OTHER"); /** * devm_lwmi_om_unregister_notifier() - Remove a notifier from the blocking * notifier chain. * @data: Void pointer to the notifier_block struct to register. * * Call lwmi_om_unregister_notifier to unregister the notifier block from the * lenovo-wmi-other driver notifier chain. * * Return: 0 on success, %-ENOENT on error. */ static void devm_lwmi_om_unregister_notifier(void *data) { struct notifier_block *nb = data; lwmi_om_unregister_notifier(nb); } /** * devm_lwmi_om_register_notifier() - Add a notifier to the blocking notifier * chain. * @dev: The parent device of the notifier_block struct. * @nb: The notifier_block struct to register * * Call lwmi_om_register_notifier to register the notifier block to the * lenovo-wmi-other driver notifier chain. Then add devm_lwmi_om_unregister_notifier * as a device managed action to automatically unregister the notifier block * upon parent device removal. * * Return: 0 on success, or an error code. */ int devm_lwmi_om_register_notifier(struct device *dev, struct notifier_block *nb) { int ret; ret = lwmi_om_register_notifier(nb); if (ret < 0) return ret; return devm_add_action_or_reset(dev, devm_lwmi_om_unregister_notifier, nb); } EXPORT_SYMBOL_NS_GPL(devm_lwmi_om_register_notifier, "LENOVO_WMI_OTHER"); /** * lwmi_om_notifier_call() - Call functions for the notifier call chain. * @mode: Pointer to a thermal mode enum to retrieve the data from. * * Call blocking_notifier_call_chain to retrieve the thermal mode from the * lenovo-wmi-gamezone driver. * * Return: 0 on success, or an error code. */ static int lwmi_om_notifier_call(enum thermal_mode *mode) { int ret; ret = blocking_notifier_call_chain(&om_chain_head, LWMI_GZ_GET_THERMAL_MODE, &mode); if ((ret & ~NOTIFY_STOP_MASK) != NOTIFY_OK) return -EINVAL; return 0; } /* Attribute Methods */ /** * int_type_show() - Emit the data type for an integer attribute * @kobj: Pointer to the driver object. * @kattr: Pointer to the attribute calling this function. * @buf: The buffer to write to. * * Return: Number of characters written to buf. */ static ssize_t int_type_show(struct kobject *kobj, struct kobj_attribute *kattr, char *buf) { return sysfs_emit(buf, "integer\n"); } /** * attr_capdata01_show() - Get the value of the specified attribute property * * @kobj: Pointer to the driver object. * @kattr: Pointer to the attribute calling this function. * @buf: The buffer to write to. * @tunable_attr: The attribute to be read. * @prop: The property of this attribute to be read. * * Retrieves the given property from the capability data 01 struct for the * specified attribute's "custom" thermal mode. This function is intended * to be generic so it can be called from any integer attributes "_show" * function. * * If the WMI is success the sysfs attribute is notified. * * Return: Either number of characters written to buf, or an error code. */ static ssize_t attr_capdata01_show(struct kobject *kobj, struct kobj_attribute *kattr, char *buf, struct tunable_attr_01 *tunable_attr, enum attribute_property prop) { struct lwmi_om_priv *priv = dev_get_drvdata(tunable_attr->dev); struct capdata01 capdata; u32 attribute_id; int value, ret; attribute_id = FIELD_PREP(LWMI_ATTR_DEV_ID_MASK, tunable_attr->device_id) | FIELD_PREP(LWMI_ATTR_FEAT_ID_MASK, tunable_attr->feature_id) | FIELD_PREP(LWMI_ATTR_MODE_ID_MASK, LWMI_GZ_THERMAL_MODE_CUSTOM) | FIELD_PREP(LWMI_ATTR_TYPE_ID_MASK, tunable_attr->type_id); ret = lwmi_cd01_get_data(priv->cd01_list, attribute_id, &capdata); if (ret) return ret; switch (prop) { case DEFAULT_VAL: value = capdata.default_value; break; case MAX_VAL: value = capdata.max_value; break; case MIN_VAL: value = capdata.min_value; break; case STEP_VAL: value = capdata.step; break; default: return -EINVAL; } return sysfs_emit(buf, "%d\n", value); } /** * attr_current_value_store() - Set the current value of the given attribute * @kobj: Pointer to the driver object. * @kattr: Pointer to the attribute calling this function. * @buf: The buffer to read from, this is parsed to `int` type. * @count: Required by sysfs attribute macros, pass in from the callee attr. * @tunable_attr: The attribute to be stored. * * Sets the value of the given attribute when operating under the "custom" * smartfan profile. The current smartfan profile is retrieved from the * lenovo-wmi-gamezone driver and error is returned if the result is not * "custom". This function is intended to be generic so it can be called from * any integer attribute's "_store" function. The integer to be sent to the WMI * method is range checked and an error code is returned if out of range. * * If the value is valid and WMI is success, then the sysfs attribute is * notified. * * Return: Either count, or an error code. */ static ssize_t attr_current_value_store(struct kobject *kobj, struct kobj_attribute *kattr, const char *buf, size_t count, struct tunable_attr_01 *tunable_attr) { struct lwmi_om_priv *priv = dev_get_drvdata(tunable_attr->dev); struct wmi_method_args_32 args; struct capdata01 capdata; enum thermal_mode mode; u32 attribute_id; u32 value; int ret; ret = lwmi_om_notifier_call(&mode); if (ret) return ret; if (mode != LWMI_GZ_THERMAL_MODE_CUSTOM) return -EBUSY; attribute_id = FIELD_PREP(LWMI_ATTR_DEV_ID_MASK, tunable_attr->device_id) | FIELD_PREP(LWMI_ATTR_FEAT_ID_MASK, tunable_attr->feature_id) | FIELD_PREP(LWMI_ATTR_MODE_ID_MASK, mode) | FIELD_PREP(LWMI_ATTR_TYPE_ID_MASK, tunable_attr->type_id); ret = lwmi_cd01_get_data(priv->cd01_list, attribute_id, &capdata); if (ret) return ret; ret = kstrtouint(buf, 10, &value); if (ret) return ret; if (value < capdata.min_value || value > capdata.max_value) return -EINVAL; args.arg0 = attribute_id; args.arg1 = value; ret = lwmi_dev_evaluate_int(priv->wdev, 0x0, LWMI_FEATURE_VALUE_SET, (unsigned char *)&args, sizeof(args), NULL); if (ret) return ret; return count; }; /** * attr_current_value_show() - Get the current value of the given attribute * @kobj: Pointer to the driver object. * @kattr: Pointer to the attribute calling this function. * @buf: The buffer to write to. * @tunable_attr: The attribute to be read. * * Retrieves the value of the given attribute for the current smartfan profile. * The current smartfan profile is retrieved from the lenovo-wmi-gamezone driver. * This function is intended to be generic so it can be called from any integer * attribute's "_show" function. * * If the WMI is success the sysfs attribute is notified. * * Return: Either number of characters written to buf, or an error code. */ static ssize_t attr_current_value_show(struct kobject *kobj, struct kobj_attribute *kattr, char *buf, struct tunable_attr_01 *tunable_attr) { struct lwmi_om_priv *priv = dev_get_drvdata(tunable_attr->dev); struct wmi_method_args_32 args; enum thermal_mode mode; u32 attribute_id; int retval; int ret; ret = lwmi_om_notifier_call(&mode); if (ret) return ret; attribute_id = FIELD_PREP(LWMI_ATTR_DEV_ID_MASK, tunable_attr->device_id) | FIELD_PREP(LWMI_ATTR_FEAT_ID_MASK, tunable_attr->feature_id) | FIELD_PREP(LWMI_ATTR_MODE_ID_MASK, mode) | FIELD_PREP(LWMI_ATTR_TYPE_ID_MASK, tunable_attr->type_id); args.arg0 = attribute_id; ret = lwmi_dev_evaluate_int(priv->wdev, 0x0, LWMI_FEATURE_VALUE_GET, (unsigned char *)&args, sizeof(args), &retval); if (ret) return ret; return sysfs_emit(buf, "%d\n", retval); } /* Lenovo WMI Other Mode Attribute macros */ #define __LWMI_ATTR_RO(_func, _name) \ { \ .attr = { .name = __stringify(_name), .mode = 0444 }, \ .show = _func##_##_name##_show, \ } #define __LWMI_ATTR_RO_AS(_name, _show) \ { \ .attr = { .name = __stringify(_name), .mode = 0444 }, \ .show = _show, \ } #define __LWMI_ATTR_RW(_func, _name) \ __ATTR(_name, 0644, _func##_##_name##_show, _func##_##_name##_store) /* Shows a formatted static variable */ #define __LWMI_ATTR_SHOW_FMT(_prop, _attrname, _fmt, _val) \ static ssize_t _attrname##_##_prop##_show( \ struct kobject *kobj, struct kobj_attribute *kattr, char *buf) \ { \ return sysfs_emit(buf, _fmt, _val); \ } \ static struct kobj_attribute attr_##_attrname##_##_prop = \ __LWMI_ATTR_RO(_attrname, _prop) /* Attribute current value read/write */ #define __LWMI_TUNABLE_CURRENT_VALUE_CAP01(_attrname) \ static ssize_t _attrname##_current_value_store( \ struct kobject *kobj, struct kobj_attribute *kattr, \ const char *buf, size_t count) \ { \ return attr_current_value_store(kobj, kattr, buf, count, \ &_attrname); \ } \ static ssize_t _attrname##_current_value_show( \ struct kobject *kobj, struct kobj_attribute *kattr, char *buf) \ { \ return attr_current_value_show(kobj, kattr, buf, &_attrname); \ } \ static struct kobj_attribute attr_##_attrname##_current_value = \ __LWMI_ATTR_RW(_attrname, current_value) /* Attribute property read only */ #define __LWMI_TUNABLE_RO_CAP01(_prop, _attrname, _prop_type) \ static ssize_t _attrname##_##_prop##_show( \ struct kobject *kobj, struct kobj_attribute *kattr, char *buf) \ { \ return attr_capdata01_show(kobj, kattr, buf, &_attrname, \ _prop_type); \ } \ static struct kobj_attribute attr_##_attrname##_##_prop = \ __LWMI_ATTR_RO(_attrname, _prop) #define LWMI_ATTR_GROUP_TUNABLE_CAP01(_attrname, _fsname, _dispname) \ __LWMI_TUNABLE_CURRENT_VALUE_CAP01(_attrname); \ __LWMI_TUNABLE_RO_CAP01(default_value, _attrname, DEFAULT_VAL); \ __LWMI_ATTR_SHOW_FMT(display_name, _attrname, "%s\n", _dispname); \ __LWMI_TUNABLE_RO_CAP01(max_value, _attrname, MAX_VAL); \ __LWMI_TUNABLE_RO_CAP01(min_value, _attrname, MIN_VAL); \ __LWMI_TUNABLE_RO_CAP01(scalar_increment, _attrname, STEP_VAL); \ static struct kobj_attribute attr_##_attrname##_type = \ __LWMI_ATTR_RO_AS(type, int_type_show); \ static struct attribute *_attrname##_attrs[] = { \ &attr_##_attrname##_current_value.attr, \ &attr_##_attrname##_default_value.attr, \ &attr_##_attrname##_display_name.attr, \ &attr_##_attrname##_max_value.attr, \ &attr_##_attrname##_min_value.attr, \ &attr_##_attrname##_scalar_increment.attr, \ &attr_##_attrname##_type.attr, \ NULL, \ }; \ static const struct attribute_group _attrname##_attr_group = { \ .name = _fsname, .attrs = _attrname##_attrs \ } LWMI_ATTR_GROUP_TUNABLE_CAP01(ppt_pl1_spl, "ppt_pl1_spl", "Set the CPU sustained power limit"); LWMI_ATTR_GROUP_TUNABLE_CAP01(ppt_pl2_sppt, "ppt_pl2_sppt", "Set the CPU slow package power tracking limit"); LWMI_ATTR_GROUP_TUNABLE_CAP01(ppt_pl3_fppt, "ppt_pl3_fppt", "Set the CPU fast package power tracking limit"); static struct capdata01_attr_group cd01_attr_groups[] = { { &ppt_pl1_spl_attr_group, &ppt_pl1_spl }, { &ppt_pl2_sppt_attr_group, &ppt_pl2_sppt }, { &ppt_pl3_fppt_attr_group, &ppt_pl3_fppt }, {}, }; /** * lwmi_om_fw_attr_add() - Register all firmware_attributes_class members * @priv: The Other Mode driver data. * * Return: Either 0, or an error code. */ static int lwmi_om_fw_attr_add(struct lwmi_om_priv *priv) { unsigned int i; int err; priv->ida_id = ida_alloc(&lwmi_om_ida, GFP_KERNEL); if (priv->ida_id < 0) return priv->ida_id; priv->fw_attr_dev = device_create(&firmware_attributes_class, NULL, MKDEV(0, 0), NULL, "%s-%u", LWMI_OM_FW_ATTR_BASE_PATH, priv->ida_id); if (IS_ERR(priv->fw_attr_dev)) { err = PTR_ERR(priv->fw_attr_dev); goto err_free_ida; } priv->fw_attr_kset = kset_create_and_add("attributes", NULL, &priv->fw_attr_dev->kobj); if (!priv->fw_attr_kset) { err = -ENOMEM; goto err_destroy_classdev; } for (i = 0; i < ARRAY_SIZE(cd01_attr_groups) - 1; i++) { err = sysfs_create_group(&priv->fw_attr_kset->kobj, cd01_attr_groups[i].attr_group); if (err) goto err_remove_groups; cd01_attr_groups[i].tunable_attr->dev = &priv->wdev->dev; } return 0; err_remove_groups: while (i--) sysfs_remove_group(&priv->fw_attr_kset->kobj, cd01_attr_groups[i].attr_group); kset_unregister(priv->fw_attr_kset); err_destroy_classdev: device_unregister(priv->fw_attr_dev); err_free_ida: ida_free(&lwmi_om_ida, priv->ida_id); return err; } /** * lwmi_om_fw_attr_remove() - Unregister all capability data attribute groups * @priv: the lenovo-wmi-other driver data. */ static void lwmi_om_fw_attr_remove(struct lwmi_om_priv *priv) { for (unsigned int i = 0; i < ARRAY_SIZE(cd01_attr_groups) - 1; i++) sysfs_remove_group(&priv->fw_attr_kset->kobj, cd01_attr_groups[i].attr_group); kset_unregister(priv->fw_attr_kset); device_unregister(priv->fw_attr_dev); } /** * lwmi_om_master_bind() - Bind all components of the other mode driver * @dev: The lenovo-wmi-other driver basic device. * * Call component_bind_all to bind the lenovo-wmi-capdata01 driver to the * lenovo-wmi-other master driver. On success, assign the capability data 01 * list pointer to the driver data struct for later access. This pointer * is only valid while the capdata01 interface exists. Finally, register all * firmware attribute groups. * * Return: 0 on success, or an error code. */ static int lwmi_om_master_bind(struct device *dev) { struct lwmi_om_priv *priv = dev_get_drvdata(dev); struct cd01_list *tmp_list; int ret; ret = component_bind_all(dev, &tmp_list); if (ret) return ret; priv->cd01_list = tmp_list; if (!priv->cd01_list) return -ENODEV; return lwmi_om_fw_attr_add(priv); } /** * lwmi_om_master_unbind() - Unbind all components of the other mode driver * @dev: The lenovo-wmi-other driver basic device * * Unregister all capability data attribute groups. Then call * component_unbind_all to unbind the lenovo-wmi-capdata01 driver from the * lenovo-wmi-other master driver. Finally, free the IDA for this device. */ static void lwmi_om_master_unbind(struct device *dev) { struct lwmi_om_priv *priv = dev_get_drvdata(dev); lwmi_om_fw_attr_remove(priv); component_unbind_all(dev, NULL); } static const struct component_master_ops lwmi_om_master_ops = { .bind = lwmi_om_master_bind, .unbind = lwmi_om_master_unbind, }; static int lwmi_other_probe(struct wmi_device *wdev, const void *context) { struct component_match *master_match = NULL; struct lwmi_om_priv *priv; priv = devm_kzalloc(&wdev->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->wdev = wdev; dev_set_drvdata(&wdev->dev, priv); component_match_add(&wdev->dev, &master_match, lwmi_cd01_match, NULL); if (IS_ERR(master_match)) return PTR_ERR(master_match); return component_master_add_with_match(&wdev->dev, &lwmi_om_master_ops, master_match); } static void lwmi_other_remove(struct wmi_device *wdev) { struct lwmi_om_priv *priv = dev_get_drvdata(&wdev->dev); component_master_del(&wdev->dev, &lwmi_om_master_ops); ida_free(&lwmi_om_ida, priv->ida_id); } static const struct wmi_device_id lwmi_other_id_table[] = { { LENOVO_OTHER_MODE_GUID, NULL }, {} }; static struct wmi_driver lwmi_other_driver = { .driver = { .name = "lenovo_wmi_other", .probe_type = PROBE_PREFER_ASYNCHRONOUS, }, .id_table = lwmi_other_id_table, .probe = lwmi_other_probe, .remove = lwmi_other_remove, .no_singleton = true, }; module_wmi_driver(lwmi_other_driver); MODULE_IMPORT_NS("LENOVO_WMI_CD01"); MODULE_IMPORT_NS("LENOVO_WMI_HELPERS"); MODULE_DEVICE_TABLE(wmi, lwmi_other_id_table); MODULE_AUTHOR("Derek J. Clark "); MODULE_DESCRIPTION("Lenovo Other Mode WMI Driver"); MODULE_LICENSE("GPL");