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; }