HAP_power.h

/*==============================================================================
@file
    HAP_power.h

@brief
    Header file of DSP power APIs.

Copyright (c) 2015,2019,2022 Qualcomm Technologies, Inc.
All rights reserved. Qualcomm Proprietary and Confidential.
==============================================================================*/

#ifndef _HAP_POWER_H
#define _HAP_POWER_H

#include "AEEStdErr.h"
#include "AEEStdDef.h"
#include <string.h>
#include <stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

//Add a weak reference so shared objects do not throw link error
#pragma weak HAP_power_destroy_client

#define HAP_DCVS_LPM_LEVEL1                     1    
#define HAP_DCVS_LPM_LEVEL2                     2    
#define HAP_DCVS_LPM_LEVEL3                     3    
#define HAP_DCVS_LPM_ENABLE_ALL                 0    
#define HAP_DCVS_VOLT_CORNER_TURBO_L2_L3_DEFINED     
#define HAP_POWER_SET_HMX_V2_DEFINED                 
#define HAP_POWER_SET_CENG_BUS_VOTING_DEFINED        
typedef enum {
    HAP_POWER_ERR_UNKNOWN           = -1,
    HAP_POWER_ERR_INVALID_PARAM     = -2,
    HAP_POWER_ERR_UNSUPPORTED_API   = -3
} HAP_power_error_codes;

typedef struct {
    boolean set_mips;                       
    unsigned int mipsPerThread;             
    unsigned int mipsTotal;                 
    boolean set_bus_bw;                     
    uint64 bwBytePerSec;                    
    unsigned short busbwUsagePercentage;    
    boolean set_latency;                    
    int latency;                            
} HAP_power_mips_bw_payload;

typedef enum {
    HAP_FREQ_AT_LEAST,              
    HAP_FREQ_AT_MOST,               
    HAP_FREQ_CLOSEST,               
    HAP_FREQ_EXACT,                 
    HAP_FREQ_MAX_COUNT              
} HAP_freq_match_type;
typedef struct {
    boolean set_bus_bw;                     
    uint64 bwBytePerSec;                    
    unsigned short busbwUsagePercentage;    
} HAP_power_bus_bw;

typedef struct {
    boolean set_clk;                        
    unsigned int clkFreqHz;                 
    HAP_freq_match_type freqMatch;          
    HAP_power_bus_bw dma_ext;               
    HAP_power_bus_bw hcp_ext;               
    HAP_power_bus_bw dma_int;               
    HAP_power_bus_bw hcp_int;               
} HAP_power_vapss_payload;

typedef struct {
    boolean set_dma_clk;                    
    boolean set_hcp_clk;                    
    unsigned int dmaClkFreqHz;              
    unsigned int hcpClkFreqHz;              
    HAP_freq_match_type freqMatch;          
    HAP_power_bus_bw dma_ext;               
    HAP_power_bus_bw hcp_ext;               
    HAP_power_bus_bw dma_int;               
    HAP_power_bus_bw hcp_int;               
} HAP_power_vapss_payload_v2;

typedef struct {
    boolean power_up;                       
} HAP_power_hvx_payload;

typedef struct {
    boolean power_up;                       
} HAP_power_hmx_payload;

typedef enum {
    HAP_POWER_UNKNOWN_CLIENT_CLASS          = 0x00,     
    HAP_POWER_AUDIO_CLIENT_CLASS            = 0x01,     
    HAP_POWER_VOICE_CLIENT_CLASS            = 0x02,     
    HAP_POWER_COMPUTE_CLIENT_CLASS          = 0x04,     
    HAP_POWER_STREAMING_1HVX_CLIENT_CLASS   = 0x08,     
    HAP_POWER_STREAMING_2HVX_CLIENT_CLASS = 0x10,       
} HAP_power_app_type_payload;
typedef struct {
    void* startAddress;                 
    uint32 size;                        
    uint32 throttleBlockSize;           
    uint32 throttlePauseUs;             
} HAP_power_linelock_payload;

typedef struct {
    void* startAddress;                         
    uint32 size;                                
} HAP_power_linelock_nothrottle_payload;

typedef enum {
    HAP_DCVS_ADJUST_UP_DOWN =   0x1,        
    HAP_DCVS_ADJUST_ONLY_UP =   0x2,        
} HAP_power_dcvs_payload_option;
typedef struct {
    boolean dcvs_enable;                                
    HAP_power_dcvs_payload_option dcvs_option;          
} HAP_power_dcvs_payload;

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_TURBO_L2,                  
    HAP_DCVS_VCORNER_TURBO_L3,                  
    HAP_DCVS_VCORNER_MAX = 255,
} HAP_dcvs_voltage_corner_t;

