static eEsifError ActionConfigSignalChangeEvents(
EsifUpPtr upPtr,
const EsifPrimitiveTuple tuple,
const EsifDataPtr requestPtr
)
{
eEsifError rc = ESIF_OK;
eEsifEventType targetEvent = 0;
char domainStr[8] = "";
esif_temp_t hysteresis_val = 0;
esif_temp_t *hysteresis_ptr = NULL;
esif_time_t polling_val = 0;
esif_time_t *polling_ptr = NULL;
ESIF_ASSERT(upPtr != NULL);
switch (tuple.id) {
case SET_TRIP_POINT_ACTIVE:
case SET_TRIP_POINT_CRITICAL:
case SET_TRIP_POINT_HOT:
case SET_TRIP_POINT_PASSIVE:
case SET_TRIP_POINT_WARM:
targetEvent = ESIF_EVENT_PARTICIPANT_SPEC_INFO_CHANGED;
break;
case SET_THERMAL_RELATIONSHIP_TABLE:
targetEvent = ESIF_EVENT_APP_THERMAL_RELATIONSHIP_CHANGED;
break;
case SET_PASSIVE_RELATIONSHIP_TABLE:
targetEvent = ESIF_EVENT_PASSIVE_TABLE_CHANGED;
break;
case SET_ACTIVE_RELATIONSHIP_TABLE:
targetEvent = ESIF_EVENT_APP_ACTIVE_RELATIONSHIP_CHANGED;
break;
case SET_ADAPTIVE_PERFORMANCE_CONDITIONS_TABLE:
targetEvent = ESIF_EVENT_ADAPTIVE_PERFORMANCE_CONDITIONS_TABLE_CHANGED;
break;
case SET_ADAPTIVE_PERFORMANCE_ACTIONS_TABLE:
targetEvent = ESIF_EVENT_ADAPTIVE_PERFORMANCE_ACTIONS_TABLE_CHANGED;
break;
case SET_ADAPTIVE_PERFORMANCE_PARTICIPANT_CONDITION_TABLE:
targetEvent = ESIF_EVENT_ADAPTIVE_PERFORMANCE_PARTICIPANT_CONDITION_TABLE_CHANGED;
break;
case SET_VIRTUAL_SENSOR_CALIB_TABLE:
targetEvent = ESIF_EVENT_VIRTUAL_SENSOR_CALIB_TABLE_CHANGED;
break;
case SET_VIRTUAL_SENSOR_POLLING_TABLE:
targetEvent = ESIF_EVENT_VIRTUAL_SENSOR_POLLING_TABLE_CHANGED;
break;
case SET_RAPL_POWER_CONTROL_CAPABILITIES:
targetEvent = ESIF_EVENT_DOMAIN_POWER_CAPABILITY_CHANGED;
break;
case SET_PROC_PERF_PSTATE_DEPTH_LIMIT:
case SET_PERF_PSTATE_DEPTH_LIMIT:
case SET_PERF_SUPPORT_STATE:
targetEvent = ESIF_EVENT_DOMAIN_PERF_CAPABILITY_CHANGED;
break;
case SET_TEMPERATURE:
targetEvent = ESIF_EVENT_DOMAIN_TEMP_THRESHOLD_CROSSED;
break;
case SET_TEMPERATURE_THRESHOLD_HYSTERESIS:
targetEvent = ESIF_EVENT_PARTICIPANT_SPEC_INFO_CHANGED;
if (requestPtr != NULL) {
if (requestPtr->buf_ptr == NULL) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
hysteresis_val = *(esif_temp_t *)requestPtr->buf_ptr;
hysteresis_ptr = &hysteresis_val;
esif_primitive_domain_str(tuple.domain, domainStr, sizeof(domainStr));
ESIF_TRACE_DEBUG("Hysteresis changed for domain:%s\n", domainStr);
EsifUp_UpdateHysteresis(upPtr, tuple.domain, hysteresis_ptr);
}
break;
case SET_PARTICIPANT_SAMPLE_PERIOD:
targetEvent = 0;
if (requestPtr != NULL) {
if (requestPtr->buf_ptr == NULL) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
polling_val = *(esif_time_t *)requestPtr->buf_ptr;
polling_ptr = &polling_val;
esif_primitive_domain_str(tuple.domain, domainStr, sizeof(domainStr));
ESIF_TRACE_DEBUG("Participant sample period changed for domain:%s\n", domainStr);
EsifUp_UpdatePolling(upPtr, tuple.domain, polling_ptr);
}
break;
case SET_DISPLAY_BRIGHTNESS_LEVELS:
case SET_DISPLAY_CAPABILITY:
case SET_DISPLAY_DEPTH_LIMIT:
targetEvent = ESIF_EVENT_DOMAIN_DISPLAY_CAPABILITY_CHANGED;
break;
case SET_POWER_BOSS_CONDITIONS_TABLE:
targetEvent = ESIF_EVENT_POWER_BOSS_CONDITIONS_TABLE_CHANGED;
break;
case SET_POWER_BOSS_ACTIONS_TABLE:
targetEvent = ESIF_EVENT_POWER_BOSS_ACTIONS_TABLE_CHANGED;
break;
case SET_POWER_BOSS_MATH_TABLE:
targetEvent = ESIF_EVENT_POWER_BOSS_MATH_TABLE_CHANGED;
break;
case SET_EMERGENCY_CALL_MODE_TABLE:
targetEvent = ESIF_EVENT_EMERGENCY_CALL_MODE_TABLE_CHANGED;
break;
case SET_PID_ALGORITHM_TABLE:
targetEvent = ESIF_EVENT_PID_ALGORITHM_TABLE_CHANGED;
break;
case SET_ACTIVE_CONTROL_POINT_RELATIONSHIP_TABLE:
targetEvent = ESIF_EVENT_ACTIVE_CONTROL_POINT_RELATIONSHIP_TABLE_CHANGED;
break;
default:
targetEvent = 0;
break;
}
if (targetEvent > 0) {
EsifEventMgr_SignalEvent(EsifUp_GetInstance(upPtr), tuple.domain, targetEvent, NULL);
}
exit:
return rc;
}
void EsifEvent_SignalIpcEvent(struct esif_ipc_event *eventHdrPtr)
{
#ifdef ESIF_FEAT_OPT_ACTION_SYSFS
UNREFERENCED_PARAMETER(domainStr);
#else
eEsifError rc = ESIF_OK;
EsifData binaryData = {ESIF_DATA_BINARY, NULL, 0, 0};
EsifData voidData = {ESIF_DATA_VOID, NULL, 0};
EsifDataPtr dataPtr = NULL;
UInt8 participantId;
char domainStr[8] = "";
esif_ccb_time_t now;
UNREFERENCED_PARAMETER(domainStr);
esif_ccb_system_time(&now);
ESIF_TRACE_DEBUG(
"\n"
"===================================================\n"
"ESIF IPC EVENT HEADER: Timestamp: %llu\n"
" Latency: %u msec\n"
"===================================================\n"
"Version: %d\n"
"Type: %s(%d)\n"
"ID: %llu\n"
"Timestamp: %llu\n"
"Priority: %s(%d)\n"
"Source: %d\n"
"Dest: %d\n"
"Dest Domain: %s(%04X)\n"
"Data Size: %u\n\n",
(u64)now,
(int)(now - eventHdrPtr->timestamp),
eventHdrPtr->version,
esif_event_type_str(eventHdrPtr->type),
eventHdrPtr->type,
eventHdrPtr->id,
eventHdrPtr->timestamp,
esif_event_priority_str(eventHdrPtr->priority),
eventHdrPtr->priority,
eventHdrPtr->src_id,
eventHdrPtr->dst_id,
esif_primitive_domain_str(eventHdrPtr->dst_domain_id, domainStr, 8),
eventHdrPtr->dst_domain_id,
eventHdrPtr->data_len);
dataPtr = &voidData;
if (eventHdrPtr->data_len > 0) {
binaryData.buf_ptr = eventHdrPtr + 1;
binaryData.buf_len = eventHdrPtr->data_len;
binaryData.data_len = eventHdrPtr->data_len;
dataPtr = &binaryData;
}
/*
* If the mapping function fails, we assume that the participant hasn't been created
* In that case, we use 0 for the participant as the real ID will be gathered from
* the creation data.
*/
participantId = eventHdrPtr->dst_id;
if (eventHdrPtr->dst_id == ESIF_INSTANCE_UF) {
rc = EsifUpPm_MapLpidToParticipantInstance(eventHdrPtr->src_id, &participantId);
if (rc != ESIF_OK) {
participantId = 0;
}
}
// Best Effort Delivery
EsifEventMgr_SignalEvent(participantId, eventHdrPtr->dst_domain_id, eventHdrPtr->type, dataPtr);
return;
#endif
}
static eEsifError ActionConfigSignalChangeEvents(
EsifUpPtr upPtr,
const EsifFpcPrimitivePtr primitivePtr,
const EsifDataPtr requestPtr
)
{
eEsifError rc = ESIF_OK;
eEsifEventType targetEvent = 0;
char domainStr[8] = "";
struct esif_data voidData = {ESIF_DATA_VOID, NULL, 0};
ESIF_ASSERT(upPtr != NULL);
ESIF_ASSERT(primitivePtr != NULL);
ESIF_ASSERT(requestPtr != NULL);
switch (primitivePtr->tuple.id) {
case SET_TRIP_POINT_ACTIVE:
case SET_TRIP_POINT_CRITICAL:
case SET_TRIP_POINT_HOT:
case SET_TRIP_POINT_PASSIVE:
case SET_TRIP_POINT_WARM:
targetEvent = ESIF_EVENT_PARTICIPANT_SPEC_INFO_CHANGED;
break;
case SET_THERMAL_RELATIONSHIP_TABLE:
targetEvent = ESIF_EVENT_APP_THERMAL_RELATIONSHIP_CHANGED;
break;
case SET_PASSIVE_RELATIONSHIP_TABLE:
targetEvent = ESIF_EVENT_PASSIVE_TABLE_CHANGED;
break;
case SET_ACTIVE_RELATIONSHIP_TABLE:
targetEvent = ESIF_EVENT_APP_ACTIVE_RELATIONSHIP_CHANGED;
break;
case SET_ADAPTIVE_PERFORMANCE_CONDITIONS_TABLE:
targetEvent = ESIF_EVENT_ADAPTIVE_PERFORMANCE_CONDITIONS_CHANGED;
break;
case SET_ADAPTIVE_PERFORMANCE_ACTIONS_TABLE:
targetEvent = ESIF_EVENT_ADAPTIVE_PERFORMANCE_ACTIONS_CHANGED;
break;
case SET_VIRTUAL_SENSOR_CALIB_TABLE:
targetEvent = ESIF_EVENT_VIRTUAL_SENSOR_CALIB_TABLE_CHANGED;
break;
case SET_VIRTUAL_SENSOR_POLLING_TABLE:
targetEvent = ESIF_EVENT_VIRTUAL_SENSOR_POLLING_TABLE_CHANGED;
break;
case SET_RAPL_POWER_CONTROL_CAPABILITIES:
targetEvent = ESIF_EVENT_DOMAIN_POWER_CAPABILITY_CHANGED;
break;
case SET_PROC_PERF_PSTATE_DEPTH_LIMIT:
case SET_PERF_PSTATE_DEPTH_LIMIT:
case SET_PERF_SUPPORT_STATE:
targetEvent = ESIF_EVENT_DOMAIN_PERF_CAPABILITY_CHANGED;
break;
case SET_TEMPERATURE:
targetEvent = ESIF_EVENT_DOMAIN_TEMP_THRESHOLD_CROSSED;
break;
case SET_TEMPERATURE_THRESHOLD_HYSTERESIS:
targetEvent = ESIF_EVENT_PARTICIPANT_SPEC_INFO_CHANGED;
if (requestPtr->buf_ptr == NULL) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
esif_primitive_domain_str(primitivePtr->tuple.domain, domainStr, sizeof(domainStr));
ESIF_TRACE_DEBUG("Hysteresis changed for domain:%s\n", domainStr);
EsifUp_UpdateHysteresis(upPtr, primitivePtr->tuple.domain, *(esif_temp_t *) requestPtr->buf_ptr);
break;
case SET_PARTICIPANT_SAMPLE_PERIOD:
targetEvent = 0;
if (requestPtr->buf_ptr == NULL) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
esif_primitive_domain_str(primitivePtr->tuple.domain, domainStr, sizeof(domainStr));
ESIF_TRACE_DEBUG("Participant sample period changed for domain:%s\n", domainStr);
EsifUp_UpdatePolling(upPtr, primitivePtr->tuple.domain, *(UInt32 *) requestPtr->buf_ptr);
break;
case SET_DISPLAY_BRIGHTNESS_LEVELS:
case SET_DISPLAY_CAPABILITY:
case SET_DISPLAY_DEPTH_LIMIT:
targetEvent = ESIF_EVENT_DOMAIN_DISPLAY_CAPABILITY_CHANGED;
break;
case SET_PDR_TABLE:
targetEvent = ESIF_EVENT_OS_POWER_SOURCE_CHANGED;
break;
default:
targetEvent = 0;
break;
}
if (targetEvent > 0) {
EsifEventMgr_SignalEvent(upPtr->fInstance, primitivePtr->tuple.domain, targetEvent, &voidData);
}
exit:
return rc;
}
static eEsifError EsifEventMgr_ProcessEvent(
UInt8 participantId,
UInt16 domainId,
eEsifEventType eventType,
EsifDataPtr eventDataPtr
)
{
eEsifError rc = ESIF_OK;
EsifLinkListPtr listPtr = NULL;
EsifLinkListNodePtr nodePtr = NULL;
EsifLinkListNodePtr nextNodePtr = NULL;
EventMgrEntryPtr entryPtr = NULL;
char domain_str[8] = "";
atomic_t refCount = 0;
UInt8 shouldDumpGarbage = ESIF_FALSE;
UNREFERENCED_PARAMETER(domain_str);
if (NULL == eventDataPtr) {
ESIF_TRACE_DEBUG("APPLICATION_EVENT_NO_DATA:\n"
" ParticipantID: %u\n"
" Domain: %s(%04X)\n"
" EventType: %s(%d)\n",
participantId,
esif_primitive_domain_str(domainId, domain_str, sizeof(domain_str)),
domainId,
esif_event_type_str(eventType), eventType);
} else {
ESIF_TRACE_DEBUG("APPLICATION_EVENT\n"
" ParticipantID: %u\n"
" Domain: %s(%04X)\n"
" EventType: %s(%d)\n"
" EventDataType: %s(%d)\n"
" EventData: %p\n"
" buf_ptr %p\n"
" buf_len %d\n"
" data_len %d\n",
participantId,
esif_primitive_domain_str(domainId, domain_str, 8),
domainId,
esif_event_type_str(eventType), eventType,
esif_data_type_str(eventDataPtr->type), eventDataPtr->type,
eventDataPtr,
eventDataPtr->buf_ptr, eventDataPtr->buf_len, eventDataPtr->data_len
);
if ((ESIF_DATA_STRING == eventDataPtr->type) && (NULL != eventDataPtr->buf_ptr)) {
ESIF_TRACE_DEBUG(
" Data Length: %d\n"
" Data: %s\n",
eventDataPtr->data_len,
(EsifString)eventDataPtr->buf_ptr);
}
}
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
listPtr = g_EsifEventMgr.observerLists[(unsigned)eventType % NUM_EVENT_LISTS];
if(NULL == listPtr) {
rc = ESIF_E_UNSPECIFIED;
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
goto exit;
}
nodePtr = listPtr->head_ptr;
while (NULL != nodePtr) {
nextNodePtr = nodePtr->next_ptr;
entryPtr = (EventMgrEntryPtr)nodePtr->data_ptr;
ESIF_ASSERT(entryPtr != NULL);
if ((eventType == entryPtr->fpcEvent.esif_event) &&
((entryPtr->participantId == participantId) || (entryPtr->participantId == EVENT_MGR_MATCH_ANY)) &&
((entryPtr->domainId == domainId) || (entryPtr->domainId == EVENT_MGR_MATCH_ANY) || (domainId == EVENT_MGR_DOMAIN_NA)) &&
(entryPtr->refCount > 0)) {
/*
* Increment the reference count so that the node is not removed while in use,
* then release the lock so that we avoid a deadlock condition
*/
atomic_inc(&entryPtr->refCount);
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
entryPtr->callback(entryPtr->contextPtr,
participantId,
domainId,
&entryPtr->fpcEvent,
eventDataPtr);
/*
* Get the lock back and decrement the reference count. Remove the node now
* if the reference count is 0
*/
esif_ccb_write_lock(&g_EsifEventMgr.listLock);
nextNodePtr = nodePtr->next_ptr;
refCount = atomic_dec(&entryPtr->refCount);
if (refCount <= 0) {
EsifEventMgr_MoveEntryToGarbage(entryPtr);
esif_link_list_node_remove(listPtr, nodePtr);
shouldDumpGarbage = ESIF_TRUE;
}
}
nodePtr = nextNodePtr;
}
esif_ccb_write_unlock(&g_EsifEventMgr.listLock);
if (shouldDumpGarbage) {
EsifEventMgr_DumpGarbage();
}
exit:
return rc;
}
static eEsifError EsifSetActionDelegateRset(
const EsifUpDomainPtr domainPtr,
const EsifDataPtr requestPtr)
{
eEsifError rc = ESIF_E_PRIMITIVE_ACTION_FAILURE;
EsifPrimitiveTupleParameter parameters = { 0 };
EsifPrimitiveTuple tuple = { 0 };
Bool signal_event = ESIF_FALSE;
char domain_str[8] = { 0 };
int j = 0;
ESIF_ASSERT(domainPtr != NULL);
ESIF_ASSERT(requestPtr != NULL);
if (requestPtr->buf_ptr == NULL) {
rc = ESIF_E_PARAMETER_IS_NULL;
goto exit;
}
if (requestPtr->data_len != sizeof(parameters)) {
rc = ESIF_E_REQUEST_DATA_OUT_OF_BOUNDS;
goto exit;
}
// Convert BINARY Parameters to Primitive Tuple
esif_ccb_memcpy(¶meters, requestPtr->buf_ptr, sizeof(parameters));
ESIF_TRACE_DEBUG("CONFIG RESET: { %s (%hd), %s, %hd }\n",
esif_primitive_str(parameters.id.integer.value),
(u16)parameters.id.integer.value,
esif_primitive_domain_str((u16)parameters.domain.integer.value, domain_str, sizeof(domain_str)),
(u16)parameters.instance.integer.value
);
// Look up Primitive Tuple in the DSP and verify it is a valid SET primtive
EsifDspPtr dspPtr = EsifUp_GetDsp(domainPtr->upPtr);
if (dspPtr == NULL) {
rc = ESIF_E_NEED_DSP;
goto exit;
}
tuple.id = (u16) parameters.id.integer.value;
tuple.domain = (u16) parameters.domain.integer.value;
tuple.instance = (u16) parameters.instance.integer.value;
EsifFpcPrimitivePtr primitivePtr = dspPtr->get_primitive(dspPtr, &tuple);
if (primitivePtr == NULL) {
rc = ESIF_E_PRIMITIVE_NOT_FOUND_IN_DSP;
goto exit;
}
if (primitivePtr->operation != ESIF_PRIMITIVE_OP_SET) {
rc = ESIF_E_INVALID_REQUEST_TYPE;
goto exit;
}
// Find first CONFIG Action and Delete its Key from its DataVault
for (j = 0; j < (int)primitivePtr->num_actions; j++) {
EsifFpcActionPtr fpcActionPtr = dspPtr->get_action(dspPtr, primitivePtr, (u8)j);
DataItemPtr paramDataVault = EsifFpcAction_GetParam(fpcActionPtr, (const UInt8)0);
DataItemPtr paramKeyName = EsifFpcAction_GetParam(fpcActionPtr, (const UInt8)1);
EsifString expandedKeyName = NULL;
if (fpcActionPtr->type != ESIF_ACTION_CONFIG) {
continue;
}
if (paramDataVault == NULL || paramKeyName == NULL || paramDataVault->data_type != ESIF_DSP_PARAMETER_TYPE_STRING || paramKeyName->data_type != ESIF_DSP_PARAMETER_TYPE_STRING) {
rc = ESIF_E_PARAMETER_IS_OUT_OF_BOUNDS;
goto exit;
}
// Replace "%nm%" tokens in the key name or make a copy of the key name for static keys
expandedKeyName = EsifUp_CreateTokenReplacedParamString(domainPtr->upPtr, primitivePtr, (StringPtr)paramKeyName->data);
if (expandedKeyName == NULL) {
expandedKeyName = esif_ccb_strdup((StringPtr)paramKeyName->data);
if (expandedKeyName == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
}
// Valid SET CONFIG Primitive found with valid DV/Key Name; Delete the associated Key from the DataVault
EsifDataPtr data_nspace = EsifData_CreateAs(ESIF_DATA_STRING, (StringPtr)paramDataVault->data, 0, ESIFAUTOLEN);
EsifDataPtr data_key = EsifData_CreateAs(ESIF_DATA_STRING, expandedKeyName, 0, ESIFAUTOLEN);
// Do not signal an Event if Key does not exist in DataVault
if (DataBank_KeyExists(g_DataBankMgr, (StringPtr)paramDataVault->data, expandedKeyName) == ESIF_FALSE) {
rc = ESIF_OK;
}
else if (data_nspace == NULL || data_key == NULL) {
rc = ESIF_E_NO_MEMORY;
}
else {
// Delete Existing Key from DataVault
rc = EsifConfigDelete(data_nspace, data_key);
if (rc == ESIF_OK) {
signal_event = ESIF_TRUE;
}
ESIF_TRACE_DEBUG("CONFIG RESET: config delete @%s %s [rc=%s (%d)]\n",
(StringPtr)data_nspace->buf_ptr,
(StringPtr)data_key->buf_ptr,
esif_rc_str(rc),
rc
);
}
// Signal any Event(s) associated with this SET Primitive
if (signal_event) {
EsifActConfigSignalChangeEvents(domainPtr->upPtr, tuple, NULL);
}
EsifData_Destroy(data_nspace);
EsifData_Destroy(data_key);
esif_ccb_free(expandedKeyName);
break;
}
if (j >= (int)primitivePtr->num_actions) {
rc = ESIF_E_UNSUPPORTED_ACTION_TYPE;
}
exit:
return rc;
}
static eEsifError EsifDataLogAddParticipant(char *logString, int logColumn, int isHeader)
{
eEsifError rc = ESIF_OK;
char qualifier_str[32] = "D0";
u8 domain_count = 1;
char *participantNullValue = "";
int j = 0;
DataLogParticipant currentParticipant = g_dataLogParticipants[logColumn];
UInt8 participantId = currentParticipant.participantId;
EsifUpPtr upPtr = EsifUpPm_GetAvailableParticipantByInstance(participantId);
if (NULL == upPtr) {
int colCounter = 0;
/*
* If we get here, the participant went offline (because the participantId was pre-validated on log start)
* so we must output placeholders
*/
for (colCounter = 0; colCounter < currentParticipant.participantNumFields; colCounter++){
esif_ccb_sprintf_concat(MAX_LOG_LINE, logString, "%s,", participantNullValue);
}
goto exit;
}
domain_count = (u8)upPtr->fDspPtr->get_domain_count(upPtr->fDspPtr);
for (j = 0; j < domain_count; j++) {
UInt32 temp = 255;
UInt32 aux0 = 255;
UInt32 aux1 = 255;
UInt32 hyst = 0;
UInt32 power = 0;
UInt32 powerLimit = 0;
UInt32 fanspeed = 0;
struct esif_fpc_domain *domain_ptr = NULL;
struct esif_data request = { ESIF_DATA_VOID, NULL, 0, 0 };
struct esif_data temp_response = { ESIF_DATA_TEMPERATURE, &temp, sizeof(temp), 4 };
struct esif_data aux0_response = { ESIF_DATA_TEMPERATURE, &aux0, sizeof(aux0), 4 };
struct esif_data aux1_response = { ESIF_DATA_TEMPERATURE, &aux1, sizeof(aux1), 4 };
struct esif_data hyst_response = { ESIF_DATA_TEMPERATURE, &hyst, sizeof(hyst), 4 };
struct esif_data power_response = { ESIF_DATA_POWER, &power, sizeof(power), 4 };
struct esif_data power_limit_response = { ESIF_DATA_POWER, &powerLimit, sizeof(powerLimit), 4 };
struct esif_data_binary_fst_package fanpkg = { 0 };
struct esif_data fan_response = { ESIF_DATA_BINARY, &fanpkg, sizeof(fanpkg), 4 };
domain_ptr = upPtr->fDspPtr->get_domain(upPtr->fDspPtr, j + 1);
if (NULL == domain_ptr) {
continue;
}
if (domain_ptr->capability_for_domain.capability_flags & ESIF_CAPABILITY_TEMP_STATUS) {
if (isHeader) {
esif_ccb_sprintf_concat(MAX_LOG_LINE, logString, "%s_D%d_temp,%s_D%d_aux0,%s_D%d_aux1,%s_D%d_hysteresis,", upPtr->fMetadata.fName, j, upPtr->fMetadata.fName, j, upPtr->fMetadata.fName, j, upPtr->fMetadata.fName, j);
}
else {
rc = EsifExecutePrimitive((u8) participantId, GET_TEMPERATURE, esif_primitive_domain_str(domain_ptr->descriptor.domain, qualifier_str, 32), 255, &request, &temp_response);
LOG_APPEND_VALUE_OR_DEFAULT(rc, temp);
rc = EsifExecutePrimitive((u8) participantId, GET_TEMPERATURE_THRESHOLDS, esif_primitive_domain_str(domain_ptr->descriptor.domain, qualifier_str, 32), 0, &request, &aux0_response);
LOG_APPEND_VALUE_OR_DEFAULT(rc, aux0);
rc = EsifExecutePrimitive((u8) participantId, GET_TEMPERATURE_THRESHOLDS, esif_primitive_domain_str(domain_ptr->descriptor.domain, qualifier_str, 32), 1, &request, &aux1_response);
LOG_APPEND_VALUE_OR_DEFAULT(rc, aux1);
rc = EsifExecutePrimitive((u8) participantId, GET_TEMPERATURE_THRESHOLD_HYSTERESIS, esif_primitive_domain_str(domain_ptr->descriptor.domain, qualifier_str, 32), 255, &request, &hyst_response);
LOG_APPEND_VALUE_OR_DEFAULT(rc, hyst);
}
}
if (domain_ptr->capability_for_domain.capability_flags & ESIF_CAPABILITY_POWER_CONTROL) {
if (isHeader) {
esif_ccb_sprintf_concat(MAX_LOG_LINE, logString, "%s_D%d_power,%s_D%d_powerlimit,", upPtr->fMetadata.fName, j, upPtr->fMetadata.fName, j);
}
else {
rc = EsifExecutePrimitive((u8) participantId, GET_RAPL_POWER, esif_primitive_domain_str(domain_ptr->descriptor.domain, qualifier_str, 32), 255, &request, &power_response);
LOG_APPEND_VALUE_OR_DEFAULT(rc, power);
rc = EsifExecutePrimitive((u8) participantId, GET_RAPL_POWER_LIMIT, esif_primitive_domain_str(domain_ptr->descriptor.domain, qualifier_str, 32), 0, &request, &power_limit_response);
LOG_APPEND_VALUE_OR_DEFAULT(rc, powerLimit);
}
}
if (domain_ptr->capability_for_domain.capability_flags & ESIF_CAPABILITY_ACTIVE_CONTROL) {
if (isHeader) {
esif_ccb_sprintf_concat(MAX_LOG_LINE, logString, "%s_D%d_fanspeed,", upPtr->fMetadata.fName, j);
}
else {
rc = EsifExecutePrimitive((u8) participantId, GET_FAN_STATUS, esif_primitive_domain_str(domain_ptr->descriptor.domain, qualifier_str, 32), 255, &request, &fan_response);
if (rc == ESIF_OK) {
struct esif_data_binary_fst_package *fanPtr = (struct esif_data_binary_fst_package *)fan_response.buf_ptr;
fanspeed = (u32) fanPtr->control.integer.value;
}
LOG_APPEND_VALUE_OR_DEFAULT(rc, fanspeed);
}
}
}
exit:
if (upPtr != NULL) {
EsifUp_PutRef(upPtr);
}
return rc;
}
