/*==============================================================================
@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 <string.h>
//#include <stdlib.h>
#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

