// SPDX-License-Identifier: GPL-2.0-or-later /* * HP WMI hotkeys * * Copyright ( C ) 2008 Red Hat < mjg @ redhat . com > * Copyright ( C ) 2010 , 2011 Anssi Hannula < anssi . hannula @ iki . fi > * * Portions based on wistron_btns . c : * Copyright ( C ) 2005 Miloslav Trmac < mitr @ volny . cz > * Copyright ( C ) 2005 Bernhard Rosenkraenzer < bero @ arklinux . org > * Copyright ( C ) 2005 Dmitry Torokhov < dtor @ mail . ru > #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt#include <linux/kernel.h>#include <linux/module.h>#include <linux/init.h>#include <linux/slab.h>#include <linux/types.h>#include <linux/input.h>#include <linux/input/sparse-keymap.h>#include <linux/platform_device.h>#include <linux/platform_profile.h>#include <linux/hwmon.h>#include <linux/acpi.h>#include <linux/mutex.h>#include <linux/cleanup.h>#include <linux/power_supply.h>#include <linux/rfkill.h>#include <linux/string.h>#include <linux/dmi.h>"Matthew Garrett <mjg59@srcf.ucam.org>" );"HP laptop WMI driver" );"GPL" );"wmi:95F24279-4D7B-4334-9387-ACCDC67EF61C" );"wmi:5FB7F034-2C63-45E9-BE91-3D44E2C707E4" );#define HPWMI_EVENT_GUID "95F24279-4D7B-4334-9387-ACCDC67EF61C" #define HPWMI_BIOS_GUID "5FB7F034-2C63-45E9-BE91-3D44E2C707E4" #define HP_OMEN_EC_THERMAL_PROFILE_FLAGS_OFFSET 0 x62#define HP_OMEN_EC_THERMAL_PROFILE_TIMER_OFFSET 0 x63#define HP_OMEN_EC_THERMAL_PROFILE_OFFSET 0 x95#define HP_FAN_SPEED_AUTOMATIC 0 x00#define HP_POWER_LIMIT_DEFAULT 0 x00#define HP_POWER_LIMIT_NO_CHANGE 0 xFF#define ACPI_AC_CLASS "ac_adapter" #define zero_if_sup(tmp) (zero_insize_support?0 :sizeof (tmp)) // use when zero insize is required /* DMI board names of devices that should use the omen specific path for * thermal profiles . * This was obtained by taking a look in the windows omen command center * app and parsing a json file that they use to figure out what capabilities * the device should have . * A device is considered an omen if the DisplayName in that list contains * " OMEN " , and it can use the thermal profile stuff if the " Feature " array * contains " PerformanceControl " . static const char * const omen_thermal_profile_boards[] = {"84DA" , "84DB" , "84DC" , "8574" , "8575" , "860A" , "87B5" , "8572" , "8573" ,"8600" , "8601" , "8602" , "8605" , "8606" , "8607" , "8746" , "8747" , "8749" ,"874A" , "8603" , "8604" , "8748" , "886B" , "886C" , "878A" , "878B" , "878C" ,"88C8" , "88CB" , "8786" , "8787" , "8788" , "88D1" , "88D2" , "88F4" , "88FD" ,"88F5" , "88F6" , "88F7" , "88FE" , "88FF" , "8900" , "8901" , "8902" , "8912" ,"8917" , "8918" , "8949" , "894A" , "89EB" , "8BAD" , "8A42" , "8A15" /* DMI Board names of Omen laptops that are specifically set to be thermal * profile version 0 by the Omen Command Center app , regardless of what * the get system design information WMI call returns static const char * const omen_thermal_profile_force_v0_boards[] = {"8607" , "8746" , "8747" , "8749" , "874A" , "8748" /* DMI board names of Omen laptops that have a thermal profile timer which will * cause the embedded controller to set the thermal profile back to * " balanced " when reaching zero . static const char * const omen_timed_thermal_profile_boards[] = {"8BAD" , "8A42" , "8A15" /* DMI Board names of Victus 16-d1xxx laptops */ static const char * const victus_thermal_profile_boards[] = {"8A25" /* DMI Board names of Victus 16-r1000 and Victus 16-s1000 laptops */ static const char * const victus_s_thermal_profile_boards[] = {"8C99" , "8C9C" enum hp_wmi_radio {0 x0,0 x1,0 x2,0 x3,enum hp_wmi_event_ids {0 x01,0 x02,0 x03,0 x04,0 x05,0 x06,0 x07,0 x08,0 x09,0 x0A,0 x0B,0 x0C,0 x0D,0 x0F,0 x10,0 x17,0 x1A,0 x1B,0 x1D,0 x21,/* * struct bios_args buffer is dynamically allocated . New WMI command types * were introduced that exceeds 128 - byte data size . Changes to handle * the data size allocation scheme were kept in hp_wmi_perform_qurey function . struct bios_args {enum hp_wmi_commandtype {0 x01,0 x02,0 x03,0 x04,0 x05,0 x07,0 x09,0 x0b,0 x0c,0 x0d,0 x1b,0 x2a,0 x40,0 x4c,struct victus_power_limits {struct victus_gpu_power_modes {enum hp_wmi_gm_commandtype {0 x11,0 x1A,0 x26,0 x27,0 x28,0 x10,0 x21,0 x22,0 x29,0 x2D,0 x2E,enum hp_wmi_command {0 x01,0 x02,0 x03,0 x20008,enum hp_wmi_hardware_mask {0 x01,0 x04,struct bios_return {enum hp_return_value {0 x02,0 x03,0 x04,0 x05,enum hp_wireless2_bits {0 x01,0 x02,0 x04,0 x08,enum hp_thermal_profile_omen_v0 {0 x00,0 x01,0 x02,enum hp_thermal_profile_omen_v1 {0 x30,0 x31,0 x50,enum hp_thermal_profile_omen_flags {0 x04,0 x02,0 x01,enum hp_thermal_profile_victus {0 x00,0 x01,0 x03,enum hp_thermal_profile_victus_s {0 x00,0 x01,enum hp_thermal_profile {0 x00,0 x01,0 x02,0 x03,#define IS_HWBLOCKED(x) ((x & HPWMI_POWER_FW_OR_HW) != HPWMI_POWER_FW_OR_HW)#define IS_SWBLOCKED(x) !(x & HPWMI_POWER_SOFT)struct bios_rfkill2_device_state {4 ];/* 7 devices fit into the 128 byte buffer */ #define HPWMI_MAX_RFKILL2_DEVICES 7 struct bios_rfkill2_state {7 ];8 ];struct bios_rfkill2_device_state device[HPWMI_MAX_RFKILL2_DEVICES];static const struct key_entry hp_wmi_keymap[] = {0 x02, { KEY_BRIGHTNESSUP } },0 x03, { KEY_BRIGHTNESSDOWN } },0 x270, { KEY_MICMUTE } },0 x20e6, { KEY_PROG1 } },0 x20e8, { KEY_MEDIA } },0 x2142, { KEY_MEDIA } },0 x213b, { KEY_INFO } },0 x2169, { KEY_ROTATE_DISPLAY } },0 x216a, { KEY_SETUP } },0 x21a4, }, /* Win Lock On */ 0 x121a4, }, /* Win Lock Off */ 0 x21a5, { KEY_PROG2 } }, /* HP Omen Key */ 0 x21a7, { KEY_FN_ESC } },0 x21a8, { KEY_PROG2 } }, /* HP Envy x360 programmable key */ 0 x21a9, { KEY_TOUCHPAD_OFF } },0 x121a9, { KEY_TOUCHPAD_ON } },0 x231b, { KEY_HELP } },0 }/* * Mutex for the active_platform_profile variable , * see omen_powersource_event . static DEFINE_MUTEX(active_platform_profile_lock);static struct input_dev *hp_wmi_input_dev;static struct input_dev *camera_shutter_input_dev;static struct platform_device *hp_wmi_platform_dev;static struct device *platform_profile_device;static struct notifier_block platform_power_source_nb;static enum platform_profile_option active_platform_profile;static bool platform_profile_support;static bool zero_insize_support;static struct rfkill *wifi_rfkill;static struct rfkill *bluetooth_rfkill;static struct rfkill *wwan_rfkill;struct rfkill2_device {int num;struct rfkill *rfkill;static int rfkill2_count;static struct rfkill2_device rfkill2[HPWMI_MAX_RFKILL2_DEVICES];/* * Chassis Types values were obtained from SMBIOS reference * specification version 3 . 00 . A complete list of system enclosures * and chassis types is available on Table 17 . static const char * const tablet_chassis_types[] = {"30" , /* Tablet*/ "31" , /* Convertible */ "32" /* Detachable */ #define DEVICE_MODE_TABLET 0 x06/* map output size to the corresponding WMI method id */ static inline int encode_outsize_for_pvsz(int outsize)if (outsize > 4096 )return -EINVAL;if (outsize > 1024 )return 5 ;if (outsize > 128 )return 4 ;if (outsize > 4 )return 3 ;if (outsize > 0 )return 2 ;return 1 ;/* * hp_wmi_perform_query * * query : The commandtype ( enum hp_wmi_commandtype ) * write : The command ( enum hp_wmi_command ) * buffer : Buffer used as input and / or output * insize : Size of input buffer * outsize : Size of output buffer * * returns zero on success * an HP WMI query specific error code ( which is positive ) * - EINVAL if the query was not successful at all * - EINVAL if the output buffer size exceeds buffersize * * Note : The buffersize must at least be the maximum of the input and output * size . E . g . Battery info query is defined to have 1 byte input * and 128 byte output . The caller would do : * buffer = kzalloc ( 128 , GFP_KERNEL ) ; * ret = hp_wmi_perform_query ( HPWMI_BATTERY_QUERY , HPWMI_READ , buffer , 1 , 128 ) static int hp_wmi_perform_query(int query, enum hp_wmi_command command,void *buffer, int insize, int outsize)struct acpi_buffer input, output = { ACPI_ALLOCATE_BUFFER, NULL };struct bios_return *bios_return;union acpi_object *obj = NULL;struct bios_args *args = NULL;int mid, actual_insize, actual_outsize;int ret;if (WARN_ON(mid < 0 ))return mid;128 );if (!args)return -ENOMEM;0 x55434553;0 , mid, &input, &output);if (ret)goto out_free;if (!obj) {goto out_free;if (obj->type != ACPI_TYPE_BUFFER) {"query 0x%x returned an invalid object 0x%x\n" , query, ret);goto out_free;struct bios_return *)obj->buffer.pointer;if (ret) {if (ret != HPWMI_RET_UNKNOWN_COMMAND &&"query 0x%x returned error 0x%x\n" , query, ret);goto out_free;/* Ignore output data of zero size */ if (!outsize)goto out_free;int )(obj->buffer.length - sizeof (*bios_return)));sizeof (*bios_return), actual_outsize);0 , outsize - actual_outsize);return ret;/* * Calling this hp_wmi_get_fan_count_userdefine_trigger function also enables * and / or maintains the laptop in user defined thermal and fan states , instead * of using a fallback state . After a 120 seconds timeout however , the laptop * goes back to its fallback state . static int hp_wmi_get_fan_count_userdefine_trigger(void )4 ] = {};int ret;sizeof (u8),sizeof (fan_data));if (ret != 0 )return -EINVAL;return fan_data[0 ]; /* Others bytes aren't providing fan count */ static int hp_wmi_get_fan_speed(int fan)char fan_data[4 ] = { fan, 0 , 0 , 0 };int ret = hp_wmi_perform_query(HPWMI_FAN_SPEED_GET_QUERY, HPWMI_GM,sizeof (char ),sizeof (fan_data));if (ret != 0 )return -EINVAL;2 ];3 ];return (fsh << 8 ) | fsl;static int hp_wmi_get_fan_speed_victus_s(int fan)128 ] = {};int ret;if (fan < 0 || fan >= sizeof (fan_data))return -EINVAL;sizeof (u8),sizeof (fan_data));if (ret != 0 )return -EINVAL;return fan_data[fan] * 100 ;static int hp_wmi_read_int(int query)int val = 0 , ret;sizeof (val));if (ret)return ret < 0 ? ret : -EINVAL;return val;static int hp_wmi_get_dock_state(void )int state = hp_wmi_read_int(HPWMI_HARDWARE_QUERY);if (state < 0 )return state;return !!(state & HPWMI_DOCK_MASK);static int hp_wmi_get_tablet_mode(void )char system_device_mode[4 ] = { 0 };const char *chassis_type;bool tablet_found;int ret;if (!chassis_type)return -ENODEV;0 ;if (!tablet_found)return -ENODEV;sizeof (system_device_mode));if (ret < 0 )return ret;return system_device_mode[0 ] == DEVICE_MODE_TABLET;static int omen_thermal_profile_set(int mode)/* The Omen Control Center actively sets the first byte of the buffer to * 255 , so let ' s mimic this behaviour to be as close as possible to * the original software . char buffer[2 ] = {-1 , mode};int ret;sizeof (buffer), 0 );if (ret)return ret < 0 ? ret : -EINVAL;return mode;static bool is_omen_thermal_profile(void )const char *board_name = dmi_get_system_info(DMI_BOARD_NAME);if (!board_name)return false ;return match_string(omen_thermal_profile_boards,0 ;static int omen_get_thermal_policy_version(void )unsigned char buffer[8 ] = { 0 };int ret;const char *board_name = dmi_get_system_info(DMI_BOARD_NAME);if (board_name) {int matches = match_string(omen_thermal_profile_force_v0_boards,if (matches >= 0 )return 0 ;sizeof (buffer), sizeof (buffer));if (ret)return ret < 0 ? ret : -EINVAL;return buffer[3 ];static int omen_thermal_profile_get(void )int ret = ec_read(HP_OMEN_EC_THERMAL_PROFILE_OFFSET, &data);if (ret)return ret;return data;static int hp_wmi_fan_speed_max_set(int enabled)int ret;sizeof (enabled), 0 );if (ret)return ret < 0 ? ret : -EINVAL;return enabled;static int hp_wmi_fan_speed_reset(void )2 ] = { HP_FAN_SPEED_AUTOMATIC, HP_FAN_SPEED_AUTOMATIC };int ret;sizeof (fan_speed), 0 );return ret;static int hp_wmi_fan_speed_max_reset(void )int ret;0 );if (ret)return ret;/* Disabling max fan speed on Victus s1xxx laptops needs a 2nd step: */ return ret;static int hp_wmi_fan_speed_max_get(void )int val = 0 , ret;sizeof (val));if (ret)return ret < 0 ? ret : -EINVAL;return val;static int __init hp_wmi_bios_2008_later(void )int state = 0 ;int ret = hp_wmi_perform_query(HPWMI_FEATURE_QUERY, HPWMI_READ, &state,sizeof (state));if (!ret)return 1 ;return (ret == HPWMI_RET_UNKNOWN_CMDTYPE) ? 0 : -ENXIO;static int __init hp_wmi_bios_2009_later(void )128 ];int ret = hp_wmi_perform_query(HPWMI_FEATURE2_QUERY, HPWMI_READ, &state,sizeof (state));if (!ret)return 1 ;return (ret == HPWMI_RET_UNKNOWN_CMDTYPE) ? 0 : -ENXIO;static int __init hp_wmi_enable_hotkeys(void )int value = 0 x6e;int ret = hp_wmi_perform_query(HPWMI_BIOS_QUERY, HPWMI_WRITE, &value,sizeof (value), 0 );return ret <= 0 ? ret : -EINVAL;static int hp_wmi_set_block(void *data, bool blocked)enum hp_wmi_radio r = (long )data;int query = BIT(r + 8 ) | ((!blocked) << r);int ret;sizeof (query), 0 );return ret <= 0 ? ret : -EINVAL;static const struct rfkill_ops hp_wmi_rfkill_ops = {static bool hp_wmi_get_sw_state(enum hp_wmi_radio r)int mask = 0 x200 << (r * 8 );int wireless = hp_wmi_read_int(HPWMI_WIRELESS_QUERY);/* TBD: Pass error */ 0 , "error executing HPWMI_WIRELESS_QUERY" );return !(wireless & mask);static bool hp_wmi_get_hw_state(enum hp_wmi_radio r)int mask = 0 x800 << (r * 8 );int wireless = hp_wmi_read_int(HPWMI_WIRELESS_QUERY);/* TBD: Pass error */ 0 , "error executing HPWMI_WIRELESS_QUERY" );return !(wireless & mask);static int hp_wmi_rfkill2_set_block(void *data, bool blocked)int rfkill_id = (int )(long )data;char buffer[4 ] = { 0 x01, 0 x00, rfkill_id, !blocked };int ret;sizeof (buffer), 0 );return ret <= 0 ? ret : -EINVAL;static const struct rfkill_ops hp_wmi_rfkill2_ops = {static int hp_wmi_rfkill2_refresh(void )struct bios_rfkill2_state state;int err, i;sizeof (state));if (err)return err;for (i = 0 ; i < rfkill2_count; i++) {int num = rfkill2[i].num;struct bios_rfkill2_device_state *devstate;if (num >= state.count ||"power configuration of the wireless devices unexpectedly changed\n" );continue ;return 0 ;static ssize_t display_show(struct device *dev, struct device_attribute *attr,char *buf)int value = hp_wmi_read_int(HPWMI_DISPLAY_QUERY);if (value < 0 )return value;return sysfs_emit(buf, "%d\n" , value);static ssize_t hddtemp_show(struct device *dev, struct device_attribute *attr,char *buf)int value = hp_wmi_read_int(HPWMI_HDDTEMP_QUERY);if (value < 0 )return value;return sysfs_emit(buf, "%d\n" , value);static ssize_t als_show(struct device *dev, struct device_attribute *attr,char *buf)int value = hp_wmi_read_int(HPWMI_ALS_QUERY);if (value < 0 )return value;return sysfs_emit(buf, "%d\n" , value);static ssize_t dock_show(struct device *dev, struct device_attribute *attr,char *buf)int value = hp_wmi_get_dock_state();if (value < 0 )return value;return sysfs_emit(buf, "%d\n" , value);static ssize_t tablet_show(struct device *dev, struct device_attribute *attr,char *buf)int value = hp_wmi_get_tablet_mode();if (value < 0 )return value;return sysfs_emit(buf, "%d\n" , value);static ssize_t postcode_show(struct device *dev, struct device_attribute *attr,char *buf)/* Get the POST error code of previous boot failure. */ int value = hp_wmi_read_int(HPWMI_POSTCODEERROR_QUERY);if (value < 0 )return value;return sysfs_emit(buf, "0x%x\n" , value);static ssize_t als_store(struct device *dev, struct device_attribute *attr,const char *buf, size_t count)int ret;10 , &tmp);if (ret)return ret;sizeof (tmp), 0 );if (ret)return ret < 0 ? ret : -EINVAL;return count;static ssize_t postcode_store(struct device *dev, struct device_attribute *attr,const char *buf, size_t count)1 ;bool clear;int ret;if (ret)return ret;if (clear == false )return -EINVAL;/* Clear the POST error code. It is kept until cleared. */ sizeof (tmp), 0 );if (ret)return ret < 0 ? ret : -EINVAL;return count;static int camera_shutter_input_setup(void )int err;if (!camera_shutter_input_dev)return -ENOMEM;"HP WMI camera shutter" ;"wmi/input1" ;if (err)goto err_free_dev;return 0 ;return err;static DEVICE_ATTR_RO(display);static DEVICE_ATTR_RO(hddtemp);static DEVICE_ATTR_RW(als);static DEVICE_ATTR_RO(dock);static DEVICE_ATTR_RO(tablet);static DEVICE_ATTR_RW(postcode);static struct attribute *hp_wmi_attrs[] = {static void hp_wmi_notify(union acpi_object *obj, void *context)int key_code;if (!obj)return ;if (obj->type != ACPI_TYPE_BUFFER) {"Unknown response received %d\n" , obj->type);return ;/* * Depending on ACPI version the concatenation of id and event data * inside _ WED function will result in a 8 or 16 byte buffer . if (obj->buffer.length == 8 ) {1 );else if (obj->buffer.length == 16 ) {2 );else {"Unknown buffer length %d\n" , obj->buffer.length);return ;switch (event_id) {case HPWMI_DOCK_EVENT:if (test_bit(SW_DOCK, hp_wmi_input_dev->swbit))if (test_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit))break ;case HPWMI_PARK_HDD:break ;case HPWMI_SMART_ADAPTER:break ;case HPWMI_BEZEL_BUTTON:if (key_code < 0 )break ;if (!sparse_keymap_report_event(hp_wmi_input_dev,1 , true ))"Unknown key code - 0x%x\n" , key_code);break ;case HPWMI_FN_P_HOTKEY:break ;case HPWMI_OMEN_KEY:if (event_data) /* Only should be true for HP Omen */ else if (!sparse_keymap_report_event(hp_wmi_input_dev,1 , true ))"Unknown key code - 0x%x\n" , key_code);break ;case HPWMI_WIRELESS:if (rfkill2_count) {break ;if (wifi_rfkill)if (bluetooth_rfkill)if (wwan_rfkill)break ;case HPWMI_CPU_BATTERY_THROTTLE:"Unimplemented CPU throttle because of 3 Cell battery event detected\n" );break ;case HPWMI_LOCK_SWITCH:break ;case HPWMI_LID_SWITCH:break ;case HPWMI_SCREEN_ROTATION:break ;case HPWMI_COOLSENSE_SYSTEM_MOBILE:break ;case HPWMI_COOLSENSE_SYSTEM_HOT:break ;case HPWMI_PROXIMITY_SENSOR:break ;case HPWMI_BACKLIT_KB_BRIGHTNESS:break ;case HPWMI_PEAKSHIFT_PERIOD:break ;case HPWMI_BATTERY_CHARGE_PERIOD:break ;case HPWMI_SANITIZATION_MODE:break ;case HPWMI_CAMERA_TOGGLE:if (!camera_shutter_input_dev)if (camera_shutter_input_setup()) {"Failed to setup camera shutter input device\n" );break ;if (event_data == 0 xff)1 );else if (event_data == 0 xfe)0 );else "Unknown camera shutter state - 0x%x\n" , event_data);break ;case HPWMI_SMART_EXPERIENCE_APP:break ;default :"Unknown event_id - %d - 0x%x\n" , event_id, event_data);break ;static int __init hp_wmi_input_setup(void )int err, val;if (!hp_wmi_input_dev)return -ENOMEM;"HP WMI hotkeys" ;"wmi/input0" ;/* Dock */ if (!(val < 0 )) {/* Tablet mode */ if (!(val < 0 )) {if (err)goto err_free_dev;/* Set initial hardware state */ if (!hp_wmi_bios_2009_later() && hp_wmi_bios_2008_later())if (ACPI_FAILURE(status)) {goto err_free_dev;if (err)goto err_uninstall_notifier;return 0 ;return err;static void hp_wmi_input_destroy(void )static int __init hp_wmi_rfkill_setup(struct platform_device *device)int err, wireless;if (wireless < 0 )return wireless;sizeof (wireless), 0 );if (err)return err;if (wireless & 0 x1) {"hp-wifi" , &device->dev,void *) HPWMI_WIFI);if (!wifi_rfkill)return -ENOMEM;if (err)goto register_wifi_error;if (wireless & 0 x2) {"hp-bluetooth" , &device->dev,void *) HPWMI_BLUETOOTH);if (!bluetooth_rfkill) {goto register_bluetooth_error;if (err)goto register_bluetooth_error;if (wireless & 0 x4) {"hp-wwan" , &device->dev,void *) HPWMI_WWAN);if (!wwan_rfkill) {goto register_wwan_error;if (err)goto register_wwan_error;return 0 ;if (bluetooth_rfkill)if (wifi_rfkill)return err;static int __init hp_wmi_rfkill2_setup(struct platform_device *device)struct bios_rfkill2_state state;int err, i;sizeof (state));if (err)return err < 0 ? err : -EINVAL;if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {"unable to parse 0x1b query output\n" );return -EINVAL;for (i = 0 ; i < state.count; i++) {struct rfkill *rfkill;enum rfkill_type type;char *name;switch (state.device[i].radio_type) {case HPWMI_WIFI:"hp-wifi" ;break ;case HPWMI_BLUETOOTH:"hp-bluetooth" ;break ;case HPWMI_WWAN:"hp-wwan" ;break ;case HPWMI_GPS:"hp-gps" ;break ;default :"unknown device type 0x%x\n" ,continue ;if (!state.device[i].vendor_id) {"zero device %d while %d reported\n" ,continue ;void *)(long )i);if (!rfkill) {goto fail;if (!(state.device[i].power & HPWMI_POWER_BIOS))"device %s blocked by BIOS\n" , name);if (err) {goto fail;return 0 ;for (; rfkill2_count > 0 ; rfkill2_count--) {1 ].rfkill);1 ].rfkill);return err;static int platform_profile_omen_get_ec(enum platform_profile_option *profile)int tp;if (tp < 0 )return tp;switch (tp) {case HP_OMEN_V0_THERMAL_PROFILE_PERFORMANCE:case HP_OMEN_V1_THERMAL_PROFILE_PERFORMANCE:break ;case HP_OMEN_V0_THERMAL_PROFILE_DEFAULT:case HP_OMEN_V1_THERMAL_PROFILE_DEFAULT:break ;case HP_OMEN_V0_THERMAL_PROFILE_COOL:case HP_OMEN_V1_THERMAL_PROFILE_COOL:break ;default :return -EINVAL;return 0 ;static int platform_profile_omen_get(struct device *dev,enum platform_profile_option *profile)/* * We directly return the stored platform profile , as the embedded * controller will not accept switching to the performance option when * the conditions are not met ( e . g . the laptop is not plugged in ) . * * If we directly return what the EC reports , the platform profile will * immediately " switch back " to normal mode , which is against the * expected behaviour from a userspace point of view , as described in * the Platform Profile Section page of the kernel documentation . * * See also omen_powersource_event . return 0 ;static bool has_omen_thermal_profile_ec_timer(void )const char *board_name = dmi_get_system_info(DMI_BOARD_NAME);if (!board_name)return false ;return match_string(omen_timed_thermal_profile_boards,0 ;inline int omen_thermal_profile_ec_flags_set(enum hp_thermal_profile_omen_flags flags)return ec_write(HP_OMEN_EC_THERMAL_PROFILE_FLAGS_OFFSET, flags);inline int omen_thermal_profile_ec_timer_set(u8 value)return ec_write(HP_OMEN_EC_THERMAL_PROFILE_TIMER_OFFSET, value);static int platform_profile_omen_set_ec(enum platform_profile_option profile)int err, tp, tp_version;enum hp_thermal_profile_omen_flags flags = 0 ;if (tp_version < 0 || tp_version > 1 )return -EOPNOTSUPP;switch (profile) {case PLATFORM_PROFILE_PERFORMANCE:if (tp_version == 0 )else break ;case PLATFORM_PROFILE_BALANCED:if (tp_version == 0 )else break ;case PLATFORM_PROFILE_COOL:if (tp_version == 0 )else break ;default :return -EOPNOTSUPP;if (err < 0 )return err;if (has_omen_thermal_profile_ec_timer()) {0 );if (err < 0 )return err;if (profile == PLATFORM_PROFILE_PERFORMANCE)if (err < 0 )return err;return 0 ;static int platform_profile_omen_set(struct device *dev,enum platform_profile_option profile)int err;if (err < 0 )return err;return 0 ;static int thermal_profile_get(void )return hp_wmi_read_int(HPWMI_THERMAL_PROFILE_QUERY);static int thermal_profile_set(int thermal_profile)return hp_wmi_perform_query(HPWMI_THERMAL_PROFILE_QUERY, HPWMI_WRITE, &thermal_profile,sizeof (thermal_profile), 0 );static int hp_wmi_platform_profile_get(struct device *dev,enum platform_profile_option *profile)int tp;if (tp < 0 )return tp;switch (tp) {case HP_THERMAL_PROFILE_PERFORMANCE:break ;case HP_THERMAL_PROFILE_DEFAULT:break ;case HP_THERMAL_PROFILE_COOL:break ;case HP_THERMAL_PROFILE_QUIET:break ;default :return -EINVAL;return 0 ;static int hp_wmi_platform_profile_set(struct device *dev,enum platform_profile_option profile)int err, tp;switch (profile) {case PLATFORM_PROFILE_PERFORMANCE:break ;case PLATFORM_PROFILE_BALANCED:break ;case PLATFORM_PROFILE_COOL:break ;case PLATFORM_PROFILE_QUIET:break ;default :return -EOPNOTSUPP;if (err)return err;return 0 ;static bool is_victus_thermal_profile(void )const char *board_name = dmi_get_system_info(DMI_BOARD_NAME);if (!board_name)return false ;return match_string(victus_thermal_profile_boards,0 ;static int platform_profile_victus_get_ec(enum platform_profile_option *profile)int tp;if (tp < 0 )return tp;switch (tp) {case HP_VICTUS_THERMAL_PROFILE_PERFORMANCE:break ;case HP_VICTUS_THERMAL_PROFILE_DEFAULT:break ;case HP_VICTUS_THERMAL_PROFILE_QUIET:break ;default :return -EOPNOTSUPP;return 0 ;static int platform_profile_victus_get(struct device *dev,enum platform_profile_option *profile)/* Same behaviour as platform_profile_omen_get */ return platform_profile_omen_get(dev, profile);static int platform_profile_victus_set_ec(enum platform_profile_option profile)int err, tp;switch (profile) {case PLATFORM_PROFILE_PERFORMANCE:break ;case PLATFORM_PROFILE_BALANCED:break ;case PLATFORM_PROFILE_QUIET:break ;default :return -EOPNOTSUPP;if (err < 0 )return err;return 0 ;static bool is_victus_s_thermal_profile(void )const char *board_name;if (!board_name)return false ;return match_string(victus_s_thermal_profile_boards,0 ;static int victus_s_gpu_thermal_profile_get(bool *ctgp_enable,bool *ppab_enable,struct victus_gpu_power_modes gpu_power_modes;int ret;sizeof (gpu_power_modes),sizeof (gpu_power_modes));if (ret == 0 ) {true : false ;true : false ;return ret;static int victus_s_gpu_thermal_profile_set(bool ctgp_enable,bool ppab_enable,struct victus_gpu_power_modes gpu_power_modes;int ret;bool current_ctgp_state, current_ppab_state;/* Retrieving GPU slowdown temperature, in order to keep it unchanged */ if (ret < 0 ) {"GPU modes not updated, unable to get slowdown temp\n" );return ret;0 x01 : 0 x00;0 x01 : 0 x00;sizeof (gpu_power_modes), 0 );return ret;/* Note: HP_POWER_LIMIT_DEFAULT can be used to restore default PL1 and PL2 */ static int victus_s_set_cpu_pl1_pl2(u8 pl1, u8 pl2)struct victus_power_limits power_limits;int ret;/* We need to know both PL1 and PL2 values in order to check them */ if (pl1 == HP_POWER_LIMIT_NO_CHANGE || pl2 == HP_POWER_LIMIT_NO_CHANGE)return -EINVAL;/* PL2 is not supposed to be lower than PL1 */ if (pl2 < pl1)return -EINVAL;sizeof (power_limits), 0 );return ret;static int platform_profile_victus_s_set_ec(enum platform_profile_option profile)bool gpu_ctgp_enable, gpu_ppab_enable;/* Test shows 1 = 100%, 2 = 50%, 3 = 25%, 4 = 12.5% */ int err, tp;switch (profile) {case PLATFORM_PROFILE_PERFORMANCE:true ;true ;1 ;break ;case PLATFORM_PROFILE_BALANCED:false ;true ;1 ;break ;case PLATFORM_PROFILE_LOW_POWER:false ;false ;1 ;break ;default :return -EOPNOTSUPP;if (err < 0 ) {"Failed to set platform profile %d: %d\n" , profile, err);return err;if (err < 0 ) {"Failed to set GPU profile %d: %d\n" , profile, err);return err;return 0 ;static int platform_profile_victus_s_set(struct device *dev,enum platform_profile_option profile)int err;if (err < 0 )return err;return 0 ;static int platform_profile_victus_set(struct device *dev,enum platform_profile_option profile)int err;if (err < 0 )return err;return 0 ;static int hp_wmi_platform_profile_probe(void *drvdata, unsigned long *choices)if (is_omen_thermal_profile()) {else if (is_victus_thermal_profile()) {else if (is_victus_s_thermal_profile()) {/* Adding an equivalent to HP Omen software ECO mode: */ else {return 0 ;static int omen_powersource_event(struct notifier_block *nb,unsigned long value,void *data)struct acpi_bus_event *event_entry = data;enum platform_profile_option actual_profile;int err;if (strcmp(event_entry->device_class, ACPI_AC_CLASS) != 0 )return NOTIFY_DONE;"Received power source device event\n" );/* * This handler can only be called on Omen and Victus models , so * there ' s no need to call is_victus_thermal_profile ( ) here . if (is_omen_thermal_profile())else if (err < 0 ) {/* * Although we failed to get the current platform profile , we * still want the other event consumers to process it . "Failed to read current platform profile (%d)\n" , err);return NOTIFY_DONE;/* * If we ' re back on AC and that the user - chosen power profile is * different from what the EC reports , we restore the user - chosen * one . if (power_supply_is_system_supplied() <= 0 ||"Platform profile update skipped, conditions unmet\n" );return NOTIFY_DONE;if (is_omen_thermal_profile())else if (err < 0 ) {"Failed to restore platform profile (%d)\n" , err);return NOTIFY_DONE;return NOTIFY_OK;static int victus_s_powersource_event(struct notifier_block *nb,unsigned long value,void *data)struct acpi_bus_event *event_entry = data;int err;if (strcmp(event_entry->device_class, ACPI_AC_CLASS) != 0 )return NOTIFY_DONE;"Received power source device event\n" );/* * Switching to battery power source while Performance mode is active * needs manual triggering of CPU power limits . Same goes when switching * to AC power source while Performance mode is active . Other modes * however are automatically behaving without any manual action . * Seen on HP 16 - s1034nf ( board 8 C9C ) with F . 11 and F . 13 BIOS versions . if (active_platform_profile == PLATFORM_PROFILE_PERFORMANCE) {"Triggering CPU PL1/PL2 actualization\n" );if (err)"Failed to actualize power limits: %d\n" , err);return NOTIFY_DONE;return NOTIFY_OK;static int omen_register_powersource_event_handler(void )int err;if (err < 0 ) {"Failed to install ACPI power source notify handler\n" );return err;return 0 ;static int victus_s_register_powersource_event_handler(void )int err;if (err < 0 ) {"Failed to install ACPI power source notify handler\n" );return err;return 0 ;static inline void omen_unregister_powersource_event_handler(void )static inline void victus_s_unregister_powersource_event_handler(void )static const struct platform_profile_ops platform_profile_omen_ops = {static const struct platform_profile_ops platform_profile_victus_ops = {static const struct platform_profile_ops platform_profile_victus_s_ops = {static const struct platform_profile_ops hp_wmi_platform_profile_ops = {static int thermal_profile_setup(struct platform_device *device)const struct platform_profile_ops *ops;int err, tp;if (is_omen_thermal_profile()) {if (err < 0 )return err;/* * call thermal profile write command to ensure that the * firmware correctly sets the OEM variables if (err < 0 )return err;else if (is_victus_thermal_profile()) {if (err < 0 )return err;/* * call thermal profile write command to ensure that the * firmware correctly sets the OEM variables if (err < 0 )return err;else if (is_victus_s_thermal_profile()) {/* * Being unable to retrieve laptop ' s current thermal profile , * during this setup , we set it to Balanced by default . if (err < 0 )return err;else {if (tp < 0 )return tp;/* * call thermal profile write command to ensure that the * firmware correctly sets the OEM variables for the DPTF if (err)return err;"hp-wmi" ,if (IS_ERR(platform_profile_device))return PTR_ERR(platform_profile_device);"Registered as platform profile handler\n" );true ;return 0 ;static int hp_wmi_hwmon_init(void );static int __init hp_wmi_bios_setup(struct platform_device *device)int err;/* clear detected rfkill devices */ 0 ;/* * In pre - 2009 BIOS , command 1 Bh return 0 x4 to indicate that * BIOS no longer controls the power for the wireless * devices . All features supported by this command will no * longer be supported . if (!hp_wmi_bios_2009_later()) {if (hp_wmi_rfkill_setup(device))if (err < 0 )return err;return 0 ;static void __exit hp_wmi_bios_remove(struct platform_device *device)int i;for (i = 0 ; i < rfkill2_count; i++) {if (wifi_rfkill) {if (bluetooth_rfkill) {if (wwan_rfkill) {static int hp_wmi_resume_handler(struct device *device)/* * Hardware state may have changed while suspended , so trigger * input events for the current state . As this is a switch , * the input layer will only actually pass it on if the state * changed . if (hp_wmi_input_dev) {if (test_bit(SW_DOCK, hp_wmi_input_dev->swbit))if (test_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit))if (rfkill2_count)if (wifi_rfkill)if (bluetooth_rfkill)if (wwan_rfkill)return 0 ;static const struct dev_pm_ops hp_wmi_pm_ops = {/* * hp_wmi_bios_remove ( ) lives in . exit . text . For drivers registered via * module_platform_driver_probe ( ) this is ok because they cannot get unbound at * runtime . So mark the driver struct with _ _ refdata to prevent modpost * triggering a section mismatch warning . static struct platform_driver hp_wmi_driver __refdata = {"hp-wmi" ,static umode_t hp_wmi_hwmon_is_visible(const void *data,enum hwmon_sensor_types type,int channel)switch (type) {case hwmon_pwm:return 0644 ;case hwmon_fan:if (is_victus_s_thermal_profile()) {if (hp_wmi_get_fan_speed_victus_s(channel) >= 0 )return 0444 ;else {if (hp_wmi_get_fan_speed(channel) >= 0 )return 0444 ;break ;default :return 0 ;return 0 ;static int hp_wmi_hwmon_read(struct device *dev, enum hwmon_sensor_types type,int channel, long *val)int ret;switch (type) {case hwmon_fan:if (is_victus_s_thermal_profile())else if (ret < 0 )return ret;return 0 ;case hwmon_pwm:switch (hp_wmi_fan_speed_max_get()) {case 0 :/* 0 is automatic fan, which is 2 for hwmon */ 2 ;return 0 ;case 1 :/* 1 is max fan, which is 0 * ( no fan speed control ) for hwmon 0 ;return 0 ;default :/* shouldn't happen */ return -ENODATA;default :return -EINVAL;static int hp_wmi_hwmon_write(struct device *dev, enum hwmon_sensor_types type,int channel, long val)switch (type) {case hwmon_pwm:switch (val) {case 0 :if (is_victus_s_thermal_profile())/* 0 is no fan speed control (max), which is 1 for us */ return hp_wmi_fan_speed_max_set(1 );case 2 :/* 2 is automatic speed control, which is 0 for us */ if (is_victus_s_thermal_profile()) {return hp_wmi_fan_speed_max_reset();else return hp_wmi_fan_speed_max_set(0 );default :/* we don't support manual fan speed control */ return -EINVAL;default :return -EOPNOTSUPP;static const struct hwmon_channel_info * const info[] = {static const struct hwmon_ops ops = {static const struct hwmon_chip_info chip_info = {static int hp_wmi_hwmon_init(void )struct device *dev = &hp_wmi_platform_dev->dev;struct device *hwmon;"hp" , &hp_wmi_driver,if (IS_ERR(hwmon)) {"Could not register hp hwmon device\n" );return PTR_ERR(hwmon);return 0 ;static int __init hp_wmi_init(void )int event_capable = wmi_has_guid(HPWMI_EVENT_GUID);int bios_capable = wmi_has_guid(HPWMI_BIOS_GUID);int err, tmp = 0 ;if (!bios_capable && !event_capable)return -ENODEV;if (hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, HPWMI_READ, &tmp,sizeof (tmp), sizeof (tmp)) == HPWMI_RET_INVALID_PARAMETERS)true ;if (event_capable) {if (err)return err;if (bios_capable) {"hp-wmi" , PLATFORM_DEVID_NONE, NULL, 0 );if (IS_ERR(hp_wmi_platform_dev)) {goto err_destroy_input;if (err)goto err_unregister_device;if (is_omen_thermal_profile() || is_victus_thermal_profile()) {if (err)goto err_unregister_device;else if (is_victus_s_thermal_profile()) {if (err)goto err_unregister_device;return 0 ;if (event_capable)return err;static void __exit hp_wmi_exit(void )if (is_omen_thermal_profile() || is_victus_thermal_profile())if (is_victus_s_thermal_profile())if (wmi_has_guid(HPWMI_EVENT_GUID))if (camera_shutter_input_dev)if (hp_wmi_platform_dev) {
Messung V0.5 in Prozent C=98 H=96 G=96
¤ Dauer der Verarbeitung: 0.39 Sekunden
(vorverarbeitet am 2026-10-03)
¤ *© Formatika GbR, Deutschland
