Audio HW Control/audio_hw_control_chipset_api.h
changeset 3 89965ac1daf8
parent 0 bb4b476bbb96
child 5 ef85d0a8d402
equal deleted inserted replaced
2:ea09f30a96a5 3:89965ac1daf8
     1 /*
     1 /*
     2   audio_hw_control_chipset_api.h
     2   audio_hwctrl_chipset_api.h
     3 
     3 
     4   Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). 
     4   Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
     5   All rights reserved.
     5   All rights reserved.
     6 
     6 
     7   This program and the accompanying materials are made available 
     7   This program and the accompanying materials are made available 
     8   under the terms of the Eclipse Public License v1.0 which accompanies 
     8   under the terms of the Eclipse Public License v1.0 which accompanies 
     9   this distribution, and is available at 
     9   this distribution, and is available at 
    20 
    20 
    21 #ifdef __cplusplus
    21 #ifdef __cplusplus
    22 extern "C" {
    22 extern "C" {
    23 #endif /* __cplusplus */
    23 #endif /* __cplusplus */
    24 
    24 
    25 
       
    26 /* Each OMX header must include all required header files to allow the
    25 /* Each OMX header must include all required header files to allow the
    27  * header to compile without errors.  The includes below are required
    26  * header to compile without errors.  The includes below are required
    28  * for this header file to compile successfully 
    27  * for this header file to compile successfully 
    29  */
    28  */
    30 
    29 
    31 #include <OMX_Audio.h>
    30 #include <OMX_Audio.h>
    32 
    31 
    33 
    32 
    34 /* structures and enums used by OMX interface */
    33 /** Audio power control.
    35 
    34 */
    36  typedef enum OMX_AUDIO_HWREGISTERTYPE { 
    35 typedef struct OMX_AUDIO_CONFIG_POWERTYPE  { 
    37      OMX_AUDIO_IO = 0,
    36     OMX_U32 nSize;                                    
    38      OMX_AUDIO_I2C,
    37     OMX_VERSIONTYPE nVersion;                   
    39      OMX_AUDIO_SLIMBUS,
    38     OMX_U32 nPortIndex;            
    40      OMX_AUDIO_CBUS = 0xFFFF     
    39     OMX_U32 nChannel;
    41  } OMX_AUDIO_HWREGISTERTYPE;
    40     OMX_BOOL bPower;
       
    41 } OMX_AUDIO_CONFIG_POWERTYPE;
       
    42 
       
    43 /** Audio volume ramp control.
       
    44 */
       
    45 typedef struct OMX_AUDIO_CONFIG_VOLUMERAMPTYPE  { 
       
    46     OMX_U32 nSize;                                    
       
    47     OMX_VERSIONTYPE nVersion;                   
       
    48     OMX_U32 nPortIndex;            
       
    49     OMX_U32 nChannel;
       
    50     OMX_BOOL bLinear;
       
    51     OMX_BS32 sStartVolume;
       
    52     OMX_BS32 sEndVolume;
       
    53     OMX_TICKS nRampDuration;
       
    54     OMX_BOOL bRampTerminate;
       
    55     OMX_BS32 sCurrentVolume;
       
    56     OMX_TICKS nRampCurrentTime;
       
    57     OMX_TICKS nRampMinDuration;
       
    58     OMX_TICKS nRampMaxDuration;
       
    59     OMX_U32 nVolumeStep;
       
    60 } OMX_AUDIO_CONFIG_VOLUMERAMPTYPE;
       
    61 
       
    62 /** Settings burst control.
       
    63 */
       
    64 typedef struct OMX_AUDIO_CONFIG_BURSTCONTROLTYPE  { 
       
    65     OMX_U32 nSize;                                    
       
    66     OMX_VERSIONTYPE nVersion;                   
       
    67     OMX_U32 nPortIndex;            
       
    68     OMX_BOOL bBurstControl;
       
    69     OMX_BOOL bStatus;
       
    70 } OMX_AUDIO_CONFIG_BURSTCONTROLTYPE;
       
    71 
       
    72 /** Audio register bank query.
       
    73 */
       
    74 typedef struct OMX_AUDIO_CONFIG_REGISTERBANKQUERYTYPE  { 
       
    75     OMX_U32 nSize;                                    
       
    76     OMX_VERSIONTYPE nVersion;                   
       
    77     OMX_U32 nPortIndex;   
       
    78     OMX_U16 nNumRegisterBanks;           
       
    79 } OMX_AUDIO_CONFIG_REGISTERBANKQUERYTYPE;
       
    80 
       
    81 
       
    82 typedef enum OMX_AUDIO_HWREGISTERTYPE { 
       
    83     OMX_AUDIO_IO = 0,
       
    84     OMX_AUDIO_I2C,
       
    85     OMX_AUDIO_SLIMBUS,
       
    86     OMX_AUDIO_CBUS = 0xFFFF     
       
    87 } OMX_AUDIO_HWREGISTERTYPE;
    42  
    88  
    43  typedef struct OMX_AUDIO_REGBANKDESCRIPTORTYPE { 
    89 typedef struct OMX_AUDIO_REGBANKDESCRIPTORTYPE { 
    44      OMX_U32 nSize;                                    
    90     OMX_U32 nSize;                                    
    45      OMX_VERSIONTYPE nVersion;                   
    91     OMX_VERSIONTYPE nVersion;                   
    46      OMX_U32 nRegBankIndex;   
    92     OMX_U32 nRegBankIndex;   
    47      OMX_U32 nLogicalStartAddr;
    93     OMX_U32 nLogicalStartAddr;
    48      OMX_U32 nLogicalEndAddr;
    94     OMX_U32 nLogicalEndAddr;
    49      OMX_AUDIO_HWREGISTERTYPE eRegBankType;
    95     OMX_AUDIO_HWREGISTERTYPE eRegBankType;
    50        
    96 } OMX_AUDIO_REGBANKDESCRIPTORTYPE;
    51  } OMX_AUDIO_REGBANKDESCRIPTORTYPE;
    97 
    52 
    98 /** Audio register bank table control.
    53  typedef enum OMX_AUDIO_HWLOOPSTYPE { 
    99 */
    54      OMX_AUDIO_NOLOOP = 0,
   100 typedef struct OMX_AUDIO_CONFIG_REGISTERBANKTABLETYPE  { 
    55      OMX_AUDIO_SIDETONE_LOOP = 0xFFFF
   101     OMX_U32 nSize;                                    
    56      /* rest of HW loops are to be defined on a vendor specific basis */
   102     OMX_VERSIONTYPE nVersion;                   
    57      
   103     OMX_U32 nPortIndex;   
    58  } OMX_AUDIO_HWLOOPSTYPE;
   104     OMX_U16 nNumRegisterBanks; 
    59 
   105     OMX_AUDIO_REGBANKDESCRIPTORTYPE RegBankDescriptorTable;     
    60  typedef enum OMX_AUDIO_HWOPERATIONTYPE { 
   106 } OMX_AUDIO_CONFIG_REGISTERBANKTABLETYPE;
    61      OMX_AUDIO_NOOP = 0,
   107 
    62      OMX_AUDIO_16BIT_SINGLE_READ,
   108 
    63      OMX_AUDIO_16BIT_SINGLE_WRITE,
   109 typedef enum OMX_AUDIO_HWCTRL_STATUSTYPE { 
    64      OMX_AUDIO_32BIT_SINGLE_READ,
   110     OMX_AUDIO_OK = 0,
    65      OMX_AUDIO_32BIT_SINGLE_WRITE,
   111     OMX_AUDIO_FAIL,
    66      OMX_AUDIO_16BIT_MULTI_READ,
   112     /* if callback facility is somehow solved in OpenMAX IL for getconfig/setconfig parameter calls, it is expected */
    67      OMX_AUDIO_16BIT_MULTI_WRITE,
   113     /* to have here extra status information that can be returned for e.g. multi-read/write commands */
    68      OMX_AUDIO_32BIT_MULTI_READ,
   114     OMX_AUDIO_NOT_SUPPORTED = 0xFFFF     
    69      OMX_AUDIO_32BIT_MULTI_WRITE,
   115 } OMX_AUDIO_HWCTRL_STATUSTYPE;
    70      OMX_AUDIO_16BIT_BURST_MULTI_READ,
   116 
    71      OMX_AUDIO_16BIT_BURST_MULTI_WRITE,
   117 typedef enum OMX_AUDIO_HWOPERATIONTYPE { 
    72      OMX_AUDIO_32BIT_BURST_MULTI_READ,
   118     OMX_AUDIO_NOOP = 0,
    73      OMX_AUDIO_32BIT_BURST_MULTI_WRITE = 0xFFFF     
   119     OMX_AUDIO_16BIT_SINGLE_READ,
    74  } OMX_AUDIO_HWOPERATIONTYPE;
   120     OMX_AUDIO_16BIT_SINGLE_WRITE,
    75 
   121     OMX_AUDIO_32BIT_SINGLE_READ,
    76  
   122     OMX_AUDIO_32BIT_SINGLE_WRITE,
    77  typedef enum OMX_AUDIO_HWCTRL_STATUSTYPE { 
   123     OMX_AUDIO_16BIT_MULTI_READ,
    78      OMX_AUDIO_OK = 0,
   124     OMX_AUDIO_16BIT_MULTI_WRITE,
    79      OMX_AUDIO_FAIL,
   125     OMX_AUDIO_32BIT_MULTI_READ,
    80      /* if callback facility is somehow solved in OpenMAX IL for 
   126     OMX_AUDIO_32BIT_MULTI_WRITE,
    81         getconfig/setconfig parameter calls, it is expected */
   127     OMX_AUDIO_16BIT_BURST_MULTI_READ,
    82      /* to have here extra status information that can be returned 
   128     OMX_AUDIO_16BIT_BURST_MULTI_WRITE,
    83         for e.g. multi-read/write commands */
   129     OMX_AUDIO_32BIT_BURST_MULTI_READ,
    84      OMX_AUDIO_NOT_SUPPORTED = 0xFFFF     
   130     OMX_AUDIO_32BIT_BURST_MULTI_WRITE = 0xFFFF     
    85  } OMX_AUDIO_HWCTRL_STATUSTYPE;
   131 } OMX_AUDIO_HWOPERATIONTYPE;
    86 
   132 
    87 
   133 /** Custom audio HW control.
    88 
   134 */
    89 /* Configuration parameters */
   135 typedef struct OMX_AUDIO_CONFIG_CUSTOMHWCONTROLTYPE  { 
    90 
   136     OMX_U32 nSize;                                    
    91 typedef struct OMX_AUDIO_CONFIG_POWERTYPE  { 
   137     OMX_VERSIONTYPE nVersion;                   
    92      OMX_U32 nSize;                                    
   138     OMX_U32 nPortIndex;   
    93      OMX_VERSIONTYPE nVersion;                   
   139     OMX_AUDIO_HWCTRL_STATUSTYPE eStatus;
    94      OMX_U32 nPortIndex;            
   140     OMX_AUDIO_HWOPERATIONTYPE eHwOperation;
    95      OMX_U32 nChannel;
   141     OMX_AUDIO_HWREGISTERTYPE eRegisterType;
    96      OMX_BOOL bPower;
   142     OMX_U16 nDataCount;
    97 } OMX_AUDIO_CONFIG_POWERTYPE;
   143     OMX_U32 nLogicalAddress;
    98 
   144     OMX_U16 nData;     
    99 
   145 } OMX_AUDIO_CONFIG_CUSTOMHWCONTROLTYPE;
   100 typedef struct OMX_AUDIO_CONFIG_VOLUMERAMPTYPE  { 
   146 
   101      OMX_U32 nSize;                                    
   147 
   102      OMX_VERSIONTYPE nVersion;                   
   148 typedef enum OMX_AUDIO_HWLOOPSTYPE { 
   103      OMX_U32 nPortIndex;            
   149     OMX_AUDIO_NOLOOP = 0,
   104      OMX_U32 nChannel;
   150     OMX_AUDIO_SIDETONE_LOOP = 0xFFFF
   105      OMX_BOOL bLinear;
   151     /* rest of HW loops are to be defined on a vendor specific basis */
   106      OMX_BS32 sStartVolume;
   152 } OMX_AUDIO_HWLOOPSTYPE;
   107      OMX_BS32 sEndVolume;
   153 
   108      OMX_TICKS nRampDuration;
   154 /** Audio HW loop support query.
   109      OMX_BOOL bRampTerminate;
   155 */
   110      OMX_BS32 sCurrentVolume;
       
   111      OMX_TICKS nRampCurrentTime;
       
   112      OMX_TICKS nRampMinDuration;
       
   113      OMX_TICKS nRampMaxDuration;
       
   114      OMX_U32 nVolumeStep;
       
   115  } OMX_AUDIO_CONFIG_VOLUMERAMPTYPE;
       
   116 
       
   117 
       
   118  typedef struct OMX_AUDIO_CONFIG_BURSTCONTROLTYPE  { 
       
   119      OMX_U32 nSize;                                    
       
   120      OMX_VERSIONTYPE nVersion;                   
       
   121      OMX_U32 nPortIndex;            
       
   122      OMX_BOOL bBurstControl;
       
   123      OMX_BOOL bStatus;
       
   124  } OMX_AUDIO_CONFIG_BURSTCONTROLTYPE;
       
   125 
       
   126  typedef struct OMX_AUDIO_CONFIG_REGISTERBANKQUERYTYPE  { 
       
   127      OMX_U32 nSize;                                    
       
   128      OMX_VERSIONTYPE nVersion;                   
       
   129      OMX_U32 nPortIndex;   
       
   130      OMX_U16 nNumRegisterBanks;           
       
   131  } OMX_AUDIO_CONFIG_REGISTERBANKQUERYTYPE;
       
   132 
       
   133 
       
   134  typedef enum OMX_AUDIO_HWREGISTERTYPE { 
       
   135      OMX_AUDIO_IO = 0,
       
   136      OMX_AUDIO_I2C,
       
   137      OMX_AUDIO_SLIMBUS,
       
   138      OMX_AUDIO_CBUS = 0xFFFF     
       
   139  } OMX_AUDIO_HWREGISTERTYPE;
       
   140  
       
   141  
       
   142  typedef struct OMX_AUDIO_REGBANKDESCRIPTORTYPE { 
       
   143      OMX_U32 nSize;                                    
       
   144      OMX_VERSIONTYPE nVersion;                   
       
   145      OMX_U32 nRegBankIndex;   
       
   146      OMX_U32 nLogicalStartAddr;
       
   147      OMX_U32 nLogicalEndAddr;
       
   148      OMX_AUDIO_HWREGISTERTYPE eRegBankType;
       
   149        
       
   150  } OMX_AUDIO_REGBANKDESCRIPTORTYPE;
       
   151 
       
   152  typedef struct OMX_AUDIO_CONFIG_REGISTERBANKTABLETYPE  { 
       
   153      OMX_U32 nSize;                                    
       
   154      OMX_VERSIONTYPE nVersion;                   
       
   155      OMX_U32 nPortIndex;   
       
   156      OMX_U16 nNumRegisterBanks; 
       
   157      OMX_AUDIO_REGBANKDESCRIPTORTYPE RegBankDescriptorTable;     
       
   158  } OMX_AUDIO_CONFIG_REGISTERBANKTABLETYPE;
       
   159 
       
   160 
       
   161  typedef struct OMX_AUDIO_CONFIG_CUSTOMHWCONTROLTYPE  { 
       
   162      OMX_U32 nSize;                                    
       
   163      OMX_VERSIONTYPE nVersion;                   
       
   164      OMX_U32 nPortIndex;   
       
   165      OMX_AUDIO_HWCTRL_STATUSTYPE eStatus;
       
   166      OMX_AUDIO_HWOPERATIONTYPE eHwOperation;
       
   167      OMX_AUDIO_HWREGISTERTYPE eRegisterType;
       
   168      OMX_U16 nDataCount;
       
   169      OMX_U32 nLogicalAddress;
       
   170      OMX_U16 nData;     
       
   171  } OMX_AUDIO_CONFIG_CUSTOMHWCONTROLTYPE;
       
   172 
       
   173 typedef struct OMX_AUDIO_CONFIG_HWLOOPSUPPORTTYPE  { 
   156 typedef struct OMX_AUDIO_CONFIG_HWLOOPSUPPORTTYPE  { 
   174      OMX_U32 nSize;                                    
   157     OMX_U32 nSize;                                    
   175      OMX_VERSIONTYPE nVersion;                   
   158     OMX_VERSIONTYPE nVersion;                   
   176      OMX_U32 nPortIndex;
   159     OMX_U32 nPortIndex;
   177      OMX_U32 nSupportedLoops;    
   160     OMX_U32 nSupportedLoops;    
   178      OMX_AUDIO_HWLOOPSTYPE eLoopIndex;
   161     OMX_AUDIO_HWLOOPSTYPE eLoopIndex;
   179          
   162 } OMX_AUDIO_CONFIG_HWLOOPSUPPORTTYPE;
   180  } OMX_AUDIO_CONFIG_HWLOOPSUPPORTTYPE;
   163 
   181 
   164 /** Audio HW loop control.
       
   165 */
   182 typedef struct OMX_AUDIO_CONFIG_HWLOOPCONTROLTYPE  { 
   166 typedef struct OMX_AUDIO_CONFIG_HWLOOPCONTROLTYPE  { 
   183      OMX_U32 nSize;                                    
   167     OMX_U32 nSize;                                    
   184      OMX_VERSIONTYPE nVersion;                   
   168     OMX_VERSIONTYPE nVersion;                   
   185      OMX_U32 nPortIndex;   
   169     OMX_U32 nPortIndex;   
   186      OMX_AUDIO_HWLOOPSTYPE eLoopIndex;
   170     OMX_AUDIO_HWLOOPSTYPE eLoopIndex;
   187      OMX_U32 nChannel;
   171     OMX_U32 nChannel;
   188      OMX_BOOL bControlSwitch;
   172     OMX_BOOL bControlSwitch;
   189      OMX_BOOL bLinear;
   173     OMX_BOOL bLinear;
   190      OMX_BS32 sLoopVolume;
   174     OMX_BS32 sLoopVolume;
   191      
   175 } OMX_AUDIO_CONFIG_HWLOOPCONTROLTYPE;
   192  } OMX_AUDIO_CONFIG_HWLOOPCONTROLTYPE;
   176 
   193 
   177 
   194 
   178 /** Non-OpenMAX API layers */
   195 
   179 /***************************/
   196 /* End of OMX part */
   180 
   197 
   181 /* channel ID denoting special case of all channels being selected where possible */       
   198 /************  non-OMX interface definition **************/  
       
   199 
       
   200 /* types and constants used by non-OMX APIs */
       
   201 
       
   202 /* channel ID denoting special case of all channels being selected 
       
   203    where possible */       
       
   204 #define AUDIO_COMMON_CHANNEL_ALL	0x7FFFFFFF
   182 #define AUDIO_COMMON_CHANNEL_ALL	0x7FFFFFFF
       
   183 
       
   184 /** 16 bit unsigned quantity that is 16 bit word aligned */
       
   185 typedef unsigned short uint16;
       
   186 
       
   187 /** 16 bit signed quantity that is 16 bit word aligned */
       
   188 typedef signed short int16;
       
   189 
       
   190 /** 32 bit unsigned quantity that is 32 bit word aligned */
       
   191 typedef unsigned long uint32;
       
   192 
       
   193 /** signed quantity that is 32 bit word aligned */
       
   194 typedef signed long int32;
   205 
   195 
   206 typedef enum AUDIO_COMMON_SWITCH { 
   196 typedef enum AUDIO_COMMON_SWITCH { 
   207      AUDIO_COMMON_OFF = 0,
   197      AUDIO_COMMON_OFF = 0,
   208      AUDIO_COMMON_ON,  
   198      AUDIO_COMMON_ON,  
   209      AUDIO_COMMON_UNSUPPORTED = 0xFFFF     
   199      AUDIO_COMMON_UNSUPPORTED = 0xFFFF     
   211 
   201 
   212 
   202 
   213 typedef enum AUDIO_COMMON_STATUS { 
   203 typedef enum AUDIO_COMMON_STATUS { 
   214      AUDIO_COMMON_OK = 0,
   204      AUDIO_COMMON_OK = 0,
   215      AUDIO_COMMON_FAIL,  
   205      AUDIO_COMMON_FAIL,  
   216      AUDIO_COMMON_UNSUPPORTED = 0xFFFF     
   206      AUDIO_COMMON_ALLCHANNELS_UNSUPPORTED = 0xFFFF     
   217 } AUDIO_COMMON_STATUS;
   207 } AUDIO_COMMON_STATUS;
   218         
   208         
   219 typedef enum AUDIO_HAL_HW_LOOPS { 
   209 typedef enum AUDIO_HAL_HW_LOOPS { 
   220      AUDIO_NOLOOP = 0,
   210      AUDIO_NOLOOP = 0,
   221      AUDIO_SIDETONE_LOOP = 0xFFFF
   211      AUDIO_SIDETONE_LOOP = 0xFFFF
   238      AUDIO_HAL_32BIT_BURST_MULTI_READ,
   228      AUDIO_HAL_32BIT_BURST_MULTI_READ,
   239      AUDIO_HAL_32BIT_BURST_MULTI_WRITE = 0xFFFF     
   229      AUDIO_HAL_32BIT_BURST_MULTI_WRITE = 0xFFFF     
   240 } AUDIO_HAL_HW_OPERATION;
   230 } AUDIO_HAL_HW_OPERATION;
   241 
   231 
   242 typedef enum AUDIO_HAL_HW_REGISTER_TYPE { 
   232 typedef enum AUDIO_HAL_HW_REGISTER_TYPE { 
   243      OMX_AUDIO_IO = 0,
   233      AUDIO_HAL_IO = 0,
   244      OMX_AUDIO_I2C,
   234      AUDIO_HAL_I2C,
   245      OMX_AUDIO_SLIMBUS,
   235      AUDIO_HAL_SLIMBUS,
   246      OMX_AUDIO_CBUS = 0xFFFF     
   236      AUDIO_HAL_CBUS = 0xFFFF     
   247 } AUDIO_HAL_HW_REGISTER_TYPE;
   237 } AUDIO_HAL_HW_REGISTER_TYPE;
   248 
       
   249 
       
   250 /** 16 bit unsigned quantity that is 16 bit word aligned */
       
   251 typedef unsigned short uint16;
       
   252 
       
   253 /** 16 bit signed quantity that is 16 bit word aligned */
       
   254 typedef signed short int16;
       
   255 
       
   256 /** 32 bit unsigned quantity that is 32 bit word aligned */
       
   257 typedef unsigned long uint32;
       
   258 
       
   259 /** signed quantity that is 32 bit word aligned */
       
   260 typedef signed long int32;
       
   261 
   238 
   262 typedef struct AUDIO_HAL_REGBANK_DESCRIPTOR{ 
   239 typedef struct AUDIO_HAL_REGBANK_DESCRIPTOR{ 
   263      uint32 reg_bank_index;   
   240      uint32 reg_bank_index;   
   264      uint32 logical_start_addr;
   241      uint32 logical_start_addr;
   265      uint32 logical_end_addr;
   242      uint32 logical_end_addr;
   277      
   254      
   278 } AUDIO_HAL_GAIN_DESCRIPTOR;
   255 } AUDIO_HAL_GAIN_DESCRIPTOR;
   279 
   256 
   280 typedef struct AUDIO_TIMED_RAMP_INFO  { 
   257 typedef struct AUDIO_TIMED_RAMP_INFO  { 
   281 
   258 
   282       uint32 linear,
   259       uint32 linear;
   283       int32 ramp_start_volume;
   260       int32 ramp_start_volume;
   284       int32 ramp_end_volume;
   261       int32 ramp_end_volume;
   285       int32 current_volume;
   262       int32 current_volume;
   286       uint32 current_time_hi;
   263       uint32 current_time_hi;
   287       uint32 current_time_lo;
   264       uint32 current_time_lo;
   293       int32 max_volume;
   270       int32 max_volume;
   294       uint32 volume_step;
   271       uint32 volume_step;
   295      
   272      
   296 } AUDIO_TIMED_RAMP_INFO;
   273 } AUDIO_TIMED_RAMP_INFO;
   297 
   274 
   298 
   275 // Function prototypes
   299 /* API functions */
       
   300 
       
   301 /* The convention for the functions will be:       */
       
   302 /* <supplier>_<component>_<API function name(...)>    */
       
   303 
   276 
   304 /* HAL layer */
   277 /* HAL layer */
   305 
   278 
   306 void audio_hal_mute_control (void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   279 void audio_hal_mute_control (void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
   307                              uint32 channel_index, 
   280                              uint32 channel_index, 
   308                              AUDIO_COMMON_SWITCH mute_control);
   281                              AUDIO_COMMON_SWITCH mute_control);
   309 
   282 
   310 AUDIO_COMMON_SWITCH audio_hal_mute_status (uint32 channel_index);
   283 AUDIO_COMMON_SWITCH audio_hal_mute_status (uint32 channel_index);
   311 
   284 
   312 void audio_hal_power_control (void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   285 void audio_hal_power_control (void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
   313                              uint32 channel_index, AUDIO_COMMON_SWITCH power_control);
   286                              uint32 channel_index, AUDIO_COMMON_SWITCH power_control);
   314 
   287 
   315 AUDIO_COMMON_SWITCH audio_hal_power_status(uint32 channel_index);
   288 AUDIO_COMMON_SWITCH audio_hal_power_status(uint32 channel_index);
   316 
   289 
   317 void audio_hal_gain_capabilities_query(uint32* num_channels, uint16* max_num_gains);
   290 void audio_hal_gain_capabilities_query(uint32* num_channels, uint16* max_num_gains);
   318 
   291 
   319 void audio_hal_gains_descriptor_query(AUDIO_HAL_GAIN_DESCRIPTOR* gain_descriptor_table);
   292 void audio_hal_gains_descriptor_query(AUDIO_HAL_GAIN_DESCRIPTOR* gain_descriptor_table);
   320 
   293 
   321 void audio_hal_loop_gain_capabilities_query(AUDIO_HAL_HW_LOOPS* num_loops, uint16* max_num_gains);
   294 void audio_hal_loop_gain_capabilities_query(uint16* num_loops, uint16* max_num_gains);
   322 
   295 
   323 void audio_hal_supported_loops_query (uint16* supported_loop_indexes);
   296 void audio_hal_supported_loops_query (uint16* supported_loop_indexes);
   324 
   297 
   325 void audio_hal_loop_gains_descriptor_query (AUDIO_HAL_HW_LOOPS loop_index,
   298 void audio_hal_loop_gains_descriptor_query (AUDIO_HAL_HW_LOOPS loop_index,
   326                                     AUDIO_HAL_GAIN_DESCRIPTOR* gain_descriptor_table);
   299                                     AUDIO_HAL_GAIN_DESCRIPTOR* gain_descriptor_table);
   327 
   300 
   328 AUDIO_COMMON_STATUS audio_hal_gain_control (uint32 channel_index, uint16 gain_index,
   301 AUDIO_COMMON_STATUS audio_hal_gain_control (void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
       
   302                                     uint32 channel_index, uint16 gain_index,
   329                                     uint32 linear, int32 gain_value);
   303                                     uint32 linear, int32 gain_value);
   330 
   304 
   331 AUDIO_COMMON_STATUS audio_hal_gain_query (uint32 channel_index, uint16 gain_index,
   305 AUDIO_COMMON_STATUS audio_hal_gain_query (uint32 channel_index, uint16 gain_index,
   332                                     uint32 linear, int32* gain_value);
   306                                     uint32 linear, int32* gain_value);
   333 
   307 
   334 AUDIO_COMMON_STATUS audio_hal_loop_control(AUDIO_HAL_HW_LOOPS loop_index, AUDIO_COMMON_SWITCH loop_switch,
   308 AUDIO_COMMON_STATUS audio_hal_loop_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, 
       
   309                                                   AUDIO_HAL_HW_LOOPS loop_index, uint32 extra_status_info), 
       
   310                                     AUDIO_HAL_HW_LOOPS loop_index, AUDIO_COMMON_SWITCH loop_switch,
   335                                     uint16 channel_index, uint16 gain_index, uint32 linear,
   311                                     uint16 channel_index, uint16 gain_index, uint32 linear,
   336                                     int32 loop_gain_value);
   312                                     int32 loop_gain_value);
   337 
   313 
   338 															             
   314 															             
   339 uint16 audio_hal_registerbank_query();
   315 uint16 audio_hal_registerbank_query();
   344                                  AUDIO_HAL_HW_OPERATION hw_operation, AUDIO_HAL_HW_REGISTER_TYPE register_type,
   320                                  AUDIO_HAL_HW_OPERATION hw_operation, AUDIO_HAL_HW_REGISTER_TYPE register_type,
   345                                  uint16 num_data, uint32* address_data_sequence);
   321                                  uint16 num_data, uint32* address_data_sequence);
   346 
   322 
   347                                  
   323                                  
   348 /* Sequencer layer */
   324 /* Sequencer layer */
   349 void audio_sequencer_mute_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   325 void audio_sequencer_mute_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
   350                                   uint32 channel_index, AUDIO_COMMON_SWITCH mute_control);
   326                                   uint32 channel_index, AUDIO_COMMON_SWITCH mute_control);
   351 
   327 
   352 void audio_sequencer_power_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   328 void audio_sequencer_power_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
   353                                   uint32 channel_index, AUDIO_COMMON_SWITCH power_control);
   329                                   uint32 channel_index, AUDIO_COMMON_SWITCH power_control);
   354                                   
   330                                   
   355 AUDIO_COMMON_STATUS audio_sequencer_burst_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   331 AUDIO_COMMON_STATUS audio_sequencer_burst_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 extra_status_info), 
   356                                                   AUDIO_COMMON_SWITCH burst_control);
   332                                                   AUDIO_COMMON_SWITCH burst_control);
   357 
   333 
   358 void audio_sequencer_volume_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   334 void audio_sequencer_volume_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
   359                                      uint32 channel_index, uint32 linear, int32 volume);
   335                                      uint32 channel_index, uint32 linear, int32 volume);
   360 
   336 
   361 void audio_sequencer_volume_query(uint32 channel_index, uint32 linear, int32* min_volume,
   337 void audio_sequencer_volume_query(uint32 channel_index, uint32 linear, int32* min_volume, int32* max_volume, int32* current_volume);
   362                                    int32* max_volume, int32* current_volume);
       
   363 
   338 
   364 /* Timing critical layer */
   339 /* Timing critical layer */
   365 void audio_timed_mute_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   340 void audio_timed_mute_control(void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
   366                               uint32 channel_index, AUDIO_COMMON_SWITCH mute_control);
   341                               uint32 channel_index, AUDIO_COMMON_SWITCH mute_control);
   367                               
   342                               
   368 void audio_timed_volume_ramp_control (void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status), 
   343 void audio_timed_volume_ramp_control (void (*call_back_fn_ptr)(AUDIO_COMMON_STATUS status, uint32 channel_index, uint32 extra_status_info), 
   369                              uint32 channel_index, uint32 linear, int32 start_volume,
   344                              uint32 channel_index, uint32 linear, int32 start_volume,
   370                              int32 end_volume, uint32 ramp_duration_hi, uint32 ram_duration_lo,
   345                              int32 end_volume, uint32 ramp_duration_hi, uint32 ram_duration_lo,
   371                              AUDIO_COMMON_SWITCH ramp_terminate);
   346                              AUDIO_COMMON_SWITCH ramp_terminate);
   372 
   347 
   373 void audio_timed_volume_ramp_query (uint32 channel_index, AUDIO_TIMED_RAMP_INFO* volume_ramp_info);
   348 void audio_timed_volume_ramp_query (uint32 channel_index, AUDIO_TIMED_RAMP_INFO* volume_ramp_info);
   374 
   349 
   375 
   350 
   376                                      
       
   377 
       
   378 #ifdef __cplusplus
   351 #ifdef __cplusplus
   379 }
   352 }
   380 #endif /* __cplusplus */
   353 #endif /* __cplusplus */
   381 
   354 
   382 #endif
   355 #endif /* OMX_Nokia_AudioExt_h */