typedef enum {
    HAP_DCVS_EXP_VCORNER_DISABLE    = 0,
    HAP_DCVS_EXP_VCORNER_MIN        = 0x100,
    HAP_DCVS_EXP_VCORNER_LOW_SVS_D2 = 0x134,
    HAP_DCVS_EXP_VCORNER_LOW_SVS_D1 = 0x138,
    HAP_DCVS_EXP_VCORNER_LOW_SVS    = 0x140,
    HAP_DCVS_EXP_VCORNER_SVS        = 0x180,
    HAP_DCVS_EXP_VCORNER_SVS_L1     = 0x1C0,
    HAP_DCVS_EXP_VCORNER_NOM        = 0x200,
    HAP_DCVS_EXP_VCORNER_NOM_L1     = 0x240,
    HAP_DCVS_EXP_VCORNER_TUR        = 0x280,
    HAP_DCVS_EXP_VCORNER_TUR_L1     = 0x2A0,
    HAP_DCVS_EXP_VCORNER_TUR_L2     = 0x2B0,
    HAP_DCVS_EXP_VCORNER_TUR_L3     = 0x2C0,
    HAP_DCVS_EXP_VCORNER_MAX        = 0xFFFF,
} HAP_dcvs_exp_voltage_corner_t;

typedef enum {
    HAP_CLK_PERF_HIGH = 0,                      
    HAP_CLK_PERF_LOW,                           
} HAP_clk_perf_mode_t;

#define HAP_DCVS_VCORNER_SVSPLUS HAP_DCVS_VCORNER_SVS_PLUS
#define HAP_DCVS_VCORNER_NOMPLUS HAP_DCVS_VCORNER_NOM_PLUS
#define HAP_DCVS_VCORNER_TURBO_L1 HAP_DCVS_VCORNER_TURBO_PLUS

typedef struct {
    HAP_dcvs_voltage_corner_t target_corner;    
    HAP_dcvs_voltage_corner_t min_corner;       
    HAP_dcvs_voltage_corner_t max_corner;       
    uint32 param1;                              
    uint32 param2;                              
    uint32 param3;                              
} HAP_dcvs_params_t;

typedef struct {
    HAP_dcvs_voltage_corner_t target_corner;    
    HAP_dcvs_voltage_corner_t min_corner;       
    HAP_dcvs_voltage_corner_t max_corner;       
    uint32 param1;                              
    uint32 param2;                              
    uint32 param3;                              
} HAP_core_params_t;

typedef struct {
    HAP_dcvs_voltage_corner_t target_corner;    
    HAP_dcvs_voltage_corner_t min_corner;       
    HAP_dcvs_voltage_corner_t max_corner;       
    uint32 param1;                              
    uint32 param2;                              
    uint32 param3;                              
} HAP_bus_params_t;

typedef struct {
    uint32 param1;                  
    uint32 param2;                  
    uint32 param3;                  
    uint32 param4;                  
    uint32 param5;                  
    uint32 param6;                  
} HAP_dcvs_v3_params_t;

typedef enum {
    HAP_DCVS_V2_ADJUST_UP_DOWN =   0x1,                 
    HAP_DCVS_V2_ADJUST_ONLY_UP =   0x2,                 
    HAP_DCVS_V2_POWER_SAVER_MODE = 0x4,                 
    HAP_DCVS_V2_POWER_SAVER_AGGRESSIVE_MODE = 0x8,      
    HAP_DCVS_V2_PERFORMANCE_MODE = 0x10,                
    HAP_DCVS_V2_DUTY_CYCLE_MODE = 0x20,                 
} HAP_power_dcvs_v2_payload_option;
typedef struct {
    boolean dcvs_enable;                                
    HAP_power_dcvs_v2_payload_option dcvs_option;       
    boolean set_latency;                                
    uint32 latency;                                     
    boolean set_dcvs_params;                            
    HAP_dcvs_params_t dcvs_params;                      
} HAP_power_dcvs_v2_payload;

typedef struct {
    boolean set_dcvs_enable;                            
    boolean dcvs_enable;                                
    HAP_power_dcvs_v2_payload_option dcvs_option;       
    boolean set_latency;                                
    uint32 latency;                                     
    boolean set_core_params;                            
    HAP_core_params_t core_params;                      
    boolean set_bus_params;                             
    HAP_bus_params_t bus_params;                        
    boolean set_dcvs_v3_params;                         
    HAP_dcvs_v3_params_t dcvs_v3_params;                
    boolean set_sleep_disable;                          
    unsigned char sleep_disable;                        
} HAP_power_dcvs_v3_payload;

typedef enum {
    HAP_POWER_UPDATE_DCVS = 1,
    HAP_POWER_UPDATE_SLEEP_LATENCY,
    HAP_POWER_UPDATE_DCVS_PARAMS,
} HAP_power_update_type_t;
typedef struct {
    boolean dcvs_enable;                            
    HAP_power_dcvs_v2_payload_option dcvs_option;   
} HAP_power_update_dcvs_t;

typedef struct {
    boolean set_latency;                            
    unsigned int latency;                           
} HAP_power_update_latency_t;

typedef struct {
    boolean set_dcvs_params;                        
    HAP_dcvs_params_t dcvs_params;                  
} HAP_power_update_dcvs_params_t;

typedef struct {
    HAP_power_update_type_t update_param;           
    union {
        HAP_power_update_dcvs_t dcvs_payload;
        HAP_power_update_latency_t latency_payload;
        HAP_power_update_dcvs_params_t dcvs_params_payload;
    };                                              
} HAP_power_dcvs_v2_update_payload;

