1915 lines
69 KiB
C
1915 lines
69 KiB
C
/*******************************************************************************
|
|
** This file is provided under a dual BSD/GPLv2 license. When using or
|
|
** redistributing this file, you may do so under either license.
|
|
**
|
|
** GPL LICENSE SUMMARY
|
|
**
|
|
** Copyright (c) 2013 Intel Corporation All Rights Reserved
|
|
**
|
|
** This program is free software; you can redistribute it and/or modify it under
|
|
** the terms of version 2 of the GNU General Public License as published by the
|
|
** Free Software Foundation.
|
|
**
|
|
** This program is distributed in the hope that it will be useful, but WITHOUT
|
|
** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
** FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
|
|
** details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License along with
|
|
** this program; if not, write to the Free Software Foundation, Inc.,
|
|
** 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
|
|
** The full GNU General Public License is included in this distribution in the
|
|
** file called LICENSE.GPL.
|
|
**
|
|
** BSD LICENSE
|
|
**
|
|
** Copyright (c) 2013 Intel Corporation All Rights Reserved
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions are met:
|
|
**
|
|
** * Redistributions of source code must retain the above copyright notice, this
|
|
** list of conditions and the following disclaimer.
|
|
** * Redistributions in binary form must reproduce the above copyright notice,
|
|
** this list of conditions and the following disclaimer in the documentation
|
|
** and/or other materials provided with the distribution.
|
|
** * Neither the name of Intel Corporation nor the names of its contributors may
|
|
** be used to endorse or promote products derived from this software without
|
|
** specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
** POSSIBILITY OF SUCH DAMAGE.
|
|
**
|
|
*******************************************************************************/
|
|
#ifndef _ESIF_AUTOGEN_H_
|
|
#define _ESIF_AUTOGEN_H_
|
|
|
|
#ifdef ESIF_ATTR_USER
|
|
#include "esif.h"
|
|
#endif
|
|
|
|
/*
|
|
** PRIMITIVE Declarations
|
|
*/
|
|
|
|
/* Enumerated Type Base Macros */
|
|
#define ENUMDECL(ENUM) ENUM,
|
|
#define ENUMSWITCH(ENUM) case ENUM: \
|
|
return #ENUM;break;
|
|
#define ENUMLIST(ENUM) {ENUM, #ENUM},
|
|
#define ENUMDECL_VAL(ENUM, VAL) ENUM = VAL,
|
|
#define ENUMSWITCH_VAL(ENUM, VAL) ENUMSWITCH(ENUM)
|
|
#define ENUMLIST_VAL(ENUM, VAL) ENUMLIST(ENUM)
|
|
|
|
#define ENUM_ESIF_PRIMITIVE_TYPE(ENUM) \
|
|
ENUM##_VAL(GET_ACTIVE_RELATIONSHIP_TABLE, 89) \
|
|
ENUM##_VAL(GET_AMBIENT_CAPICITANCE_COEF, 243) \
|
|
ENUM##_VAL(GET_AMBIENT_NOTIFICATION_THRESHOLD, 244) \
|
|
ENUM##_VAL(GET_BATTERY_INFORMATION, 224) \
|
|
ENUM##_VAL(GET_BATTERY_STATUS, 223) \
|
|
ENUM##_VAL(GET_CLOCK_COUNT, 185) \
|
|
ENUM##_VAL(GET_CLOCK_ORIGINAL_FREQUENCY, 187) \
|
|
ENUM##_VAL(GET_CURRENT_LOW_POWER_MODE, 94) \
|
|
ENUM##_VAL(GET_DEVICE_ADDRESS_ON_PARENT_BUS, 49) \
|
|
ENUM##_VAL(GET_DEVICE_COMPATABILITY_ID, 50) \
|
|
ENUM##_VAL(GET_DEVICE_DESCRIPTION, 60) \
|
|
ENUM##_VAL(GET_DEVICE_HARDWARE_ID, 53) \
|
|
ENUM##_VAL(GET_DEVICE_STATUS, 88) \
|
|
ENUM##_VAL(GET_DEVICE_UNIQUE_ID, 67) \
|
|
ENUM##_VAL(GET_DISPLAY_BRIGHTNESS_LEVELS, 158) \
|
|
ENUM##_VAL(GET_DISPLAY_BRIGHTNESS_SOFT, 157) \
|
|
ENUM##_VAL(GET_DISPLAY_CAPABILITY, 159) \
|
|
ENUM##_VAL(GET_DISPLAY_CLOCK_DEVIATION, 181) \
|
|
ENUM##_VAL(GET_DISPLAY_CLOCK_DOWNWARD_DEVIATION, 250) \
|
|
ENUM##_VAL(GET_DISPLAY_CLOCK_UPWARD_DEVIATION, 249) \
|
|
ENUM##_VAL(GET_DISPLAY_CLOCK_SPREAD_DIRECTION, 191) \
|
|
ENUM##_VAL(GET_DISPLAY_CLOCK_SPREAD_PERCENTAGE, 190) \
|
|
ENUM##_VAL(GET_DISPLAY_CLOCK_SSC_DISABLED_FREQUENCY, 189) \
|
|
ENUM##_VAL(GET_DISPLAY_CLOCK_SSC_ENABLED_FREQUENCY, 188) \
|
|
ENUM##_VAL(GET_DISPLAY_DEPTH_LIMIT, 160) \
|
|
ENUM##_VAL(GET_DISPLAY_PANEL_TYPE, 179) \
|
|
ENUM##_VAL(GET_DOMAIN_PRIORITY, 178) \
|
|
ENUM##_VAL(GET_DYNAMIC_BATTERY_POWER_ACTION, 279) \
|
|
ENUM##_VAL(GET_FAN_INFORMATION, 84) \
|
|
ENUM##_VAL(GET_FAN_PERFORMANCE_STATES, 85) \
|
|
ENUM##_VAL(GET_FAN_STATUS, 86) \
|
|
ENUM##_VAL(GET_GRAPHICS_CHIPSET_CHANNEL_TYPE, 182) \
|
|
ENUM##_VAL(GET_GRAPHICS_CHIPSET_SSC_ENABLED, 184) \
|
|
ENUM##_VAL(GET_LPM_TABLE, 237) \
|
|
ENUM##_VAL(GET_NOTIFICATION_TEMP_THRESHOLD, 54) \
|
|
ENUM##_VAL(GET_PARTICIPANT_LIST, 90) \
|
|
ENUM##_VAL(GET_PARTICIPANT_PERF_PRESENT_CAPABILITY, 176) \
|
|
ENUM##_VAL(GET_PARTICIPANT_SKU, 141) \
|
|
ENUM##_VAL(GET_PARTICIPANT_TYPE, 139) \
|
|
ENUM##_VAL(GET_PARTICIPANT_UTILIZATION, 138) \
|
|
ENUM##_VAL(GET_PDR_TABLE, 239) \
|
|
ENUM##_VAL(GET_PERF_PSTATE_DEPTH_LIMIT, 76) \
|
|
ENUM##_VAL(GET_PERF_SUPPORT_STATES, 137) \
|
|
ENUM##_VAL(GET_PLATFORM_STATE_OF_CHARGE, 278) \
|
|
ENUM##_VAL(GET_POWER_THRESHOLD_COUNT, 196) \
|
|
ENUM##_VAL(GET_POWER_THRESHOLD_HYSTERESIS, 197) \
|
|
ENUM##_VAL(GET_POWER_THRESHOLDS, 198) \
|
|
ENUM##_VAL(GET_PROC_APPLICATION_EXCLUDE_LIST, 68) \
|
|
ENUM##_VAL(GET_PROC_CTDP_CAPABILITY, 79) \
|
|
ENUM##_VAL(GET_PROC_CTDP_CURRENT_SETTING, 26) \
|
|
ENUM##_VAL(GET_PROC_CTDP_LOCK_STATUS, 27) \
|
|
ENUM##_VAL(GET_PROC_CTDP_POINT_LIST, 80) \
|
|
ENUM##_VAL(GET_PROC_CTDP_SUPPORT_CHECK, 25) \
|
|
ENUM##_VAL(GET_PROC_CTDP_TAR_LOCK_STATUS, 28) \
|
|
ENUM##_VAL(GET_PROC_CURRENT_LOGICAL_PROCESSOR_OFFLINING, 69) \
|
|
ENUM##_VAL(GET_PROC_IO_THROTTLE_STATUS, 151) \
|
|
ENUM##_VAL(GET_PROC_LOGICAL_PROCESSOR_AFFINITY, 228) \
|
|
ENUM##_VAL(GET_PROC_LOGICAL_PROCESSOR_COUNT, 101) \
|
|
ENUM##_VAL(GET_PROC_MFM_LPM_SUPPORTED, 207) \
|
|
ENUM##_VAL(GET_PROC_MFM_MAX_EFFICIENCY_RATIO, 209) \
|
|
ENUM##_VAL(GET_PROC_MFM_MIN_SUPPORTED_RATIO, 208) \
|
|
ENUM##_VAL(GET_PROC_PERF_MAX_TIME, 103) \
|
|
ENUM##_VAL(GET_PROC_PERF_PRESENT_CAPABILITY, 56) \
|
|
ENUM##_VAL(GET_PROC_PERF_PSTATE_CURRENT_MAX_TODO, 99) \
|
|
ENUM##_VAL(GET_PROC_PERF_PSTATE_DEPTH_LIMIT, 55) \
|
|
ENUM##_VAL(GET_PROC_PERF_PSTATE_STATUS_TODO, 98) \
|
|
ENUM##_VAL(GET_PROC_PERF_SUPPORT_STATES, 95) \
|
|
ENUM##_VAL(GET_PROC_PERF_THROTTLE_CONTROL, 58) \
|
|
ENUM##_VAL(GET_PROC_PERF_THROTTLE_PRESENT_CAPABILITY, 62) \
|
|
ENUM##_VAL(GET_PROC_PERF_TSTATE_DEPTH_LIMIT, 61) \
|
|
ENUM##_VAL(GET_PROC_RF_TUNING_AVAILABLE, 268) \
|
|
ENUM##_VAL(GET_PROC_RP_STATE_CAPABILITY, 277) \
|
|
ENUM##_VAL(GET_PROC_THERMAL_DESIGN_POWER, 21) \
|
|
ENUM##_VAL(GET_PROC_TJMAX, 20) \
|
|
ENUM##_VAL(GET_PROC_TURBO_ACTIVATION_RATIO, 219) \
|
|
ENUM##_VAL(GET_PROC_PROGRAMMABLE_POWER_LIMITS, 97) \
|
|
ENUM##_VAL(GET_PROC_TURBO_STATE, 218) \
|
|
ENUM##_VAL(GET_RAPL_DUTY_CYCLE, 149) \
|
|
ENUM##_VAL(GET_RAPL_ENERGY, 128) \
|
|
ENUM##_VAL(GET_RAPL_ENERGY_UNIT, 123) \
|
|
ENUM##_VAL(GET_RAPL_POWER, 35) \
|
|
ENUM##_VAL(GET_RAPL_POWER_CONTROL_CAPABILITIES, 75) \
|
|
ENUM##_VAL(GET_RAPL_POWER_DEFAULT, 148) \
|
|
ENUM##_VAL(GET_RAPL_POWER_LIMIT, 38) \
|
|
ENUM##_VAL(GET_RAPL_POWER_LIMIT_ENABLE, 126) \
|
|
ENUM##_VAL(GET_RAPL_POWER_LIMIT_LOCK, 172) \
|
|
ENUM##_VAL(GET_RAPL_POWER_MAX, 23) \
|
|
ENUM##_VAL(GET_RAPL_POWER_MAX_TIME_WINDOW, 24) \
|
|
ENUM##_VAL(GET_RAPL_POWER_MIN, 22) \
|
|
ENUM##_VAL(GET_RAPL_POWER_UNIT, 124) \
|
|
ENUM##_VAL(GET_RAPL_TIME_UNIT, 122) \
|
|
ENUM##_VAL(GET_RAPL_TIME_WINDOW, 39) \
|
|
ENUM##_VAL(GET_RFPROFILE_BIT_ERROR, 265) \
|
|
ENUM##_VAL(GET_RFPROFILE_CENTER_FREQUENCY, 245) \
|
|
ENUM##_VAL(GET_RFPROFILE_CHANNEL_NUMBER, 260) \
|
|
ENUM##_VAL(GET_RFPROFILE_CLIP_PERCENT_LEFT, 255) \
|
|
ENUM##_VAL(GET_RFPROFILE_CLIP_PERCENT_RIGHT, 256) \
|
|
ENUM##_VAL(GET_RFPROFILE_CONNECTION_STATUS, 264) \
|
|
ENUM##_VAL(GET_RFPROFILE_DEFAULT_CENTER_FREQUENCY, 254) \
|
|
ENUM##_VAL(GET_RFPROFILE_FREQUENCY_ADJUST_RESOLUTION, 257) \
|
|
ENUM##_VAL(GET_RFPROFILE_FREQUENCY_SPREAD_LEFT, 246) \
|
|
ENUM##_VAL(GET_RFPROFILE_FREQUENCY_SPREAD_RIGHT, 251) \
|
|
ENUM##_VAL(GET_RFPROFILE_NOISE_POWER, 261) \
|
|
ENUM##_VAL(GET_RFPROFILE_NOTCH_LEFT, 258) \
|
|
ENUM##_VAL(GET_RFPROFILE_NOTCH_RIGHT, 259) \
|
|
ENUM##_VAL(GET_RFPROFILE_RSSI, 263) \
|
|
ENUM##_VAL(GET_RFPROFILE_SHAPE_LEFT, 247) \
|
|
ENUM##_VAL(GET_RFPROFILE_SHAPE_RIGHT, 253) \
|
|
ENUM##_VAL(GET_RFPROFILE_SIGNAL_TO_NOISE_RATIO, 262) \
|
|
ENUM##_VAL(GET_SUPPORTED_POLICIES, 92) \
|
|
ENUM##_VAL(GET_SYSTEM_CONFIGTDP_LEVEL_NAME, 272) \
|
|
ENUM##_VAL(GET_TEMPERATURE, 14) \
|
|
ENUM##_VAL(GET_TEMPERATURE_APPROX_TABLE, 164) \
|
|
ENUM##_VAL(GET_TEMPERATURE_THRESHOLD_COUNT, 72) \
|
|
ENUM##_VAL(GET_TEMPERATURE_THRESHOLD_HYSTERESIS, 15) \
|
|
ENUM##_VAL(GET_TEMPERATURE_THRESHOLDS, 143) \
|
|
ENUM##_VAL(GET_THERMAL_RELATIONSHIP_TABLE, 91) \
|
|
ENUM##_VAL(GET_TRIP_POINT_ACTIVE, 1) \
|
|
ENUM##_VAL(GET_TRIP_POINT_CRITICAL, 13) \
|
|
ENUM##_VAL(GET_TRIP_POINT_HOT, 12) \
|
|
ENUM##_VAL(GET_TRIP_POINT_PASSIVE, 11) \
|
|
ENUM##_VAL(GET_TRIP_POINT_WARM, 177) \
|
|
ENUM##_VAL(GET_TSTATE_CURRENT, 16) \
|
|
ENUM##_VAL(GET_TSTATES, 65) \
|
|
ENUM##_VAL(SET_ACTIVE_RELATIONSHIP_TABLE, 230) \
|
|
ENUM##_VAL(SET_AMBIENT_TEMPERATURE_INDICATION, 242) \
|
|
ENUM##_VAL(SET_CLOCK_SSC_DISABLED, 194) \
|
|
ENUM##_VAL(SET_CLOCK_SSC_ENABLED, 193) \
|
|
ENUM##_VAL(SET_COOLING_POLICY, 81) \
|
|
ENUM##_VAL(SET_CTDP_POINT, 83) \
|
|
ENUM##_VAL(SET_CURRENT_LOW_POWER_MODE, 236) \
|
|
ENUM##_VAL(SET_DEVICE_TEMPERATURE_INDICATION, 51) \
|
|
ENUM##_VAL(SET_DISPLAY_BRIGHTNESS_HARD, 226) \
|
|
ENUM##_VAL(SET_DISPLAY_BRIGHTNESS_SOFT, 163) \
|
|
ENUM##_VAL(SET_DSP, 200) \
|
|
ENUM##_VAL(SET_FAN_LEVEL, 87) \
|
|
ENUM##_VAL(SET_GFX_RPCP, 281) \
|
|
ENUM##_VAL(SET_LPM_TABLE, 238) \
|
|
ENUM##_VAL(SET_OPERATING_SYSTEM_CAPABILITIES, 93) \
|
|
ENUM##_VAL(SET_PDR_TABLE, 240) \
|
|
ENUM##_VAL(SET_PERF_PRESENT_CAPABILITY, 82) \
|
|
ENUM##_VAL(SET_PERF_SUPPORT_STATE, 227) \
|
|
ENUM##_VAL(SET_POWER_THRESHOLD_HYSTERESIS, 233) \
|
|
ENUM##_VAL(SET_POWER_THRESHOLDS, 199) \
|
|
ENUM##_VAL(SET_PROC_CTDP_CONTROL, 221) \
|
|
ENUM##_VAL(SET_PROC_NUMBER_OFFLINE_CORES, 153) \
|
|
ENUM##_VAL(SET_RFPROFILE_CENTER_FREQUENCY, 211) \
|
|
ENUM##_VAL(SET_PROC_IO_THROTTLE_CONTROL, 152) \
|
|
ENUM##_VAL(SET_PROC_LOGICAL_PROCESSOR_AFFINITY, 229) \
|
|
ENUM##_VAL(SET_PROC_PERF_PSTATE_DEPTH_LIMIT, 275) \
|
|
ENUM##_VAL(SET_PROC_PERF_TSTATE_DEPTH_LIMIT, 276) \
|
|
ENUM##_VAL(SET_PROC_TURBO_ACTIVATION_RATIO, 220) \
|
|
ENUM##_VAL(SET_PROC_TURBO_STATE, 100) \
|
|
ENUM##_VAL(SET_RAPL_POWER_CONTROL_CAPABILITIES, 274) \
|
|
ENUM##_VAL(SET_RAPL_POWER_LIMIT, 130) \
|
|
ENUM##_VAL(SET_RAPL_POWER_LIMIT_ENABLE, 222) \
|
|
ENUM##_VAL(SET_RAPL_TIME_WINDOW, 127) \
|
|
ENUM##_VAL(SET_SUPPORTED_POLICIES, 271) \
|
|
ENUM##_VAL(SET_SYSTEM_CONFIGTDP_CLEAR_LEVELS, 269) \
|
|
ENUM##_VAL(SET_SYSTEM_CONFIGTDP_LEVEL_NAME, 270) \
|
|
ENUM##_VAL(SET_SYSTEM_HIBERNATE, 175) \
|
|
ENUM##_VAL(SET_SYSTEM_POWER_SETTING_REMOVE, 273) \
|
|
ENUM##_VAL(SET_SYSTEM_SHUTDOWN, 173) \
|
|
ENUM##_VAL(SET_SYSTEM_SLEEP, 174) \
|
|
ENUM##_VAL(SET_TEMPERATURE, 241) \
|
|
ENUM##_VAL(SET_TEMPERATURE_INTERRUPT_STATE, 280) \
|
|
ENUM##_VAL(SET_TEMPERATURE_THRESHOLD_HYSTERESIS, 232) \
|
|
ENUM##_VAL(SET_TEMPERATURE_THRESHOLDS, 47) \
|
|
ENUM##_VAL(SET_THERMAL_RELATIONSHIP_TABLE, 231) \
|
|
ENUM##_VAL(SET_TRIP_POINT_ACTIVE, 202) \
|
|
ENUM##_VAL(SET_TRIP_POINT_CRITICAL, 203) \
|
|
ENUM##_VAL(SET_TRIP_POINT_HOT, 204) \
|
|
ENUM##_VAL(SET_TRIP_POINT_PASSIVE, 206) \
|
|
ENUM##_VAL(SET_TRIP_POINT_WARM, 205) \
|
|
ENUM##_VAL(SET_TSTATE_CURRENT, 147) \
|
|
|
|
enum esif_primitive_type {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
GET_ACTIVE_RELATIONSHIP_TABLE = 89,
|
|
GET_AMBIENT_CAPICITANCE_COEF = 243,
|
|
GET_AMBIENT_NOTIFICATION_THRESHOLD = 244,
|
|
GET_BATTERY_INFORMATION = 224,
|
|
GET_BATTERY_STATUS = 223,
|
|
GET_CLOCK_COUNT = 185,
|
|
GET_CLOCK_ORIGINAL_FREQUENCY = 187,
|
|
GET_DEVICE_ADDRESS_ON_PARENT_BUS = 49,
|
|
GET_DEVICE_COMPATABILITY_ID = 50,
|
|
GET_DEVICE_DESCRIPTION = 60,
|
|
GET_DEVICE_HARDWARE_ID = 53,
|
|
GET_DEVICE_STATUS = 88,
|
|
GET_DEVICE_UNIQUE_ID = 67,
|
|
GET_DISPLAY_BRIGHTNESS_LEVELS = 158,
|
|
GET_DISPLAY_BRIGHTNESS_SOFT = 157,
|
|
GET_DISPLAY_CAPABILITY = 159,
|
|
GET_DISPLAY_CLOCK_DEVIATION = 181,
|
|
GET_DISPLAY_CLOCK_DOWNWARD_DEVIATION= 250,
|
|
GET_DISPLAY_CLOCK_UPWARD_DEVIATION = 249,
|
|
GET_DISPLAY_CLOCK_SPREAD_DIRECTION = 191,
|
|
GET_DISPLAY_CLOCK_SPREAD_PERCENTAGE = 190,
|
|
GET_DISPLAY_CLOCK_SSC_DISABLED_FREQUENCY = 189,
|
|
GET_DISPLAY_CLOCK_SSC_ENABLED_FREQUENCY = 188,
|
|
GET_DISPLAY_DEPTH_LIMIT = 160,
|
|
GET_DISPLAY_PANEL_TYPE = 179,
|
|
GET_DOMAIN_PRIORITY = 178,
|
|
GET_DYNAMIC_BATTERY_POWER_ACTION = 279,
|
|
GET_FAN_INFORMATION = 84,
|
|
GET_FAN_PERFORMANCE_STATES = 85,
|
|
GET_FAN_STATUS = 86,
|
|
GET_GRAPHICS_CHIPSET_CHANNEL_TYPE = 182,
|
|
GET_GRAPHICS_CHIPSET_SSC_ENABLED = 184,
|
|
GET_LPM_TABLE = 237,
|
|
GET_NOTIFICATION_TEMP_THRESHOLD = 54,
|
|
GET_PARTICIPANT_LIST = 90,
|
|
GET_PARTICIPANT_PERF_PRESENT_CAPABILITY = 176,
|
|
GET_PARTICIPANT_SKU = 141,
|
|
GET_PARTICIPANT_TYPE = 139,
|
|
GET_PARTICIPANT_UTILIZATION = 138,
|
|
GET_PDR_TABLE = 239,
|
|
GET_PERF_PSTATE_DEPTH_LIMIT = 76,
|
|
GET_PERF_SUPPORT_STATES = 137,
|
|
GET_PLATFORM_STATE_OF_CHARGE = 278,
|
|
GET_POWER_THRESHOLD_COUNT = 196,
|
|
GET_POWER_THRESHOLD_HYSTERESIS = 197,
|
|
GET_POWER_THRESHOLDS = 198,
|
|
GET_PROC_APPLICATION_EXCLUDE_LIST = 68,
|
|
GET_PROC_CTDP_CAPABILITY = 79,
|
|
GET_PROC_CTDP_CURRENT_SETTING = 26,
|
|
GET_PROC_CTDP_LOCK_STATUS = 27,
|
|
GET_PROC_CTDP_POINT_LIST = 80,
|
|
GET_PROC_CTDP_SUPPORT_CHECK = 25,
|
|
GET_PROC_CTDP_TAR_LOCK_STATUS = 28,
|
|
GET_PROC_CURRENT_LOGICAL_PROCESSOR_OFFLINING = 69,
|
|
GET_CURRENT_LOW_POWER_MODE = 94,
|
|
GET_PROC_IO_THROTTLE_STATUS = 151,
|
|
GET_PROC_LOGICAL_PROCESSOR_AFFINITY = 228,
|
|
GET_PROC_LOGICAL_PROCESSOR_COUNT = 101,
|
|
GET_PROC_MFM_LPM_SUPPORTED = 207,
|
|
GET_PROC_MFM_MAX_EFFICIENCY_RATIO = 209,
|
|
GET_PROC_MFM_MIN_SUPPORTED_RATIO = 208,
|
|
GET_PROC_PERF_MAX_TIME = 103,
|
|
GET_PROC_PERF_PRESENT_CAPABILITY = 56,
|
|
GET_PROC_PERF_PSTATE_CURRENT_MAX_TODO = 99,
|
|
GET_PROC_PERF_PSTATE_DEPTH_LIMIT = 55,
|
|
GET_PROC_PERF_PSTATE_STATUS_TODO = 98,
|
|
GET_PROC_PERF_SUPPORT_STATES = 95,
|
|
GET_PROC_PERF_THROTTLE_CONTROL = 58,
|
|
GET_PROC_PERF_THROTTLE_PRESENT_CAPABILITY = 62,
|
|
GET_PROC_PERF_TSTATE_DEPTH_LIMIT = 61,
|
|
GET_PROC_RF_TUNING_AVAILABLE = 268,
|
|
GET_PROC_RP_STATE_CAPABILITY = 277,
|
|
GET_PROC_THERMAL_DESIGN_POWER = 21,
|
|
GET_PROC_TJMAX = 20,
|
|
GET_PROC_TURBO_ACTIVATION_RATIO = 219,
|
|
GET_PROC_PROGRAMMABLE_POWER_LIMITS = 97,
|
|
GET_PROC_TURBO_STATE = 218,
|
|
GET_RAPL_DUTY_CYCLE = 149,
|
|
GET_RAPL_ENERGY = 128,
|
|
GET_RAPL_ENERGY_UNIT = 123,
|
|
GET_RAPL_POWER = 35,
|
|
GET_RAPL_POWER_CONTROL_CAPABILITIES = 75,
|
|
GET_RAPL_POWER_DEFAULT = 148,
|
|
GET_RAPL_POWER_LIMIT = 38,
|
|
GET_RAPL_POWER_LIMIT_ENABLE = 126,
|
|
GET_RAPL_POWER_LIMIT_LOCK = 172,
|
|
GET_RAPL_POWER_MAX = 23,
|
|
GET_RAPL_POWER_MAX_TIME_WINDOW = 24,
|
|
GET_RAPL_POWER_MIN = 22,
|
|
GET_RAPL_POWER_UNIT = 124,
|
|
GET_RAPL_TIME_UNIT = 122,
|
|
GET_RAPL_TIME_WINDOW = 39,
|
|
GET_RFPROFILE_BIT_ERROR = 265,
|
|
GET_RFPROFILE_CENTER_FREQUENCY = 245,
|
|
GET_RFPROFILE_CHANNEL_NUMBER = 260,
|
|
GET_RFPROFILE_CLIP_PERCENT_LEFT = 255,
|
|
GET_RFPROFILE_CLIP_PERCENT_RIGHT = 256,
|
|
GET_RFPROFILE_CONNECTION_STATUS = 264,
|
|
GET_RFPROFILE_DEFAULT_CENTER_FREQUENCY = 254,
|
|
GET_RFPROFILE_FREQUENCY_ADJUST_RESOLUTION = 257,
|
|
GET_RFPROFILE_FREQUENCY_SPREAD_LEFT = 246,
|
|
GET_RFPROFILE_FREQUENCY_SPREAD_RIGHT = 251,
|
|
GET_RFPROFILE_NOISE_POWER = 261,
|
|
GET_RFPROFILE_NOTCH_LEFT = 258,
|
|
GET_RFPROFILE_NOTCH_RIGHT = 259,
|
|
GET_RFPROFILE_RSSI = 263,
|
|
GET_RFPROFILE_SHAPE_LEFT = 247,
|
|
GET_RFPROFILE_SHAPE_RIGHT = 253,
|
|
GET_RFPROFILE_SIGNAL_TO_NOISE_RATIO = 262,
|
|
GET_SUPPORTED_POLICIES = 92,
|
|
GET_SYSTEM_CONFIGTDP_LEVEL_NAME = 272,
|
|
GET_TEMPERATURE = 14,
|
|
GET_TEMPERATURE_APPROX_TABLE = 164,
|
|
GET_TEMPERATURE_THRESHOLD_COUNT = 72,
|
|
GET_TEMPERATURE_THRESHOLD_HYSTERESIS = 15,
|
|
GET_TEMPERATURE_THRESHOLDS = 143,
|
|
GET_THERMAL_RELATIONSHIP_TABLE = 91,
|
|
GET_TRIP_POINT_ACTIVE = 1,
|
|
GET_TRIP_POINT_CRITICAL = 13,
|
|
GET_TRIP_POINT_HOT = 12,
|
|
GET_TRIP_POINT_PASSIVE = 11,
|
|
GET_TRIP_POINT_WARM = 177,
|
|
GET_TSTATE_CURRENT = 16,
|
|
GET_TSTATES = 65,
|
|
SET_PROC_NUMBER_OFFLINE_CORES = 153,
|
|
SET_ACTIVE_RELATIONSHIP_TABLE = 230,
|
|
SET_AMBIENT_TEMPERATURE_INDICATION = 242,
|
|
SET_CLOCK_SSC_DISABLED = 194,
|
|
SET_CLOCK_SSC_ENABLED = 193,
|
|
SET_COOLING_POLICY = 81,
|
|
SET_CTDP_POINT = 83,
|
|
SET_CURRENT_LOW_POWER_MODE = 236,
|
|
SET_DEVICE_TEMPERATURE_INDICATION = 51,
|
|
SET_DISPLAY_BRIGHTNESS_HARD = 226,
|
|
SET_DISPLAY_BRIGHTNESS_SOFT = 163,
|
|
SET_DSP = 200,
|
|
SET_FAN_LEVEL = 87,
|
|
SET_GFX_RPCP = 281,
|
|
SET_LPM_TABLE = 238,
|
|
SET_OPERATING_SYSTEM_CAPABILITIES = 93,
|
|
SET_PDR_TABLE = 240,
|
|
SET_PERF_PRESENT_CAPABILITY = 82,
|
|
SET_PERF_SUPPORT_STATE = 227,
|
|
SET_POWER_THRESHOLD_HYSTERESIS = 233,
|
|
SET_POWER_THRESHOLDS = 199,
|
|
SET_PROC_CTDP_CONTROL = 221,
|
|
SET_RFPROFILE_CENTER_FREQUENCY = 211,
|
|
SET_PROC_IO_THROTTLE_CONTROL = 152,
|
|
SET_PROC_LOGICAL_PROCESSOR_AFFINITY = 229,
|
|
SET_PROC_PERF_PSTATE_DEPTH_LIMIT = 275,
|
|
SET_PROC_PERF_TSTATE_DEPTH_LIMIT = 276,
|
|
SET_PROC_TURBO_ACTIVATION_RATIO = 220,
|
|
SET_PROC_TURBO_STATE = 100,
|
|
SET_RAPL_POWER_CONTROL_CAPABILITIES = 274,
|
|
SET_RAPL_POWER_LIMIT = 130,
|
|
SET_RAPL_POWER_LIMIT_ENABLE = 222,
|
|
SET_RAPL_TIME_WINDOW = 127,
|
|
SET_SUPPORTED_POLICIES = 271,
|
|
SET_SYSTEM_CONFIGTDP_CLEAR_LEVELS = 269,
|
|
SET_SYSTEM_CONFIGTDP_LEVEL_NAME = 270,
|
|
SET_SYSTEM_HIBERNATE = 175,
|
|
SET_SYSTEM_POWER_SETTING_REMOVE = 273,
|
|
SET_SYSTEM_SHUTDOWN = 173,
|
|
SET_SYSTEM_SLEEP = 174,
|
|
SET_TEMPERATURE = 241,
|
|
SET_TEMPERATURE_INTERRUPT_STATE = 280,
|
|
SET_TEMPERATURE_THRESHOLD_HYSTERESIS = 232,
|
|
SET_TEMPERATURE_THRESHOLDS = 47,
|
|
SET_THERMAL_RELATIONSHIP_TABLE = 231,
|
|
SET_TRIP_POINT_ACTIVE = 202,
|
|
SET_TRIP_POINT_CRITICAL = 203,
|
|
SET_TRIP_POINT_HOT = 204,
|
|
SET_TRIP_POINT_PASSIVE = 206,
|
|
SET_TRIP_POINT_WARM = 205,
|
|
SET_TSTATE_CURRENT = 147,
|
|
#else
|
|
ENUM_ESIF_PRIMITIVE_TYPE(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_primitive_type esif_primitive_type_string2enum (esif_string str);
|
|
extern esif_string esif_primitive_type_enum2string (
|
|
enum esif_primitive_type type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_primitive_str (enum esif_primitive_type type)
|
|
{
|
|
#define CREATE_PRIMITIVE_TYPE(pt) case pt: \
|
|
str = (esif_string) #pt;break;
|
|
|
|
#define CREATE_PRIMITIVE_TYPE_VAL(pt, VAL) case pt: \
|
|
str = (esif_string) #pt;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (type) {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
CREATE_PRIMITIVE_TYPE(GET_ACTIVE_RELATIONSHIP_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_AMBIENT_CAPICITANCE_COEF)
|
|
CREATE_PRIMITIVE_TYPE(GET_AMBIENT_NOTIFICATION_THRESHOLD)
|
|
CREATE_PRIMITIVE_TYPE(GET_BATTERY_INFORMATION)
|
|
CREATE_PRIMITIVE_TYPE(GET_BATTERY_STATUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_CLOCK_COUNT)
|
|
CREATE_PRIMITIVE_TYPE(GET_CLOCK_ORIGINAL_FREQUENCY)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CLOCK_SPREAD_DIRECTION)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CLOCK_SPREAD_PERCENTAGE)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CLOCK_SSC_DISABLED_FREQUENCY)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CLOCK_SSC_ENABLED_FREQUENCY)
|
|
CREATE_PRIMITIVE_TYPE(GET_DEVICE_ADDRESS_ON_PARENT_BUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_DEVICE_COMPATABILITY_ID)
|
|
CREATE_PRIMITIVE_TYPE(GET_DEVICE_DESCRIPTION)
|
|
CREATE_PRIMITIVE_TYPE(GET_DEVICE_HARDWARE_ID)
|
|
CREATE_PRIMITIVE_TYPE(GET_DEVICE_STATUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_DEVICE_UNIQUE_ID)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_BRIGHTNESS_LEVELS)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_BRIGHTNESS_SOFT)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CAPABILITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CLOCK_DEVIATION)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CLOCK_DOWNWARD_DEVIATION)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_CLOCK_UPWARD_DEVIATION)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_DEPTH_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_DISPLAY_PANEL_TYPE)
|
|
CREATE_PRIMITIVE_TYPE(GET_DOMAIN_PRIORITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_DYNAMIC_BATTERY_POWER_ACTION)
|
|
CREATE_PRIMITIVE_TYPE(GET_FAN_INFORMATION)
|
|
CREATE_PRIMITIVE_TYPE(GET_FAN_PERFORMANCE_STATES)
|
|
CREATE_PRIMITIVE_TYPE(GET_FAN_STATUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_GRAPHICS_CHIPSET_CHANNEL_TYPE)
|
|
CREATE_PRIMITIVE_TYPE(GET_GRAPHICS_CHIPSET_SSC_ENABLED)
|
|
CREATE_PRIMITIVE_TYPE(GET_LPM_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_NOTIFICATION_TEMP_THRESHOLD)
|
|
CREATE_PRIMITIVE_TYPE(GET_PARTICIPANT_LIST)
|
|
CREATE_PRIMITIVE_TYPE(GET_PARTICIPANT_PERF_PRESENT_CAPABILITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_PARTICIPANT_SKU)
|
|
CREATE_PRIMITIVE_TYPE(GET_PARTICIPANT_TYPE)
|
|
CREATE_PRIMITIVE_TYPE(GET_PARTICIPANT_UTILIZATION)
|
|
CREATE_PRIMITIVE_TYPE(GET_PDR_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_PERF_PSTATE_DEPTH_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_PERF_SUPPORT_STATES)
|
|
CREATE_PRIMITIVE_TYPE(GET_PLATFORM_STATE_OF_CHARGE)
|
|
CREATE_PRIMITIVE_TYPE(GET_POWER_THRESHOLD_COUNT)
|
|
CREATE_PRIMITIVE_TYPE(GET_POWER_THRESHOLD_HYSTERESIS)
|
|
CREATE_PRIMITIVE_TYPE(GET_POWER_THRESHOLDS)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_APPLICATION_EXCLUDE_LIST)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_CTDP_CAPABILITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_CTDP_CURRENT_SETTING)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_CTDP_LOCK_STATUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_CTDP_POINT_LIST)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_CTDP_SUPPORT_CHECK)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_CTDP_TAR_LOCK_STATUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_CURRENT_LOGICAL_PROCESSOR_OFFLINING)
|
|
CREATE_PRIMITIVE_TYPE(GET_CURRENT_LOW_POWER_MODE)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_IO_THROTTLE_STATUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_LOGICAL_PROCESSOR_AFFINITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_LOGICAL_PROCESSOR_COUNT)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_MFM_LPM_SUPPORTED)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_MFM_MAX_EFFICIENCY_RATIO)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_MFM_MIN_SUPPORTED_RATIO)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_MAX_TIME)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_PRESENT_CAPABILITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_PSTATE_CURRENT_MAX_TODO)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_PSTATE_DEPTH_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_PSTATE_STATUS_TODO)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_SUPPORT_STATES)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_THROTTLE_CONTROL)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_THROTTLE_PRESENT_CAPABILITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PERF_TSTATE_DEPTH_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_RF_TUNING_AVAILABLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_RP_STATE_CAPABILITY)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_THERMAL_DESIGN_POWER)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_TJMAX)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_TURBO_ACTIVATION_RATIO)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_PROGRAMMABLE_POWER_LIMITS)
|
|
CREATE_PRIMITIVE_TYPE(GET_PROC_TURBO_STATE)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_DUTY_CYCLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_ENERGY)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_ENERGY_UNIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_CONTROL_CAPABILITIES)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_DEFAULT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_LIMIT_ENABLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_LIMIT_LOCK)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_MAX)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_MAX_TIME_WINDOW)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_MIN)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_POWER_UNIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_TIME_UNIT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RAPL_TIME_WINDOW)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_BIT_ERROR)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_CENTER_FREQUENCY)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_CHANNEL_NUMBER)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_CLIP_PERCENT_LEFT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_CLIP_PERCENT_RIGHT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_CONNECTION_STATUS)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_DEFAULT_CENTER_FREQUENCY)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_FREQUENCY_SPREAD_LEFT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_FREQUENCY_SPREAD_RIGHT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_FREQUENCY_ADJUST_RESOLUTION)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_NOISE_POWER)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_NOTCH_LEFT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_NOTCH_RIGHT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_RSSI)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_SHAPE_LEFT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_SHAPE_RIGHT)
|
|
CREATE_PRIMITIVE_TYPE(GET_RFPROFILE_SIGNAL_TO_NOISE_RATIO)
|
|
CREATE_PRIMITIVE_TYPE(GET_SUPPORTED_POLICIES)
|
|
CREATE_PRIMITIVE_TYPE(GET_SYSTEM_CONFIGTDP_LEVEL_NAME)
|
|
CREATE_PRIMITIVE_TYPE(GET_TEMPERATURE)
|
|
CREATE_PRIMITIVE_TYPE(GET_TEMPERATURE_APPROX_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_TEMPERATURE_THRESHOLD_COUNT)
|
|
CREATE_PRIMITIVE_TYPE(GET_TEMPERATURE_THRESHOLD_HYSTERESIS)
|
|
CREATE_PRIMITIVE_TYPE(GET_TEMPERATURE_THRESHOLDS)
|
|
CREATE_PRIMITIVE_TYPE(GET_THERMAL_RELATIONSHIP_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(GET_TRIP_POINT_ACTIVE)
|
|
CREATE_PRIMITIVE_TYPE(GET_TRIP_POINT_CRITICAL)
|
|
CREATE_PRIMITIVE_TYPE(GET_TRIP_POINT_HOT)
|
|
CREATE_PRIMITIVE_TYPE(GET_TRIP_POINT_PASSIVE)
|
|
CREATE_PRIMITIVE_TYPE(GET_TRIP_POINT_WARM)
|
|
CREATE_PRIMITIVE_TYPE(GET_TSTATE_CURRENT)
|
|
CREATE_PRIMITIVE_TYPE(GET_TSTATES)
|
|
CREATE_PRIMITIVE_TYPE(SET_ACTIVE_RELATIONSHIP_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(SET_AMBIENT_TEMPERATURE_INDICATION)
|
|
CREATE_PRIMITIVE_TYPE(SET_CLOCK_SSC_DISABLED)
|
|
CREATE_PRIMITIVE_TYPE(SET_CLOCK_SSC_ENABLED)
|
|
CREATE_PRIMITIVE_TYPE(SET_COOLING_POLICY)
|
|
CREATE_PRIMITIVE_TYPE(SET_CTDP_POINT)
|
|
CREATE_PRIMITIVE_TYPE(SET_CURRENT_LOW_POWER_MODE)
|
|
CREATE_PRIMITIVE_TYPE(SET_DEVICE_TEMPERATURE_INDICATION)
|
|
CREATE_PRIMITIVE_TYPE(SET_DISPLAY_BRIGHTNESS_HARD)
|
|
CREATE_PRIMITIVE_TYPE(SET_DISPLAY_BRIGHTNESS_SOFT)
|
|
CREATE_PRIMITIVE_TYPE(SET_DSP)
|
|
CREATE_PRIMITIVE_TYPE(SET_FAN_LEVEL)
|
|
CREATE_PRIMITIVE_TYPE(SET_GFX_RPCP)
|
|
CREATE_PRIMITIVE_TYPE(SET_LPM_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(SET_OPERATING_SYSTEM_CAPABILITIES)
|
|
CREATE_PRIMITIVE_TYPE(SET_PDR_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(SET_PERF_PRESENT_CAPABILITY)
|
|
CREATE_PRIMITIVE_TYPE(SET_PERF_SUPPORT_STATE)
|
|
CREATE_PRIMITIVE_TYPE(SET_POWER_THRESHOLD_HYSTERESIS)
|
|
CREATE_PRIMITIVE_TYPE(SET_POWER_THRESHOLDS)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_CTDP_CONTROL)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_NUMBER_OFFLINE_CORES)
|
|
CREATE_PRIMITIVE_TYPE(SET_RFPROFILE_CENTER_FREQUENCY)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_IO_THROTTLE_CONTROL)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_LOGICAL_PROCESSOR_AFFINITY)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_PERF_PSTATE_DEPTH_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_PERF_TSTATE_DEPTH_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_TURBO_ACTIVATION_RATIO)
|
|
CREATE_PRIMITIVE_TYPE(SET_PROC_TURBO_STATE)
|
|
CREATE_PRIMITIVE_TYPE(SET_RAPL_POWER_CONTROL_CAPABILITIES)
|
|
CREATE_PRIMITIVE_TYPE(SET_RAPL_POWER_LIMIT)
|
|
CREATE_PRIMITIVE_TYPE(SET_RAPL_POWER_LIMIT_ENABLE)
|
|
CREATE_PRIMITIVE_TYPE(SET_RAPL_TIME_WINDOW)
|
|
CREATE_PRIMITIVE_TYPE(SET_SUPPORTED_POLICIES)
|
|
CREATE_PRIMITIVE_TYPE(SET_SYSTEM_CONFIGTDP_CLEAR_LEVELS)
|
|
CREATE_PRIMITIVE_TYPE(SET_SYSTEM_CONFIGTDP_LEVEL_NAME)
|
|
CREATE_PRIMITIVE_TYPE(SET_SYSTEM_HIBERNATE)
|
|
CREATE_PRIMITIVE_TYPE(SET_SYSTEM_POWER_SETTING_REMOVE)
|
|
CREATE_PRIMITIVE_TYPE(SET_SYSTEM_SHUTDOWN)
|
|
CREATE_PRIMITIVE_TYPE(SET_SYSTEM_SLEEP)
|
|
CREATE_PRIMITIVE_TYPE(SET_TEMPERATURE)
|
|
CREATE_PRIMITIVE_TYPE(SET_TEMPERATURE_INTERRUPT_STATE)
|
|
CREATE_PRIMITIVE_TYPE(SET_TEMPERATURE_THRESHOLD_HYSTERESIS)
|
|
CREATE_PRIMITIVE_TYPE(SET_TEMPERATURE_THRESHOLDS)
|
|
CREATE_PRIMITIVE_TYPE(SET_THERMAL_RELATIONSHIP_TABLE)
|
|
CREATE_PRIMITIVE_TYPE(SET_TRIP_POINT_ACTIVE)
|
|
CREATE_PRIMITIVE_TYPE(SET_TRIP_POINT_CRITICAL)
|
|
CREATE_PRIMITIVE_TYPE(SET_TRIP_POINT_HOT)
|
|
CREATE_PRIMITIVE_TYPE(SET_TRIP_POINT_PASSIVE)
|
|
CREATE_PRIMITIVE_TYPE(SET_TRIP_POINT_WARM)
|
|
CREATE_PRIMITIVE_TYPE(SET_TSTATE_CURRENT)
|
|
#else
|
|
ENUM_ESIF_PRIMITIVE_TYPE(CREATE_PRIMITIVE_TYPE)
|
|
#endif
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/*
|
|
** Data Type Declarations
|
|
*/
|
|
|
|
#define ENUM_ESIF_DATA_TYPE(ENUM) \
|
|
ENUM##_VAL(ESIF_DATA_ANGLE, 41) \
|
|
ENUM##_VAL(ESIF_DATA_AUTO, 36) \
|
|
ENUM##_VAL(ESIF_DATA_BINARY, 7) \
|
|
ENUM##_VAL(ESIF_DATA_BIT, 27) \
|
|
ENUM##_VAL(ESIF_DATA_BLOB, 34) \
|
|
ENUM##_VAL(ESIF_DATA_DSP, 33) \
|
|
ENUM##_VAL(ESIF_DATA_ENUM, 19) \
|
|
ENUM##_VAL(ESIF_DATA_GUID, 5) \
|
|
ENUM##_VAL(ESIF_DATA_HANDLE, 20) \
|
|
ENUM##_VAL(ESIF_DATA_INSTANCE, 30) \
|
|
ENUM##_VAL(ESIF_DATA_INT16, 12) \
|
|
ENUM##_VAL(ESIF_DATA_INT32, 13) \
|
|
ENUM##_VAL(ESIF_DATA_INT64, 14) \
|
|
ENUM##_VAL(ESIF_DATA_INT8, 11) \
|
|
ENUM##_VAL(ESIF_DATA_IPV4, 16) \
|
|
ENUM##_VAL(ESIF_DATA_IPV6, 17) \
|
|
ENUM##_VAL(ESIF_DATA_PERCENT, 29) \
|
|
ENUM##_VAL(ESIF_DATA_POINTER, 18) \
|
|
ENUM##_VAL(ESIF_DATA_POWER, 26) \
|
|
ENUM##_VAL(ESIF_DATA_QUALIFIER, 28) \
|
|
ENUM##_VAL(ESIF_DATA_REGISTER, 15) \
|
|
ENUM##_VAL(ESIF_DATA_STRING, 8) \
|
|
ENUM##_VAL(ESIF_DATA_STRUCTURE, 32) \
|
|
ENUM##_VAL(ESIF_DATA_TABLE, 35) \
|
|
ENUM##_VAL(ESIF_DATA_TEMPERATURE, 6) \
|
|
ENUM##_VAL(ESIF_DATA_TIME, 31) \
|
|
ENUM##_VAL(ESIF_DATA_UINT16, 2) \
|
|
ENUM##_VAL(ESIF_DATA_UINT32, 3) \
|
|
ENUM##_VAL(ESIF_DATA_UINT64, 4) \
|
|
ENUM##_VAL(ESIF_DATA_UINT8, 1) \
|
|
ENUM##_VAL(ESIF_DATA_UNICODE, 9) \
|
|
ENUM##_VAL(ESIF_DATA_VOID, 24) \
|
|
ENUM##_VAL(ESIF_DATA_XML, 38) \
|
|
ENUM##_VAL(ESIF_DATA_DECIBEL, 39) \
|
|
ENUM##_VAL(ESIF_DATA_FREQUENCY, 40) \
|
|
|
|
enum esif_data_type {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_DATA_ANGLE = 41,
|
|
ESIF_DATA_AUTO = 36,
|
|
ESIF_DATA_BINARY = 7,
|
|
ESIF_DATA_BIT = 27,
|
|
ESIF_DATA_BLOB = 34,
|
|
ESIF_DATA_DSP = 33,
|
|
ESIF_DATA_ENUM = 19,
|
|
ESIF_DATA_GUID = 5,
|
|
ESIF_DATA_HANDLE = 20,
|
|
ESIF_DATA_INSTANCE = 30,
|
|
ESIF_DATA_INT16 = 12,
|
|
ESIF_DATA_INT32 = 13,
|
|
ESIF_DATA_INT64 = 14,
|
|
ESIF_DATA_INT8 = 11,
|
|
ESIF_DATA_IPV4 = 16,
|
|
ESIF_DATA_IPV6 = 17,
|
|
ESIF_DATA_PERCENT = 29,
|
|
ESIF_DATA_POINTER = 18,
|
|
ESIF_DATA_POWER = 26,
|
|
ESIF_DATA_QUALIFIER = 28,
|
|
ESIF_DATA_REGISTER = 15,
|
|
ESIF_DATA_STRING = 8,
|
|
ESIF_DATA_STRUCTURE = 32,
|
|
ESIF_DATA_TABLE = 35,
|
|
ESIF_DATA_TEMPERATURE = 6,
|
|
ESIF_DATA_TIME = 31,
|
|
ESIF_DATA_UINT16 = 2,
|
|
ESIF_DATA_UINT32 = 3,
|
|
ESIF_DATA_UINT64 = 4,
|
|
ESIF_DATA_UINT8 = 1,
|
|
ESIF_DATA_UNICODE = 9,
|
|
ESIF_DATA_VOID = 24,
|
|
ESIF_DATA_XML = 38,
|
|
ESIF_DATA_DECIBEL = 39,
|
|
ESIF_DATA_FREQUENCY = 40,
|
|
#else
|
|
ENUM_ESIF_DATA_TYPE(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_data_type esif_data_type_string2enum (esif_string str);
|
|
extern esif_string esif_data_type_enum2string (enum esif_data_type type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_data_type_str (enum esif_data_type type)
|
|
{
|
|
#define CREATE_DATA_TYPE(dt) case dt: \
|
|
str = (esif_string) #dt;break;
|
|
|
|
#define CREATE_DATA_TYPE_VAL(dt, VAL) case dt: \
|
|
str = (esif_string) #dt;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (type) {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
CREATE_DATA_TYPE(ESIF_DATA_ANGLE)
|
|
CREATE_DATA_TYPE(ESIF_DATA_AUTO)
|
|
CREATE_DATA_TYPE(ESIF_DATA_BINARY)
|
|
CREATE_DATA_TYPE(ESIF_DATA_BIT)
|
|
CREATE_DATA_TYPE(ESIF_DATA_BLOB)
|
|
CREATE_DATA_TYPE(ESIF_DATA_DSP)
|
|
CREATE_DATA_TYPE(ESIF_DATA_ENUM)
|
|
CREATE_DATA_TYPE(ESIF_DATA_GUID)
|
|
CREATE_DATA_TYPE(ESIF_DATA_HANDLE)
|
|
|
|
CREATE_DATA_TYPE(ESIF_DATA_INSTANCE)
|
|
CREATE_DATA_TYPE(ESIF_DATA_INT16)
|
|
CREATE_DATA_TYPE(ESIF_DATA_INT32)
|
|
CREATE_DATA_TYPE(ESIF_DATA_INT64)
|
|
CREATE_DATA_TYPE(ESIF_DATA_INT8)
|
|
CREATE_DATA_TYPE(ESIF_DATA_IPV4)
|
|
CREATE_DATA_TYPE(ESIF_DATA_IPV6)
|
|
CREATE_DATA_TYPE(ESIF_DATA_PERCENT)
|
|
CREATE_DATA_TYPE(ESIF_DATA_POINTER)
|
|
CREATE_DATA_TYPE(ESIF_DATA_POWER)
|
|
CREATE_DATA_TYPE(ESIF_DATA_QUALIFIER)
|
|
CREATE_DATA_TYPE(ESIF_DATA_REGISTER)
|
|
CREATE_DATA_TYPE(ESIF_DATA_STRING)
|
|
CREATE_DATA_TYPE(ESIF_DATA_STRUCTURE)
|
|
CREATE_DATA_TYPE(ESIF_DATA_TABLE)
|
|
CREATE_DATA_TYPE(ESIF_DATA_TEMPERATURE)
|
|
CREATE_DATA_TYPE(ESIF_DATA_TIME)
|
|
CREATE_DATA_TYPE(ESIF_DATA_UINT16)
|
|
CREATE_DATA_TYPE(ESIF_DATA_UINT32)
|
|
CREATE_DATA_TYPE(ESIF_DATA_UINT64)
|
|
CREATE_DATA_TYPE(ESIF_DATA_UINT8)
|
|
CREATE_DATA_TYPE(ESIF_DATA_UNICODE)
|
|
CREATE_DATA_TYPE(ESIF_DATA_VOID)
|
|
CREATE_DATA_TYPE(ESIF_DATA_XML)
|
|
CREATE_DATA_TYPE(ESIF_DATA_DECIBEL)
|
|
CREATE_DATA_TYPE(ESIF_DATA_FREQUENCY)
|
|
#else
|
|
ENUM_ESIF_DATA_TYPE(CREATE_DATA_TYPE)
|
|
#endif
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/*
|
|
** Action Type Declarations
|
|
*/
|
|
|
|
#define ENUM_ESIF_ACTION_TYPE(ENUM) \
|
|
ENUM##_VAL(ESIF_ACTION_ACPI, 4) \
|
|
ENUM##_VAL(ESIF_ACTION_ACPILPAT, 40) \
|
|
ENUM##_VAL(ESIF_ACTION_CODE, 38) \
|
|
ENUM##_VAL(ESIF_ACTION_KODE, 29) \
|
|
ENUM##_VAL(ESIF_ACTION_CONFIG, 20) \
|
|
ENUM##_VAL(ESIF_ACTION_CONST, 33) \
|
|
ENUM##_VAL(ESIF_ACTION_DDIGFXDISP, 35) \
|
|
ENUM##_VAL(ESIF_ACTION_DDIGFXPERF, 36) \
|
|
ENUM##_VAL(ESIF_ACTION_DPPEBRT, 32) \
|
|
ENUM##_VAL(ESIF_ACTION_GFXESC, 30) \
|
|
ENUM##_VAL(ESIF_ACTION_KONST, 1) \
|
|
ENUM##_VAL(ESIF_ACTION_LAL, 11) \
|
|
ENUM##_VAL(ESIF_ACTION_IOSF, 34) \
|
|
ENUM##_VAL(ESIF_ACTION_MMIO, 2) \
|
|
ENUM##_VAL(ESIF_ACTION_MMIOTJMAX, 48) \
|
|
ENUM##_VAL(ESIF_ACTION_MSR, 22) \
|
|
ENUM##_VAL(ESIF_ACTION_PSM, 44) \
|
|
ENUM##_VAL(ESIF_ACTION_RFPWIFI, 43) \
|
|
ENUM##_VAL(ESIF_ACTION_RFPWWAN, 41) \
|
|
ENUM##_VAL(ESIF_ACTION_SYSTEM, 31) \
|
|
ENUM##_VAL(ESIF_ACTION_SYSTEMIO, 24) \
|
|
ENUM##_VAL(ESIF_ACTION_VAR, 17) \
|
|
ENUM##_VAL(ESIF_ACTION_VIRTUAL, 39)
|
|
|
|
#define ENUM_ESIF_ACTION_MSR_HINT(ENUM) \
|
|
ENUM##_VAL(ESIF_ACTION_MSR_HINT_UNI, 1) \
|
|
ENUM##_VAL(ESIF_ACTION_MSR_HINT_MAX, 2) \
|
|
ENUM##_VAL(ESIF_ACTION_MSR_HINT_MIN, 3)
|
|
|
|
enum esif_action_type {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_ACTION_ACPI = 4,
|
|
ESIF_ACTION_ACPILPAT = 40,
|
|
ESIF_ACTION_CODE = 38,
|
|
ESIF_ACTION_KODE = 29,
|
|
ESIF_ACTION_CONFIG = 20,
|
|
ESIF_ACTION_CONST = 33,
|
|
ESIF_ACTION_DDIGFXDISP = 35,
|
|
ESIF_ACTION_DDIGFXPERF = 36,
|
|
ESIF_ACTION_DPPEBRT = 32,
|
|
ESIF_ACTION_GFXESC = 30,
|
|
ESIF_ACTION_KONST = 1,
|
|
ESIF_ACTION_LAL = 11,
|
|
ESIF_ACTION_IOSF = 34,
|
|
ESIF_ACTION_MMIO = 2,
|
|
ESIF_ACTION_MMIOTJMAX = 48,
|
|
ESIF_ACTION_MSR = 22,
|
|
ESIF_ACTION_PSM = 44,
|
|
ESIF_ACTION_RFPWIFI = 43,
|
|
ESIF_ACTION_RFPWWAN = 41,
|
|
ESIF_ACTION_SYSTEM = 31,
|
|
ESIF_ACTION_SYSTEMIO = 24,
|
|
ESIF_ACTION_VAR = 17,
|
|
ESIF_ACTION_VIRTUAL = 39
|
|
#else
|
|
ENUM_ESIF_ACTION_TYPE(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
enum esif_action_msr_hint {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_ACTION_MSR_HINT_UNI = 1,
|
|
ESIF_ACTION_MSR_HINT_MAX = 2,
|
|
ESIF_ACTION_MSR_HINT_MIN = 3
|
|
#else
|
|
ENUM_ESIF_ACTION_MSR_HINT(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_action_type esif_action_type_string2enum (esif_string str);
|
|
extern esif_string esif_action_type_enum2string (enum esif_action_type type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_action_type_str (enum esif_action_type type)
|
|
{
|
|
#define CREATE_ACTION_TYPE(at) case at: \
|
|
str = (esif_string) #at;break;
|
|
|
|
#define CREATE_ACTION_TYPE_VAL(at, VAL) case at: \
|
|
str = (esif_string) #at;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (type) {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_ACPI)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_ACPILPAT)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_KODE)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_CODE)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_CONFIG)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_CONST)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_DDIGFXDISP)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_DDIGFXPERF)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_DPPEBRT)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_GFXESC)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_KONST)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_LAL)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_IOSF)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_MMIO)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_MMIOTJMAX)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_MSR)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_PSM)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_RFPWIFI)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_RFPWWAN)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_SYSTEM)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_SYSTEMIO)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_VAR)
|
|
CREATE_ACTION_TYPE(ESIF_ACTION_VIRTUAL)
|
|
#else
|
|
ENUM_ESIF_ACTION_TYPE(CREATE_ACTION_TYPE)
|
|
#endif
|
|
}
|
|
return str;
|
|
}
|
|
|
|
static ESIF_INLINE esif_string esif_action_msr_hint (enum esif_action_msr_hint hint)
|
|
{
|
|
#define CREATE_ACTION_MSR_HINT(mh) case mh: \
|
|
str = (esif_string) #mh;break;
|
|
|
|
#define CREATE_ACTION_MSR_HINT_VAL(mh, VAL) case mh: \
|
|
str = (esif_string) #mh;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (hint) {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
CREATE_ACTION_MSR_HINT(ESIF_ACTION_MSR_HINT_UNI)
|
|
CREATE_ACTION_MSR_HINT(ESIF_ACTION_MSR_HINT_MAX)
|
|
CREATE_ACTION_MSR_HINT(ESIF_ACTION_MSR_HINT_MIN)
|
|
#else
|
|
ENUM_ESIF_ACTION_MSR_HINT(CREATE_ACTION_MSR_HINT)
|
|
#endif
|
|
}
|
|
return str;
|
|
}
|
|
|
|
/*
|
|
** Capability Type Declarations
|
|
*/
|
|
|
|
#define ENUM_ESIF_CAPABILITY_TYPE(ENUM) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_ACTIVE_CONTROL, 0) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_CTDP_CONTROL, 1) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_CORE_CONTROL, 2) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_DISPLAY_CONTROL, 3) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_DOMAIN_PRIORITY, 4) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_PERF_CONTROL, 5) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_POWER_CONTROL, 6) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_POWER_STATUS, 7) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_TEMP_STATUS, 8) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_UTIL_STATUS, 9) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_PIXELCLOCK_STATUS, 10) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_PIXELCLOCK_CONTROL, 11) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_BATTERY_STATUS, 12) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_TEMP_THRESHOLD, 13) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_RFPROFILE_STATUS, 14) \
|
|
ENUM##_VAL(ESIF_CAPABILITY_TYPE_RFPROFILE_CONTROL, 15) \
|
|
|
|
enum esif_capability_type {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_CAPABILITY_TYPE_ACTIVE_CONTROL = 0,
|
|
ESIF_CAPABILITY_TYPE_CTDP_CONTROL = 1,
|
|
ESIF_CAPABILITY_TYPE_CORE_CONTROL = 2,
|
|
ESIF_CAPABILITY_TYPE_DISPLAY_CONTROL = 3,
|
|
ESIF_CAPABILITY_TYPE_DOMAIN_PRIORITY = 4,
|
|
ESIF_CAPABILITY_TYPE_PERF_CONTROL = 5,
|
|
ESIF_CAPABILITY_TYPE_POWER_CONTROL = 6,
|
|
ESIF_CAPABILITY_TYPE_POWER_STATUS = 7,
|
|
ESIF_CAPABILITY_TYPE_TEMP_STATUS = 8,
|
|
ESIF_CAPABILITY_TYPE_UTIL_STATUS = 9,
|
|
ESIF_CAPABILITY_TYPE_PIXELCLOCK_STATUS = 10,
|
|
ESIF_CAPABILITY_TYPE_PIXELCLOCK_CONTROL = 11,
|
|
ESIF_CAPABILITY_TYPE_BATTERY_STATUS = 12,
|
|
ESIF_CAPABILITY_TYPE_TEMP_THRESHOLD = 13,
|
|
ESIF_CAPABILITY_TYPE_RFPROFILE_STATUS = 14,
|
|
ESIF_CAPABILITY_TYPE_RFPROFILE_CONTROL = 15
|
|
#else
|
|
ENUM_ESIF_CAPABILITY_TYPE(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_capability_type esif_capability_type_string2enum (
|
|
esif_string str);
|
|
extern esif_string esif_capability_type_enum2string (
|
|
enum esif_capability_type type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_capability_type_str (
|
|
enum esif_capability_type type)
|
|
{
|
|
#define CREATE_CAPABILITY_TYPE(ct) case ct: \
|
|
str = (esif_string) #ct;break;
|
|
|
|
#define CREATE_CAPABILITY_TYPE_VAL(ct, VAL) case ct: \
|
|
str = (esif_string) #ct;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (type) {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_ACTIVE_CONTROL)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_CTDP_CONTROL)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_CORE_CONTROL)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_DISPLAY_CONTROL)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_DOMAIN_PRIORITY)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_PERF_CONTROL)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_POWER_CONTROL)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_POWER_STATUS)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_TEMP_STATUS)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_UTIL_STATUS)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_PIXELCLOCK_STATUS)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_PIXELCLOCK_CONTROL)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_BATTERY_STATUS)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_TEMP_THRESHOLD)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_RFPROFILE_STATUS)
|
|
CREATE_CAPABILITY_TYPE(ESIF_CAPABILITY_TYPE_RFPROFILE_CONTROL)
|
|
#else
|
|
ENUM_ESIF_CAPABILITY_TYPE(CREATE_CAPABILITY_TYPE)
|
|
#endif
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
#define ESIF_CAPABILITY_ACTIVE_CONTROL 0x1
|
|
#define ESIF_CAPABILITY_CTDP_CONTROL 0x2
|
|
#define ESIF_CAPABILITY_CORE_CONTROL 0x4
|
|
#define ESIF_CAPABILITY_DISPLAY_CONTROL 0x8
|
|
#define ESIF_CAPABILITY_DOMAIN_PRIORITY 0x10
|
|
#define ESIF_CAPABILITY_PERF_CONTROL 0x20
|
|
#define ESIF_CAPABILITY_POWER_CONTROL 0x40
|
|
#define ESIF_CAPABILITY_POWER_STATUS 0x80
|
|
#define ESIF_CAPABILITY_TEMP_STATUS 0x100
|
|
#define ESIF_CAPABILITY_UTIL_STATUS 0x200
|
|
#define ESIF_CAPABILITY_PIXELCLOCK_STATUS 0x400
|
|
#define ESIF_CAPABILITY_PIXELCLOCK_CONTROL 0x800
|
|
#define ESIF_CAPABILITY_BATTERY_STATUS 0x1000
|
|
#define ESIF_CAPABILITY_TEMP_THRESHOLD 0x2000
|
|
#define ESIF_CAPABILITY_RFPROFILE_STATUS 0x4000
|
|
#define ESIF_CAPABILITY_RFPROFILE_CONTROL 0x8000
|
|
|
|
/*
|
|
** Vendor Strings
|
|
*/
|
|
static ESIF_INLINE esif_string esif_vendor_str (u32 vendor_id)
|
|
{
|
|
#define CREATE_VENDOR(v, vs) case v: \
|
|
str = (esif_string)vs;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (vendor_id) {
|
|
CREATE_VENDOR(0x8086, "Intel Corp")
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/*
|
|
** PCI Devices
|
|
*/
|
|
|
|
#define ENUM_ESIF_PCI_DEVICE_ID(ENUM) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_SNB, 0x0103) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_IVB, 0x0153) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_HSW_ULT, 0x0a03) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_HSW, 0x0c03) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_BDW, 0x1603) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_SKL, 0x1903) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_CPT, 0x1c24) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_PPT, 0x1e24) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_LPT, 0x8c24) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_LPT_LP, 0x9c24) \
|
|
ENUM##_VAL(ESIF_PCI_DEVICE_ID_WCP, 0x9ca4) \
|
|
|
|
enum esif_pci_device_id {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_PCI_DEVICE_ID_SNB = 0x0103,
|
|
ESIF_PCI_DEVICE_ID_IVB = 0x0153,
|
|
ESIF_PCI_DEVICE_ID_HSW_ULT = 0x0a03,
|
|
ESIF_PCI_DEVICE_ID_HSW = 0x0c03,
|
|
ESIF_PCI_DEVICE_ID_BDW = 0x1603,
|
|
ESIF_PCI_DEVICE_ID_SKL = 0x1903,
|
|
ESIF_PCI_DEVICE_ID_CPT = 0x1c24,
|
|
ESIF_PCI_DEVICE_ID_PPT = 0x1e24,
|
|
ESIF_PCI_DEVICE_ID_LPT = 0x8c24,
|
|
ESIF_PCI_DEVICE_ID_LPT_LP = 0x9c24,
|
|
ESIF_PCI_DEVICE_ID_WCP = 0x9ca4,
|
|
#else
|
|
ENUM_ESIF_PCI_DEVICE_ID(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_pci_device_id esif_pci_device_id_string2enum (esif_string str);
|
|
extern esif_string esif_pci_device_id_enum2string (enum esif_pci_device_id type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_device_str (u32 device_id)
|
|
{
|
|
#define CREATE_DEVICE(d, ds) case d: \
|
|
str = (esif_string)ds;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (device_id) {
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_SNB,
|
|
"DPTF Participant for 2nd Generation Intel Core i7/i5/i3 Mobile Processors(DPTF CPU)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_IVB,
|
|
"DPTF Participant for 3nd Generation Intel Core i7/i5/i3 Mobile Processors(DPTF CPU)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_HSW_ULT,
|
|
"DPTF Participant for 4th Generation Intel Core i7/i5/i3 Mobile Processors(DPTF CPU)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_HSW,
|
|
"DPTF Participant for 4th Generation Intel Core i7/i5/i3 Mobile Processors(DPTF CPU)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_BDW,
|
|
"DPTF Participant for 5th Generation Intel Core i7/i5/i3 Mobile Processors(DPTF CPU)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_SKL,
|
|
"DPTF Participant for 6th Generation Intel Core i7/i5/i3 Mobile Processors(DPTF CPU)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_CPT, "Cougar Point(DPTF PCH)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_PPT, "Panther Point(DPTF PCH)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_LPT, "Lynx Point(DPTF PCH)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_LPT_LP,
|
|
"Lynx Point Low Power(DPTF PCH)")
|
|
CREATE_DEVICE(ESIF_PCI_DEVICE_ID_WCP,
|
|
"Wild Cat Point (DPTF PCH)")
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
#if defined(ESIF_ATTR_OS_LINUX_DRIVER)
|
|
|
|
#pragma pack(push,1)
|
|
|
|
const struct pci_device_id esif_pci_cpu_ids[] = {
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_SNB)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_IVB)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_HSW_ULT)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_HSW)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_BDW)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_SKL)
|
|
},
|
|
{
|
|
0,
|
|
}
|
|
};
|
|
|
|
const struct pci_device_id esif_pci_pch_ids[] = {
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_CPT)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_PPT)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_LPT)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_LPT_LP)
|
|
},
|
|
{
|
|
PCI_DEVICE(PCI_VENDOR_ID_INTEL, ESIF_PCI_DEVICE_ID_WCP)
|
|
},
|
|
{
|
|
0,
|
|
}
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_pci_class_str (u8 class_id)
|
|
{
|
|
#define CREATE_PCI_CLASS(c, cs) case c: \
|
|
str = (esif_string)cs;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (class_id) {
|
|
CREATE_PCI_CLASS(0x00, "NA")
|
|
CREATE_PCI_CLASS(0x01, "Mass Storage Controller")
|
|
CREATE_PCI_CLASS(0x02, "Network Controller")
|
|
CREATE_PCI_CLASS(0x03, "Display Controller")
|
|
CREATE_PCI_CLASS(0x04, "Multimedia Device")
|
|
CREATE_PCI_CLASS(0x05, "Memory Controller")
|
|
CREATE_PCI_CLASS(0x06, "Bridge Device")
|
|
CREATE_PCI_CLASS(0x07, "Simple Communications Controller")
|
|
CREATE_PCI_CLASS(0x08, "Base System Peripherals")
|
|
CREATE_PCI_CLASS(0x09, "Input Devices")
|
|
CREATE_PCI_CLASS(0x0a, "Docking Stations")
|
|
CREATE_PCI_CLASS(0x0b, "Processors")
|
|
CREATE_PCI_CLASS(0x0c, "Serial Bus Controllers")
|
|
CREATE_PCI_CLASS(0x0d, "Wireless Controllers")
|
|
CREATE_PCI_CLASS(0x0e, "Intelligent I/O Controllers")
|
|
CREATE_PCI_CLASS(0x0f, "Satelite Communication Controllers")
|
|
CREATE_PCI_CLASS(0x10, "Encryption/Decryption Controllers")
|
|
CREATE_PCI_CLASS(0x11,
|
|
"Data Acquisition and Signal Processing Controllers")
|
|
CREATE_PCI_CLASS(0xff, "Misc")
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/*
|
|
** ACPI Devices
|
|
*/
|
|
|
|
#define ESIF_ACPI_DEVICE_INT3400 "INT3400"
|
|
#define ESIF_ACPI_DEVICE_INT3401 "INT3401"
|
|
#define ESIF_ACPI_DEVICE_INT3402 "INT3402"
|
|
#define ESIF_ACPI_DEVICE_INT3403 "INT3403"
|
|
#define ESIF_ACPI_DEVICE_INT3404 "INT3404"
|
|
#define ESIF_ACPI_DEVICE_INT3405 "INT3405"
|
|
#define ESIF_ACPI_DEVICE_INT3406 "INT3406"
|
|
#define ESIF_ACPI_DEVICE_INT3407 "INT3407"
|
|
#define ESIF_ACPI_DEVICE_INT3408 "INT3408"
|
|
#define ESIF_ACPI_DEVICE_INT3409 "INT3409"
|
|
#define ESIF_ACPI_DEVICE_INT340A "INT340A"
|
|
#define ESIF_ACPI_DEVICE_INT340B "INT340B"
|
|
#define ESIF_ACPI_DEVICE_INT340C "INT340C"
|
|
|
|
static ESIF_INLINE esif_string esif_acpi_device_str (esif_string acpi_device)
|
|
{
|
|
#define CREATE_ACPI_DEVICE(d, ds) if (!strncmp(acpi_device, d, 7)) { \
|
|
str = (esif_string)ds; \
|
|
}
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
if (NULL == acpi_device) {
|
|
return str;
|
|
}
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3400, "DPTF Zone")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3401, "DPTF Processor Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3402, "DPTF Memory Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3403, "DPTF Generic Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3404, "DPTF Fan Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3405, "DPTF Depricated")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3406, "DPTF Display Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3407, "DPTF Charger Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3408, "DPTF Wireless Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT3409,
|
|
"DPTF Ambient Temperature Sensor")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT340A, "DPTF Storage Device")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT340B,
|
|
"DPTF Perceptual Computing Camera")
|
|
CREATE_ACPI_DEVICE(ESIF_ACPI_DEVICE_INT340C, "DPTF Thunderbolt Device")
|
|
|
|
return str;
|
|
}
|
|
|
|
|
|
#if defined(ESIF_ATTR_OS_LINUX_DRIVER)
|
|
|
|
#pragma pack(push,1)
|
|
|
|
const struct acpi_device_id esif_acpi_ids[] = {
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3400, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3401, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3402, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3403, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3404, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3405, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3406, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3407, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3408, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT3409, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT340A, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT340B, 0
|
|
},
|
|
{
|
|
ESIF_ACPI_DEVICE_INT340C, 0
|
|
},
|
|
{
|
|
"", 0
|
|
},
|
|
};
|
|
|
|
#pragma pack(pop)
|
|
|
|
#endif
|
|
|
|
#define ENUM_ESIF_DOMAIN_TYPE(ENUM) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_PROCESSOR, 0) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_GRAPHICS, 1) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_MEMORY, 2) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_TEMPERATURE, 3) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_FAN, 4) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_CHIPSET, 5) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_ETHERNET, 6) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_WIRELESS, 7) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_STORAGE, 8) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_MULTIFUNCTION, 9) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_DISPLAY, 10) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_CHARGER, 11) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_BATTERY, 12) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_AUDIO, 13) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_OTHER, 14) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_WWAN, 15) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_WGIG, 16) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_POWER, 17) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_THERMISTOR, 18) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_INFRARED, 19) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_WIRELESSRFEM, 20) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_VIRTUAL, 21) \
|
|
ENUM##_VAL(ESIF_DOMAIN_TYPE_AMBIENT, 22) \
|
|
|
|
enum esif_domain_type {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_DOMAIN_TYPE_PROCESSOR = 0,
|
|
ESIF_DOMAIN_TYPE_GRAPHICS = 1,
|
|
ESIF_DOMAIN_TYPE_MEMORY = 2,
|
|
ESIF_DOMAIN_TYPE_TEMPERATURE = 3,
|
|
ESIF_DOMAIN_TYPE_FAN = 4,
|
|
ESIF_DOMAIN_TYPE_CHIPSET = 5,
|
|
ESIF_DOMAIN_TYPE_ETHERNET = 6,
|
|
ESIF_DOMAIN_TYPE_WIRELESS = 7,
|
|
ESIF_DOMAIN_TYPE_STORAGE = 8,
|
|
ESIF_DOMAIN_TYPE_MULTIFUNCTION = 9,
|
|
ESIF_DOMAIN_TYPE_DISPLAY = 10,
|
|
ESIF_DOMAIN_TYPE_CHARGER = 11,
|
|
ESIF_DOMAIN_TYPE_BATTERY = 12,
|
|
ESIF_DOMAIN_TYPE_AUDIO = 13,
|
|
ESIF_DOMAIN_TYPE_OTHER = 14,
|
|
ESIF_DOMAIN_TYPE_WWAN = 15,
|
|
ESIF_DOMAIN_TYPE_WGIG = 16,
|
|
ESIF_DOMAIN_TYPE_POWER = 17,
|
|
ESIF_DOMAIN_TYPE_THERMISTOR = 18,
|
|
ESIF_DOMAIN_TYPE_INFRARED = 19,
|
|
ESIF_DOMAIN_TYPE_WIRELESSRFEM = 20,
|
|
ESIF_DOMAIN_TYPE_VIRTUAL = 21,
|
|
ESIF_DOMAIN_TYPE_AMBIENT = 22,
|
|
#else
|
|
ENUM_ESIF_DOMAIN_TYPE(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_domain_type esif_domain_type_string2enum (esif_string str);
|
|
extern esif_string esif_domain_type_enum2string (enum esif_domain_type type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_domain_type_str (enum esif_domain_type type)
|
|
{
|
|
#define CREATE_DOMAIN_TYPE(dt) case dt: \
|
|
str = (esif_string) #dt;break;
|
|
|
|
#define CREATE_DOMAIN_TYPE_VAL(dt, VAL) case dt: \
|
|
str = (esif_string) #dt;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (type) {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_PROCESSOR)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_GRAPHICS)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_MEMORY)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_TEMPERATURE)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_FAN)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_CHIPSET)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_ETHERNET)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_WIRELESS)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_STORAGE)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_MULTIFUNCTION)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_DISPLAY)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_CHARGER)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_BATTERY)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_AUDIO)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_OTHER)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_WWAN)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_WGIG)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_POWER)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_THERMISTOR)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_INFRARED)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_WIRELESSRFEM)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_VIRTUAL)
|
|
CREATE_DOMAIN_TYPE(ESIF_DOMAIN_TYPE_AMBIENT)
|
|
|
|
|
|
|
|
#else
|
|
ENUM_ESIF_DOMAIN_TYPE(CREATE_DOMAIN_TYPE)
|
|
#endif
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
#define ESIF_PRODUCT "Dynamic Platform Thermal Framework"
|
|
#define ESIF_COPYRIGHT "(c) 2012 - 2014 Intel Corporation"
|
|
#define ESIF_COMPANY "Intel Corporation"
|
|
#define ESIF_LOWER_FRAMEWORK "ESIF Lower Framework"
|
|
#define ESIF_UPPER_FRAMEWORK "ESIF Upper Framework"
|
|
|
|
#define ESIF_PARTICIPANT_DPTF_NAME "DPTFZ"
|
|
#define ESIF_PARTICIPANT_DPTF_DESC "DPTF Zone"
|
|
#define ESIF_PARTICIPANT_DPTF_CLASS_GUID {0x23, 0xa9, 0xe1, 0x5f, 0x0b, 0xa4, \
|
|
0x46, 0x9c, 0xb1, 0x6f, 0x1c, 0x46, \
|
|
0x79, 0x75, 0x4f, 0x80}
|
|
#define ESIF_PARTICIPANT_ACPI_NAME "ACPI"
|
|
#define ESIF_PARTICIPANT_ACPI_DESC "DPTF ACPI Device"
|
|
#define ESIF_PARTICIPANT_ACPI_CLASS_GUID {0xd9, 0xd5, 0xbe, 0x64, 0x3c, 0xe2, \
|
|
0x49, 0x27, 0x95, 0xa3, 0xee, 0xe4, \
|
|
0xc, 0x9a, 0x58, 0x3b}
|
|
#define ESIF_PARTICIPANT_CPU_NAME "TCPU"
|
|
#define ESIF_PARTICIPANT_CPU_DESC "DPTF CPU Device"
|
|
#define ESIF_PARTICIPANT_CPU_CLASS_GUID {0x53, 0x4a, 0x09, 0x8f, 0x5e, 0x42, \
|
|
0x4c, 0x64, 0xbe, 0xb3, 0x91, 0x7a, \
|
|
0xb3, 0x7c, 0x5d, 0xa5}
|
|
#define ESIF_PARTICIPANT_PCH_NAME "TPCH"
|
|
#define ESIF_PARTICIPANT_PCH_DESC "DPTF PCH Device"
|
|
#define ESIF_PARTICIPANT_PCH_CLASS_GUID {0x33, 0xab, 0xb9, 0xb2, 0xe6, 0x86, \
|
|
0x43, 0xb8, 0xb0, 0xdf, 0x3e, 0x91, \
|
|
0x53, 0x90, 0xcb, 0xe5}
|
|
#define ESIF_PARTICIPANT_PLAT_NAME "PLAT"
|
|
#define ESIF_PARTICIPANT_PLAT_DESC "DPTF Platform Device"
|
|
#define ESIF_PARTICIPANT_PLAT_CLASS_GUID {0xd4, 0x08, 0x04, 0xf4, 0xdc, 0x73, \
|
|
0x4b, 0x33, 0xb2, 0x8c, 0x19, 0x5a, \
|
|
0xe9, 0x8f, 0x29, 0xe}
|
|
|
|
#define ENUM_ESIF_ALGORITHM_TYPE(ENUM) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_POWER_DECIW, 0) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_POWER_MILLIW, 1) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_POWER_NONE, 2) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_POWER_UNIT_ATOM, 12) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_POWER_UNIT_CORE, 3) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_PCH_CORE, 4) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_DECIK, 5) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_NONE, 6) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_TJMAX_CORE, 7) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TIME_NONE, 8) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_MILLIC, 9) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_TJMAX_ATOM, 10) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_DTS_ATOM, 11) \
|
|
ENUM##_VAL(ESIF_ALGORITHM_TYPE_TEMP_LPAT, 13) \
|
|
|
|
enum esif_algorithm_type {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_ALGORITHM_TYPE_POWER_DECIW = 0,
|
|
ESIF_ALGORITHM_TYPE_POWER_MILLIW = 1,
|
|
ESIF_ALGORITHM_TYPE_POWER_NONE = 2,
|
|
ESIF_ALGORITHM_TYPE_POWER_UNIT_ATOM = 12,
|
|
ESIF_ALGORITHM_TYPE_POWER_UNIT_CORE = 3,
|
|
ESIF_ALGORITHM_TYPE_TEMP_PCH_CORE = 4,
|
|
ESIF_ALGORITHM_TYPE_TEMP_DECIK = 5,
|
|
ESIF_ALGORITHM_TYPE_TEMP_NONE = 6,
|
|
ESIF_ALGORITHM_TYPE_TEMP_TJMAX_CORE = 7,
|
|
ESIF_ALGORITHM_TYPE_TIME_NONE = 8,
|
|
ESIF_ALGORITHM_TYPE_TEMP_MILLIC = 9,
|
|
ESIF_ALGORITHM_TYPE_TEMP_TJMAX_ATOM = 10,
|
|
ESIF_ALGORITHM_TYPE_TEMP_DTS_ATOM = 11,
|
|
ESIF_ALGORITHM_TYPE_TEMP_LPAT = 13
|
|
#else
|
|
ENUM_ESIF_ALGORITHM_TYPE(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_algorithm_type esif_algorithm_type_string2enum (esif_string str);
|
|
extern esif_string esif_algorithm_type_enum2string (
|
|
enum esif_algorithm_type type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
static ESIF_INLINE esif_string esif_algorithm_type_str (
|
|
enum esif_algorithm_type type)
|
|
{
|
|
#define CREATE_ALGORITHM_TYPE(at) case at: \
|
|
str = (esif_string) #at;break;
|
|
|
|
#define CREATE_ALGORITHM_TYPE_VAL(at, VAL) case at: \
|
|
str = (esif_string) #at;break;
|
|
esif_string str = (esif_string)ESIF_NOT_AVAILABLE;
|
|
switch (type) {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_POWER_DECIW)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_POWER_MILLIW)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_POWER_NONE)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_POWER_UNIT_ATOM)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_POWER_UNIT_CORE)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_PCH_CORE)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_TJMAX_ATOM)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_DECIK)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_NONE)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_TJMAX_CORE)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TIME_NONE)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_MILLIC)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_DTS_ATOM)
|
|
CREATE_ALGORITHM_TYPE(ESIF_ALGORITHM_TYPE_TEMP_LPAT)
|
|
|
|
#else
|
|
ENUM_ESIF_ALGORITHM_TYPE(CREATE_ALGORITHM_TYPE)
|
|
#endif
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/* Enumeration */
|
|
#define ENUM_ESIF_PARTICIPANT_ENUM(ENUM) \
|
|
ENUM(ESIF_PARTICIPANT_ENUM_ACPI) \
|
|
ENUM(ESIF_PARTICIPANT_ENUM_PCI) \
|
|
ENUM(ESIF_PARTICIPANT_ENUM_PLAT) \
|
|
ENUM(ESIF_PARTICIPANT_ENUM_CONJURE) \
|
|
|
|
enum esif_participant_enum {
|
|
#ifdef ESIF_ATTR_KERNEL
|
|
ESIF_PARTICIPANT_ENUM_ACPI,
|
|
ESIF_PARTICIPANT_ENUM_PCI,
|
|
ESIF_PARTICIPANT_ENUM_PLAT,
|
|
ESIF_PARTICIPANT_ENUM_CONJURE,
|
|
#else
|
|
ENUM_ESIF_PARTICIPANT_ENUM(ENUMDECL)
|
|
#endif
|
|
};
|
|
|
|
/* Implement these if they are needed */
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
extern enum esif_participant_enum esif_participant_enum_string2enum (
|
|
esif_string str);
|
|
extern esif_string esif_participant_enum_enum2string (
|
|
enum esif_participant_enum type);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/* Enumeration String */
|
|
static ESIF_INLINE esif_string esif_participant_enum_str (
|
|
enum esif_participant_enum index)
|
|
{
|
|
#define CREATE_PARTICIPANT_ENUM(pe) case pe: \
|
|
str = (esif_string) #pe;break;
|
|
esif_string str = (esif_string) ESIF_NOT_AVAILABLE;
|
|
switch (index) {
|
|
CREATE_PARTICIPANT_ENUM(ESIF_PARTICIPANT_ENUM_ACPI)
|
|
CREATE_PARTICIPANT_ENUM(ESIF_PARTICIPANT_ENUM_PCI)
|
|
CREATE_PARTICIPANT_ENUM(ESIF_PARTICIPANT_ENUM_PLAT)
|
|
CREATE_PARTICIPANT_ENUM(ESIF_PARTICIPANT_ENUM_CONJURE)
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
#ifdef ESIF_ATTR_USER
|
|
typedef enum esif_action_type eEsifActionType;
|
|
#endif
|
|
|
|
/* Todo Move to Autogen.h */
|
|
enum esif_event_group {
|
|
ESIF_EVENT_GROUP_DPTF = 0,
|
|
ESIF_EVENT_GROUP_POWER = 1,
|
|
ESIF_EVENT_GROUP_SENSOR = 2,
|
|
ESIF_EVENT_GROUP_ACPI = 3,
|
|
ESIF_EVENT_GROUP_CODE = 4
|
|
};
|
|
|
|
/* Enumeration String */
|
|
static ESIF_INLINE esif_string esif_event_group_enum_str (
|
|
enum esif_event_group group)
|
|
{
|
|
#define CREATE_EV_GROUP_ENUM(eg) case eg: \
|
|
str = (esif_string) #eg;break;
|
|
esif_string str = (esif_string) ESIF_NOT_AVAILABLE;
|
|
switch (group) {
|
|
CREATE_EV_GROUP_ENUM(ESIF_EVENT_GROUP_DPTF)
|
|
CREATE_EV_GROUP_ENUM(ESIF_EVENT_GROUP_POWER)
|
|
CREATE_EV_GROUP_ENUM(ESIF_EVENT_GROUP_SENSOR)
|
|
CREATE_EV_GROUP_ENUM(ESIF_EVENT_GROUP_ACPI)
|
|
CREATE_EV_GROUP_ENUM(ESIF_EVENT_GROUP_CODE)
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/*
|
|
* Event Name: CONNECTED_STANDBY_ENTRY
|
|
* Event GUID: FD34F756-F7B6-47DD-B3D5-0011A34E4337
|
|
* Event Desc: Enter connected standby
|
|
*/
|
|
#define CONNECTED_STANDBY_ENTRY {0xFD, 0x34, 0xF7, 0x56, 0xF7, 0xB6, 0x47, 0xDD, \
|
|
0xB3, 0xD5, 0x00, 0x11, 0xA3, 0x4E, 0x43, 0x37}
|
|
|
|
/*
|
|
* Event Name: CONNECTED_STANDBY_EXIT
|
|
* Event GUID: 9604508D-F4AA-4716-83D9-6EE951EBBEA9
|
|
* Event Desc: Exit connected standby
|
|
*/
|
|
#define CONNECTED_STANDBY_EXIT {0x96, 0x04, 0x50, 0x8D, 0xF4, 0xAA, 0x47, 0x16, \
|
|
0x83, 0xD9, 0x6E, 0xE9, 0x51, 0xEB, 0xBE, 0xA9}
|
|
|
|
/*
|
|
* Event Name: ACTIVE_RELATIONSHIP_CHANGED
|
|
* Event GUID: C7C5FC88-8AAC-42C2-8B51-21777033E75D
|
|
* Event Desc: Active relationship table changed
|
|
*/
|
|
#define ACTIVE_RELATIONSHIP_CHANGED {0xC7, 0xC5, 0xFC, 0x88, 0x8A, 0xAC, 0x42, \
|
|
0xC2, 0x8B, 0x51, 0x21, 0x77, 0x70, 0x33, \
|
|
0xE7, 0x5D}
|
|
|
|
/*
|
|
* Event Name: THERMAL_RELATIONSHIP_CHANGED
|
|
* Event GUID: 7E99E90E-0A22-4EEC-AD6C-908DEB21E9A9
|
|
* Event Desc: Thermal relationship table changed
|
|
*/
|
|
#define THERMAL_RELATIONSHIP_CHANGED {0x7E, 0x99, 0xE9, 0x0E, 0x0A, 0x22, 0x4E, \
|
|
0xEC, 0xAD, 0x6C, 0x90, 0x8D, 0xEB, 0x21, \
|
|
0xE9, 0xA9}
|
|
|
|
/*
|
|
* Event Name: FOREGROUND_CHANGED
|
|
* Event GUID: 88E419E3-609B-4BDA-9A17-83DE899831FD
|
|
* Event Desc: Foreground application changed
|
|
*/
|
|
#define FOREGROUND_CHANGED {0x88, 0xE4, 0x19, 0xE3, 0x60, 0x9B, 0x4B, 0xDA, \
|
|
0x9A, 0x17, 0x83, 0xDE, 0x89, 0x98, 0x31, 0xFD}
|
|
|
|
/*
|
|
* Event Name: SUSPEND
|
|
* Event GUID: 547F7465-D98A-40FD-AC12-E6D20F7B091B
|
|
* Event Desc: Suspend Upper Framework
|
|
*/
|
|
#define SUSPEND {0x54, 0x7F, 0x74, 0x65, 0xD9, 0x8A, 0x40, 0xFD, 0xAC, 0x12, \
|
|
0xE6, 0xD2, 0x0F, 0x7B, 0x09, 0x1B}
|
|
|
|
/*
|
|
* Event Name: RESUME
|
|
* Event GUID: AB3E045F-6B51-4EC5-9330-EAB70836F02F
|
|
* Event Desc: Resume Upper Framework
|
|
*/
|
|
#define RESUME {0xAB, 0x3E, 0x04, 0x5F, 0x6B, 0x51, 0x4E, 0xC5, 0x93, 0x30, \
|
|
0xEA, 0xB7, 0x08, 0x36, 0xF0, 0x2F}
|
|
|
|
/*
|
|
* Event Name: CTDP_CAPABILITY_CHANGED
|
|
* Event GUID: 68D16E98-2C89-4A3D-95C7-5DEEAA4FD73F
|
|
* Event Desc: Config TDP Capability changed (Configurable TDP)
|
|
*/
|
|
#define CTDP_CAPABILITY_CHANGED {0x68, 0xD1, 0x6E, 0x98, 0x2C, 0x89, 0x4A, 0x3D, \
|
|
0x95, 0xC7, 0x5D, 0xEE, 0xAA, 0x4F, 0xD7, 0x3F}
|
|
|
|
/*
|
|
* Event Name: CORE_CAPABILITY_CHANGED
|
|
* Event GUID: 8487D740-62F7-4030-BE1A-C201377E0C18
|
|
* Event Desc: For future use
|
|
*/
|
|
#define CORE_CAPABILITY_CHANGED {0x84, 0x87, 0xD7, 0x40, 0x62, 0xF7, 0x40, 0x30, \
|
|
0xBE, 0x1A, 0xC2, 0x01, 0x37, 0x7E, 0x0C, 0x18}
|
|
|
|
/*
|
|
* Event Name: DISPLAY_CAPABILITY_CHANGED
|
|
* Event GUID: F1CDA338-0F3C-4F8D-A1D9-8033E672F672
|
|
* Event Desc: Display control upper/lower limits changed.
|
|
*/
|
|
#define DISPLAY_CAPABILITY_CHANGED {0xF1, 0xCD, 0xA3, 0x38, 0x0F, 0x3C, 0x4F, \
|
|
0x8D, 0xA1, 0xD9, 0x80, 0x33, 0xE6, 0x72, \
|
|
0xF6, 0x72}
|
|
|
|
/*
|
|
* Event Name: DISPLAY_STATUS_CHANGED
|
|
* Event GUID: BDB4F356-CF69-4152-99A9-1DCE4972AB9D
|
|
* Event Desc: Current Display brightness status has changed due to a user or
|
|
* other override
|
|
*/
|
|
#define DISPLAY_STATUS_CHANGED {0xBD, 0xB4, 0xF3, 0x56, 0xCF, 0x69, 0x41, 0x52, \
|
|
0x99, 0xA9, 0x1D, 0xCE, 0x49, 0x72, 0xAB, 0x9D}
|
|
|
|
/*
|
|
* Event Name: PERF_CAPABILITY_CHANGED
|
|
* Event GUID: 9091810C-F301-44D6-B2B5-B301812E4D08
|
|
* Event Desc: Performance Control Upper/Lower Limits Changed
|
|
*/
|
|
#define PERF_CAPABILITY_CHANGED {0x90, 0x91, 0x81, 0x0C, 0xF3, 0x01, 0x44, 0xD6, \
|
|
0xB2, 0xB5, 0xB3, 0x01, 0x81, 0x2E, 0x4D, 0x08}
|
|
|
|
/*
|
|
* Event Name: PERF_CONTROL_CHANGED
|
|
* Event GUID: D8B5EA17-5486-40FC-A0C6-2AE92AEB3775
|
|
* Event Desc: For future use
|
|
*/
|
|
#define PERF_CONTROL_CHANGED {0xD8, 0xB5, 0xEA, 0x17, 0x54, 0x86, 0x40, 0xFC, \
|
|
0xA0, 0xC6, 0x2A, 0xE9, 0x2A, 0xEB, 0x37, 0x75}
|
|
|
|
/*
|
|
* Event Name: POWER_CAPABILITY_CHANGED
|
|
* Event GUID: 82C438DD-673B-46A6-995F-24CAF4644DCF
|
|
* Event Desc: Power Control Capability Changed
|
|
*/
|
|
#define POWER_CAPABILITY_CHANGED {0x82, 0xC4, 0x38, 0xDD, 0x67, 0x3B, 0x46, \
|
|
0xA6, 0x99, 0x5F, 0x24, 0xCA, 0xF4, 0x64, \
|
|
0x4D, 0xCF}
|
|
|
|
/*
|
|
* Event Name: POWER_THRESHOLD_CROSSED
|
|
* Event GUID: 68138891-C225-438A-8F43-04B071CBF4E3
|
|
* Event Desc: Programmable Threshold Power Event
|
|
*/
|
|
#define POWER_THRESHOLD_CROSSED {0x68, 0x13, 0x88, 0x91, 0xC2, 0x25, 0x43, 0x8A, \
|
|
0x8F, 0x43, 0x04, 0xB0, 0x71, 0xCB, 0xF4, 0xE3}
|
|
|
|
/*
|
|
* Event Name: PRIORITY_CHANGED
|
|
* Event GUID: 98077FF3-AD61-4E50-AFEE-51D0CE8DE396
|
|
* Event Desc: Domain priority has changed
|
|
*/
|
|
#define PRIORITY_CHANGED {0x98, 0x07, 0x7F, 0xF3, 0xAD, 0x61, 0x4E, 0x50, 0xAF, \
|
|
0xEE, 0x51, 0xD0, 0xCE, 0x8D, 0xE3, 0x96}
|
|
|
|
/*
|
|
* Event Name: TEMP_THRESHOLD_CROSSED
|
|
* Event GUID: 43CDD7D8-C96D-4EE7-9A4A-7EC5C2EE1B6E
|
|
* Event Desc: Temperature Threshold Changed
|
|
*/
|
|
#define TEMP_THRESHOLD_CROSSED {0x43, 0xCD, 0xD7, 0xD8, 0xC9, 0x6D, 0x4E, 0xE7, \
|
|
0x9A, 0x4A, 0x7E, 0xC5, 0xC2, 0xEE, 0x1B, 0x6E}
|
|
|
|
/*
|
|
* Event Name: SPEC_INFO_CHANGED
|
|
* Event GUID: 75494A00-417C-4E51-9FAB-FBDD965577D4
|
|
* Event Desc: Participant Specific Information Changed
|
|
*/
|
|
#define SPEC_INFO_CHANGED {0x75, 0x49, 0x4A, 0x00, 0x41, 0x7C, 0x4E, 0x51, 0x9F, \
|
|
0xAB, 0xFB, 0xDD, 0x96, 0x55, 0x77, 0xD4}
|
|
|
|
/*
|
|
* Event Name: CREATE
|
|
* Event GUID: F3B70F0B-79BC-4414-BCF7-6389658E9FAB
|
|
* Event Desc: Create Upper Framework (Participant)
|
|
*/
|
|
#define CREATE {0xF3, 0xB7, 0x0F, 0x0B, 0x79, 0xBC, 0x44, 0x14, 0xBC, 0xF7, \
|
|
0x63, 0x89, 0x65, 0x8E, 0x9F, 0xAB}
|
|
|
|
/*
|
|
* Event Name: DESTROY
|
|
* Event GUID: D58C6702-BB4E-4F82-87F9-E527FEBBBEE1
|
|
* Event Desc: Destroy Upper Framework (Participant)
|
|
*/
|
|
#define DESTROY {0xD5, 0x8C, 0x67, 0x02, 0xBB, 0x4E, 0x4F, 0x82, 0x87, 0xF9, \
|
|
0xE5, 0x27, 0xFE, 0xBB, 0xBE, 0xE1}
|
|
|
|
/*
|
|
* Event Name: SHUTDOWN
|
|
* Event GUID: DE7CA990-66C6-4F0F-B78F-E2774E3CE790
|
|
* Event Desc: Shutdown Upper Framework (Participant)
|
|
*/
|
|
#define SHUTDOWN {0xDE, 0x7C, 0xA9, 0x90, 0x66, 0xC6, 0x4F, 0x0F, 0xB7, 0x8F, \
|
|
0xE2, 0x77, 0x4E, 0x3C, 0xE7, 0x90}
|
|
|
|
/*
|
|
* Event Name: ACPI
|
|
* Event GUID: 722610FF-EDA3-4FED-BEAE-B70290011287
|
|
* Event Desc: ACPI Notify To ESIF Event Translation
|
|
*/
|
|
#define ACPI {0x72, 0x26, 0x10, 0xFF, 0xED, 0xA3, 0x4F, 0xED, 0xBE, 0xAE, 0xB7, \
|
|
0x02, 0x90, 0x01, 0x12, 0x87}
|
|
|
|
/*
|
|
* Event Name: COOLING_MODE_ACOUSTIC_LIMIT_CHANGED
|
|
* Event GUID: 0CB6C2E2-3242-40FC-845F-17F824FB857E
|
|
* Event Desc: Cooling mode Acoustic Limit Changed
|
|
*/
|
|
#define COOLING_MODE_ACOUSTIC_LIMIT_CHANGED {0x0C, 0xB6, 0xC2, 0xE2, 0x32, 0x42, \
|
|
0x40, 0xFC, 0x84, 0x5F, 0x17, 0xF8, \
|
|
0x24, 0xFB, 0x85, 0x7E}
|
|
|
|
/*
|
|
* Event Name: COOLING_MODE_POWER_LIMIT_CHANGED
|
|
* Event GUID: DBF7B2CF-3B16-4773-9CA9-DD74FF91D6BF
|
|
* Event Desc: Cooling Mode Power Limit Changed
|
|
*/
|
|
#define COOLING_MODE_POWER_LIMIT_CHANGED {0xDB, 0xF7, 0xB2, 0xCF, 0x3B, 0x16, \
|
|
0x47, 0x73, 0x9C, 0xA9, 0xDD, 0x74, \
|
|
0xFF, 0x91, 0xD6, 0xBF}
|
|
|
|
/*
|
|
* Event Name: OS_LPM_MODE_CHANGED
|
|
* Event GUID: 5569447B-6E8F-4FE2-94DE-C31DA011ECF7
|
|
* Event Desc: OS LPM Changed
|
|
*/
|
|
#define OS_LPM_MODE_CHANGED {0x55, 0x69, 0x44, 0x7B, 0x6E, 0x8F, 0x4F, 0xE2, \
|
|
0x94, 0xDE, 0xC3, 0x1D, 0xA0, 0x11, 0xEC, 0xF7}
|
|
|
|
/*
|
|
* Event Name: PASSIVE_TABLE_CHANGED
|
|
* Event GUID: 661C68E1-B73E-4D02-859B-F1C1505F90D1
|
|
* Event Desc: PSV Object Changed
|
|
*/
|
|
#define PASSIVE_TABLE_CHANGED {0x66, 0x1C, 0x68, 0xE1, 0xB7, 0x3E, 0x4D, 0x02, \
|
|
0x85, 0x9B, 0xF1, 0xC1, 0x50, 0x5F, 0x90, 0xD1}
|
|
|
|
/*
|
|
* Event Name: SENSOR_ORIENTATION_CHANGED
|
|
* Event GUID: 019C3571-3560-4EC6-BDED-884F6125B5F9
|
|
* Event Desc: Sensor Orientation Changed
|
|
*/
|
|
#define SENSOR_ORIENTATION_CHANGED {0x01, 0x9C, 0x35, 0x71, 0x35, 0x60, 0x4E, \
|
|
0xC6, 0xBD, 0xED, 0x88, 0x4F, 0x61, 0x25, \
|
|
0xB5, 0xF9}
|
|
|
|
/*
|
|
* Event Name: SENSOR_SPATIAL_ORIENTATION_CHANGED
|
|
* Event GUID: 164B8FD7-C165-4C86-8E9B-4464B6EEC015
|
|
* Event Desc: Sensor Spatial Orientation Changed
|
|
*/
|
|
#define SENSOR_SPATIAL_ORIENTATION_CHANGED {0x16, 0x4B, 0x8F, 0xD7, 0xC1, 0x65, \
|
|
0x4C, 0x86, 0x8E, 0x9B, 0x44, 0x64, \
|
|
0xB6, 0xEE, 0xC0, 0x15}
|
|
|
|
/*
|
|
* Event Name: SENSOR_PROXIMITY_CHANGED
|
|
* Event GUID: C7C83E34-519B-4650-A8B2-640E31F5BB0A
|
|
* Event Desc: Sensor Proximity Changed
|
|
*/
|
|
#define SENSOR_PROXIMITY_CHANGED {0xC7, 0xC8, 0x3E, 0x34, 0x51, 0x9B, 0x46, \
|
|
0x50, 0xA8, 0xB2, 0x64, 0x0E, 0x31, 0xF5, \
|
|
0xBB, 0x0A}
|
|
|
|
/*
|
|
* Event Name: SYSTEM_COOLING_POLICY_CHANGED
|
|
* Event GUID: 5C7D591E-2EA8-4DA1-85A4-476191404650
|
|
* Event Desc: System Cooling Policy
|
|
*/
|
|
#define SYSTEM_COOLING_POLICY_CHANGED {0x5C, 0x7D, 0x59, 0x1E, 0x2E, 0xA8, 0x4D, \
|
|
0xA1, 0x85, 0xA4, 0x47, 0x61, 0x91, 0x40, \
|
|
0x46, 0x50}
|
|
|
|
/*
|
|
* Event Name: LPM_MODE_CHANGED
|
|
* Event GUID: DDADD3BF-2385-4E3B-B242-2793B81293AA
|
|
* Event Desc: Non OS LPM Changed
|
|
*/
|
|
#define LPM_MODE_CHANGED {0xDD, 0xAD, 0xD3, 0xBF, 0x23, 0x85, 0x4E, 0x3B, 0xB2, \
|
|
0x42, 0x27, 0x93, 0xB8, 0x12, 0x93, 0xAA}
|
|
|
|
/*
|
|
* Event Name: OS_CTDP_CAPABILITY_CHANGED
|
|
* Event GUID: 07029cd8-4664-4698-95d8-43b2e9666596
|
|
* Event Desc: OS CTDP Capability Changed
|
|
*/
|
|
#define OS_CTDP_CAPABILITY_CHANGED {0x07, 0x02, 0x9c, 0xd8, 0x46, 0x64, 0x46, \
|
|
0x98, 0x95, 0xd8, 0x43, 0xb2, 0xe9, 0x66, \
|
|
0x65, 0x96}
|
|
|
|
// Event Name: RF_PROFILE_CHANGED
|
|
// Event GUID: C13C9EAF-9F51-4027-BFE2-E278152D238B
|
|
// Event Desc: RF Profile Changed
|
|
#define RF_PROFILE_CHANGED {0xC1, 0x3C, 0x9E, 0xAF, 0x9F, 0x51, 0x40, 0x27, \
|
|
0xBF, 0xE2, 0xE2, 0x78, 0x15, 0x2D, 0x23, 0x8B}
|
|
|
|
// Event Name: RF_CONNECTION_STATUS_CHANGED
|
|
// Event GUID: 127FB178-2FF0-4286-8A3F-9161B6E87D57
|
|
// Event Desc: RF Connection Status Changed
|
|
#define RF_CONNECTION_STATUS_CHANGED {0x12, 0x7F, 0xB1, 0x78, 0x2F, 0xF0, 0x42, 0x86, \
|
|
0x8A, 0x3F, 0x91, 0x61, 0xB6, 0xE8, 0x7D, 0x57}
|
|
|
|
// Event Name: LOG_VERBOSITY_CHANGED
|
|
// Event GUID: F77BD545-C448-4B5F-99C8-D0BA02968665
|
|
// Event Desc: Log Verbosity Changed
|
|
#define LOG_VERBOSITY_CHANGED {0xF7,0x7B,0xD5,0x45,0xC4,0x48,0x4B,0x5F, \
|
|
0x99,0xC8,0xD0,0xBA,0x02,0x96,0x86,0x65}
|
|
|
|
|
|
#endif /* _ESIF_AUTOGEN_H_ */
|