Merge "hal: fix unused param warnings"

16 files changed, 227 insertions, 192 deletions

diff --git a/hal/audio_extn/audio_extn.c b/hal/audio_extn/audio_extn.c
index c1b53aa3..6c158795 100644
--- a/hal/audio_extn/audio_extn.c
+++ b/hal/audio_extn/audio_extn.c
@@ -209,7 +209,7 @@ void audio_extn_set_fluence_parameters(struct audio_device *adev,
     }
 }
 
-int audio_extn_get_fluence_parameters(struct audio_device *adev,
+int audio_extn_get_fluence_parameters(const struct audio_device *adev,
                        struct str_parms *query, struct str_parms *reply)
 {
     int ret = 0, err;
diff --git a/hal/audio_extn/audio_extn.h b/hal/audio_extn/audio_extn.h
index c0d8b411..e6d28f7c 100644
--- a/hal/audio_extn/audio_extn.h
+++ b/hal/audio_extn/audio_extn.h
@@ -76,7 +76,7 @@ bool audio_extn_should_use_handset_anc(int in_channels);
 #else
 void audio_extn_set_fluence_parameters(struct audio_device *adev,
                                            struct str_parms *parms);
-int audio_extn_get_fluence_parameters(struct audio_device *adev,
+int audio_extn_get_fluence_parameters(const struct audio_device *adev,
                   struct str_parms *query, struct str_parms *reply);
 #endif
 
@@ -113,14 +113,13 @@ bool audio_extn_usb_is_proxy_inuse();
 #endif
 
 #ifndef SSR_ENABLED
-#define audio_extn_ssr_init(adev, in)                 (0)
+#define audio_extn_ssr_init(in)                       (0)
 #define audio_extn_ssr_deinit()                       (0)
 #define audio_extn_ssr_update_enabled()               (0)
 #define audio_extn_ssr_get_enabled()                  (0)
 #define audio_extn_ssr_read(stream, buffer, bytes)    (0)
 #else
-int32_t audio_extn_ssr_init(struct audio_device *adev,
-                            struct stream_in *in);
+int32_t audio_extn_ssr_init(struct stream_in *in);
 int32_t audio_extn_ssr_deinit();
 void audio_extn_ssr_update_enabled();
 bool audio_extn_ssr_get_enabled();
@@ -181,7 +180,7 @@ bool audio_extn_spkr_prot_is_enabled();
 #endif
 
 #ifndef COMPRESS_CAPTURE_ENABLED
-#define audio_extn_compr_cap_init(adev,in)                (0)
+#define audio_extn_compr_cap_init(in)                     (0)
 #define audio_extn_compr_cap_enabled()                    (0)
 #define audio_extn_compr_cap_format_supported(format)     (0)
 #define audio_extn_compr_cap_usecase_supported(usecase)   (0)
@@ -189,8 +188,7 @@ bool audio_extn_spkr_prot_is_enabled();
 #define audio_extn_compr_cap_read(in, buffer, bytes)      (0)
 #define audio_extn_compr_cap_deinit()                     (0)
 #else
-void audio_extn_compr_cap_init(struct audio_device *adev,
-                                    struct stream_in *in);
+void audio_extn_compr_cap_init(struct stream_in *in);
 bool audio_extn_compr_cap_enabled();
 bool audio_extn_compr_cap_format_supported(audio_format_t format);
 bool audio_extn_compr_cap_usecase_supported(audio_usecase_t usecase);
@@ -292,8 +290,4 @@ int audio_extn_dolby_set_dap_bypass(struct audio_device *adev, int state);
 #define audio_extn_ds2_enable(adev)                                   (0)
 #define audio_extn_dolby_set_dap_bypass(adev, state)                  (0)
 #endif
-typedef enum {
-    DAP_STATE_ON = 0,
-    DAP_STATE_BYPASS,
-};
 #endif /* AUDIO_EXTN_H */
diff --git a/hal/audio_extn/compress_capture.c b/hal/audio_extn/compress_capture.c
index 0a2de360..cdc1adb2 100644
--- a/hal/audio_extn/compress_capture.c
+++ b/hal/audio_extn/compress_capture.c
@@ -51,8 +51,7 @@ static struct compress_in_module c_in_mod = {
 };
 
 
-void audio_extn_compr_cap_init(struct audio_device *adev,
-                            struct stream_in *in)
+void audio_extn_compr_cap_init(struct stream_in *in)
 {
     in->usecase = USECASE_AUDIO_RECORD_COMPRESS;
     in->config.channels = COMPRESS_IN_CONFIG_CHANNELS;
@@ -137,7 +136,7 @@ size_t audio_extn_compr_cap_read(struct stream_in * in,
                     header->frame_size =
                         bytes - sizeof(*header) - header->reserved[0];
                 }
-                ALOGV("c_in_buf: %p, data offset: %p, header size: %u,"
+                ALOGV("c_in_buf: %p, data offset: %p, header size: %zu,"
                     "reserved[0]: %u frame_size: %d", c_in_mod.in_buf,
                         c_in_mod.in_buf + c_in_header,
                         sizeof(*header), header->reserved[0],
diff --git a/hal/audio_extn/dolby.c b/hal/audio_extn/dolby.c
index 7333be78..c24a5e29 100644
--- a/hal/audio_extn/dolby.c
+++ b/hal/audio_extn/dolby.c
@@ -184,7 +184,7 @@ int update_ddp_endp_table(int device, int dev_ch_cap, int param_id,
 
 void send_ddp_endp_params_stream(struct stream_out *out,
                                  int device, int dev_ch_cap,
-                                 bool set_cache)
+                                 bool set_cache __unused)
 {
     int idx, i;
     int ddp_endp_params_data[2*DDP_ENDP_NUM_PARAMS + 1];
diff --git a/hal/audio_extn/hfp.c b/hal/audio_extn/hfp.c
index c841c92d..c40b803c 100644
--- a/hal/audio_extn/hfp.c
+++ b/hal/audio_extn/hfp.c
@@ -80,7 +80,7 @@ static struct pcm_config pcm_config_hfp = {
 };
 
 static int32_t start_hfp(struct audio_device *adev,
-                               struct str_parms *parms)
+                         struct str_parms *parms __unused)
 {
     int32_t i, ret = 0;
     struct audio_usecase *uc_info;
@@ -238,7 +238,7 @@ void audio_extn_hfp_set_parameters(struct audio_device *adev, struct str_parms *
     ret = str_parms_get_str(parms, AUDIO_PARAMETER_HFP_ENABLE, value,
                             sizeof(value));
     if (ret >= 0) {
-           if(!strncmp(value,"true",sizeof(value)))
+           if (!strncmp(value,"true",sizeof(value)))
                ret = start_hfp(adev,parms);
            else
                stop_hfp(adev);
@@ -251,22 +251,20 @@ void audio_extn_hfp_set_parameters(struct audio_device *adev, struct str_parms *
            if (rate == 8000){
                hfpmod.ucid = USECASE_AUDIO_HFP_SCO;
                pcm_config_hfp.rate = rate;
-           }
-           else if (rate == 16000){
+           } else if (rate == 16000){
                hfpmod.ucid = USECASE_AUDIO_HFP_SCO_WB;
                pcm_config_hfp.rate = rate;
-           }
-           else
+           } else
                ALOGE("Unsupported rate..");
     }
 
-    if(hfpmod.is_hfp_running) {
+    if (hfpmod.is_hfp_running) {
         memset(value, 0, sizeof(value));
         ret = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING,
                                 value, sizeof(value));
         if (ret >= 0) {
             val = atoi(value);
-            if(val > 0)
+            if (val > 0)
                 select_devices(adev, hfpmod.ucid);
         }
     }
diff --git a/hal/audio_extn/spkr_protection.c b/hal/audio_extn/spkr_protection.c
index 7932e484..f2db4d0c 100644
--- a/hal/audio_extn/spkr_protection.c
+++ b/hal/audio_extn/spkr_protection.c
@@ -111,7 +111,7 @@ struct speaker_prot_session {
     struct pcm *pcm_rx;
     struct pcm *pcm_tx;
     int (*client_register_callback)
-    (char *client_name, int (*callback)(int, void *, void *), void *data);
+    (char *client_name, int (*callback)(int), void *data);
     void (*thermal_client_unregister_callback)(int handle);
     int (*thermal_client_request)(char *client_name, int req_data);
     bool spkr_prot_enable;
@@ -372,7 +372,7 @@ exit:
     return status.status;
 }
 
-static void* spkr_calibration_thread(void *context)
+static void* spkr_calibration_thread()
 {
     unsigned long sec = 0;
     int t0;
@@ -496,7 +496,7 @@ static void* spkr_calibration_thread(void *context)
     return NULL;
 }
 
-static int thermal_client_callback(int temp, void *user_data, void *reserved)
+static int thermal_client_callback(int temp)
 {
     pthread_mutex_lock(&handle.spkr_prot_thermalsync_mutex);
     ALOGD("%s: spkr_prot set t0 %d and signal", __func__, temp);
@@ -541,7 +541,7 @@ void audio_extn_spkr_prot_init(void *adev)
     } else {
         /*Query callback function symbol*/
         handle.client_register_callback =
-       (int (*)(char *, int (*)(int, void *, void *),void *))
+       (int (*)(char *, int (*)(int),void *))
         dlsym(handle.thermal_handle, "thermal_client_register_callback");
         handle.thermal_client_unregister_callback =
         (void (*)(int) )
diff --git a/hal/audio_extn/ssr.c b/hal/audio_extn/ssr.c
index ac6da8b7..db4c04cd 100644
--- a/hal/audio_extn/ssr.c
+++ b/hal/audio_extn/ssr.c
@@ -63,10 +63,10 @@ typedef void (*surround_filters_intl_process_t)(void *, Word16 *, Word16 *);
 struct ssr_module {
     FILE                *fp_4ch;
     FILE                *fp_6ch;
-    int16_t             **real_coeffs;
-    int16_t             **imag_coeffs;
+    Word16             **real_coeffs;
+    Word16             **imag_coeffs;
     void                *surround_obj;
-    int16_t             *surround_raw_buffer;
+    Word16             *surround_raw_buffer;
     bool                is_ssr_enabled;
 
     void *surround_filters_handle;
@@ -378,8 +378,7 @@ bool audio_extn_ssr_get_enabled()
     return (ssrmod.is_ssr_enabled ? true: false);
 }
 
-int32_t audio_extn_ssr_init(struct audio_device *adev,
-                            struct stream_in *in)
+int32_t audio_extn_ssr_init(struct stream_in *in)
 {
     uint32_t ret;
     char c_multi_ch_dump[128] = {0};
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index 67e7b60a..3484a50e 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -1330,7 +1330,8 @@ static uint32_t out_get_sample_rate(const struct audio_stream *stream)
     return out->sample_rate;
 }
 
-static int out_set_sample_rate(struct audio_stream *stream, uint32_t rate)
+static int out_set_sample_rate(struct audio_stream *stream __unused,
+                               uint32_t rate __unused)
 {
     return -ENOSYS;
 }
@@ -1362,7 +1363,8 @@ static audio_format_t out_get_format(const struct audio_stream *stream)
     return out->format;
 }
 
-static int out_set_format(struct audio_stream *stream, audio_format_t format)
+static int out_set_format(struct audio_stream *stream __unused,
+                          audio_format_t format __unused)
 {
     return -ENOSYS;
 }
@@ -1408,7 +1410,8 @@ static int out_standby(struct audio_stream *stream)
     return 0;
 }
 
-static int out_dump(const struct audio_stream *stream, int fd)
+static int out_dump(const struct audio_stream *stream __unused,
+                    int fd __unused)
 {
     return 0;
 }
@@ -1724,7 +1727,7 @@ static ssize_t out_write(struct audio_stream_out *stream, const void *buffer,
     }
 
     if (is_offload_usecase(out->usecase)) {
-        ALOGVV("copl(%x): writing buffer (%d bytes) to compress device", (unsigned int)out, bytes);
+        ALOGVV("copl(%x): writing buffer (%zu bytes) to compress device", out, bytes);
         if (out->send_new_metadata) {
             ALOGVV("send new gapless metadata");
             compress_set_gapless_metadata(out->compr, &out->gapless_mdata);
@@ -1786,18 +1789,20 @@ static int out_get_render_position(const struct audio_stream_out *stream,
         return -EINVAL;
 }
 
-static int out_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+static int out_add_audio_effect(const struct audio_stream *stream __unused,
+                                effect_handle_t effect __unused)
 {
     return 0;
 }
 
-static int out_remove_audio_effect(const struct audio_stream *stream, effect_handle_t effect)
+static int out_remove_audio_effect(const struct audio_stream *stream __unused,
+                                   effect_handle_t effect __unused)
 {
     return 0;
 }
 
-static int out_get_next_write_timestamp(const struct audio_stream_out *stream,
-                                        int64_t *timestamp)
+static int out_get_next_write_timestamp(const struct audio_stream_out *stream __unused,
+                                        int64_t *timestamp __unused)
 {
     return -EINVAL;
 }
@@ -1824,7 +1829,7 @@ static int out_get_presentation_position(const struct audio_stream_out *stream,
         }
     } else {
         if (out->pcm) {
-            size_t avail;
+            unsigned int avail;
             if (pcm_get_htimestamp(out->pcm, &avail, timestamp) == 0) {
                 size_t kernel_buffer_size = out->config.period_size * out->config.period_count;
                 int64_t signed_frames = out->written - kernel_buffer_size + avail;
@@ -1933,7 +1938,8 @@ static uint32_t in_get_sample_rate(const struct audio_stream *stream)
     return in->config.rate;
 }
 
-static int in_set_sample_rate(struct audio_stream *stream, uint32_t rate)
+static int in_set_sample_rate(struct audio_stream *stream __unused,
+                              uint32_t rate __unused)
 {
     return -ENOSYS;
 }
@@ -1965,7 +1971,8 @@ static audio_format_t in_get_format(const struct audio_stream *stream)
     return in->format;
 }
 
-static int in_set_format(struct audio_stream *stream, audio_format_t format)
+static int in_set_format(struct audio_stream *stream __unused,
+                         audio_format_t format __unused)
 {
     return -ENOSYS;
 }
@@ -2001,7 +2008,8 @@ static int in_standby(struct audio_stream *stream)
     return status;
 }
 
-static int in_dump(const struct audio_stream *stream, int fd)
+static int in_dump(const struct audio_stream *stream __unused,
+                   int fd __unused)
 {
     return 0;
 }
@@ -2087,7 +2095,8 @@ static char* in_get_parameters(const struct audio_stream *stream,
     return str;
 }
 
-static int in_set_gain(struct audio_stream_in *stream, float gain)
+static int in_set_gain(struct audio_stream_in *stream __unused,
+                       float gain __unused)
 {
     return 0;
 }
@@ -2142,7 +2151,7 @@ exit:
     return bytes;
 }
 
-static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream)
+static uint32_t in_get_input_frames_lost(struct audio_stream_in *stream __unused)
 {
     return 0;
 }
@@ -2442,7 +2451,7 @@ error_open:
     return ret;
 }
 
-static void adev_close_output_stream(struct audio_hw_device *dev,
+static void adev_close_output_stream(struct audio_hw_device *dev __unused,
                                      struct audio_stream_out *stream)
 {
     struct stream_out *out = (struct stream_out *)stream;
@@ -2587,7 +2596,7 @@ static char* adev_get_parameters(const struct audio_hw_device *dev,
     return str;
 }
 
-static int adev_init_check(const struct audio_hw_device *dev)
+static int adev_init_check(const struct audio_hw_device *dev __unused)
 {
     return 0;
 }
@@ -2603,23 +2612,26 @@ static int adev_set_voice_volume(struct audio_hw_device *dev, float volume)
     return ret;
 }
 
-static int adev_set_master_volume(struct audio_hw_device *dev, float volume)
+static int adev_set_master_volume(struct audio_hw_device *dev __unused,
+                                  float volume __unused)
 {
     return -ENOSYS;
 }
 
-static int adev_get_master_volume(struct audio_hw_device *dev,
-                                  float *volume)
+static int adev_get_master_volume(struct audio_hw_device *dev __unused,
+                                  float *volume __unused)
 {
     return -ENOSYS;
 }
 
-static int adev_set_master_mute(struct audio_hw_device *dev, bool muted)
+static int adev_set_master_mute(struct audio_hw_device *dev __unused,
+                                bool muted __unused)
 {
     return -ENOSYS;
 }
 
-static int adev_get_master_mute(struct audio_hw_device *dev, bool *muted)
+static int adev_get_master_mute(struct audio_hw_device *dev __unused,
+                                bool *muted __unused)
 {
     return -ENOSYS;
 }
@@ -2654,7 +2666,7 @@ static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state)
     return 0;
 }
 
-static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
+static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev __unused,
                                          const struct audio_config *config)
 {
     int channel_count = audio_channel_count_from_in_mask(config->channel_mask);
@@ -2663,7 +2675,7 @@ static size_t adev_get_input_buffer_size(const struct audio_hw_device *dev,
 }
 
 static int adev_open_input_stream(struct audio_hw_device *dev,
-                                  audio_io_handle_t handle,
+                                  audio_io_handle_t handle __unused,
                                   audio_devices_t devices,
                                   struct audio_config *config,
                                   struct audio_stream_in **stream_in,
@@ -2715,7 +2727,7 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
 
     if (channel_count == 6) {
         if(audio_extn_ssr_get_enabled()) {
-            if(audio_extn_ssr_init(adev, in)) {
+            if(audio_extn_ssr_init(in)) {
                 ALOGE("%s: audio_extn_ssr_init failed", __func__);
                 ret = -EINVAL;
                 goto err_open;
@@ -2726,7 +2738,7 @@ static int adev_open_input_stream(struct audio_hw_device *dev,
     } else if (audio_extn_compr_cap_enabled() &&
             audio_extn_compr_cap_format_supported(config->format) &&
             (in->dev->mode != AUDIO_MODE_IN_COMMUNICATION)) {
-        audio_extn_compr_cap_init(adev, in);
+        audio_extn_compr_cap_init(in);
     } else {
         in->config.channels = channel_count;
         frame_size = audio_stream_in_frame_size(&in->stream);
@@ -2751,10 +2763,14 @@ static void adev_close_input_stream(struct audio_hw_device *dev,
 {
     int ret;
     struct stream_in *in = (struct stream_in *)stream;
-    ALOGV("%s", __func__);
+    struct audio_device *adev = (struct audio_device *)dev;
+
+    ALOGD("%s: enter:stream_handle(%p)",__func__, in);
 
     if (in->usecase == USECASE_COMPRESS_VOIP_CALL) {
+        pthread_mutex_lock(&adev->lock);
         ret = voice_extn_compress_voip_close_input_stream(&stream->common);
+        pthread_mutex_unlock(&adev->lock);
         if (ret != 0)
             ALOGE("%s: Compress voip input cannot be closed, error:%d",
                   __func__, ret);
@@ -2765,15 +2781,17 @@ static void adev_close_input_stream(struct audio_hw_device *dev,
             (audio_channel_count_from_in_mask(in->channel_mask) == 6)) {
         audio_extn_ssr_deinit();
     }
-    free(stream);
 
     if(audio_extn_compr_cap_enabled() &&
             audio_extn_compr_cap_format_supported(in->config.format))
         audio_extn_compr_cap_deinit();
+
+    free(stream);
     return;
 }
 
-static int adev_dump(const audio_hw_device_t *device, int fd)
+static int adev_dump(const audio_hw_device_t *device __unused,
+                     int fd __unused)
 {
     return 0;
 }
diff --git a/hal/msm8960/platform.c b/hal/msm8960/platform.c
index 73749718..997b6535 100644
--- a/hal/msm8960/platform.c
+++ b/hal/msm8960/platform.c
@@ -82,8 +82,6 @@ struct platform_data {
     int  fluence_type;
     int  dualmic_config;
 
-    void *hw_info;
-
     /* Audio calibration related functions */
     void *acdb_handle;
     acdb_init_t acdb_init;
@@ -126,9 +124,12 @@ static const char * const device_table[SND_DEVICE_MAX] = {
     [SND_DEVICE_OUT_HDMI] = "hdmi",
     [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = "speaker-and-hdmi",
     [SND_DEVICE_OUT_BT_SCO] = "bt-sco-headset",
+    [SND_DEVICE_OUT_BT_SCO_WB] = "bt-sco-headset-wb",
     [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = "voice-tty-full-headphones",
     [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = "voice-tty-vco-headphones",
     [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = "voice-tty-hco-handset",
+    [SND_DEVICE_OUT_USB_HEADSET] = "usb-headphones",
+    [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = "speaker-and-usb-headphones",
 
     /* Capture sound devices */
     [SND_DEVICE_IN_HANDSET_MIC] = "handset-mic",
@@ -141,6 +142,7 @@ static const char * const device_table[SND_DEVICE_MAX] = {
     [SND_DEVICE_IN_VOICE_HEADSET_MIC] = "voice-headset-mic",
     [SND_DEVICE_IN_HDMI_MIC] = "hdmi-mic",
     [SND_DEVICE_IN_BT_SCO_MIC] = "bt-sco-mic",
+    [SND_DEVICE_IN_BT_SCO_MIC_WB] = "bt-sco-mic-wb",
     [SND_DEVICE_IN_CAMCORDER_MIC] = "camcorder-mic",
     [SND_DEVICE_IN_VOICE_DMIC] = "voice-dmic-ef",
     [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = "voice-speaker-dmic-ef",
@@ -150,6 +152,7 @@ static const char * const device_table[SND_DEVICE_MAX] = {
     [SND_DEVICE_IN_VOICE_REC_MIC] = "voice-rec-mic",
     [SND_DEVICE_IN_VOICE_REC_DMIC] = "voice-rec-dmic-ef",
     [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = "voice-rec-dmic-ef-fluence",
+    [SND_DEVICE_IN_USB_HEADSET_MIC] = "usb-headset-mic",
 };
 
 /* ACDB IDs (audio DSP path configuration IDs) for each sound device */
@@ -165,9 +168,12 @@ static const int acdb_device_table[SND_DEVICE_MAX] = {
     [SND_DEVICE_OUT_HDMI] = 18,
     [SND_DEVICE_OUT_SPEAKER_AND_HDMI] = 14,
     [SND_DEVICE_OUT_BT_SCO] = 22,
+    [SND_DEVICE_OUT_BT_SCO_WB] = 39,
     [SND_DEVICE_OUT_VOICE_TTY_FULL_HEADPHONES] = 17,
     [SND_DEVICE_OUT_VOICE_TTY_VCO_HEADPHONES] = 17,
     [SND_DEVICE_OUT_VOICE_TTY_HCO_HANDSET] = 37,
+    [SND_DEVICE_OUT_USB_HEADSET] = 45,
+    [SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET] = 14,
 
     [SND_DEVICE_IN_HANDSET_MIC] = 4,
     [SND_DEVICE_IN_SPEAKER_MIC] = 4,
@@ -179,6 +185,7 @@ static const int acdb_device_table[SND_DEVICE_MAX] = {
     [SND_DEVICE_IN_VOICE_HEADSET_MIC] = 8,
     [SND_DEVICE_IN_HDMI_MIC] = 4,
     [SND_DEVICE_IN_BT_SCO_MIC] = 21,
+    [SND_DEVICE_IN_BT_SCO_MIC_WB] = 38,
     [SND_DEVICE_IN_CAMCORDER_MIC] = 61,
     [SND_DEVICE_IN_VOICE_DMIC] = 6,
     [SND_DEVICE_IN_VOICE_SPEAKER_DMIC] = 13,
@@ -186,6 +193,7 @@ static const int acdb_device_table[SND_DEVICE_MAX] = {
     [SND_DEVICE_IN_VOICE_TTY_VCO_HANDSET_MIC] = 36,
     [SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC] = 16,
     [SND_DEVICE_IN_VOICE_REC_MIC] = 62,
+    [SND_DEVICE_IN_USB_HEADSET_MIC] = 44,
     /* TODO: Update with proper acdb ids */
     [SND_DEVICE_IN_VOICE_REC_DMIC] = 62,
     [SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE] = 6,
@@ -228,10 +236,6 @@ void *platform_init(struct audio_device *adev)
     my_data = calloc(1, sizeof(struct platform_data));
 
     snd_card_name = mixer_get_name(adev->mixer);
-    my_data->hw_info = hw_info_init(snd_card_name);
-    if (!my_data->hw_info) {
-        ALOGE("%s: Failed to init hardware info", __func__);
-    }
 
     my_data->adev = adev;
     my_data->fluence_in_spkr_mode = false;
@@ -332,7 +336,6 @@ void platform_deinit(void *platform)
 {
     struct platform_data *my_data = (struct platform_data *)platform;
 
-    hw_info_deinit(my_data->hw_info);
     free(platform);
 }
 
@@ -351,7 +354,6 @@ int platform_get_snd_device_name_extn(void *platform, snd_device_t snd_device,
 
     if (snd_device >= SND_DEVICE_MIN && snd_device < SND_DEVICE_MAX) {
         strlcpy(device_name, device_table[snd_device], DEVICE_NAME_MAX_SIZE);
-        hw_info_append_hw_type(my_data->hw_info, snd_device, device_name);
     } else {
         strlcpy(device_name, "", DEVICE_NAME_MAX_SIZE);
         return -EINVAL;
@@ -386,16 +388,71 @@ int platform_get_pcm_device_id(audio_usecase_t usecase, int device_type)
     return device_id;
 }
 
-int platform_get_snd_device_index(char *snd_device_index_name)
+int platform_get_snd_device_index(char *snd_device_index_name __unused)
 {
     return -ENODEV;
 }
 
-int platform_set_snd_device_acdb_id(snd_device_t snd_device, unsigned int acdb_id)
+int platform_set_snd_device_acdb_id(snd_device_t snd_device __unused,
+                                    unsigned int acdb_id __unused)
 {
     return -ENODEV;
 }
 
+uint32_t platform_get_compress_offload_buffer_size(audio_offload_info_t* info __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_get_snd_device_acdb_id(snd_device_t snd_device __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_switch_voice_call_enable_device_config(void *platform __unused,
+                                                    snd_device_t out_snd_device __unused,
+                                                    snd_device_t in_snd_device __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_switch_voice_call_usecase_route_post(void *platform __unused,
+                                                  snd_device_t out_snd_device __unused,
+                                                  snd_device_t in_snd_device __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_set_incall_recording_session_id(void *platform __unused,
+                                             uint32_t session_id __unused,
+                                             int rec_mode __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_stop_incall_recording_usecase(void *platform __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_get_sample_rate(void *platform __unused, uint32_t *rate __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_get_default_app_type(void *platform __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
 int platform_send_audio_calibration(void *platform, snd_device_t snd_device)
 {
     struct platform_data *my_data = (struct platform_data *)platform;
@@ -473,7 +530,7 @@ int platform_switch_voice_call_device_post(void *platform,
     return ret;
 }
 
-int platform_start_voice_call(void *platform, uint32_t vsid)
+int platform_start_voice_call(void *platform, uint32_t vsid __unused)
 {
     struct platform_data *my_data = (struct platform_data *)platform;
     int ret = 0;
@@ -493,7 +550,7 @@ int platform_start_voice_call(void *platform, uint32_t vsid)
     return ret;
 }
 
-int platform_stop_voice_call(void *platform, uint32_t vsid)
+int platform_stop_voice_call(void *platform, uint32_t vsid __unused)
 {
     struct platform_data *my_data = (struct platform_data *)platform;
     int ret = 0;
@@ -556,7 +613,7 @@ int platform_set_mic_mute(void *platform, bool state)
     return ret;
 }
 
-int platform_set_device_mute(void *platform, bool state, char *dir)
+int platform_set_device_mute(void *platform __unused, bool state __unused, char *dir __unused)
 {
     ALOGE("%s: Not implemented", __func__);
     return -ENOSYS;
@@ -832,7 +889,7 @@ int platform_set_hdmi_channels(void *platform,  int channel_count)
     return 0;
 }
 
-int platform_edid_get_max_channels(void *platform)
+int platform_edid_get_max_channels(void *platform __unused)
 {
     FILE *file;
     struct audio_block_header header;
@@ -878,19 +935,21 @@ int platform_edid_get_max_channels(void *platform)
     return max_channels;
 }
 
-void platform_get_parameters(void *platform, struct str_parms *query,
-                             struct str_parms *reply)
+void platform_get_parameters(void *platform __unused,
+                             struct str_parms *query __unused,
+                             struct str_parms *reply __unused)
 {
     ALOGE("%s: Not implemented", __func__);
 }
 
-int platform_set_parameters(void *platform, struct str_parms *parms)
+int platform_set_parameters(void *platform __unused, struct str_parms *parms __unused)
 {
     ALOGE("%s: Not implemented", __func__);
     return -ENOSYS;
 }
 
-int platform_set_incall_recoding_session_id(void *platform, uint32_t session_id)
+int platform_set_incall_recoding_session_id(void *platform __unused,
+                                            uint32_t session_id __unused)
 {
     ALOGE("%s: Not implemented", __func__);
     return -ENOSYS;
@@ -900,7 +959,19 @@ int platform_update_lch(void *platform __unused,
                         struct voice_session *session __unused,
                         enum voice_lch_mode lch_mode __unused)
 {
-    LOGE("%s: Not implemented", __func__);
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_start_incall_music_usecase(void *platform __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
+    return -ENOSYS;
+}
+
+int platform_stop_incall_music_usecase(void *platform __unused)
+{
+    ALOGE("%s: Not implemented", __func__);
     return -ENOSYS;
 }
 
@@ -928,12 +999,6 @@ bool platform_listen_update_status(snd_device_t snd_device __unused)
      return false;
 }
 
-int platform_switch_voice_call_enable_device_config(void *platform __unused,
-                                        snd_device_t out_snd_device __unused,
-                                        snd_device_t in_snd_device __unused)
-{
-    return 0;
-}
 int platform_set_channel_allocation(void *platform __unused,
                                     int channelAlloc __unused)
 {
@@ -953,35 +1018,6 @@ int platform_get_fluence_type(void *platform __unused,
     return 0;
 }
 
-int platform_switch_voice_call_usecase_route_post(void *platform __unused,
-                                          snd_device_t out_snd_device __unused,
-                                          snd_device_t in_snd_device __unused)
-{
-    return 0;
-}
-
-int platform_set_incall_recording_session_id(void *platform __unused,
-                                             uint32_t session_id __unused,
-                                             int rec_mode __unused)
-{
-    return 0;
-}
-int platform_stop_incall_recording_usecase(void *platform __unused)
-{
-    return 0;
-}
-
-uint32_t platform_get_compress_offload_buffer_size(
-        audio_offload_info_t* info __unused)
-{
-    return 0;
-}
-
-int platform_get_sample_rate(void *platform __unused, uint32_t *rate __unused)
-{
-    return 0;
-}
-
 uint32_t platform_get_pcm_offload_buffer_size(audio_offload_info_t* info __unused)
 {
     return 0;
diff --git a/hal/msm8960/platform.h b/hal/msm8960/platform.h
index a5c5c882..bec6ed2f 100644
--- a/hal/msm8960/platform.h
+++ b/hal/msm8960/platform.h
@@ -126,4 +126,11 @@ enum {
 #define DEVICE_NAME_MAX_SIZE 128
 
 #define FM_RX_VOLUME "Internal FM RX Volume"
+
+#define DEFAULT_VOLUME_RAMP_DURATION_MS 20
+#define MAX_VOL_INDEX 5
+#define MIN_VOL_INDEX 0
+#define percent_to_index(val, min, max) \
+            ((val) * ((max) - (min)) * 0.01 + (min) + .5)
+
 #endif // QCOM_AUDIO_PLATFORM_H
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index 010002b5..59084639 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -115,7 +115,7 @@ struct audio_block_header
 
 /* Audio calibration related functions */
 typedef void (*acdb_deallocate_t)();
-typedef int  (*acdb_init_t)(char *);
+typedef int  (*acdb_init_t)(const char *);
 typedef void (*acdb_send_audio_cal_t)(int, int);
 typedef void (*acdb_send_voice_cal_t)(int, int);
 typedef int (*acdb_reload_vocvoltable_t)(int);
@@ -1368,8 +1368,7 @@ snd_device_t platform_get_output_snd_device(void *platform, audio_devices_t devi
                 snd_device = SND_DEVICE_OUT_ANC_FB_HEADSET;
             else
                 snd_device = SND_DEVICE_OUT_ANC_HEADSET;
-        }
-        else
+        } else
             snd_device = SND_DEVICE_OUT_HEADPHONES;
     } else if (devices & AUDIO_DEVICE_OUT_SPEAKER) {
         if (adev->speaker_lr_swap)
@@ -1440,8 +1439,7 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
                     snd_device = SND_DEVICE_IN_VOICE_TTY_HCO_HEADSET_MIC;
                     break;
                 default:
-                    ALOGE("%s: Invalid TTY mode (%#x)",
-                          __func__, adev->voice.tty_mode);
+                    ALOGE("%s: Invalid TTY mode (%#x)", __func__, adev->voice.tty_mode);
                 }
                 goto exit;
             }
@@ -1458,7 +1456,6 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
                 set_echo_reference(adev, true);
             } else {
                 snd_device = SND_DEVICE_IN_VOICE_DMIC;
-                adev->acdb_settings |= DMIC_FLAG;
             }
         } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
             snd_device = SND_DEVICE_IN_VOICE_HEADSET_MIC;
@@ -1472,10 +1469,8 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
                 my_data->fluence_in_voice_call &&
                 my_data->fluence_in_spkr_mode) {
                 if(my_data->fluence_type & FLUENCE_QUAD_MIC) {
-                    adev->acdb_settings |= QMIC_FLAG;
                     snd_device = SND_DEVICE_IN_VOICE_SPEAKER_QMIC;
                 } else {
-                    adev->acdb_settings |= DMIC_FLAG;
                     if (my_data->fluence_mode == FLUENCE_BROADSIDE)
                        snd_device = SND_DEVICE_IN_VOICE_SPEAKER_DMIC_BROADSIDE;
                     else
@@ -1494,13 +1489,11 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
         if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
             if (channel_count == 2) {
                 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_STEREO;
-                adev->acdb_settings |= DMIC_FLAG;
             } else if (adev->active_input->enable_ns)
                 snd_device = SND_DEVICE_IN_VOICE_REC_MIC_NS;
             else if (my_data->fluence_type != FLUENCE_NONE &&
                      my_data->fluence_in_voice_rec) {
                 snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
-                adev->acdb_settings |= DMIC_FLAG;
             } else {
                 snd_device = SND_DEVICE_IN_VOICE_REC_MIC;
             }
@@ -1518,13 +1511,11 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
                             snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS_BROADSIDE;
                         else
                             snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
                     } else
                         snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC_NS;
                 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
                     if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
                         snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
                     } else
                         snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC_NS;
                 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
@@ -1539,13 +1530,11 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
                             snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC_BROADSIDE;
                         else
                             snd_device = SND_DEVICE_IN_SPEAKER_DMIC_AEC;
-                        adev->acdb_settings |= DMIC_FLAG;
                     } else
                         snd_device = SND_DEVICE_IN_SPEAKER_MIC_AEC;
                 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
                     if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
                         snd_device = SND_DEVICE_IN_HANDSET_DMIC_AEC;
-                        adev->acdb_settings |= DMIC_FLAG;
                     } else
                         snd_device = SND_DEVICE_IN_HANDSET_MIC_AEC;
                 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
@@ -1560,13 +1549,11 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
                             snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS_BROADSIDE;
                         else
                             snd_device = SND_DEVICE_IN_SPEAKER_DMIC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
                     } else
                         snd_device = SND_DEVICE_IN_SPEAKER_MIC_NS;
                 } else if (in_device & AUDIO_DEVICE_IN_BUILTIN_MIC) {
                     if (my_data->fluence_type & FLUENCE_DUAL_MIC) {
                         snd_device = SND_DEVICE_IN_HANDSET_DMIC_NS;
-                        adev->acdb_settings |= DMIC_FLAG;
                     } else
                         snd_device = SND_DEVICE_IN_HANDSET_MIC_NS;
                 } else if (in_device & AUDIO_DEVICE_IN_WIRED_HEADSET) {
@@ -1635,7 +1622,7 @@ snd_device_t platform_get_input_snd_device(void *platform, audio_devices_t out_d
         } else if (out_device & AUDIO_DEVICE_OUT_WIRED_HEADSET) {
             snd_device = SND_DEVICE_IN_HEADSET_MIC;
         } else if (out_device & AUDIO_DEVICE_OUT_SPEAKER) {
-            if (channel_count > 1)
+            if (channel_count == 2)
                 snd_device = SND_DEVICE_IN_SPEAKER_STEREO_DMIC;
             else
                 snd_device = SND_DEVICE_IN_SPEAKER_MIC;
diff --git a/hal/platform_info.c b/hal/platform_info.c
index 85a05eb9..047ac4c6 100644
--- a/hal/platform_info.c
+++ b/hal/platform_info.c
@@ -72,7 +72,7 @@ done:
     return;
 }
 
-static void start_tag(void *userdata, const XML_Char *tag_name,
+static void start_tag(void *userdata __unused, const XML_Char *tag_name,
                       const XML_Char **attr)
 {
     const XML_Char              *attr_name = NULL;
@@ -85,7 +85,7 @@ static void start_tag(void *userdata, const XML_Char *tag_name,
     return;
 }
 
-static void end_tag(void *userdata, const XML_Char *tag_name)
+static void end_tag(void *userdata __unused, const XML_Char *tag_name __unused)
 {
 
 }
diff --git a/hal/voice.c b/hal/voice.c
index ac3c125b..8dd04bc8 100644
--- a/hal/voice.c
+++ b/hal/voice.c
@@ -442,7 +442,7 @@ void voice_init(struct audio_device *adev)
         adev->voice.session[i].pcm_tx = NULL;
         adev->voice.session[i].state.current = CALL_INACTIVE;
         adev->voice.session[i].state.new = CALL_INACTIVE;
-        adev->voice.session[i].vsid = 0;
+        adev->voice.session[i].vsid = VOICE_VSID;
     }
 
     voice_extn_init(adev);
diff --git a/hal/voice_extn/compress_voip.c b/hal/voice_extn/compress_voip.c
index 9937a612..348170a7 100644
--- a/hal/voice_extn/compress_voip.c
+++ b/hal/voice_extn/compress_voip.c
@@ -469,8 +469,7 @@ done:
     return ret;
 }
 
-void voice_extn_compress_voip_get_parameters(const struct audio_device *adev,
-                                             struct str_parms *query,
+void voice_extn_compress_voip_get_parameters(struct str_parms *query,
                                              struct str_parms *reply)
 {
     int ret;
diff --git a/hal/voice_extn/voice_extn.c b/hal/voice_extn/voice_extn.c
index adfc050c..b352f9c3 100644
--- a/hal/voice_extn/voice_extn.c
+++ b/hal/voice_extn/voice_extn.c
@@ -475,8 +475,8 @@ done:
     return ret;
 }
 
-int get_all_call_states_str(const struct audio_device *adev,
-                            char *value)
+static int get_all_call_states_str(const struct audio_device *adev,
+                                   char *value)
 {
     int ret = 0;
     char *cur_ptr = value;
@@ -520,7 +520,7 @@ void voice_extn_get_parameters(const struct audio_device *adev,
         }
         str_parms_add_str(reply, AUDIO_PARAMETER_KEY_ALL_CALL_STATES, value);
     }
-    voice_extn_compress_voip_get_parameters(adev, query, reply);
+    voice_extn_compress_voip_get_parameters(query, reply);
 
     str = str_parms_to_str(reply);
     ALOGV_IF(str != NULL, "%s: exit: returns \"%s\"", __func__, str);
diff --git a/hal/voice_extn/voice_extn.h b/hal/voice_extn/voice_extn.h
index a31aefee..4a04adb8 100644
--- a/hal/voice_extn/voice_extn.h
+++ b/hal/voice_extn/voice_extn.h
@@ -43,60 +43,60 @@ void voice_extn_out_get_parameters(struct stream_out *out,
                                    struct str_parms *query,
                                    struct str_parms *reply);
 #else
-static int voice_extn_start_call(struct audio_device *adev)
+static int voice_extn_start_call(struct audio_device *adev __unused)
 {
     return -ENOSYS;
 }
 
-static int voice_extn_stop_call(struct audio_device *adev)
+static int voice_extn_stop_call(struct audio_device *adev __unused)
 {
     return -ENOSYS;
 }
 
-static int voice_extn_get_session_from_use_case(struct audio_device *adev,
-                                                const audio_usecase_t usecase_id,
-                                                struct voice_session **session)
+static int voice_extn_get_session_from_use_case(struct audio_device *adev __unused,
+                                                const audio_usecase_t usecase_id __unused,
+                                                struct voice_session **session __unused)
 {
     return -ENOSYS;
 }
 
-static void voice_extn_init(struct audio_device *adev)
+static void voice_extn_init(struct audio_device *adev __unused)
 {
 }
 
-static int voice_extn_set_parameters(struct audio_device *adev,
-                                     struct str_parms *parms)
+static int voice_extn_set_parameters(struct audio_device *adev __unused,
+                                     struct str_parms *parms __unused)
 {
     return -ENOSYS;
 }
 
-static void voice_extn_get_parameters(const struct audio_device *adev,
-                                      struct str_parms *query,
-                                      struct str_parms *reply)
+static void voice_extn_get_parameters(const struct audio_device *adev __unused,
+                                      struct str_parms *query __unused,
+                                      struct str_parms *reply __unused)
 {
 }
 
-static int voice_extn_is_call_state_active(struct audio_device *adev,
-                                           bool *is_call_active)
+static int voice_extn_is_call_state_active(struct audio_device *adev __unused,
+                                           bool *is_call_active __unused)
 {
     return -ENOSYS;
 }
 
-static int voice_extn_get_active_session_id(struct audio_device *adev,
-                                            uint32_t *session_id)
+static int voice_extn_get_active_session_id(struct audio_device *adev __unused,
+                                            uint32_t *session_id __unused)
 {
     return -ENOSYS;
 }
 
-static void voice_extn_in_get_parameters(struct stream_in *in,
-                                         struct str_parms *query,
-                                         struct str_parms *reply)
+static void voice_extn_in_get_parameters(struct stream_in *in __unused,
+                                         struct str_parms *query __unused,
+                                         struct str_parms *reply __unused)
 {
 }
 
-static void voice_extn_out_get_parameters(struct stream_out *out,
-                                          struct str_parms *query,
-                                          struct str_parms *reply)
+static void voice_extn_out_get_parameters(struct stream_out *out __unused,
+                                          struct str_parms *query __unused,
+                                          struct str_parms *reply __unused)
 {
 }
 #endif
@@ -105,8 +105,8 @@ static void voice_extn_out_get_parameters(struct stream_out *out,
 int voice_extn_check_and_set_incall_music_usecase(struct audio_device *adev,
                                                   struct stream_out *out);
 #else
-static int voice_extn_check_and_set_incall_music_usecase(struct audio_device *adev,
-                                                         struct stream_out *out)
+static int voice_extn_check_and_set_incall_music_usecase(struct audio_device *adev __unused,
+                                                         struct stream_out *out __unused)
 {
     return -ENOSYS;
 }
@@ -132,8 +132,7 @@ int voice_extn_compress_voip_select_devices(struct audio_device *adev,
                                             snd_device_t *in_snd_device);
 int voice_extn_compress_voip_set_parameters(struct audio_device *adev,
                                              struct str_parms *parms);
-void voice_extn_compress_voip_get_parameters(const struct audio_device *adev,
-                                             struct str_parms *query,
+void voice_extn_compress_voip_get_parameters(struct str_parms *query,
                                              struct str_parms *reply);
 
 void voice_extn_compress_voip_out_get_parameters(struct stream_out *out,
@@ -147,98 +146,97 @@ bool voice_extn_compress_voip_is_active(struct audio_device *adev);
 bool voice_extn_compress_voip_is_format_supported(audio_format_t format);
 bool voice_extn_compress_voip_is_config_supported(struct audio_config *config);
 #else
-static int voice_extn_compress_voip_close_output_stream(struct audio_stream *stream)
+static int voice_extn_compress_voip_close_output_stream(struct audio_stream *stream __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_open_output_stream(struct stream_out *out)
+static int voice_extn_compress_voip_open_output_stream(struct stream_out *out __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_close_input_stream(struct audio_stream *stream)
+static int voice_extn_compress_voip_close_input_stream(struct audio_stream *stream __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_open_input_stream(struct stream_in *in)
+static int voice_extn_compress_voip_open_input_stream(struct stream_in *in __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_out_get_buffer_size(struct stream_out *stream)
+static int voice_extn_compress_voip_out_get_buffer_size(struct stream_out *stream __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_in_get_buffer_size(struct stream_in *in)
+static int voice_extn_compress_voip_in_get_buffer_size(struct stream_in *in __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_start_input_stream(struct stream_in *in)
+static int voice_extn_compress_voip_start_input_stream(struct stream_in *in __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_start_output_stream(struct stream_out *out)
+static int voice_extn_compress_voip_start_output_stream(struct stream_out *out __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_set_mic_mute(struct audio_device *adev, bool state)
+static int voice_extn_compress_voip_set_mic_mute(struct audio_device *adev, bool state __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return 0;
 }
 
-static int voice_extn_compress_voip_set_volume(struct audio_device *adev, float volume)
+static int voice_extn_compress_voip_set_volume(struct audio_device *adev __unused, float volume __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return 0;
 }
 
-static int voice_extn_compress_voip_select_devices(struct audio_device *adev,
-                                                   snd_device_t *out_snd_device,
-                                                   snd_device_t *in_snd_device)
+static int voice_extn_compress_voip_select_devices(struct audio_device *adev __unused,
+                                                   snd_device_t *out_snd_device __unused,
+                                                   snd_device_t *in_snd_device __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static int voice_extn_compress_voip_set_parameters(struct audio_device *adev,
-                                                    struct str_parms *parms)
+static int voice_extn_compress_voip_set_parameters(struct audio_device *adev __unused,
+                                                    struct str_parms *parms __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return -ENOSYS;
 }
 
-static void voice_extn_compress_voip_get_parameters(const struct audio_device *adev,
-                                                    struct str_parms *query,
-                                                    struct str_parms *reply)
+static void voice_extn_compress_voip_get_parameters(struct str_parms *query __unused,
+                                                    struct str_parms *reply __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
 }
 
-static void voice_extn_compress_voip_out_get_parameters(struct stream_out *out,
-                                                        struct str_parms *query,
-                                                        struct str_parms *reply)
+static void voice_extn_compress_voip_out_get_parameters(struct stream_out *out __unused,
+                                                        struct str_parms *query __unused,
+                                                        struct str_parms *reply __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
 }
 
-static void voice_extn_compress_voip_in_get_parameters(struct stream_in *in,
-                                                       struct str_parms *query,
-                                                       struct str_parms *reply)
+static void voice_extn_compress_voip_in_get_parameters(struct stream_in *in __unused,
+                                                       struct str_parms *query __unused,
+                                                       struct str_parms *reply __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
 }
@@ -249,19 +247,19 @@ static bool voice_extn_compress_voip_pcm_prop_check()
     return false;
 }
 
-static bool voice_extn_compress_voip_is_active(struct audio_device *adev)
+static bool voice_extn_compress_voip_is_active(struct audio_device *adev __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return false;
 }
 
-static bool voice_extn_compress_voip_is_format_supported(audio_format_t format)
+static bool voice_extn_compress_voip_is_format_supported(audio_format_t format __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return true;
 }
 
-static bool voice_extn_compress_voip_is_config_supported(struct audio_config *config)
+static bool voice_extn_compress_voip_is_config_supported(struct audio_config *config __unused)
 {
     ALOGE("%s: COMPRESS_VOIP_ENABLED is not defined", __func__);
     return true;