typedef struct {
    boolean set_streamer0_clk;              
    boolean set_streamer1_clk;              
    unsigned int streamer0_clkFreqHz;       
    unsigned int streamer1_clkFreqHz;       
    HAP_freq_match_type freqMatch;          
    uint32 param1;                          
    uint32 param2;                          
    uint32 param3;                          
} HAP_power_streamer_payload;

typedef struct {
    boolean set_power;                          
    boolean power_up;                           
    boolean set_clock;                          
    boolean pick_default;                       
    HAP_dcvs_exp_voltage_corner_t target_corner;    
    HAP_dcvs_exp_voltage_corner_t min_corner;   
    HAP_dcvs_exp_voltage_corner_t max_corner;   
    HAP_clk_perf_mode_t perf_mode;              
    uint32 freq_mhz;                            
    uint32 floor_freq_mhz;                      
    uint32 param1;                              
    uint32 param2;                              
    uint32 param3;                              
} HAP_power_hmx_payload_v2;

typedef struct {
    HAP_dcvs_voltage_corner_t target_corner;    
    HAP_dcvs_voltage_corner_t min_corner;       
    HAP_dcvs_voltage_corner_t max_corner;       
    HAP_clk_perf_mode_t perf_mode;              
    uint64 bwBytePerSec;                        
    uint32 busbwUsagePercentage;                
    uint32 param1;                              
    uint32 param2;                              
    uint32 param3;                              
} HAP_power_ceng_bus_payload;

typedef enum {
    HAP_power_set_mips_bw = 1,              
    HAP_power_set_HVX,                      
    HAP_power_set_apptype,                  
    HAP_power_set_linelock,                 
    HAP_power_set_DCVS,                     
    HAP_power_set_linelock_nothrottle,      
    HAP_power_set_DCVS_v2,                  
    HAP_power_set_vapss,                    
    HAP_power_set_vapss_v2,                 
    HAP_power_set_dcvs_v2_update,           
    HAP_power_set_streamer,                 
    HAP_power_set_DCVS_v3,                  
    HAP_power_set_HMX,                      
    HAP_power_set_HMX_v2,                   
    HAP_power_set_CENG_bus,                 
} HAP_Power_request_type;
typedef struct {
    HAP_Power_request_type type;                                    
    union{
        HAP_power_mips_bw_payload mips_bw;                          
        HAP_power_vapss_payload vapss;                              
        HAP_power_vapss_payload_v2 vapss_v2;                        
        HAP_power_streamer_payload streamer;                        
        HAP_power_hvx_payload hvx;                                  
        HAP_power_app_type_payload apptype;                         
        HAP_power_linelock_payload linelock;                        
        HAP_power_dcvs_payload dcvs;                                
        HAP_power_dcvs_v2_payload dcvs_v2;                          
        HAP_power_dcvs_v2_update_payload dcvs_v2_update;            
        HAP_power_linelock_nothrottle_payload linelock_nothrottle;  
        HAP_power_dcvs_v3_payload dcvs_v3;                          
        HAP_power_hmx_payload hmx;                                  
        HAP_power_hmx_payload_v2 hmx_v2;                                
        HAP_power_ceng_bus_payload ceng_bus;                            
    };
} HAP_power_request_t;

int HAP_power_set(void* context, HAP_power_request_t* request);
typedef enum {
    HAP_power_get_max_mips = 1,             
    HAP_power_get_max_bus_bw,               
    HAP_power_get_client_class,             
    HAP_power_get_clk_Freq,                 
    HAP_power_get_aggregateAVSMpps,         
    HAP_power_get_dcvsEnabled,              
    HAP_power_get_vapss_core_clk_Freq,      
    HAP_power_get_dma_core_clk_Freq,        
    HAP_power_get_hcp_core_clk_Freq,        
    HAP_power_get_streamer0_core_clk_Freq,  
    HAP_power_get_streamer1_core_clk_Freq,  
} HAP_Power_response_type;
typedef struct {
    HAP_Power_response_type type;           
    union{
        unsigned int max_mips;              
        uint64 max_bus_bw;                  
        unsigned int client_class;          
        unsigned int clkFreqHz;             
        unsigned int aggregateAVSMpps;      
        boolean dcvsEnabled;                
    };
} HAP_power_response_t;

int HAP_power_get(void* context, HAP_power_response_t* response);

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

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

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

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

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

static inline int HAP_power_set_sleep_mode(void* context, unsigned char 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);
}


int HAP_power_request(int clock, int bus, int latency);

int HAP_power_request_abs(int clock, int bus, int latency);

int HAP_power_get_max_speed(int* clock_max, int* bus_max);

int HVX_power_request(void);

int HVX_power_release(void);

int HAP_power_destroy_client(void *context);

static inline int HAP_power_destroy(void *client){
    if(0 != HAP_power_destroy_client)
        return HAP_power_destroy_client(client);
    return AEE_EUNSUPPORTEDAPI;
}

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

static inline void HAP_utils_destroy_context(void* context) {
    free(context);
}

#ifdef __cplusplus
}
#endif
#endif //_HAP_POWER_H