X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=service%2Fsystem%2Finterface_unified%2Flibrary%2Fsrc%2Fss_pwrsvc_if.cpp;fp=service%2Fsystem%2Finterface_unified%2Flibrary%2Fsrc%2Fss_pwrsvc_if.cpp;h=86d8ebbe705afb084fbcd02c1ea28ba7dcaf8a74;hb=17cf21bcf8a2e29d2cbcf0a313474d2a4ee44f5d;hp=0000000000000000000000000000000000000000;hpb=9e86046cdb356913ae026f616e5bf17f6f238aa5;p=staging%2Fbasesystem.git diff --git a/service/system/interface_unified/library/src/ss_pwrsvc_if.cpp b/service/system/interface_unified/library/src/ss_pwrsvc_if.cpp new file mode 100755 index 0000000..86d8ebb --- /dev/null +++ b/service/system/interface_unified/library/src/ss_pwrsvc_if.cpp @@ -0,0 +1,343 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_PowerServiceIf +/// \brief This file supports the Power Service module interface. +/// +/////////////////////////////////////////////////////////////////////////////// +#include "system_service/ss_power_service_if.h" +#include +#include +#include +#include +#include +#include "system_service/ss_power_service.h" +#include "system_service/ss_power_service_protocol.h" +#include "system_service/ss_power_service_notifications.h" +#include "system_service/ss_system_if.h" +#include "system_service/ss_services.h" +#include "system_service/ss_string_maps.h" +#include "system_service/ss_templates.h" +#include "ss_power_if_interfaceunifiedlog.h" + +HANDLE OpenPowerService(HANDLE f_hApp) { + EFrameworkunifiedStatus l_eStatus; + HANDLE l_hService = NULL; + if (NULL == f_hApp) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_App"); + } else if (NULL == (l_hService = FrameworkunifiedOpenService(f_hApp, SERVICE_POWER))) { + l_eStatus = eFrameworkunifiedStatusNullPointer; + LOG_ERROR("FrameworkunifiedOpenService(f_hApp, SERVICE_POWER)"); + } + return l_hService; +} + +EFrameworkunifiedStatus ClosePowerService(HANDLE f_hApp, HANDLE f_hService) { + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hApp) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_App"); + } else if (NULL == f_hService) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hService"); + } else { + l_eStatus = FrameworkunifiedCloseService(f_hApp, f_hService); + LOG_STATUS(l_eStatus, "FrameworkunifiedCloseService(f_hApp, f_hService)"); + f_hService = NULL; + } + return l_eStatus; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////// +/// Session Related Requests +/// Any client can also use FrameworkunifiedOpenSession and FrameworkunifiedOpenSessionWithData. +/// In that case, the PVOID data passed as a parameter should be MM_OpenSessionRequestIf +/// to open a session with the Power Service. +/// The client can also use the below API for Opening a session with Power Service. +/////////////////////////////////////////////////////////////////////////////////////////////////// + +EFrameworkunifiedStatus PwrServiceOpenSessionRequest(HANDLE f_hService, + EPWR_SESSION_TYPE f_eSessionType) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + + if (NULL == f_hService) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hService"); + } else if (epsstUNKNOWN == f_eSessionType) { + l_eStatus = eFrameworkunifiedStatusInvldParam; + LOG_ERROR("epsstUNKNOWN == f_eSessionType"); + } else { + l_eStatus = FrameworkunifiedOpenSessionWithData(f_hService, &f_eSessionType, + sizeof(f_eSessionType)); + LOG_STATUS(l_eStatus, "FrameworkunifiedOpenSessionWithData()"); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus PwrServiceCloseSessionRequest(HANDLE f_hService, HANDLE f_hSession) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + + if (NULL == f_hService) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hService"); + } else if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + CALL_AND_LOG_STATUS(FrameworkunifiedCloseSession(f_hService, f_hSession)); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus PwrServiceDecodeOpenSessionResponse(HANDLE f_hApp, + HANDLE& f_hSession) { // NOLINT (runtime/references) + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK; + + if (NULL == f_hApp) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_App"); + } else { + if (NULL == (f_hSession = FrameworkunifiedGetOpenSessionHandle(f_hApp))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: FrameworkunifiedGetOpenSessionHandle('%s') returned NULL", + FrameworkunifiedGetAppName(f_hApp)); + l_eStatus = eFrameworkunifiedStatusNullPointer; + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus PwrServiceSetVoltageState(HANDLE f_hSession, + EPWR_VOLTAGE_STATE_TYPE f_eVoltage_state) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else if (epsvsINVALID == f_eVoltage_state) { + l_eStatus = eFrameworkunifiedStatusInvldParam; + LOG_ERROR("epsvsINVALID == f_eVoltage_state"); + } else { + Pwr_ServiceSetInterface l_tServiceSetIf; + std::memset(&l_tServiceSetIf, 0, sizeof(l_tServiceSetIf)); + l_tServiceSetIf.data.voltage.state = f_eVoltage_state; + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_VOLTAGE_STATE, + sizeof(l_tServiceSetIf), (PVOID) &l_tServiceSetIf); + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_POWER_VOLTAGE_STATE)"); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus PwrServiceSetCrankState(HANDLE f_hSession, + EPWR_CRANK_STATE_TYPE f_eCrank_state) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else if (epscsINVALID == f_eCrank_state) { + l_eStatus = eFrameworkunifiedStatusInvldParam; + LOG_ERROR("epsvsINVALID == f_eCrank_state"); + } else { + Pwr_ServiceSetInterface l_tServiceSetIf; + std::memset(&l_tServiceSetIf, 0, sizeof(l_tServiceSetIf)); + l_tServiceSetIf.data.crank.state = f_eCrank_state; + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_CRANK_STATE, + sizeof(l_tServiceSetIf), (PVOID) &l_tServiceSetIf); + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_POWER_CRANK_STATE)"); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus PwrServiceSendShutdownRequest( + HANDLE f_hSession, EPWR_SHUTDOWN_REQUEST_MSG_STRUCT &f_eState) { // NOLINT (runtime/references) + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + Pwr_ServiceSetInterface l_tServiceSetIf; + std::memset(&l_tServiceSetIf, 0, sizeof(l_tServiceSetIf)); + l_tServiceSetIf.data.shutdownRequestMsg = f_eState; + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_SHUTDOWN_REQUEST_MSG, + sizeof(l_tServiceSetIf), &l_tServiceSetIf); + + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_POWER_SHUTDOWN_REQUEST_MSG)"); + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus PwrServiceSendShutdownRequest( + +EFrameworkunifiedStatus PwrServiceSendSetShutdownPopupRequest( + HANDLE f_hSession, EPWR_SHUTDOWN_POPUP_TYPE f_eShutdownPopup) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + Pwr_ServiceSetInterface l_tServiceSetIf; + std::memset(&l_tServiceSetIf, 0, sizeof(l_tServiceSetIf)); + switch (f_eShutdownPopup) { + case epsspPowerSave1: + case epsspPowerSave2: + case epsspPowerSave3: + case epsspPowerSaveClr: + case epsspLowVoltage1: + case epsspLowVoltage2: + case epsspLowVoltage3: + case epsspLowVoltageClr: + case epsspBattCouplingSW1: + case epsspBattCouplingSW2: + case epsspBattCouplingSW3: + case epsspBattCouplingSWClr: + case epsspAbnormalTemp_1st: + case epsspAbnormalTemp_Clr: + case epsspLimpHome_1st: + case epsspLimpHome_2nd: + case epsspLimpHome_3rd: + case epsspLimpHome_Clr: + case epsspProdMd_1st: + case epsspProdMd_Clr: + case epsspTransMd_1st: + case epsspTransMd_Clr: + case epsspAllClr: + l_tServiceSetIf.data.shutdownPopup.shutdownPopupEvent = + f_eShutdownPopup; + l_eStatus = FrameworkunifiedSendMsg(f_hSession, + SS_POWER_PUBLISH_SHUTDOWN_CONDITION_REQ, + sizeof(l_tServiceSetIf), &l_tServiceSetIf); + LOG_STATUS(l_eStatus, + "FrameworkunifiedSendMsg(SS_POWER_PUBLISH_SHUTDOWN_CONDITION_REQ)"); + break; + + default: + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: Unknown 'ShutdownPopup' value: 0x%X/%d", + f_eShutdownPopup, f_eShutdownPopup); + l_eStatus = eFrameworkunifiedStatusInvldParam; + break; + } + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus PwrServiceSendSetShutdownPopupRequest( HANDLE f_hSession, + +EFrameworkunifiedStatus PwrServiceSendStartupConfirmationMsgRequest( + HANDLE f_hSession, EPWR_SC_MSG_STRUCT f_eState) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + Pwr_ServiceSetInterface l_tServiceSetIf; + std::memset(&l_tServiceSetIf, 0, sizeof(l_tServiceSetIf)); + l_tServiceSetIf.data.startupConfirmationMsg = f_eState; + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_FWD_START_CONFIRMATION_MSG_REQ, + sizeof(l_tServiceSetIf), &l_tServiceSetIf); + + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_POWER_FWD_START_CONFIRMATION_MSG_REQ)"); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus PwrServiceSendStartupConfirmationMsgRequest ( HANDLE f_hSession, + +EFrameworkunifiedStatus PwrServiceSystemModeInfoRequest(HANDLE f_hSession) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_SYSTEM_MODE_INFO_REQ, 0, NULL); + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_POWER_SYSTEM_MODE_INFO_REQ)"); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus PwrServiceSendInitCompReport(HANDLE f_hSession) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_INITCOMP_REP, 0, NULL); + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_POWER_INITCOMP_REP)"); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} + +EFrameworkunifiedStatus PwrServiceSendPowerRequest( + HANDLE f_hSession, EPWR_POWER_REQUEST_MSG_STRUCT_WITH_UMCR &f_eState) { // NOLINT (runtime/references) + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + Pwr_ServiceSetInterface l_tServiceSetIf; + std::memset(&l_tServiceSetIf, 0, sizeof(l_tServiceSetIf)); + l_tServiceSetIf.data.powerRequestMsg = f_eState; + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_POWER_REQUEST_MSG, + sizeof(l_tServiceSetIf), (PVOID) &l_tServiceSetIf); + + char l_cBuf[200] = { 0 }; + snprintf( + l_cBuf, + sizeof(l_cBuf), + "FrameworkunifiedSendMsg(SS_POWER_POWER_REQUEST_MSG(%s, %s))", + GetStr(l_tServiceSetIf.data.powerRequestMsg.userMode).c_str(), + GetStr(l_tServiceSetIf.data.powerRequestMsg.userModeChangeReason).c_str()); + LOG_STATUS(l_eStatus, l_cBuf); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // End of EFrameworkunifiedStatus PwrServiceSendPowerRequest( HANDLE f_hSession + +EFrameworkunifiedStatus PwrServiceSendHeartBeatRequest(HANDLE f_hSession, + EPWR_HB_REQ_MSG_STRUCT *f_eHbReqMsg) { + FRAMEWORKUNIFIEDLOG0(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus l_eStatus; + if (NULL == f_hSession) { + l_eStatus = eFrameworkunifiedStatusInvldHandle; + LOG_ERROR("NULL == f_hSession"); + } else { + l_eStatus = FrameworkunifiedSendMsg(f_hSession, SS_POWER_HEARTBEAT_REQ, + sizeof(EPWR_HB_REQ_MSG_STRUCT), + reinterpret_cast(f_eHbReqMsg)); + LOG_STATUS(l_eStatus, "FrameworkunifiedSendMsg(SS_POWER_HEARTBEAT_REQ)"); + } + FRAMEWORKUNIFIEDLOG0(ZONE_FUNC, __FUNCTION__, "-"); + return l_eStatus; +} // LCOV_EXCL_BR_LINE 10:Because the last line