video_in_hal/systemservice/interface_unified/library/include/system_service/ss_power_service.h

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @file ss_power_service.h
  19  * @brief \~english This file supports the Power Service interface.
  20  */
  21 /** @addtogroup BaseSystem
  22  *  @{
  23  */
  24 /** @addtogroup system_service
  25  *  @ingroup BaseSystem
  26  *  @{
  27  */
  28 /** @addtogroup power_service
  29  *  @ingroup system_service
  30  *  @{
  31  */
  32 #ifndef SS_POWER_SERVICE_H_  // NOLINT (build/header_guard)
  33 #define SS_POWER_SERVICE_H_
  34
  35 #include <native_service/frameworkunified_types.h>
  36 #include <map>
  37 #include "system_service/ss_system_types.h"
  38
  39
  40
  41 typedef enum _PwLevelTypes {
  42   epspltUNKNOWN,
  43   epspltWAKEUP = 0x99,
  44   epspltNORMAL,
  45   epspltSHUTDOWN,
  46   epspltEMERGENCY,
  47 } PowerSrvLevelType, EPWR_LEVEL_TYPE;
  48
  49
  50 typedef enum {
  51   epsstUNKNOWN,
  52   epsstBASIC,
  53   epsstSUPERVISOR,
  54   epsstSYSTEM,
  55 } PowerSrvSessionType, EPWR_SESSION_TYPE;
  56
  57
  58 typedef enum {
  59   epscnINVALID     = 0xFF,
  60   epscnCANWAKEUP   = 0x07,  //< All modules up with Display Off and Audio Muted
  61   epscnCANSLEEP    = 0x08,  //< Communication and all modules shut down
  62 } ePowerSrvCANStates, EPWR_CAN_STATE_TYPE;
  63
  64
  65
  66 // Not in use for PastModel003*1. Can be used for Platform
  67 typedef enum {
  68   epswlINVALID     = 0xFF,
  69   epswlFULLRUN     = 0x0A,  //< Normal ignition on and full wakeup
  70   epswlLOCALWAKEUP = 0x0B,  //< Only certain modules are up.
  71 } ePowerSrvWakeupLevels, EPWR_WAKEUP_LEVEL_TYPE;
  72
  73 typedef EPWR_WAKEUP_LEVEL_TYPE * PEPWR_WAKEUP_LEVEL_TYPE;
  74
  75 typedef enum {
  76   epswsINVALID     = 0xFF,
  77   epswsPWRON       = 0x00,  //< Enable Display and Audio
  78   epswsPWROFF      = 0x01,  //< Disable Audio and HMI
  79 } ePowerSrvPowerStates, EPWR_POWER_STATE_TYPE;
  80
  81
  82 typedef enum {
  83   epsvsINVALID    = 0xFF,
  84   epsvsNORMAL     = 0x20,
  85   epsvsLVI1       = 0x22,
  86   epsvsLVI2       = 0x24,
  87 } ePowerSrvVoltageStates, EPWR_VOLTAGE_STATE_TYPE;
  88
  89 typedef EPWR_VOLTAGE_STATE_TYPE * PEPWR_VOLTAGE_STATE_TYPE;
  90
  91 typedef enum {
  92   epscsINVALID    = 0xFF,
  93   epscsENTRY      = 0xA0,
  94   epscsEXIT       = 0xA2,
  95 } ePowerSrvCrankStates, EPWR_CRANK_STATE_TYPE;
  96
  97
  98 //******************************************************************************
  99 //  Startup Reason / EPWR_WAKEUP_FACTOR_TYPE typedefs                          *
 100 //                                                                             *
 101 /**
 102  * \~english
 103  */
 104 typedef enum {
 105   epswfINVALID         = 0xFF,  //!< \~english
 106   epswfTESTACC         = 0x00,  //!< \~english
 107   epswfON_KEY          = 0x01,  //!< \~english
 108   epswfIGN_ACC         = 0x02,  //!< \~english
 109   epswfDR_OPEN_CLOSE   = 0x03,  //!< \~english
 110   epswfDX_ACTIVATION   = 0x04,  //!< \~english
 111   epswfPASS_ACTIVATION = 0x05,  //!< \~english
 112   epswfSPVACTIVATION   = 0x06,  //!< \~english
 113   epswfUSER_DATA_RESET = 0x07   //!< \~english
 114 //
 115 //  Carry-over enums from CCR
 116 //
 117 //  epswfPWRBUTTONON    = 0x0C,
 118 //  epswfIGNON       = 0x0D,
 119 //  epswfDISCEJECT      = 0x0F,
 120 //  epswfSHOWTIME     = 0x11,
 121 //  epswfPHONECALL     = 0x12,
 122 //
 123 //  End of Carry-over enums from CCR
 124 //
 125 } ePowerSrvWakeupFactors, EPWR_WAKEUP_FACTOR_TYPE;
 126 typedef EPWR_WAKEUP_FACTOR_TYPE * PEPWR_WAKEUP_FACTOR_TYPE;
 127 //                                                                             *
 128 //  End of Startup Reason / EPWR_WAKEUP_FACTOR_TYPE                            *
 129 //******************************************************************************
 130
 131 //****************************************************************************
 132 // Shutdown Popup Protocol enums & typedefs                                  *
 133 //                                                                           *
 134 typedef enum {                                                            // *
 135   epsspPowerSave1        = 0x00,                                          // *
 136   epsspPowerSave2        = 0x01,                                          // *
 137   epsspPowerSave3        = 0x02,                                          // *
 138   epsspPowerSaveClr      = 0x03,                                          // *
 139   epsspLowVoltage1       = 0x04,                                          // *
 140   epsspLowVoltage2       = 0x05,                                          // *
 141   epsspLowVoltage3       = 0x06,                                          // *
 142   epsspLowVoltageClr     = 0x07,                                          // *
 143   epsspBattCouplingSW1   = 0x08,                                          // *
 144   epsspBattCouplingSW2   = 0x09,                                          // *
 145   epsspBattCouplingSW3   = 0x0A,                                          // *
 146   epsspBattCouplingSWClr = 0x0B,                                          // *
 147   epsspAbnormalTemp_1st  = 0x0C,                                          // *
 148   epsspAbnormalTemp_Clr  = 0x0D,                                          // *
 149   epsspLimpHome_1st      = 0x0E,                                          // *
 150   epsspLimpHome_2nd      = 0x0F,                                          // *
 151   epsspLimpHome_3rd      = 0x10,                                          // *
 152   epsspLimpHome_Clr      = 0x11,                                          // *
 153   epsspProdMd_1st        = 0x12,                                          // *
 154   epsspProdMd_Clr        = 0x13,                                          // *
 155   epsspTransMd_1st       = 0x14,                                          // *
 156   epsspTransMd_Clr       = 0x15,                                          // *
 157   epsspAllClr            = 0xFF                                           // *
 158 } ePwrServiceShutdownPopupType, EPWR_SHUTDOWN_POPUP_TYPE;                 // *
 159                                                                           // *
 160 //                                                                           *
 161 // End of Shutdown Condition Protocol enums & typedefs                       *
 162 //****************************************************************************
 163
 164 //****************************************************************************
 165 // CPMShowPowerPopup Protocol enums & typedefs                               *
 166 //                                                                           *
 167 typedef enum {                                                            // *
 168   epssppNormal           = 0x00,                                          // *
 169   epssppCritical         = 0x01,                                          // *
 170   epssppAppCritical      = 0x02,                                          // *
 171   epssppAllClr           = 0xFF                                           // *
 172 } ePwrServicePowerPopupType, EPWR_POWER_POPUP_TYPE;                       // *
 173                                                                           // *
 174 //                                                                           *
 175 // End of CPMShowPowerPopup Protocol enums & typedefs                        *
 176 //****************************************************************************
 177
 178 //****************************************************************************
 179 // Limp Home Cutoff Protocol enums & typedefs                                *
 180 //                                                                           *
 181 typedef enum {                                                            // *
 182   epslhcINVALID   = 0xFF,                                                 // *
 183   epslhcDISABLED  = 0x00,                                                 // *
 184   epslhcENABLED   = 0x01                                                  // *
 185 } ePwrServiceLHCType, EPWR_LHC_TYPE;                                      // *
 186                                                                           // *
 187 //                                                                           *
 188 // End of Limp Home Cutoff Protocol enums & typedefs                         *
 189 //****************************************************************************
 190
 191 //****************************************************************************
 192 // Production Mode Protocol enums & typedefs                                 *
 193 //                                                                           *
 194 typedef enum {                                                            // *
 195   epspmINVALID   = 0xFF,                                                  // *
 196   epspmDISABLED  = 0x00,                                                  // *
 197   epspmENABLED   = 0x01                                                   // *
 198 } ePwrServiceProdModeType, EPWR_PROD_MODE_TYPE;                           // *
 199                                                                           // *
 200 //                                                                           *
 201 // End of Production Mode Protocol enums & typedefs                          *
 202 //****************************************************************************
 203
 204 //****************************************************************************
 205 // Transport Mode Protocol enums & typedefs                                  *
 206 //                                                                           *
 207 typedef enum {                                                            // *
 208   epstmINVALID   = 0xFF,                                                  // *
 209   epstmDISABLED  = 0x00,                                                  // *
 210   epstmENABLED   = 0x01                                                   // *
 211 } ePwrServiceTransportModeType, EPWR_TRANSPORT_MODE_TYPE;                 // *
 212                                                                           // *
 213 //                                                                           *
 214 // End of Transport Mode Protocol enums & typedefs                           *
 215 //****************************************************************************
 216
 217 //****************************************************************************
 218 // Last User Mode, User Mode , User Mode Change Reason Protocol enums &      *
 219 // typedefs                                                                  *
 220 //                                                                           *
 221 /**
 222  * \~english
 223  */
 224 typedef enum {
 225   epsumINVALID    = 0xFF,   //!< \~english
 226   epsumOFF        = 0x00,   //!< \~english
 227   epsumON         = 0x01    //!< \~english
 228 } ePwrServiceUserModeType, EPWR_USER_MODE_TYPE;
 229
 230 /**
 231  * \~english State transition reason.
 232  */
 233 typedef enum {
 234   epsumcrNOT_AVAILABLE  = 0x00,   //!< \~english Not available.
 235   epsumcrON_KEY         = 0x01,   //!< \~english
 236   epsumcrPARKING_B,               //!< \~english Parking(+B) Power state transition.
 237   epsumcrPRE_BA,                  //!< \~english Pre-boot(+BA) Power state transition.
 238   epsumcrNORMAL,                  //!< \~english Normal-boot Power state transition.
 239   epsumcrBACKGROUND_BA,           //!< \~english Background-boot(+BA) Power state transition.
 240 } ePwrServiceUserModeChangeReasonType, EPWR_USER_MODE_CHANGE_REASON_TYPE;
 241                                                                           // *
 242 //                                                                           *
 243 // End of Last User Mode, User Mode Protocol enums & typedefs                *
 244 //****************************************************************************
 245
 246 /**
 247  * \~english
 248  */
 249 typedef struct _upinfo {
 250   EPWR_WAKEUP_LEVEL_TYPE   level;                           //!< \~english
 251   EPWR_WAKEUP_FACTOR_TYPE  factor;                          //!< \~english
 252   EPWR_USER_MODE_CHANGE_REASON_TYPE  userModeChangeReason;  //!< \~english State transition reason.
 253 } upInfo;
 254
 255 /**
 256  * \~english
 257  */
 258 typedef struct _wakeinfo {
 259   EPWR_POWER_STATE_TYPE   powerupType;  //!< \~english
 260   upInfo up;                            //!< \~english
 261 } wakeInfo;
 262
 263 //****************************************************************************
 264 // System Mode Info enums & typedefs                                         *
 265 //                                                                           *
 266 typedef enum {                                                            // *
 267   epssinfINVALID      = 0xFF,                                             // *
 268   epssinfNORMAL       = 0x00,                                             // *
 269   epssinfPROGRAMMING  = 0x08,                                             // *
 270 }ePowerSrvSystemModeInfo, EPWR_SYSTEM_MODE_INFO;                          // *
 271                                                                           // *
 272 typedef enum {                                                            // *
 273   epssusfINVALID                = 0xFF,                                   // *
 274   epssusSYSTEM_SERVICES_STARTED = 0x00,                                   // *
 275   epssusALL_SERVICES_LAUNCHED   = 0x01                                    // *
 276 }ePowerSrvStartupStageType, EPWR_STARTUP_STAGE_TYPE;                      // *
 277                                                                           // *
 278 typedef struct _SystemModeInfo {                                          // *
 279   EPWR_USER_MODE_TYPE      lastUserMode; // NOTE: Don't use this. just only remained for backward compatibility.
 280   EPWR_LHC_TYPE            limpHomeCutoff;                                // *
 281   EPWR_PROD_MODE_TYPE      productionMode;                                // *
 282   EPWR_TRANSPORT_MODE_TYPE transportMode;                                 // *
 283   EPWR_SYSTEM_MODE_INFO    systemMode;                                    // *
 284   EPWR_STARTUP_STAGE_TYPE  startupStage;                                  // *
 285 } SystemModeInfo;                                                         // *
 286 //                                                                           *
 287 // End of System Mode Info enums & typedefs                                  *
 288 //****************************************************************************
 289
 290 //****************************************************************************
 291 // Startup Confirmation enums & typedefs                                     *
 292 //                                                                           *
 293 typedef enum {                                                            // *
 294   eps_CWORD56_bmINVALID          = 0xFF,                                       // *
 295   eps_CWORD56_bmAPPLICATION_MODE = 0x00,                                       // *
 296   eps_CWORD56_bmPROGRAMMING_MODE = 0x08                                        // *
 297 } EPWR_SC__CWORD56__BOOT_MODE_TYPE;                                            // *
 298                                                                           // *
 299 typedef enum {                                                            // *
 300   epsstINVALID     = 0xFF,                                                // *
 301   epsstWARMSTART   = 0x00,                                                // *
 302   epsstCOLDSTART   = 0x01                                                 // *
 303 } EPWR_SC_WAKEUP_TYPE;                                                    // *
 304                                                                           // *
 305 typedef enum {                                                            // *
 306   epsscrtINVALID      = 0xFF,                                             // *
 307   epsscrtNOT_REQUIRED = 0x00,                                             // *
 308   epsscrtREQUIRED     = 0x01                                              // *
 309 } EPWR_SC_COLD_START_REQ_TYPE;                                            // *
 310                                                                           // *
 311 typedef enum {                                                            // *
 312   epsssINVALID = 0xFF,                                                    // *
 313   epsssUNLOCK  = 0x00,                                                    // *
 314   epsssLOCK    = 0x01                                                     // *
 315 } EPWR_SC_SECURITY_STATUS;                                                // *
 316                                                                           // *
 317 typedef struct {                                                          // *
 318   EPWR_SC__CWORD56__BOOT_MODE_TYPE _CWORD56_BootMode;                               // *
 319   EPWR_SC_WAKEUP_TYPE         wakeupType;                                 // *
 320   EPWR_SC_COLD_START_REQ_TYPE coldStartRequest;                           // *
 321   EPWR_SC_SECURITY_STATUS     securityStatus;                             // *
 322   UI_32                       HWVersion;                                  // *
 323   UI_32                       matchedHardwareType;                        // *
 324   UI_32                       softwareType;                               // *
 325   UI_32                       imageType;                                  // *
 326   UI_32                       majorVersion;                               // *
 327   UI_32                       minorVersion;                               // *
 328   UI_32                       SWVersionYear;                              // *
 329   UI_32                       SWVersionWeek;                              // *
 330   UI_32                       SWVersionPatchLevel;                        // *
 331 } StartupConfirmationMsgStrut, EPWR_SC_MSG_STRUCT;                        // *
 332 //                                                                           *
 333 // End of Startup Confirmation enums & typedefs                              *
 334 //****************************************************************************
 335
 336 //****************************************************************************
 337 // Power Request Message enums & typedefs                                    *
 338 //                                                                           *
 339 /**
 340  * _CWORD102_ Startup Information
 341  */
 342 typedef enum {
 343   epsprm_CWORD102_siINVALID                = 0xFF,  //!< \~english
 344   epsprm_CWORD102_si_CWORD102__STARTUP_NORMAL      = 0x00,  //!< Normal Startup
 345   epsprm_CWORD102_si_CWORD102__STARTUP_AFTER_RESET = 0x01   //!< Startup after Irregular Reset
 346 }ePowerSrv_CWORD102_StartupInfoType, EPWR__CWORD102__STARTUP_INFO_TYPE;
 347 /**
 348  * Opening Type
 349  */
 350 typedef enum {
 351   epsprmotINVALID               = 0xFF,   //!< \~english
 352   epsprmotTIMING_TYPE_1         = 0x00,   //!< CI/DI Show timing type1
 353   epsprmotTIMING_TYPE_2         = 0x01    //!< CI/DI Show timing type2
 354 } ePowerSrvPwrReqMsgCIDIOpeningType, EPWR_OPENING_TYPE;
 355 /**
 356  * Manual Reset Information
 357  */
 358 typedef enum {
 359   epsprmriINVALID               = 0xFF,   //!< \~english
 360   epsprmriNORMAL                = 0x00,   //!< \~english
 361   epsprmriWAKEUP_AFTER_RESET    = 0x01    //!< \~english
 362 } ePowerSrvPwrManResetInfoType, EPWR_MAN_RESET_INFO_TYPE;
 363 /**
 364  * Last System Retention Request
 365  */
 366 typedef enum {
 367   epsprlsrrINVALID               = 0xFF,  //!< \~english
 368   epsprlsrrLAST_SYSTEM_OFF       = 0x00,  //!< \~english
 369   epsprlsrrLAST_SYSTEM_ON        = 0x01   //!< \~english
 370 } ePowerSrvTypeLastSysRetReq, EPWR_LAST_SYS_RET_REQ_TYPE;
 371
 372 // *
 373 typedef struct {                                                          // *
 374   EPWR__CWORD102__STARTUP_INFO_TYPE          startupType;                         // *
 375   EPWR_OPENING_TYPE                  openingType;                         // *
 376   EPWR_WAKEUP_FACTOR_TYPE            startupReason;                       // *
 377   EPWR_USER_MODE_TYPE                lastUserMode;                        // *
 378   EPWR_MAN_RESET_INFO_TYPE           manResetInfo;                        // *
 379   EPWR_LAST_SYS_RET_REQ_TYPE         lastSystemRetentionReq;              // *
 380   EPWR_USER_MODE_TYPE                userMode;                            // *
 381 } PowerRequestMsgStrut, EPWR_POWER_REQUEST_MSG_STRUCT;                    // *
 382
 383 /**
 384  * \~english structure for power request message
 385  */
 386 typedef struct {
 387   EPWR__CWORD102__STARTUP_INFO_TYPE          startupType;             //!< \~english
 388   EPWR_OPENING_TYPE                  openingType;             //!< \~english
 389   EPWR_WAKEUP_FACTOR_TYPE            startupReason;           //!< \~english
 390   EPWR_USER_MODE_TYPE                lastUserMode;            //!< \~english
 391   EPWR_MAN_RESET_INFO_TYPE           manResetInfo;            //!< \~english
 392   EPWR_LAST_SYS_RET_REQ_TYPE         lastSystemRetentionReq;  //!< \~english
 393   EPWR_USER_MODE_TYPE                userMode;                //!< \~english
 394   EPWR_USER_MODE_CHANGE_REASON_TYPE  userModeChangeReason;    //!< \~english State transition reason.
 395 } PowerRequestMsgStrutWithUMCR, EPWR_POWER_REQUEST_MSG_STRUCT_WITH_UMCR;
 396 //                                                                           *
 397 // End of Power Request Message enums & typedefs                             *
 398 //****************************************************************************
 399
 400
 401
 402 //****************************************************************************
 403 // Shutdown Request Message enums & typedefs                                 *
 404 //                                                                           *
 405 //  ONS                                                                      *
 406 //                                                                           *
 407 typedef enum {                                                            // *
 408   epssdmonsINVALID             = 0xFF,                                    // *
 409   epssdmonsNO_ONS              = 0x00,                                    // *
 410   epssdmonsONS                 = 0x01                                     // *
 411 } ePowerSrvONSType, EPWR_ONS_TYPE;                                        // *
 412 //                                                                           *
 413 //  Shutdown Trigger                                                         *
 414 //                                                                           *
 415 typedef enum {                                                            // *
 416   epssdmsdtINVALID             = 0xFF,                                    // *
 417   epssdmsdtTESTACC_OFF         = 0x00,                                    // *
 418   epssdmsdtON_KEY              = 0x01,                                    // *
 419   epssdmsdtIGN_LOCK            = 0x02,                                    // *
 420   epssdmsdtPWR_SAVE            = 0x03,                                    // *
 421   epssdmsdtTMP_STARTUP         = 0x04,                                    // *
 422   epssdmsdtDIAG_DEACTIVATION   = 0x05,                                    // *
 423   epssdmsdtABNORMAL_VOLTAGE    = 0x06,                                    // *
 424   epssdmsdtABNORMAL_TEMP       = 0x07,                                    // *
 425   epssdmsdtBATTERYCUTOFF       = 0x08,                                    // *
 426   epssdmsdtLIMPHOME            = 0x09,                                    // *
 427   epssdmsdtHU_CAN_ERROR        = 0x0A,                                    // *
 428   epssdmsdtBODY_CAN_ERROR      = 0x0B,                                    // *
 429   epssdmsdtTRANSPORT_MODE      = 0x0C,                                    // *
 430   epssdmsdtPRODUCTION_MODE     = 0x0D,                                    // *
 431   epssdmsdtIGN_OFF             = 0x0E,                                    // *
 432   epssdmsdtGENERIC_ERROR_RESET = 0x0F,                                    // *
 433   epssdmsdtFATAL_ERROR_RESET   = 0x10,                                    // *
 434   epssdmsdtUSER_DATA_RESET     = 0x11,                                    // *
 435   epssdmsdtFACTORY_DATA_RESET  = 0x12,                                    // *
 436   epssdmsdtFAST_SLEEP_MODE     = 0x13,                                    // *
 437   epssdmsdtNORMAL_RESET        = 0x14,                                    // *
 438   epssdmsdtPROGUPDATE_RESET    = 0x15,      // cannot use this
 439     //                                                                       *
 440     // Note to self: Make sure to update all enum-to-enum and                *
 441     // enum-to-string maps when changing these enums !                       *
 442 } ePowerSrvPwrShutdownTriggerType, EPWR_SHUTDOWN_TRIGGER_TYPE;            // *
 443 //                                                                           *
 444 typedef struct {                                                          // *
 445   EPWR_ONS_TYPE                  ONS_Type;                                // *
 446   EPWR_SHUTDOWN_TRIGGER_TYPE     shutdownTrigger;                         // *
 447   EPWR_USER_MODE_TYPE            lastUserMode;                            // *
 448   EPWR_TRANSPORT_MODE_TYPE       transportMode;                           // *
 449   EPWR_PROD_MODE_TYPE            productionMode;                          // *
 450   EPWR_LHC_TYPE                  limpHomeCutoffRequest;                   // *
 451 } ShutdownRequestMsgStrut, EPWR_SHUTDOWN_REQUEST_MSG_STRUCT;              // *
 452 //                                                                           *
 453 // End of Shutdown Request Message enums & typedefs                          *
 454 //****************************************************************************
 455
 456 //****************************************************************************
 457 // HeartBeat enums & typedefs                                                *
 458 //                                                                           *
 459 // HeartBeat Request Message                                                 *
 460 typedef struct {                                                          // *
 461   UI_8  IntervalSec;                                                      // *
 462 } EPWR_HB_REQ_MSG_STRUCT;                                                 // *
 463 //                                                                           *
 464 // HeartBeat Response Message                                                *
 465 // Zero byte data message returned.                                          *
 466 // End of HeartBeat enums & typedefs                                         *
 467 //****************************************************************************
 468
 469 //****************************************************************************
 470 // CPU Reset Reason enums & typedefs                                         *
 471 typedef  enum {                                                           // *
 472     epsCpuResetReasonGeneric = 0                                          // *
 473   , epsCpuResetReasonFatalError                                           // *
 474   , epsCpuResetReasonUserDataReset                                        // *
 475   , epsCpuResetReasonFactoryDataReset                                     // *
 476   , epsCpuResetReasonUserForceReset                                       // *
 477   , epsCpuResetReasonShipmentModeReset                                    // *
 478   , epsCpuResetReasonHeadUnitReset                                        // *
 479   , epsCpuResetReasonNormalReset                                          // *
 480   , epsCpuResetReasonProgupdateReset    // cannot use this
 481 } epsCpuResetReason;                                                      // *
 482 //
 483 typedef struct {
 484 #define PWR_RESET_MSG_STR_SIZE 32
 485     epsCpuResetReason resetReason;                                        // *
 486     CHAR              messageStr[PWR_RESET_MSG_STR_SIZE];                 // *
 487 } SS_Pwr_CpuResetMsgStruct;
 488 //                                                                           *
 489 // End of CPU Reset Reason enums & typedefs                                  *
 490 //****************************************************************************
 491
 492 typedef struct {
 493   union _data {
 494     wakeInfo wake;
 495
 496     struct _crank {
 497       EPWR_CRANK_STATE_TYPE   state;
 498     }crank;
 499
 500     struct _voltage {
 501       EPWR_VOLTAGE_STATE_TYPE state;
 502     }voltage;
 503
 504     struct _ws_complete {
 505       EPWR_WAKEUP_LEVEL_TYPE   level;
 506       EPWR_WAKEUP_FACTOR_TYPE  factor;
 507     }wk_shdwn_complete;
 508
 509     struct _commwake {
 510       EPWR_CAN_STATE_TYPE   state;
 511     }commwake;
 512
 513     struct _UserMode {
 514       EPWR_USER_MODE_TYPE    mode;
 515     } user_mode;
 516
 517     struct _ShutdownPopup {
 518       EPWR_SHUTDOWN_POPUP_TYPE shutdownPopupEvent;
 519     } shutdownPopup;
 520
 521     struct _PowerPopup {
 522       EPWR_POWER_POPUP_TYPE  powerPopupEvent;
 523     } powerPopup;
 524
 525     StartupConfirmationMsgStrut  startupConfirmationMsg;
 526     PowerRequestMsgStrutWithUMCR powerRequestMsg;
 527     ShutdownRequestMsgStrut      shutdownRequestMsg;
 528   }data;
 529 } Pwr_ServiceSetInterface;
 530
 531 #endif /* SS_POWER_SERVICE_H_ */  // NOLINT (build/header_guard)
 532
 533 /** @}*/  // end of power_service
 534 /** @}*/  // end of system_service
 535 /** @}*/  // end of BaseSystem