/*============================================================================== @file HAP_power.h @brief Header file of DSP power APIs. Copyright (c) 2015,2019 Qualcomm Technologies, Inc. All rights reserved. Qualcomm Proprietary and Confidential. ==============================================================================*/ #ifndef _HAP_POWER_H #define _HAP_POWER_H #include "AEEStdErr.h" //#include //#include #define boolean char #define FALSE 0 #define TRUE 1 #define uint64 unsigned long long #define uint32 unsigned int #define NULL 0 #ifdef __cplusplus extern "C" { #endif //Add a weak reference so shared objects do not throw link error #pragma weak HAP_power_destroy_client /** * Possible error codes returned */ typedef enum { HAP_POWER_ERR_UNKNOWN = -1, HAP_POWER_ERR_INVALID_PARAM = -2, HAP_POWER_ERR_UNSUPPORTED_API = -3 } HAP_power_error_codes; /** Payload for HAP_power_set_mips_bw */ typedef struct { boolean set_mips; /**< Set to TRUE to request MIPS */ unsigned int mipsPerThread; /**< mips requested per thread, to establish a minimal clock frequency per HW thread */ unsigned int mipsTotal; /**< Total mips requested, to establish total number of MIPS required across all HW threads */ boolean set_bus_bw; /**< Set to TRUE to request bus_bw */ uint64 bwBytePerSec; /**< Max bus BW requested (bytes per second) */ unsigned short busbwUsagePercentage; /**< Percentage of time during which bwBytesPerSec BW is required from the bus (0..100) */ boolean set_latency; /**< Set to TRUE to set latency */ int latency; /**< maximum hardware wakeup latency in microseconds. The higher the value, * the deeper state of sleep that can be entered but the longer it may take * to awaken. Only values > 0 are supported (1 microsecond is the smallest valid value) */ } HAP_power_mips_bw_payload; /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** Clock frequency match type*/ typedef enum { HAP_FREQ_AT_LEAST, /**< Matches at least the specified frequency. */ HAP_FREQ_AT_MOST, /**< Matches at most the specified frequency. */ HAP_FREQ_CLOSEST, /**< Closest match to the specified frequency. */ HAP_FREQ_EXACT, /**< Exact match with the specified frequency. */ HAP_FREQ_MAX_COUNT /**< Maximum count. */ } HAP_freq_match_type; /** * @} // HAP_power_enums */ /** Configuration for bus bandwidth */ typedef struct { boolean set_bus_bw; /**< Set to TRUE to request bus_bw */ uint64 bwBytePerSec; /**< Max bus BW requested (bytes per second) */ unsigned short busbwUsagePercentage; /**< Percentage of time during which bwBytesPerSec BW is required from the bus (0..100) */ } HAP_power_bus_bw; /** * @brief Payload for vapps power request * vapps core is used for Video post processing */ typedef struct { boolean set_clk; /**< Set to TRUE to request clock frequency */ unsigned int clkFreqHz; /**< Clock frequency in Hz */ HAP_freq_match_type freqMatch; /**< Clock frequency match */ HAP_power_bus_bw dma_ext; /**< DMA external bus bandwidth */ HAP_power_bus_bw hcp_ext; /**< HCP external bus bandwidth */ HAP_power_bus_bw dma_int; /**< DMA internal bus bandwidth */ HAP_power_bus_bw hcp_int; /**< HCP internal bus bandwidth */ } HAP_power_vapss_payload; /** * @brief Payload for vapps_v2 power request * Supported in targets which have split VAPPS core(DMA and HCP) form Hana onwards */ typedef struct { boolean set_dma_clk; /**< Set to TRUE to reqeust DMA clock frequency */ boolean set_hcp_clk; /**< Set to TRUE to reqeust HCP clock frequency */ unsigned int dmaClkFreqHz; /**< DMA Clock frequency in Hz */ unsigned int hcpClkFreqHz; /**< HCP Clock frequency in Hz */ HAP_freq_match_type freqMatch; /**< Clock frequency match type */ HAP_power_bus_bw dma_ext; /**< DMA external bus bandwidth */ HAP_power_bus_bw hcp_ext; /**< HCP external bus bandwidth */ HAP_power_bus_bw dma_int; /**< DMA internal bus bandwidth */ HAP_power_bus_bw hcp_int; /**< HCP internal bus bandwidth */ } HAP_power_vapss_payload_v2; /** Payload for HAP_power_set_HVX */ typedef struct { boolean power_up; /**< Set to TRUE to turn on HVX, and FALSE to turn off. */ } HAP_power_hvx_payload; /** * Payload for HAP_power_set_HMX * Supported from Lahaina onwards*/ typedef struct { boolean power_up; /**< Set to TRUE to turn on HMX, and FALSE to turn off. */ } HAP_power_hmx_payload; /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** Payload for HAP power client classes */ typedef enum { HAP_POWER_UNKNOWN_CLIENT_CLASS = 0x00, /**< Unknown client class */ HAP_POWER_AUDIO_CLIENT_CLASS = 0x01, /**< Audio client class */ HAP_POWER_VOICE_CLIENT_CLASS = 0x02, /**< Voice client class */ HAP_POWER_COMPUTE_CLIENT_CLASS = 0x04, /**< Compute client class */ HAP_POWER_STREAMING_1HVX_CLIENT_CLASS = 0x08, /**< Camera streaming with 1 HVX client class */ HAP_POWER_STREAMING_2HVX_CLIENT_CLASS = 0x10, /**< Camera streaming with 2 HVX client class */ } HAP_power_app_type_payload; /** * @} // HAP_power_enums */ /** Payload for HAP_power_set_linelock */ typedef struct { void* startAddress; /**< Start address of the memory region to be locked. */ uint32 size; /**< Size (bytes) of the memory region to be locked. Set size * to 0 to unlock memory. */ uint32 throttleBlockSize; /**< Block size for throttling, in bytes; * 0 for no throttling. The region to be locked will be divided into * blocks of this size for throttling purposes. * Use for locking larger cache blocks. * Applicable only when enabling line locking.Only ONE throttled linelock call is supported at this time. * You can linelock additional regions (without throttling) using HAP_power_set_linelock_nothrottle*/ uint32 throttlePauseUs; /**< Pause to be applied between locking each block, in microseconds. Applicable only when enabling line locking*/ } HAP_power_linelock_payload; /** Payload for HAP_power_set_linelock_nothrottle */ typedef struct { void* startAddress; /**< Start address of the memory region to be locked. */ uint32 size; /**< Size (bytes) of the memory region to be locked. Set size to 0 * to unlock memory */ } HAP_power_linelock_nothrottle_payload; /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** Option for dcvs payload */ typedef enum { HAP_DCVS_ADJUST_UP_DOWN = 0x1, /**< increase and decrease core/bus clock speed. */ HAP_DCVS_ADJUST_ONLY_UP = 0x2, /**< restricts DCVS from lowering the clock speed below the requested value . */ } HAP_power_dcvs_payload_option; /** * @} // HAP_power_enums */ /** Payload for HAP_power_set_DCVS */ typedef struct { boolean dcvs_enable; /**< Set to TRUE to participate in DCVS, and FALSE otherwise. */ HAP_power_dcvs_payload_option dcvs_option; /**< Set to one of * HAP_DCVS_ADJUST_UP_DOWN - Allows for DCVS to adjust up and down. * HAP_DCVS_ADJUST_ONLY_UP - Allows for DCVS to adjust up only. */ } HAP_power_dcvs_payload; /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** Voltage corners for HAP DCVS V2 interface */ typedef enum { HAP_DCVS_VCORNER_DISABLE, HAP_DCVS_VCORNER_SVS2, HAP_DCVS_VCORNER_SVS, HAP_DCVS_VCORNER_SVS_PLUS, HAP_DCVS_VCORNER_NOM, HAP_DCVS_VCORNER_NOM_PLUS, HAP_DCVS_VCORNER_TURBO, HAP_DCVS_VCORNER_TURBO_PLUS, HAP_DCVS_VCORNER_MAX = 255, } HAP_dcvs_voltage_corner_t; /** * @} // HAP_power_enums */ #define HAP_DCVS_VCORNER_SVSPLUS HAP_DCVS_VCORNER_SVS_PLUS #define HAP_DCVS_VCORNER_NOMPLUS HAP_DCVS_VCORNER_NOM_PLUS /** DCVS parameters for HAP_power_dcvs_v2_payload */ typedef struct { HAP_dcvs_voltage_corner_t target_corner; /**< target voltage corner */ HAP_dcvs_voltage_corner_t min_corner; /**< minimum voltage corner */ HAP_dcvs_voltage_corner_t max_corner; /**< maximum voltage corner */ uint32 param1; /**< reserved */ uint32 param2; /**< reserved */ uint32 param3; /**< reserved */ } HAP_dcvs_params_t; /** Core clock parameters for HAP_power_dcvs_v3_payload */ typedef struct { HAP_dcvs_voltage_corner_t target_corner; /**< target voltage corner */ HAP_dcvs_voltage_corner_t min_corner; /**< minimum voltage corner */ HAP_dcvs_voltage_corner_t max_corner; /**< maximum voltage corner */ uint32 param1; /**< reserved */ uint32 param2; /**< reserved */ uint32 param3; /**< reserved */ } HAP_core_params_t; /** Bus clock parameters for HAP_power_dcvs_v3_payload */ typedef struct { HAP_dcvs_voltage_corner_t target_corner; /**< target voltage corner */ HAP_dcvs_voltage_corner_t min_corner; /**< minimum voltage corner */ HAP_dcvs_voltage_corner_t max_corner; /**< maximum voltage corner */ uint32 param1; /**< reserved */ uint32 param2; /**< reserved */ uint32 param3; /**< reserved */ } HAP_bus_params_t; /** DCVS v3 parameters for HAP_power_dcvs_v3_payload */ typedef struct { uint32 param1; /**< reserved */ uint32 param2; /**< reserved */ uint32 param3; /**< reserved */ uint32 param4; /**< reserved */ uint32 param5; /**< reserved */ uint32 param6; /**< reserved */ } HAP_dcvs_v3_params_t; /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** option for dcvs_v2 payload */ typedef enum { HAP_DCVS_V2_ADJUST_UP_DOWN = 0x1, /**< Allows for DCVS to adjust up and down. */ HAP_DCVS_V2_ADJUST_ONLY_UP = 0x2, /**< Allows for DCVS to adjust up only. */ HAP_DCVS_V2_POWER_SAVER_MODE = 0x4, /**< HAP_DCVS_POWER_SAVER_MODE - Higher thresholds for power efficiency. */ HAP_DCVS_V2_POWER_SAVER_AGGRESSIVE_MODE = 0x8, /**< HAP_DCVS_POWER_SAVER_AGGRESSIVE_MODE - Higher thresholds for power efficiency with faster ramp down. */ HAP_DCVS_V2_PERFORMANCE_MODE = 0x10, /**< HAP_DCVS_PERFORMANCE_MODE - Lower thresholds for maximum performance */ HAP_DCVS_V2_DUTY_CYCLE_MODE = 0x20, /**< HAP_DCVS_DUTY_CYCLE_MODE - only for HVX based clients. * For streaming class clients: * > detects periodicity based on HVX usage * > lowers clocks in the no HVX activity region of each period. * For compute class clients: * > Lowers clocks on no HVX activity detects and brings clocks up on detecting HVX activity again. * > Latency involved in bringing up the clock with be at max 1 to 2 ms. */ } HAP_power_dcvs_v2_payload_option; /** * @} // HAP_power_enums */ /** Payload for HAP_power_set_DCVS_v2 */ typedef struct { boolean dcvs_enable; /**< Set to TRUE to participate in DCVS, and FALSE otherwise */ HAP_power_dcvs_v2_payload_option dcvs_option; /**< Set to one of HAP_power_dcvs_v2_payload_option */ boolean set_latency; /**< TRUE to set latency parameter, otherwise FALSE */ uint32 latency; /**< sleep latency */ boolean set_dcvs_params; /**< TRUE to set DCVS params, otherwise FALSE */ HAP_dcvs_params_t dcvs_params; /**< DCVS parameters */ } HAP_power_dcvs_v2_payload; /** Payload for HAP_power_set_DCVS_v3 */ typedef struct { boolean set_dcvs_enable; /**< TRUE to consider DCVS enable/disable and option parameters, otherwise FALSE */ boolean dcvs_enable; /**< Set to TRUE to participate in DCVS, and FALSE otherwise. */ HAP_power_dcvs_v2_payload_option dcvs_option; /**< Set to one of HAP_power_dcvs_v2_payload_option */ boolean set_latency; /**< TRUE to consider latency parameter, otherwise FALSE */ uint32 latency; /**< sleep latency */ boolean set_core_params; /**< TRUE to consider core clock params, otherwise FALSE */ HAP_core_params_t core_params; /**< Core clock parameters */ boolean set_bus_params; /**< TRUE to consider bus clock params, otherwise FALSE */ HAP_bus_params_t bus_params; /**< Bus clock parameters */ boolean set_dcvs_v3_params; /**< TRUE to consider DCVS v3 params, otherwise FALSE */ HAP_dcvs_v3_params_t dcvs_v3_params; /**< DCVS v3 parameters */ boolean set_sleep_disable; /**< TRUE to consider sleep disable/enable parameter, otherwise FALSE */ boolean sleep_disable; /**< TRUE to disable sleep/LPM modes, FALSE to enable */ } HAP_power_dcvs_v3_payload; /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** Type for dcvs update request */ typedef enum { HAP_POWER_UPDATE_DCVS = 1, HAP_POWER_UPDATE_SLEEP_LATENCY, HAP_POWER_UPDATE_DCVS_PARAMS, } HAP_power_update_type_t; /** * @} // HAP_power_enums */ /** Payload for DCVS update */ typedef struct { boolean dcvs_enable; /**< TRUE for DCVS enable and FALSE for DCVS disable */ HAP_power_dcvs_v2_payload_option dcvs_option; /**< Requested DCVS policy in case DCVS enable is TRUE */ } HAP_power_update_dcvs_t; /** Payload for latency update */ typedef struct { boolean set_latency; /**< TRUE if sleep latency request has to be considered */ unsigned int latency; /**< Sleep latency request in micro seconds */ } HAP_power_update_latency_t; /** Payload for DCVS params update */ typedef struct { boolean set_dcvs_params; /**< Flag to mark DCVS params structure validity, TRUE for valid DCVS *params request and FALSE otherwise */ HAP_dcvs_params_t dcvs_params; /**< Intended DCVS params if set_dcvs_params is set to TRUE */ } HAP_power_update_dcvs_params_t; /** Payload for HAP_power_set_DCVS_v2 */ typedef struct { HAP_power_update_type_t update_param; /**< Type for which param to update */ union { HAP_power_update_dcvs_t dcvs_payload; HAP_power_update_latency_t latency_payload; HAP_power_update_dcvs_params_t dcvs_params_payload; }; /**< Update payload for DCVS, latency or DCVS params */ } HAP_power_dcvs_v2_update_payload; /** Payload for HAP_power_set_streamer */ typedef struct { boolean set_streamer0_clk; /**< Set streamer 0 clock */ boolean set_streamer1_clk; /**< Set streamer 1 clock */ unsigned int streamer0_clkFreqHz; /**< Streamer 0 clock frequency */ unsigned int streamer1_clkFreqHz; /**< Streamer 1 clock frequency */ HAP_freq_match_type freqMatch; /**< Clock frequency match */ uint32 param1; /**< Reserved for future streamer parameters */ uint32 param2; /**< Reserved for future streamer parameters */ uint32 param3; /**< Reserved for future streamer parameters */ } HAP_power_streamer_payload; /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** Identifies the HAP power request type */ typedef enum { HAP_power_set_mips_bw = 1, /**< Requests for MIPS. Provides * fine-grained control to set MIPS values. * Payload is set to HAP_power_payload */ HAP_power_set_HVX, /**< Requests to enable / disable HVX * Payload is set to HAP_power_hvx_payload */ HAP_power_set_apptype, /**< Sets the app_type * Payload is set to HAP_power_app_type_payload */ HAP_power_set_linelock, /**< Sets the throttled L2 cache line locking parameters. * Only one throttled call is supported at this time. Additional * un-throttled line-locks can be performed using HAP_power_set_linelock_nothrottle * Payload is set to HAP_power_linelock_payload */ HAP_power_set_DCVS, /**< Requests to participate / stop participating in DCVS */ HAP_power_set_linelock_nothrottle, /**< Sets the L2 cache line locking parameters (non-throttled). * Payload is set to HAP_power_linelock_nothrottle_payload */ HAP_power_set_DCVS_v2, /**< Requests to participate / stop participating in DCVS_v2 */ HAP_power_set_vapss, /**< Sets the VAPSS core clock and DDR/IPNOC bandwidth * Payload is set to HAP_power_vapss_payload */ HAP_power_set_vapss_v2, /**< Sets the VAPSS core DMA/HCP clocks and DDR/IPNOC bandwidths * Payload is set to HAP_power_vapss_payload_v2 */ HAP_power_set_dcvs_v2_update, /**< Updates DCVS params * Payload is set to HAP_power_dcvs_v2_update_payload */ HAP_power_set_streamer, /**< Sets the streamer core clocks * Payload is set to HAP_power_streamer_payload */ HAP_power_set_DCVS_v3, /**< Updates DCVS params * Payload is set to HAP_power_dcvs_v3_payload */ HAP_power_set_HMX, /**< Requests to enable / disable HMX * Payload is set to HAP_power_hmx_payload */ } HAP_Power_request_type; /** * @} // HAP_power_enums */ /** Data type to change power values on the DSP */ typedef struct { HAP_Power_request_type type; /**< Identifies the request type */ union{ HAP_power_mips_bw_payload mips_bw; /**< Requests for performance level */ HAP_power_vapss_payload vapss; /**< Sets the VAPSS core clock and DDR/IPNOC bandwidth */ HAP_power_vapss_payload_v2 vapss_v2; /**< Sets the VAPSS core clock and DDR/IPNOC bandwidth */ HAP_power_streamer_payload streamer; /**< Sets the streamer core clocks */ HAP_power_hvx_payload hvx; /**< Requests to enable / disable HVX */ HAP_power_app_type_payload apptype; /**< Sets the app_type */ HAP_power_linelock_payload linelock; /**< Sets the throttled L2 cache linelock parameters. Only one * throttled linelock is permitted at this time. Additional * un-throttled linelocks can be performed using linelock_nothrottle */ HAP_power_dcvs_payload dcvs; /**< Updates DCVS params */ HAP_power_dcvs_v2_payload dcvs_v2; /**< Updates DCVS_v2 params */ HAP_power_dcvs_v2_update_payload dcvs_v2_update; /**< Updates DCVS_v2_update params */ HAP_power_linelock_nothrottle_payload linelock_nothrottle; /**< Sets the un-throttled L2 cache linelock parameters */ HAP_power_dcvs_v3_payload dcvs_v3; /**< Updates DCVS_v3 params */ HAP_power_hmx_payload hmx; /**< Requests to turn on / off HMX */ }; } HAP_power_request_t; /** @defgroup HAP_power_functions HAP POWER functions * @{ */ /** * Method to set power values from the DSP * @param[in] context - To identify the power client * @param[in] request - Request params. * @retval 0 on success, AEE_EMMPMREGISTER on MMPM client register request failure, -1 on unknown error */ int HAP_power_set(void* context, HAP_power_request_t* request); /** * @} // HAP_power_functions */ /** @defgroup HAP_power_enums HAP POWER enums * @{ */ /** Identifies the HAP power response type */ typedef enum { HAP_power_get_max_mips = 1, /**< Returns the max mips supported (max_mips) */ HAP_power_get_max_bus_bw, /**< Returns the max bus bandwidth supported (max_bus_bw) */ HAP_power_get_client_class, /**< Returns the client class (client_class) */ HAP_power_get_clk_Freq, /**< Returns the core clock frequency (clkFreqHz) */ HAP_power_get_aggregateAVSMpps, /**< Returns the aggregate Mpps used by audio and voice (clkFreqHz) */ HAP_power_get_dcvsEnabled, /**< Returns the dcvs status (enabled / disabled) */ HAP_power_get_vapss_core_clk_Freq, /**< Returns the VAPSS core clock frequency (clkFreqHz) */ HAP_power_get_dma_core_clk_Freq, /**< Returns the DMA core clock frequency (clkFreqHz) */ HAP_power_get_hcp_core_clk_Freq, /**< Returns the HCP core clock frequency (clkFreqHz) */ HAP_power_get_streamer0_core_clk_Freq, /**< Returns the streamer 0 core clock frequency (clkFreqHz) */ HAP_power_get_streamer1_core_clk_Freq, /**< Returns the streamer 1 core clock frequency (clkFreqHz) */ } HAP_Power_response_type; /** * @} // HAP_power_enums */ /** Data type to retrieve power values from the DSP */ typedef struct { HAP_Power_response_type type; /**< Identifies the type to retrieve. */ union{ unsigned int max_mips; /**< Max mips supported */ uint64 max_bus_bw; /**< Max bus bw supported */ unsigned int client_class; /**< Current client class */ unsigned int clkFreqHz; /**< Current core CPU frequency */ unsigned int aggregateAVSMpps; /**< Aggregate AVS Mpps used by audio and voice */ boolean dcvsEnabled; /**< Indicates if dcvs is enabled / disabled. */ }; } HAP_power_response_t; /** @defgroup HAP_power_functions HAP POWER functions * @{ */ /** * Method to retrieve power values from the DSP * @param[in] context - Ignored * @param[out] response - Response. */ int HAP_power_get(void* context, HAP_power_response_t* response); /** * Method to initialize dcvs v3 structure in request param. It enables * flags and resets params for all fields in dcvs v3. So, this * can also be used to remove applied dcvs v3 params and restore * defaults. * @param[in] request - Pointer to request params. */ /*static inline void HAP_power_set_dcvs_v3_init(HAP_power_request_t* request) { memset(request, 0, sizeof(HAP_power_request_t) ); request->type = HAP_power_set_DCVS_v3; request->dcvs_v3.set_dcvs_enable = TRUE; request->dcvs_v3.dcvs_enable = TRUE; request->dcvs_v3.dcvs_option = HAP_DCVS_V2_POWER_SAVER_MODE; request->dcvs_v3.set_latency = TRUE; request->dcvs_v3.latency = 65535; request->dcvs_v3.set_core_params = TRUE; request->dcvs_v3.set_bus_params = TRUE; request->dcvs_v3.set_dcvs_v3_params = TRUE; request->dcvs_v3.set_sleep_disable = TRUE; return; }*/ /** * Method to enable/disable dcvs and set particular dcvs policy. * @param[in] context - User context. * @param[in] dcvs_enable - TRUE to enable dcvs, FALSE to disable dcvs. * @param[in] dcvs_option - To set particular dcvs policy. In case of dcvs disable * request, this param will be ignored. * @returns - 0 on success */ /*static inline int HAP_power_set_dcvs_option(void* context, boolean dcvs_enable, HAP_power_dcvs_v2_payload_option dcvs_option) { HAP_power_request_t request; memset(&request, 0, sizeof(HAP_power_request_t) ); request.type = HAP_power_set_DCVS_v3; request.dcvs_v3.set_dcvs_enable = TRUE; request.dcvs_v3.dcvs_enable = dcvs_enable; if(dcvs_enable) request.dcvs_v3.dcvs_option = dcvs_option; return HAP_power_set(context, &request); }*/ /** * Method to set/reset sleep latency. * @param[in] context - User context. * @param[in] latency - Sleep latency value in microseconds, should be > 1. * Use 65535 max value to reset it to default. * @returns - 0 on success */ /*static inline int HAP_power_set_sleep_latency(void* context, uint32 latency) { HAP_power_request_t request; memset(&request, 0, sizeof(HAP_power_request_t) ); request.type = HAP_power_set_DCVS_v3; request.dcvs_v3.set_latency = TRUE; request.dcvs_v3.latency = latency; return HAP_power_set(context, &request); }*/ /** * Method to set/reset DSP core clock voltage corners. * @param[in] context - User context. * @param[in] target_corner - Target voltage corner. * @param[in] min_corner - Minimum voltage corner. * @param[in] max_corner - Maximum voltage corner. * @returns - 0 on success */ /*static inline int HAP_power_set_core_corner(void* context, uint32 target_corner, uint32 min_corner, uint32 max_corner) { HAP_power_request_t request; memset(&request, 0, sizeof(HAP_power_request_t) ); request.type = HAP_power_set_DCVS_v3; request.dcvs_v3.set_core_params = TRUE; request.dcvs_v3.core_params.min_corner = (HAP_dcvs_voltage_corner_t) (min_corner); request.dcvs_v3.core_params.max_corner = (HAP_dcvs_voltage_corner_t) (max_corner); request.dcvs_v3.core_params.target_corner = (HAP_dcvs_voltage_corner_t) (target_corner); return HAP_power_set(context, &request); }*/ /** * Method to set/reset bus clock voltage corners. * @param[in] context - User context. * @param[in] target_corner - Target voltage corner. * @param[in] min_corner - Minimum voltage corner. * @param[in] max_corner - Maximum voltage corner. * @returns - 0 on success */ /*static inline int HAP_power_set_bus_corner(void* context, uint32 target_corner, uint32 min_corner, uint32 max_corner) { HAP_power_request_t request; memset(&request, 0, sizeof(HAP_power_request_t) ); request.type = HAP_power_set_DCVS_v3; request.dcvs_v3.set_bus_params = TRUE; request.dcvs_v3.bus_params.min_corner = (HAP_dcvs_voltage_corner_t) (min_corner); request.dcvs_v3.bus_params.max_corner = (HAP_dcvs_voltage_corner_t) (max_corner); request.dcvs_v3.bus_params.target_corner = (HAP_dcvs_voltage_corner_t) (target_corner); return HAP_power_set(context, &request); }*/ /** * Method to disable/enable all low power modes. * @param[in] context - User context. * @param[in] sleep_disable - TRUE to disable all low power modes. * FALSE to re-enable all low power modes. * @returns - 0 on success */ /*static inline int HAP_power_set_sleep_mode(void* context, boolean sleep_disable) { HAP_power_request_t request; memset(&request, 0, sizeof(HAP_power_request_t) ); request.type = HAP_power_set_DCVS_v3; request.dcvs_v3.set_sleep_disable = TRUE; request.dcvs_v3.sleep_disable = sleep_disable; return HAP_power_set(context, &request); }*/ /** * This API is deprecated and might generate undesired results. * Please use the HAP_power_get() and HAP_power_set() APIs instead. * Requests a performance level by percentage for clock speed * and bus speed. Passing 0 for any parameter results in no * request being issued for that particular attribute. * @param[in] clock - percentage of target's maximum clock speed * @param[in] bus - percentage of target's maximum bus speed * @param[in] latency - maximum hardware wake up latency in microseconds. The * higher the value the deeper state of sleep * that can be entered but the longer it may * take to awaken. * @retval 0 on success * @par Comments : Performance metrics vary from target to target so the * intent of this API is to allow callers to set a relative * performance level to achieve the desired balance between * performance and power saving. */ int HAP_power_request(int clock, int bus, int latency); /** * This API is deprecated and might generate undesired results. * Please use the HAP_power_get() and HAP_power_set() APIs instead. * Requests a performance level by absolute values. Passing 0 * for any parameter results in no request being issued for that * particular attribute. * @param[in] clock - speed in MHz * @param[in] bus - bus speed in MHz * @param[in] latency - maximum hardware wakeup latency in microseconds. The * higher the value the deeper state of * sleep that can be entered but the * longer it may take to awaken. * @retval 0 on success * @par Comments : This API allows callers who are aware of their target * specific capabilities to set them explicitly. */ int HAP_power_request_abs(int clock, int bus, int latency); /** * This API is deprecated and might generate undesired results. * Please use the HAP_power_get() and HAP_power_set() APIs instead. * queries the target for its clock and bus speed capabilities * @param[out] clock_max - maximum clock speed supported in MHz * @param[out] bus_max - maximum bus speed supported in MHz * @retval 0 on success */ int HAP_power_get_max_speed(int* clock_max, int* bus_max); /** * This API is deprecated and might generate undesired results. * Please use the HAP_power_get() and HAP_power_set() APIs instead. * Upvote for HVX power * @retval 0 on success */ int HVX_power_request(void); /** * This API is deprecated and might generate undesired results. * Please use the HAP_power_get() and HAP_power_set() APIs instead. * Downvote for HVX power * @retval 0 on success */ int HVX_power_release(void); /** * Method to destroy clients created through HAP_power_set * @param[in] context - To uniquely identify the client * @retval 0 on success, AEE_ENOSUCHCLIENT on Invalid context, -1 on unknown error * @brief DO NOT call this API directly, use HAP_power_destroy instead. */ int HAP_power_destroy_client(void *context); /** * @param[in] client - To uniquely identify the client context. * @retval 0 on success, AEE_EUNSUPPORTEDAPI if the API is not supported on the DSP image, AEE_ENOSUCHCLIENT on Invalid context, -1 on unknown error * @brief Method to destroy clients created through HAP_power_set, wrapper to HAP_power_destroy_client API */ static inline int HAP_power_destroy(void *client){ if(0 != HAP_power_destroy_client) return HAP_power_destroy_client(client); return AEE_EUNSUPPORTEDAPI; } /** * Method to create user client context * @retval context for client */ //static inline void* HAP_utils_create_context(void) { /* * Allocate 1 byte of memory for a unique context identifier * Clients can also allocate memory and use it as unique context identifier */ // return malloc(1); //} /** * Method to destroy user client context * @param context of client */ /*static inline void HAP_utils_destroy_context(void* context) { free(context); }*/ /** * @} // HAP_power_functions */ #ifdef __cplusplus } #endif #endif //_HAP_POWER_H