esif_sdk_event_map.h

/*******************************************************************************
** 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-2023 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-2023 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.
**
*******************************************************************************/

#pragma once

#include <string.h>
#include "esif_sdk.h"
#include "esif_sdk_event_type.h"
#include "esif_sdk_event_guid.h"
#include "esif_ccb_memory.h"

/*
* Event GUID/Type Mapping
*/

/* Use these Helper Macros for Converting to/from GUID or Event Type */
#define esif_event_map_guid2type(guid, type)	esif_event_map(guid, type, ESIF_TRUE)
#define esif_event_map_type2guid(guid, type)	esif_event_map(guid, type, ESIF_FALSE)

/* Convert Event GUID to/from Event Type */
static ESIF_INLINE Bool esif_event_map(
	esif_guid_t *guidPtr,
	esif_event_type_t *typePtr,
	Bool isFromGuid
	)
{
	struct {
		esif_guid_t		guid;
		esif_event_type_t 	type;
	} esif_event_map_table[] = {
		{ ACPI,
		  ESIF_EVENT_ACPI },
		{ ACTION_LOADED,
		  ESIF_EVENT_ACTION_LOADED },
		{ ACTION_UNLOADED,
		  ESIF_EVENT_ACTION_UNLOADED },
		{ APP_BROADCAST,
		  ESIF_EVENT_APP_BROADCAST },
		{ APP_BROADCAST_UNPRIVILEGED,
		  ESIF_EVENT_APP_BROADCAST_UNPRIVILEGED },
		{ APP_LOADED,
		  ESIF_EVENT_APP_LOADED },
		{ APP_UNLOADED,
		  ESIF_EVENT_APP_UNLOADED },
		{ APP_UNLOADING,
		  ESIF_EVENT_APP_UNLOADING },
		{ BATTERY_COUNT_NOTIFICATION,
		  ESIF_EVENT_BATTERY_COUNT_NOTIFICATION },
		{ BATTERY_HIGH_FREQUENCY_IMPEDANCE_CHANGED,
		  ESIF_EVENT_BATTERY_HIGH_FREQUENCY_IMPEDANCE_CHANGED },
		{ BATTERY_INFORMATION_CHANGED,
		  ESIF_EVENT_BATTERY_INFORMATION_CHANGED },
		{ BATTERY_NO_LOAD_VOLTAGE_CHANGED,
		  ESIF_EVENT_BATTERY_NO_LOAD_VOLTAGE_CHANGED },
		{ BATTERY_STATE_OF_CHARGE_CHANGED,
		  ESIF_EVENT_BATTERY_STATE_OF_CHARGE_CHANGED },
		{ BATTERY_STATUS_CHANGED,
		  ESIF_EVENT_BATTERY_STATUS_CHANGED },
		{ BATTERY_TEMPERATURE_CHANGED,
		  ESIF_EVENT_BATTERY_TEMPERATURE_CHANGED },
		{ BIOMETRIC_PRESENCE_SENSOR_DISTANCE_CHANGED,
		  ESIF_EVENT_BIOMETRIC_PRESENCE_SENSOR_DISTANCE_CHANGED },
		{ BIOMETRIC_PRESENCE_SENSOR_INSTANCE_CHANGED,
		  ESIF_EVENT_BIOMETRIC_PRESENCE_SENSOR_INSTANCE_CHANGED },
		{ BIOMETRIC_PRESENCE_SENSOR_STATUS_CHANGED,
		  ESIF_EVENT_BIOMETRIC_PRESENCE_SENSOR_STATUS_CHANGED },
		{ BIOMETRIC_PRESENCE_SENSOR_WAKE,
		  ESIF_EVENT_BIOMETRIC_PRESENCE_SENSOR_WAKE },
		{ CHARGER_TYPE_CHANGED,
		  ESIF_EVENT_CHARGER_TYPE_CHANGED },
		{ COLLABORATION_CHANGED,
		  ESIF_EVENT_COLLABORATION_CHANGED },
		{ CORE_CAPABILITY_CHANGED,
		  ESIF_EVENT_CORE_CAPABILITY_CHANGED },
		{ DEVICE_ORIENTATION_CHANGED,
		  ESIF_EVENT_DEVICE_ORIENTATION_CHANGED },
		{ DISPLAY_OFF,
		  ESIF_EVENT_DISPLAY_OFF },
		{ DISPLAY_ON,
		  ESIF_EVENT_DISPLAY_ON },
		{ DISPLAY_ORIENTATION_CHANGED,
		  ESIF_EVENT_DISPLAY_ORIENTATION_CHANGED },
		{ DTT_ACTIVE_CONTROL_POINT_RELATIONSHIP_TABLE_CHANGED,
		  ESIF_EVENT_DTT_ACTIVE_CONTROL_POINT_RELATIONSHIP_TABLE_CHANGED },
		{ DTT_ACTIVE_RELATIONSHIP_TABLE_CHANGED,
		  ESIF_EVENT_DTT_ACTIVE_RELATIONSHIP_TABLE_CHANGED },
		{ DTT_ADAPTIVE_PERFORMANCE_ACTIONS_TABLE_CHANGED,
		  ESIF_EVENT_DTT_ADAPTIVE_PERFORMANCE_ACTIONS_TABLE_CHANGED },
		{ DTT_ADAPTIVE_PERFORMANCE_CONDITIONS_TABLE_CHANGED,
		  ESIF_EVENT_DTT_ADAPTIVE_PERFORMANCE_CONDITIONS_TABLE_CHANGED },
		{ DTT_ADAPTIVE_PERFORMANCE_PARTICIPANT_CONDITION_TABLE_CHANGED,
		  ESIF_EVENT_DTT_ADAPTIVE_PERFORMANCE_PARTICIPANT_CONDITION_TABLE_CHANGED },
		{ DTT_ALIVE_REQUEST,
		  ESIF_EVENT_DTT_ALIVE_REQUEST },
		{ DTT_DISPLAY_CAPABILITY_CHANGED,
		  ESIF_EVENT_DTT_DISPLAY_CAPABILITY_CHANGED },
		{ DTT_DISPLAY_STATUS_CHANGED,
		  ESIF_EVENT_DTT_DISPLAY_STATUS_CHANGED },
		{ DTT_EPP_SENSITIVITY_HINT_CHANGED,
		  ESIF_EVENT_DTT_EPP_SENSITIVITY_HINT_CHANGED },
		{ DTT_INTELLIGENT_THERMAL_MANAGEMENT_TABLE_CHANGED,
		  ESIF_EVENT_DTT_INTELLIGENT_THERMAL_MANAGEMENT_TABLE_CHANGED },
		{ DTT_PARTICIPANT_ACTIVITY_LOGGING_DISABLED,
		  ESIF_EVENT_DTT_PARTICIPANT_ACTIVITY_LOGGING_DISABLED },
		{ DTT_PARTICIPANT_ACTIVITY_LOGGING_ENABLED,
		  ESIF_EVENT_DTT_PARTICIPANT_ACTIVITY_LOGGING_ENABLED },
		{ DTT_PARTICIPANT_CONTROL_ACTION,
		  ESIF_EVENT_DTT_PARTICIPANT_CONTROL_ACTION },
		{ DTT_PASSIVE_TABLE_CHANGED,
		  ESIF_EVENT_DTT_PASSIVE_TABLE_CHANGED },
		{ DTT_PID_ALGORITHM_TABLE_CHANGED,
		  ESIF_EVENT_DTT_PID_ALGORITHM_TABLE_CHANGED },
		{ DTT_POLICY_ACTIVITY_LOGGING_DISABLED,
		  ESIF_EVENT_DTT_POLICY_ACTIVITY_LOGGING_DISABLED },
		{ DTT_POLICY_ACTIVITY_LOGGING_ENABLED,
		  ESIF_EVENT_DTT_POLICY_ACTIVITY_LOGGING_ENABLED },
		{ DTT_POLICY_LOADED_UNLOADED,
		  ESIF_EVENT_DTT_POLICY_LOADED_UNLOADED },
		{ DTT_POWER_BOSS_ACTIONS_TABLE_CHANGED,
		  ESIF_EVENT_DTT_POWER_BOSS_ACTIONS_TABLE_CHANGED },
		{ DTT_POWER_BOSS_CONDITIONS_TABLE_CHANGED,
		  ESIF_EVENT_DTT_POWER_BOSS_CONDITIONS_TABLE_CHANGED },
		{ DTT_POWER_BOSS_MATH_TABLE_CHANGED,
		  ESIF_EVENT_DTT_POWER_BOSS_MATH_TABLE_CHANGED },
		{ DTT_POWER_SHARING_ALGORITHM_TABLE_2_CHANGED,
		  ESIF_EVENT_DTT_POWER_SHARING_ALGORITHM_TABLE_2_CHANGED },
		{ DTT_POWER_SHARING_ALGORITHM_TABLE_CHANGED,
		  ESIF_EVENT_DTT_POWER_SHARING_ALGORITHM_TABLE_CHANGED },
		{ DTT_PRIORITY_CHANGED,
		  ESIF_EVENT_DTT_PRIORITY_CHANGED },
		{ DTT_SUPPORTED_POLICIES_CHANGED,
		  ESIF_EVENT_DTT_SUPPORTED_POLICIES_CHANGED },
		{ DTT_SYSTEM_COOLING_POLICY_CHANGED,
		  ESIF_EVENT_DTT_SYSTEM_COOLING_POLICY_CHANGED },
		{ DTT_THERMAL_RELATIONSHIP_TABLE_CHANGED,
		  ESIF_EVENT_DTT_THERMAL_RELATIONSHIP_TABLE_CHANGED },
		{ DTT_VIRTUAL_SENSOR_CALIB_TABLE_CHANGED,
		  ESIF_EVENT_DTT_VIRTUAL_SENSOR_CALIB_TABLE_CHANGED },
		{ DTT_VIRTUAL_SENSOR_POLLING_TABLE_CHANGED,
		  ESIF_EVENT_DTT_VIRTUAL_SENSOR_POLLING_TABLE_CHANGED },
		{ DTT_VIRTUAL_SENSOR_RECALC_CHANGED,
		  ESIF_EVENT_DTT_VIRTUAL_SENSOR_RECALC_CHANGED },
		{ DTT_VOLTAGE_THRESHOLD_MATH_TABLE_CHANGED,
		  ESIF_EVENT_DTT_VOLTAGE_THRESHOLD_MATH_TABLE_CHANGED },
		{ DTT_WORKLOAD_HINT_CONFIGURATION_CHANGED,
		  ESIF_EVENT_DTT_WORKLOAD_HINT_CONFIGURATION_CHANGED },
		{ EMERGENCY_CALL_MODE_TABLE_CHANGED,
		  ESIF_EVENT_EMERGENCY_CALL_MODE_TABLE_CHANGED },
		{ ENERGY_THRESHOLD_CROSSED,
		  ESIF_EVENT_ENERGY_THRESHOLD_CROSSED },
		{ EXTERNAL_MONITOR_CONNECTION_STATE_CHANGED,
		  ESIF_EVENT_EXTERNAL_MONITOR_CONNECTION_STATE_CHANGED },
		{ FACE_ID_CAPABILITY_SUPPORT_CHANGED,
		  ESIF_EVENT_FACE_ID_CAPABILITY_SUPPORT_CHANGED },
		{ FAN_CAPABILITIES_CHANGED,
		  ESIF_EVENT_FAN_CAPABILITIES_CHANGED },
		{ FAN_SPEED_THRESHOLD_CROSSED,
		  ESIF_EVENT_FAN_SPEED_THRESHOLD_CROSSED },
		{ FOREGROUND_APP_CHANGED,
		  ESIF_EVENT_FOREGROUND_APP_CHANGED },
		{ FOREGROUND_BACKGROUND_RATIO_CHANGED,
		  ESIF_EVENT_FOREGROUND_BACKGROUND_RATIO_CHANGED },
		{ IP_ALIGNMENT_STATE_CHANGED,
		  ESIF_EVENT_IP_ALIGNMENT_STATE_CHANGED },
		{ LF_UNLOADED,
		  ESIF_EVENT_LF_UNLOADED },
		{ LOG_VERBOSITY_CHANGED,
		  ESIF_EVENT_LOG_VERBOSITY_CHANGED },
		{ MAX_BATTERY_POWER_CHANGED,
		  ESIF_EVENT_MAX_BATTERY_POWER_CHANGED },
		{ MOTION_CHANGED,
		  ESIF_EVENT_MOTION_CHANGED },
		{ NUM_FACES_ENROLLED_CHANGED,
		  ESIF_EVENT_NUM_FACES_ENROLLED_CHANGED },
		{ OEM_VARS_CHANGED,
		  ESIF_EVENT_OEM_VARS_CHANGED },
		{ ONLOOKER_SENSOR_HUMAN_COUNT_CHANGED,
		  ESIF_EVENT_ONLOOKER_SENSOR_HUMAN_COUNT_CHANGED },
		{ ONLOOKER_SENSOR_STATUS_CHANGED,
		  ESIF_EVENT_ONLOOKER_SENSOR_STATUS_CHANGED },
		{ OS_BATTERY_PERCENT_CHANGED,
		  ESIF_EVENT_OS_BATTERY_PERCENT_CHANGED },
		{ OS_DOCK_MODE_CHANGED,
		  ESIF_EVENT_OS_DOCK_MODE_CHANGED },
		{ OS_GAME_MODE_CHANGED,
		  ESIF_EVENT_OS_GAME_MODE_CHANGED },
		{ OS_LID_STATE_CHANGED,
		  ESIF_EVENT_OS_LID_STATE_CHANGED },
		{ OS_MIXED_REALITY_MODE_CHANGED,
		  ESIF_EVENT_OS_MIXED_REALITY_MODE_CHANGED },
		{ OS_MOBILE_NOTIFICATION,
		  ESIF_EVENT_OS_MOBILE_NOTIFICATION },
		{ OS_PLATFORM_TYPE_CHANGED,
		  ESIF_EVENT_OS_PLATFORM_TYPE_CHANGED },
		{ OS_POWER_SLIDER_VALUE_CHANGED,
		  ESIF_EVENT_OS_POWER_SLIDER_VALUE_CHANGED },
		{ OS_POWER_SOURCE_CHANGED,
		  ESIF_EVENT_OS_POWER_SOURCE_CHANGED },
		{ OS_POWERSCHEME_PERSONALITY_CHANGED,
		  ESIF_EVENT_OS_POWERSCHEME_PERSONALITY_CHANGED },
		{ OS_SCREEN_STATE_CHANGED,
		  ESIF_EVENT_OS_SCREEN_STATE_CHANGED },
		{ OS_USER_INTERACTION_CHANGED,
		  ESIF_EVENT_OS_USER_INTERACTION_CHANGED },
		{ OS_USER_PRESENCE_CHANGED,
		  ESIF_EVENT_OS_USER_PRESENCE_CHANGED },
		{ PARTICIPANT_CREATE,
		  ESIF_EVENT_PARTICIPANT_CREATE },
		{ PARTICIPANT_CREATE_COMPLETE,
		  ESIF_EVENT_PARTICIPANT_CREATE_COMPLETE },
		{ PARTICIPANT_RESUME,
		  ESIF_EVENT_PARTICIPANT_RESUME },
		{ PARTICIPANT_SHUTDOWN,
		  ESIF_EVENT_PARTICIPANT_SHUTDOWN },
		{ PARTICIPANT_SPEC_INFO_CHANGED,
		  ESIF_EVENT_PARTICIPANT_SPEC_INFO_CHANGED },
		{ PARTICIPANT_SUSPEND,
		  ESIF_EVENT_PARTICIPANT_SUSPEND },
		{ PARTICIPANT_UNREGISTER,
		  ESIF_EVENT_PARTICIPANT_UNREGISTER },
		{ PARTICIPANT_UNREGISTER_COMPLETE,
		  ESIF_EVENT_PARTICIPANT_UNREGISTER_COMPLETE },
		{ PCIE_THROTTLE_REQUESTED,
		  ESIF_EVENT_PCIE_THROTTLE_REQUESTED },
		{ PERF_CAPABILITY_CHANGED,
		  ESIF_EVENT_PERF_CAPABILITY_CHANGED },
		{ PERF_CONTROL_CHANGED,
		  ESIF_EVENT_PERF_CONTROL_CHANGED },
		{ PLATFORM_BATTERY_STEADY_STATE_CHANGED,
		  ESIF_EVENT_PLATFORM_BATTERY_STEADY_STATE_CHANGED },
		{ PLATFORM_POWER_SOURCE_CHANGED,
		  ESIF_EVENT_PLATFORM_POWER_SOURCE_CHANGED },
		{ PLATFORM_REST_OF_POWER_CHANGED,
		  ESIF_EVENT_PLATFORM_REST_OF_POWER_CHANGED },
		{ PLATFORM_USER_PRESENCE_CHANGED,
		  ESIF_EVENT_PLATFORM_USER_PRESENCE_CHANGED },
		{ POWER_CAPABILITY_CHANGED,
		  ESIF_EVENT_POWER_CAPABILITY_CHANGED },
		{ POWER_SOURCE_CHANGED,
		  ESIF_EVENT_POWER_SOURCE_CHANGED },
		{ PRIMARY_PARTICIPANT_ARRIVED,
		  ESIF_EVENT_PRIMARY_PARTICIPANT_ARRIVED },
		{ PROCESS_LOAD_NOTIFICATION,
		  ESIF_EVENT_PROCESS_LOAD_NOTIFICATION },
		{ RF_CONNECTION_STATUS_CHANGED,
		  ESIF_EVENT_RF_CONNECTION_STATUS_CHANGED },
		{ RF_PROFILE_CHANGED,
		  ESIF_EVENT_RF_PROFILE_CHANGED },
		{ SENSOR_MODE_CHANGED,
		  ESIF_EVENT_SENSOR_MODE_CHANGED },
		{ SENSOR_USER_PRESENCE_CHANGED,
		  ESIF_EVENT_SENSOR_USER_PRESENCE_CHANGED },
		{ SESSION_STATE_CHANGED,
		  ESIF_EVENT_SESSION_STATE_CHANGED },
		{ SOC_POWER_FLOOR_CHANGED,
		  ESIF_EVENT_SOC_POWER_FLOOR_CHANGED },
		{ SOC_WORKLOADTYPE_CHANGED,
		  ESIF_EVENT_SOC_WORKLOADTYPE_CHANGED },
		{ SYSTEM_IN_BAG,
		  ESIF_EVENT_SYSTEM_IN_BAG },
		{ TEMP_THRESHOLD_CROSSED,
		  ESIF_EVENT_TEMP_THRESHOLD_CROSSED },
		{ TPG_POWER_STATE_CHANGED,
		  ESIF_EVENT_TPG_POWER_STATE_CHANGED },
		{ TPG_TPP_LIMIT_CHANGED,
		  ESIF_EVENT_TPG_TPP_LIMIT_CHANGED },
		{ USER_PRESENCE_CORRELATION_STATUS_CHANGED,
		  ESIF_EVENT_USER_PRESENCE_CORRELATION_STATUS_CHANGED },
		{ WINDOWS_LOW_POWER_MODE_ENTRY,
		  ESIF_EVENT_WINDOWS_LOW_POWER_MODE_ENTRY },
		{ WINDOWS_LOW_POWER_MODE_EXIT,
		  ESIF_EVENT_WINDOWS_LOW_POWER_MODE_EXIT },
		{ WORKLOAD_CLASSIFICATION_CHANGED,
		  ESIF_EVENT_WORKLOAD_CLASSIFICATION_CHANGED },
		{ 0 }
	};
	esif_guid_t null_guid = {0};

	if (guidPtr && typePtr) {
		for (size_t j = 0; memcmp(esif_event_map_table[j].guid, null_guid, sizeof(null_guid)) != 0; j++) {
			if (isFromGuid && memcmp(esif_event_map_table[j].guid, *guidPtr, sizeof(*guidPtr)) == 0) {
				*typePtr = esif_event_map_table[j].type;
				return ESIF_TRUE;
			}
			else if (!isFromGuid && esif_event_map_table[j].type == *typePtr) {
				esif_ccb_memcpy(*guidPtr, esif_event_map_table[j].guid, sizeof(*guidPtr));
				return ESIF_TRUE;
			}
		}
	}
	return ESIF_FALSE;
}