Add volume APIs

[Version] 0.2.9
[Profile] Common
[Issue Type] Add features

Change-Id: I0db82a4ab5c2fcef3cb738b4f9c3dfe76a9720be

11 files changed, 462 insertions, 113 deletions

diff --git a/packaging/libmm-radio.spec b/packaging/libmm-radio.spec
index 15a8393..7ccdf9a 100755
--- a/packaging/libmm-radio.spec
+++ b/packaging/libmm-radio.spec
@@ -1,6 +1,6 @@
 Name:       libmm-radio
 Summary:    Multimedia Framework Radio Library
-Version:    0.2.8
+Version:    0.2.9
 Release:    0
 Group:      System/Libraries
 License:    Apache-2.0
diff --git a/src/include/mm_radio.h b/src/include/mm_radio.h
index 493280e..68db5a7 100644
--- a/src/include/mm_radio.h
+++ b/src/include/mm_radio.h
@@ -2511,7 +2511,7 @@ int main(int argc, char **argv)
 
  * @endcode
  */
-int mm_radio_get_frequency(MMHandleType hradio, int* pFreq);
+int mm_radio_get_frequency(MMHandleType hradio, int *pFreq);
 
 /**
  * This function is to start for getting all effective frequencies. \n
@@ -3458,6 +3458,31 @@ int mm_radio_get_region_frequency_range(MMHandleType hradio, unsigned int *min,
  */
 int mm_radio_get_channel_spacing(MMHandleType hradio, int *channel_spacing);
 
+/**
+ * This function is to get volume
+ *
+ * @param	hradio	[in]	Handle of radio.
+ * @param	volume	[in]	volume value (0 ~ 1.0)
+ *
+ * @return	This function returns zero on success, or negative value with errors
+ * @pre		None
+ * @post	None
+ * @see mm_radio_get_volume()
+ */
+int mm_radio_set_volume(MMHandleType hradio, float volume);
+
+/**
+ * This function is to get volume
+ *
+ * @param	hradio	[in]	Handle of radio.
+ * @param	pVolume	[out]	volume value (0 ~ 1.0)
+ *
+ * @return	This function returns zero on success, or negative value with errors
+ * @pre		None
+ * @post	None
+ * @see mm_radio_set_volume()
+ */
+int mm_radio_get_volume(MMHandleType hradio, float *pVolume);
 
 /**
 	@}
diff --git a/src/include/mm_radio_priv.h b/src/include/mm_radio_priv.h
index ca8dfe5..7b773a2 100644
--- a/src/include/mm_radio_priv.h
+++ b/src/include/mm_radio_priv.h
@@ -55,7 +55,7 @@
 /*---------------------------------------------------------------------------
     GLOBAL #defines:
 ---------------------------------------------------------------------------*/
-#define SAMPLEDELAY     	15000
+#define SAMPLEDELAY					15000
 
 /* si470x dependent define */
 #define SYSCONFIG1					4		/* System Configuration 1 */
@@ -77,8 +77,7 @@
 /*---------------------------------------------------------------------------
     GLOBAL CONSTANT DEFINITIONS:
 ---------------------------------------------------------------------------*/
-typedef enum
-{
+typedef enum {
 	MMRADIO_COMMAND_CREATE = 0,
 	MMRADIO_COMMAND_DESTROY,
 	MMRADIO_COMMAND_REALIZE,
@@ -94,12 +93,13 @@ typedef enum
 	MMRADIO_COMMAND_SEEK,
 	MMRADIO_COMMAND_SET_REGION,
 	MMRADIO_COMMAND_GET_REGION,
+	MMRADIO_COMMAND_SET_VOLUME,
+	MMRADIO_COMMAND_GET_VOLUME,
 	MMRADIO_COMMAND_NUM
 } MMRadioCommand;
 
 /* max and mix frequency types, KHz */
-typedef enum
-{
+typedef enum {
 	MM_RADIO_FREQ_NONE				= 0,
 	/* min band types */
 	MM_RADIO_FREQ_MIN_76100_KHZ 		= 76100,
@@ -108,25 +108,23 @@ typedef enum
 	/* max band types */
 	MM_RADIO_FREQ_MAX_89900_KHZ		= 89900,
 	MM_RADIO_FREQ_MAX_108000_KHZ	= 108000,
-}MMRadioFreqTypes;
+} MMRadioFreqTypes;
 
 /* de-emphasis types  */
-typedef enum
-{
+typedef enum {
 	MM_RADIO_DEEMPHASIS_NONE = 0,
 	MM_RADIO_DEEMPHASIS_50_US,
 	MM_RADIO_DEEMPHASIS_75_US,
-}MMRadioDeemphasis;
+} MMRadioDeemphasis;
 
 /* radio region settings */
-typedef struct
-{
+typedef struct {
 	MMRadioRegionType country;
 	MMRadioDeemphasis deemphasis;	// unit :  us
 	MMRadioFreqTypes band_min;		// <- freq. range, unit : KHz
 	MMRadioFreqTypes band_max;		// ->
 	int channel_spacing;				// TBD
-}MMRadioRegion_t;
+} MMRadioRegion_t;
 
 /*---------------------------------------------------------------------------
     GLOBAL DATA TYPE DEFINITIONS:
@@ -134,8 +132,7 @@ typedef struct
 #define USE_GST_PIPELINE
 
 #ifdef USE_GST_PIPELINE
-typedef struct _mm_radio_gstreamer_s
-{
+typedef struct _mm_radio_gstreamer_s {
 	GMainLoop *loop;
 	GstElement *pipeline;
 	GstElement *audiosrc;
@@ -194,6 +191,7 @@ typedef struct {
 	mm_radio_gstreamer_s* pGstreamer_s;
 #endif
 	unsigned int subs_id;
+	float local_volume;
 
 	/* region settings */
 	MMRadioRegion_t	region_setting;
@@ -202,37 +200,34 @@ typedef struct {
 /*===========================================================================================
   GLOBAL FUNCTION PROTOTYPES
 ========================================================================================== */
-int _mmradio_create_radio(mm_radio_t* radio);
-int _mmradio_destroy(mm_radio_t* radio);
-int _mmradio_realize(mm_radio_t* radio);
-int _mmradio_unrealize(mm_radio_t* radio);
-int _mmradio_set_message_callback(mm_radio_t* radio, MMMessageCallback callback, void *user_param);
-int _mmradio_get_state(mm_radio_t* radio, int* pState);
-int _mmradio_set_frequency(mm_radio_t* radio, int freq);
-int _mmradio_get_frequency(mm_radio_t* radio, int* pFreq);
-int _mmradio_mute(mm_radio_t* radio);
-int _mmradio_unmute(mm_radio_t* radio);
-int _mmradio_start(mm_radio_t* radio);
-int _mmradio_stop(mm_radio_t* radio);
-int _mmradio_seek(mm_radio_t* radio, MMRadioSeekDirectionType direction);
-int _mmradio_start_scan(mm_radio_t* radio);
-int _mmradio_stop_scan(mm_radio_t* radio);
-int _mm_radio_get_signal_strength(mm_radio_t* radio, int *value);
+int _mmradio_create_radio(mm_radio_t *radio);
+int _mmradio_destroy(mm_radio_t *radio);
+int _mmradio_realize(mm_radio_t *radio);
+int _mmradio_unrealize(mm_radio_t *radio);
+int _mmradio_set_message_callback(mm_radio_t *radio, MMMessageCallback callback, void *user_param);
+int _mmradio_get_state(mm_radio_t *radio, int *pState);
+int _mmradio_set_frequency(mm_radio_t *radio, int freq);
+int _mmradio_get_frequency(mm_radio_t *radio, int *pFreq);
+int _mmradio_mute(mm_radio_t *radio);
+int _mmradio_unmute(mm_radio_t *radio);
+int _mmradio_start(mm_radio_t *radio);
+int _mmradio_stop(mm_radio_t *radio);
+int _mmradio_seek(mm_radio_t *radio, MMRadioSeekDirectionType direction);
+int _mmradio_start_scan(mm_radio_t *radio);
+int _mmradio_stop_scan(mm_radio_t *radio);
+int _mm_radio_get_signal_strength(mm_radio_t *radio, int *strength);
 #ifdef USE_GST_PIPELINE
-int _mmradio_realize_pipeline( mm_radio_t* radio);
-int _mmradio_start_pipeline(mm_radio_t* radio);
-int _mmradio_stop_pipeline( mm_radio_t* radio);
-int _mmradio_destroy_pipeline(mm_radio_t* radio);
-#endif
-int _mmradio_apply_region(mm_radio_t*radio, MMRadioRegionType region, bool update);
-int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type);
-int _mmradio_get_region_frequency_range(mm_radio_t* radio, unsigned int *min_freq, unsigned int *max_freq);
-int _mmradio_get_channel_spacing(mm_radio_t* radio, unsigned int *ch_spacing);
-
-#if 0
-int mmradio_set_attrs(mm_radio_t*  radio, MMRadioAttrsType type, MMHandleType attrs);
-MMHandleType mmradio_get_attrs(mm_radio_t*  radio, MMRadioAttrsType type);
+int _mmradio_realize_pipeline( mm_radio_t *radio);
+int _mmradio_start_pipeline(mm_radio_t *radio);
+int _mmradio_stop_pipeline( mm_radio_t *radio);
+int _mmradio_destroy_pipeline(mm_radio_t *radio);
 #endif
+int _mmradio_apply_region(mm_radio_t *radio, MMRadioRegionType region, bool update);
+int _mmradio_get_region_type(mm_radio_t *radio, MMRadioRegionType *type);
+int _mmradio_get_region_frequency_range(mm_radio_t *radio, unsigned int *min_freq, unsigned int *max_freq);
+int _mmradio_get_channel_spacing(mm_radio_t *radio, unsigned int *ch_spacing);
+int _mmradio_set_volume(mm_radio_t *radio, float volume);
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume);
 
 #ifdef __cplusplus
 	}
diff --git a/src/include/mm_radio_priv_hal.h b/src/include/mm_radio_priv_hal.h
index e214df1..72e2ef3 100644
--- a/src/include/mm_radio_priv_hal.h
+++ b/src/include/mm_radio_priv_hal.h
@@ -97,6 +97,8 @@ typedef enum {
 	MMRADIO_COMMAND_SEEK,
 	MMRADIO_COMMAND_SET_REGION,
 	MMRADIO_COMMAND_GET_REGION,
+	MMRADIO_COMMAND_SET_VOLUME,
+	MMRADIO_COMMAND_GET_VOLUME,
 	MMRADIO_COMMAND_NUM
 } MMRadioCommand;
 
@@ -175,9 +177,17 @@ typedef struct {
 	sound_stream_info_h stream_info;
 	virtual_sound_stream_h vstream;
 #endif
+	unsigned int volume_subs_id;
 
 	int freq;
 
+	/* command lock */
+	pthread_mutex_t volume_lock;
+
+	unsigned int max_media_volume;
+	unsigned int media_volume;
+	float local_volume;
+
 	/* region settings */
 	MMRadioRegion_t region_setting;
 
@@ -208,6 +218,8 @@ int _mmradio_apply_region(mm_radio_t*radio, MMRadioRegionType region, bool updat
 int _mmradio_get_region_type(mm_radio_t*radio, MMRadioRegionType *type);
 int _mmradio_get_region_frequency_range(mm_radio_t *radio, unsigned int *min_freq, unsigned int *max_freq);
 int _mmradio_get_channel_spacing(mm_radio_t* radio, unsigned int *ch_spacing);
+int _mmradio_set_volume(mm_radio_t *radio, float volume);
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume);
 
 #ifdef __cplusplus
 }
diff --git a/src/include/mm_radio_utils.h b/src/include/mm_radio_utils.h
index d498b59..35e8dc7 100644
--- a/src/include/mm_radio_utils.h
+++ b/src/include/mm_radio_utils.h
@@ -84,8 +84,11 @@ if ( x_radio->radio_fd < 0 ) \
 }
 
 /* command locking for multithreading */
-#define MMRADIO_CMD_LOCK(x_radio)		pthread_mutex_lock( &((mm_radio_t*)x_radio)->cmd_lock )
-#define MMRADIO_CMD_UNLOCK(x_radio)		pthread_mutex_unlock( &((mm_radio_t*)x_radio)->cmd_lock )
+#define MMRADIO_CMD_LOCK(x_radio)		pthread_mutex_lock(&((mm_radio_t *)x_radio)->cmd_lock)
+#define MMRADIO_CMD_UNLOCK(x_radio)		pthread_mutex_unlock(&((mm_radio_t *)x_radio)->cmd_lock)
+
+#define MMRADIO_VOLUME_LOCK(x_radio)		pthread_mutex_lock(&((mm_radio_t *)x_radio)->volume_lock)
+#define MMRADIO_VOLUME_UNLOCK(x_radio)		pthread_mutex_unlock(&((mm_radio_t *)x_radio)->volume_lock)
 
 /* message posting */
 #define MMRADIO_POST_MSG( x_radio, x_msgtype, x_msg_param ) \
diff --git a/src/include/radio_hal_interface.h b/src/include/radio_hal_interface.h
index 68bfb14..3fdac71 100644
--- a/src/include/radio_hal_interface.h
+++ b/src/include/radio_hal_interface.h
@@ -51,6 +51,9 @@ int radio_hal_set_frequency(mm_radio_hal_interface *radio_handle, uint32_t frequ
 int radio_hal_get_signal_strength(mm_radio_hal_interface *radio_handle, uint32_t *strength);
 int radio_hal_mute(mm_radio_hal_interface *radio_handle);
 int radio_hal_unmute(mm_radio_hal_interface *radio_handle);
+int radio_hal_set_volume(mm_radio_hal_interface *radio_handle, float volume);
+int radio_hal_get_volume(mm_radio_hal_interface *radio_handle, float *volume);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/include/tizen-radio.h b/src/include/tizen-radio.h
index 8f6ce17..1eedc30 100644
--- a/src/include/tizen-radio.h
+++ b/src/include/tizen-radio.h
@@ -83,12 +83,14 @@ typedef struct radio_interface {
 	radio_error_t (*mute)(void *radio_handle);
 	radio_error_t (*unmute)(void *radio_handle);
 	radio_error_t (*get_signal_strength)(void *radio_handle, uint32_t *strength);
+	radio_error_t (*get_volume)(void *radio_handle, float *volume);
+	radio_error_t (*set_volume)(void *radio_handle, float volume);
 } radio_interface_t;
 
 /**
  * @brief Initializes new handle of radio HAL.
  * @since_tizen 3.0
- * @param[out] radio_handle A newly returned handle to the radio HAL
+ * @param[out] radio_handle A newly returned the radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -98,9 +100,9 @@ typedef struct radio_interface {
 radio_error_t radio_init(void **radio_handle);
 
 /**
- * @brief Deinitializes handle of camera HAL.
+ * @brief Deinitializes handle of radio HAL.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -111,7 +113,7 @@ radio_error_t radio_deinit(void *radio_handle);
 /**
  * @brief Prepare the device of radio.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -123,7 +125,7 @@ radio_error_t radio_prepare(void *radio_handle);
 /**
  * @brief Unprepare the device of radio.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -134,7 +136,7 @@ radio_error_t radio_unprepare(void *radio_handle);
 /**
  * @brief Opens the device of radio.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -149,7 +151,7 @@ radio_error_t radio_open(void *radio_handle);
 /**
  * @brief Closes the device of radio.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -160,7 +162,7 @@ radio_error_t radio_close(void *radio_handle);
 /**
  * @brief Starts the device of radio.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -171,7 +173,7 @@ radio_error_t radio_start(void *radio_handle);
 /**
  * @brief Stops the device of radio.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -182,7 +184,7 @@ radio_error_t radio_stop(void *radio_handle);
 /**
  * @brief Seeks (up or down) the effective frequency of the radio.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @param[in] direction The seek direction type (up or down)
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
@@ -195,7 +197,7 @@ radio_error_t radio_seek(void *radio_handle, radio_seek_direction_type_t directi
 /**
  * @brief Gets the radio frequency.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @param[out] frequency The current frequency (khz)
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
@@ -208,7 +210,7 @@ radio_error_t radio_get_frequency(void *radio_handle, uint32_t *frequency);
 /**
  * @brief Sets the radio frequency.
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @param[in] frequency The frequency to set (khz)
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
@@ -221,7 +223,7 @@ radio_error_t radio_set_frequency(void *radio_handle, uint32_t frequency);
 /**
  * @brief Sets the radio's mute
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -232,7 +234,7 @@ radio_error_t radio_mute(void *radio_handle);
 /**
  * @brief Unsets the radio's mute
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
  * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
@@ -243,7 +245,7 @@ radio_error_t radio_unmute(void *radio_handle);
 /**
  * @brief Gets the current signal strength of the radio
  * @since_tizen 3.0
- * @param[in] radio_handle The handle to the radio HAL
+ * @param[in] radio_handle The radio HAL handle
  * @param[out] strength The current signal strength (dBm)
  * @return @c 0 on success, otherwise a negative error value
  * @retval #RADIO_ERROR_NONE Successful
@@ -253,6 +255,30 @@ radio_error_t radio_unmute(void *radio_handle);
 radio_error_t radio_get_signal_strength(void *radio_handle, uint32_t *strength);
 
 /**
+ * @brief Gets the radio's current volume.
+ * @since_tizen 3.0
+ * @param[in] radio_handle The radio HAL handle
+ * @param[out] volume The current radio volume (0.0 ~ 1.0)
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #RADIO_ERROR_NONE Successful
+ * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #RADIO_ERROR_INVALID_OPERATION Invalid operation
+ */
+radio_error_t radio_get_volume(void *radio_handle, float *volume);
+
+/**
+ * @brief Sets the current radio's volume.
+ * @since_tizen 3.0
+ * @param[in] radio_handle The radio HAL handle
+ * @param[in] volume The radio volume to set (0.0 ~ 1.0)
+ * @return @c 0 on success, otherwise a negative error value
+ * @retval #RADIO_ERROR_NONE Successful
+ * @retval #RADIO_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #RADIO_ERROR_INVALID_OPERATION Invalid operation
+ */
+radio_error_t radio_set_volume(void *radio_handle, float volume);
+
+/**
  * @}
  */
 
diff --git a/src/mm_radio.c b/src/mm_radio.c
index 5f8b495..2453af1 100644
--- a/src/mm_radio.c
+++ b/src/mm_radio.c
@@ -493,3 +493,49 @@ int mm_radio_get_channel_spacing(MMHandleType hradio, int *channel_spacing)
 	MMRADIO_LOG_FLEAVE();
 	return result;
 }
+
+int mm_radio_set_volume(MMHandleType hradio, float volume)
+{
+	int result = MM_ERROR_NONE;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
+
+	MMRADIO_LOG_FENTER();
+
+	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
+
+	MMRADIO_CMD_LOCK(radio);
+
+	result = _mmradio_set_volume(radio, volume);
+
+	MMRADIO_CMD_UNLOCK(radio);
+
+	MMRADIO_LOG_FLEAVE();
+
+	return result;
+}
+
+int mm_radio_get_volume(MMHandleType hradio, float *pVolume)
+{
+	int result = MM_ERROR_NONE;
+	mm_radio_t *radio = (mm_radio_t *)hradio;
+	float volume = 0.0;
+
+	MMRADIO_LOG_FENTER();
+
+	return_val_if_fail(radio, MM_ERROR_RADIO_NOT_INITIALIZED);
+	return_val_if_fail(pVolume, MM_ERROR_INVALID_ARGUMENT);
+
+	MMRADIO_CMD_LOCK(radio);
+
+	result = _mmradio_get_volume(radio, &volume);
+
+	if (result == MM_ERROR_NONE)
+		*pVolume = volume;
+
+	MMRADIO_CMD_UNLOCK(radio);
+
+	MMRADIO_LOG_FLEAVE();
+
+	return result;
+}
+
diff --git a/src/mm_radio_priv_emulator.c b/src/mm_radio_priv_emulator.c
index e601266..5363daf 100644
--- a/src/mm_radio_priv_emulator.c
+++ b/src/mm_radio_priv_emulator.c
@@ -75,6 +75,8 @@
 
 #define RADIO_DEFAULT_REGION	MM_RADIO_REGION_GROUP_USA
 #define EMULATOR_FREQ_MAX		5
+#define RADIO_MIN_VOLUME		0.0
+#define RADIO_MAX_VOLUME		1.0
 
 /*---------------------------------------------------------------------------
     LOCAL CONSTANT DEFINITIONS:
@@ -227,6 +229,7 @@ int _mmradio_create_radio(mm_radio_t * radio)
 	radio->freq = DEFAULT_FREQ;
 	memset(&radio->region_setting, 0, sizeof(MMRadioRegion_t));
 	radio->subs_id = 0;
+	radio->local_volume = 1.0;
 
 	/* create command lock */
 	ret = pthread_mutex_init(&radio->cmd_lock, NULL);
@@ -588,6 +591,8 @@ int _mmradio_start(mm_radio_t * radio)
 	/* set stored frequency */
 	_mmradio_set_frequency(radio, radio->freq);
 
+	_mmradio_set_volume(radio, radio->local_volume);
+
 	/* unmute */
 	/*  if( _mmradio_unmute(radio) != MM_ERROR_NONE) */
 	/*      return MM_ERROR_RADIO_NOT_INITIALIZED; */
@@ -663,23 +668,23 @@ int _mmradio_realize_pipeline(mm_radio_t * radio)
 	g_object_set(radio->pGstreamer_s->audiosrc, "wave", val, "volume", 0.8, NULL);
 
 	if (!radio->pGstreamer_s->pipeline || !radio->pGstreamer_s->audiosrc || !radio->pGstreamer_s->queue2 || !radio->pGstreamer_s->volume || !radio->pGstreamer_s->audiosink) {
-		MMRADIO_LOG_DEBUG("[%s][%05d] One element could not be created. Exiting.\n", __func__, __LINE__);
+		MMRADIO_LOG_DEBUG("One element could not be created. Exiting.\n");
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 	}
 
 	gst_bin_add_many(GST_BIN(radio->pGstreamer_s->pipeline),
-	                 radio->pGstreamer_s->audiosrc,
-	                 radio->pGstreamer_s->queue2,
-	                 radio->pGstreamer_s->volume,
-	                 radio->pGstreamer_s->audiosink,
-	                 NULL);
+					radio->pGstreamer_s->audiosrc,
+					radio->pGstreamer_s->queue2,
+					radio->pGstreamer_s->volume,
+					radio->pGstreamer_s->audiosink,
+					NULL);
 	if (!gst_element_link_many(
-	        radio->pGstreamer_s->audiosrc,
-	        radio->pGstreamer_s->queue2,
-	        radio->pGstreamer_s->volume,
-	        radio->pGstreamer_s->audiosink,
-	        NULL)) {
-		MMRADIO_LOG_DEBUG(, "[%s][%05d] Fail to link b/w appsrc and ffmpeg in rotate\n", __func__, __LINE__);
+		radio->pGstreamer_s->audiosrc,
+		radio->pGstreamer_s->queue2,
+		radio->pGstreamer_s->volume,
+		radio->pGstreamer_s->audiosink,
+		NULL)) {
+		MMRADIO_LOG_DEBUG("Fail to link b/w appsrc and ffmpeg in rotate\n");
 		return MM_ERROR_RADIO_NOT_INITIALIZED;
 	}
 	MMRADIO_LOG_FLEAVE();
@@ -707,7 +712,7 @@ int _mmradio_start_pipeline(mm_radio_t * radio)
 		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	} else {
-		MMRADIO_LOG_DEBUG("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
+		MMRADIO_LOG_DEBUG("GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", ret_state);
 	}
 
 	MMRADIO_LOG_FLEAVE();
@@ -734,7 +739,7 @@ int _mmradio_stop_pipeline(mm_radio_t * radio)
 		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	} else {
-		MMRADIO_LOG_DEBUG("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
+		MMRADIO_LOG_DEBUG("GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", ret_state);
 	}
 	MMRADIO_LOG_FLEAVE();
 	return ret;
@@ -760,7 +765,7 @@ int _mmradio_destroy_pipeline(mm_radio_t * radio)
 		g_free(radio->pGstreamer_s);
 		return MM_ERROR_RADIO_INVALID_STATE;
 	} else {
-		MMRADIO_LOG_DEBUG("[%s][%05d] GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", __func__, __LINE__, ret_state);
+		MMRADIO_LOG_DEBUG("GST_STATE_NULL ret_state = %d (GST_STATE_CHANGE_SUCCESS)\n", ret_state);
 	}
 
 	gst_object_unref(radio->pGstreamer_s->pipeline);
@@ -879,9 +884,8 @@ void __mmradio_scan_thread(mm_radio_t * radio)
 	if (_mmradio_set_frequency(radio, radio->region_setting.band_min) != MM_ERROR_NONE)
 		goto FINISHED;
 
-	if (radio->old_state == MM_RADIO_STATE_PLAYING) {
+	if (radio->old_state == MM_RADIO_STATE_PLAYING)
 		_mmradio_mute(radio);
-	}
 
 	MMRADIO_POST_MSG(radio, MM_MESSAGE_RADIO_SCAN_START, NULL);
 	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_SCANNING);
@@ -1279,7 +1283,7 @@ static int __mmradio_get_state(mm_radio_t * radio)
 	MMRADIO_CHECK_INSTANCE(radio);
 
 	MMRADIO_LOG_DEBUG("radio state : current : [%d]   old : [%d]   pending : [%d]\n",
-	                  radio->current_state, radio->old_state, radio->pending_state);
+						radio->current_state, radio->old_state, radio->pending_state);
 
 	return radio->current_state;
 }
@@ -1466,3 +1470,56 @@ static int __mmradio_get_wave_num(mm_radio_t * radio)
 	MMRADIO_LOG_FLEAVE();
 	return val;
 }
+
+int _mmradio_set_volume(mm_radio_t *radio, float volume)
+{
+	MMRADIO_LOG_FENTER();
+
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_VOLUME);
+
+	MMRADIO_SLOG_DEBUG("Setting %f volume", volume);
+
+	if (radio->radio_fd < 0) {
+		MMRADIO_LOG_DEBUG("radio device is not opened yet\n");
+		radio->local_volume = volume;
+		return MM_ERROR_NONE;
+	}
+
+	/* check volume range */
+	if (volume < RADIO_MIN_VOLUME || volume > RADIO_MAX_VOLUME) {
+		MMRADIO_LOG_ERROR("out of volume range");
+		return MM_ERROR_INVALID_ARGUMENT;
+	}
+
+	radio->local_volume = volume;
+
+#ifdef USE_GST_PIPELINE
+	if (radio->pGstreamer_s && radio->pGstreamer_s->volume) {
+		g_object_set(radio->pGstreamer_s->volume, "volume", volume, NULL);
+		MMRADIO_LOG_DEBUG("g_object set volume\n");
+	}
+#endif
+	MMRADIO_LOG_FLEAVE();
+
+	return MM_ERROR_NONE;
+
+}
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume)
+{
+	MMRADIO_LOG_FENTER();
+
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_VOLUME);
+
+	return_val_if_fail(pVolume, MM_ERROR_INVALID_ARGUMENT);
+
+	MMRADIO_SLOG_DEBUG("volume : %f\n", radio->local_volume);
+
+	*pVolume = radio->local_volume;
+
+	MMRADIO_LOG_FLEAVE();
+
+	return MM_ERROR_NONE;
+}
+
diff --git a/src/mm_radio_priv_hal.c b/src/mm_radio_priv_hal.c
index 6ac3757..8880da4 100644
--- a/src/mm_radio_priv_hal.c
+++ b/src/mm_radio_priv_hal.c
@@ -27,6 +27,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <math.h>
+#include <float.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
@@ -35,6 +36,7 @@
 #include <mm_error.h>
 #include <mm_debug.h>
 #include <mm_message.h>
+#include <mm_sound.h>
 
 #include "mm_radio_priv_hal.h"
 
@@ -69,6 +71,7 @@
 
 #define RADIO_DEFAULT_REGION	MM_RADIO_REGION_GROUP_USA
 #define READ_MAX_BUFFER_SIZE	1024
+#define DEFAULT_MAX_MEDIA_VOLUME	15
 /*---------------------------------------------------------------------------
     LOCAL CONSTANT DEFINITIONS:
 ---------------------------------------------------------------------------*/
@@ -131,6 +134,9 @@ static void __mmradio_sound_focus_watch_cb(int id, mm_sound_focus_type_e focus_t
 	const char *additional_info, void *user_data);
 #endif
 
+static void __mmradio_volume_changed_cb(volume_type_t type, unsigned int volume, void *user_data);
+int __mmradio_set_total_volume(mm_radio_t *radio);
+
 int _mmradio_apply_region(mm_radio_t *radio, MMRadioRegionType region, bool update)
 {
 	int ret = MM_ERROR_NONE;
@@ -187,6 +193,7 @@ int _mmradio_create_radio(mm_radio_t *radio)
 	memset(&radio->sound_focus, 0, sizeof(mm_radio_sound_focus));
 #endif
 	memset(&radio->region_setting, 0, sizeof(MMRadioRegion_t));
+	radio->local_volume = 1.0;
 
 	/* create command lock */
 	ret = pthread_mutex_init(&radio->cmd_lock, NULL);
@@ -195,6 +202,12 @@ int _mmradio_create_radio(mm_radio_t *radio)
 		return MM_ERROR_RADIO_INTERNAL;
 	}
 
+	ret = pthread_mutex_init(&radio->volume_lock, NULL);
+	if (ret) {
+		MMRADIO_LOG_ERROR("volume mutex creation failed\n");
+		return MM_ERROR_RADIO_INTERNAL;
+	}
+
 	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_NULL);
 
 #ifdef TIZEN_FEATURE_SOUND_FOCUS
@@ -225,6 +238,8 @@ int _mmradio_realize(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
 	bool update = false;
+	int max = 0;
+	unsigned volume = 0;
 	MMRadioRegionType region = MM_RADIO_REGION_GROUP_NONE;
 
 	MMRADIO_LOG_FENTER();
@@ -235,6 +250,7 @@ int _mmradio_realize(mm_radio_t *radio)
 	ret = pthread_mutex_init(&radio->seek_cancel_mutex, NULL);
 	if (ret < 0) {
 		MMRADIO_LOG_DEBUG("Mutex creation failed %d", ret);
+		return MM_ERROR_RADIO_INTERNAL;
 	}
 
 	if (radio->region_setting.country == MM_RADIO_REGION_GROUP_NONE) {
@@ -262,6 +278,28 @@ int _mmradio_realize(mm_radio_t *radio)
 		return ret;
 	}
 #endif
+
+	ret = sound_manager_get_max_volume(SOUND_TYPE_MEDIA, &max);
+	if (ret != MM_ERROR_NONE) {
+		MMRADIO_LOG_WARNING("sound_manager_get_max_volume error");
+		radio->max_media_volume = DEFAULT_MAX_MEDIA_VOLUME;
+	} else {
+		radio->max_media_volume = max;
+	}
+
+	ret = mm_sound_volume_get_value(VOLUME_TYPE_MEDIA, &volume);
+
+	if (ret != MM_ERROR_NONE)
+		MMRADIO_LOG_WARNING("failed to get MEDIA_VOLUME");
+
+	MMRADIO_VOLUME_LOCK(radio);
+	radio->media_volume = volume;
+	MMRADIO_VOLUME_UNLOCK(radio);
+
+	ret = mm_sound_add_volume_changed_callback(__mmradio_volume_changed_cb, (void *)radio, &radio->volume_subs_id);
+	if (ret != MM_ERROR_NONE)
+		MMRADIO_LOG_WARNING("mm_sound_add_volume_changed_callback error");
+
 	MMRADIO_SET_STATE(radio, MM_RADIO_STATE_READY);
 
 	MMRADIO_LOG_FLEAVE();
@@ -278,15 +316,6 @@ int _mmradio_unrealize(mm_radio_t *radio)
 	MMRADIO_CHECK_INSTANCE(radio);
 	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_UNREALIZE);
 
-	ret = radio_hal_unmute(radio->hal_inf);
-	if (ret == MM_ERROR_NOT_SUPPORT_API) {
-		MMRADIO_LOG_WARNING("radio_hal_unmute is not supported");
-	} else if (ret != MM_ERROR_NONE) {
-		MMRADIO_LOG_ERROR("radio_hal_unmute error");
-		MMRADIO_LOG_FLEAVE();
-		return ret;
-	}
-
 	/*Finish if there are scans*/
 	_mmradio_stop_scan(radio);
 
@@ -306,7 +335,7 @@ int _mmradio_unrealize(mm_radio_t *radio)
 
 	MMRADIO_LOG_FLEAVE();
 
-	return MM_ERROR_NONE;
+	return ret;
 }
 
 int _mmradio_destroy(mm_radio_t *radio)
@@ -475,6 +504,7 @@ int _mmradio_get_state(mm_radio_t *radio, int *pState)
 int _mmradio_start(mm_radio_t *radio)
 {
 	int ret = MM_ERROR_NONE;
+	unsigned int volume = 0;
 
 	MMRADIO_LOG_FENTER();
 
@@ -499,7 +529,7 @@ int _mmradio_start(mm_radio_t *radio)
 			MMRADIO_LOG_WARNING("radio_hal_prepare is not supported");
 		} else if (ret != MM_ERROR_NONE) {
 			MMRADIO_LOG_ERROR("radio_hal_prepare_device error");
-			goto error;
+			goto error2;
 		}
 
 		ret = radio_hal_open(radio->hal_inf);
@@ -507,26 +537,43 @@ int _mmradio_start(mm_radio_t *radio)
 			MMRADIO_LOG_WARNING("radio_hal_open is not supported");
 		} else if (ret != MM_ERROR_NONE) {
 			MMRADIO_LOG_ERROR("radio_hal_init error");
-			goto error;
+			goto error1;
 		}
 		radio->is_ready = TRUE;
 	} else {
 		MMRADIO_LOG_DEBUG("radio prepared and opened");
 	}
 
+	ret = mm_sound_volume_get_value(VOLUME_TYPE_MEDIA, &volume);
+
+	if (ret != MM_ERROR_NONE)
+		MMRADIO_LOG_WARNING("failed to get MEDIA_VOLUME");
+
+	MMRADIO_VOLUME_LOCK(radio);
+	radio->media_volume = volume;
+	MMRADIO_VOLUME_UNLOCK(radio);
+
+	ret = __mmradio_set_total_volume(radio);
+	if (ret == MM_ERROR_NOT_SUPPORT_API) {
+		MMRADIO_LOG_WARNING("radio_hal_start is not supported");
+	} else if (ret) {
+		MMRADIO_LOG_ERROR("failed to radio_hal_start\n");
+		goto error1;
+	}
+
 	ret = radio_hal_start(radio->hal_inf);
 	if (ret == MM_ERROR_NOT_SUPPORT_API) {
 		MMRADIO_LOG_WARNING("radio_hal_start is not supported");
 	} else if (ret) {
 		MMRADIO_LOG_ERROR("failed to radio_hal_start\n");
-		goto error;
+		goto error1;
 	}
 
 	/* set stored frequency */
 	ret = radio_hal_set_frequency(radio->hal_inf, radio->freq);
 	if (ret) {
 		MMRADIO_LOG_ERROR("failed to radio_hal_set_frequency\n");
-		goto error;
+		goto error1;
 	}
 
 #ifdef TIZEN_FEATURE_SOUND_VSTREAM
@@ -543,12 +590,15 @@ int _mmradio_start(mm_radio_t *radio)
 
 	return MM_ERROR_NONE;
 
-error:
 #ifdef TIZEN_FEATURE_SOUND_VSTREAM
+error:
 	sound_manager_stop_virtual_stream(radio->vstream);
 #endif
+error1:
 	radio_hal_close(radio->hal_inf);
+error2:
 	radio_hal_unprepare(radio->hal_inf);
+	radio->is_ready = FALSE;
 	return ret;
 }
 
@@ -566,14 +616,11 @@ int _mmradio_stop(mm_radio_t *radio)
 	_mmradio_seek_cancel(radio);
 #ifdef TIZEN_FEATURE_SOUND_VSTREAM
 	ret = sound_manager_stop_virtual_stream(radio->vstream);
-#endif
-	ret = radio_hal_mute(radio->hal_inf);
-	if (ret == MM_ERROR_NOT_SUPPORT_API) {
-		MMRADIO_LOG_WARNING("radio_hal_unmute is not supported");
-	} else if (ret) {
-		MMRADIO_LOG_ERROR("failed to radio_hal_mute\n");
+	if (ret != MM_ERROR_NONE) {
+		MMRADIO_LOG_ERROR("failed to set sound focus");
 		return ret;
 	}
+#endif
 
 	ret = radio_hal_stop(radio->hal_inf);
 	if (ret == MM_ERROR_NOT_SUPPORT_API) {
@@ -1048,7 +1095,7 @@ void __mmradio_seek_thread(mm_radio_t *radio)
 	pthread_exit(NULL);
 	return;
 
- SEEK_FAILED:
+SEEK_FAILED:
 
 	if (radio->seek_unmute) {
 		/* now turn on radio
@@ -1175,6 +1222,8 @@ static int __mmradio_check_state(mm_radio_t *radio, MMRadioCommand command)
 	case MMRADIO_COMMAND_SET_FREQ:
 	case MMRADIO_COMMAND_GET_FREQ:
 	case MMRADIO_COMMAND_SET_REGION:
+	case MMRADIO_COMMAND_SET_VOLUME:
+	case MMRADIO_COMMAND_GET_VOLUME:
 		{
 			/* we can do it at any state */
 		}
@@ -1394,6 +1443,41 @@ static void __mmradio_sound_focus_watch_cb(int id, mm_sound_focus_type_e focus_t
 }
 #endif
 
+int __mmradio_set_total_volume(mm_radio_t *radio)
+{
+	int ret = MM_ERROR_NONE;
+	float total_volume = 0.0f;
+
+	MMRADIO_CHECK_INSTANCE(radio);
+
+	MMRADIO_VOLUME_LOCK(radio);
+	if (radio->max_media_volume != 0)
+		total_volume = ((float)radio->media_volume / (float)radio->max_media_volume) * radio->local_volume;
+	else
+		MMRADIO_LOG_WARNING("max media voulme is zero");
+
+	ret = radio_hal_set_volume(radio->hal_inf, total_volume);
+	if (ret != MM_ERROR_NONE)
+		MMRADIO_LOG_ERROR("radio_hal_set_volume error");
+
+	MMRADIO_VOLUME_UNLOCK(radio);
+	return ret;
+
+}
+
+static void __mmradio_volume_changed_cb(volume_type_t type, unsigned int volume, void *user_data)
+{
+	mm_radio_t *radio = (mm_radio_t *)user_data;
+	MMRADIO_CHECK_INSTANCE_RETURN_VOID(radio);
+	if (type == VOLUME_TYPE_MEDIA) {
+		MMRADIO_LOG_DEBUG("Change FM Radio volume to %d", volume);
+		MMRADIO_VOLUME_LOCK(radio);
+		radio->media_volume = volume;
+		MMRADIO_VOLUME_UNLOCK(radio);
+		__mmradio_set_total_volume(radio);
+	}
+}
+
 int _mmradio_get_region_type(mm_radio_t *radio, MMRadioRegionType *type)
 {
 	MMRADIO_LOG_FENTER();
@@ -1436,3 +1520,66 @@ int _mmradio_get_channel_spacing(mm_radio_t *radio, unsigned int *ch_spacing)
 	MMRADIO_LOG_FLEAVE();
 	return MM_ERROR_NONE;
 }
+
+int _mmradio_set_volume(mm_radio_t *radio, float volume)
+{
+	int ret = MM_ERROR_NONE;
+
+	MMRADIO_LOG_FENTER();
+
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_SET_VOLUME);
+
+	MMRADIO_LOG_DEBUG("Setting %f volume\n", volume);
+
+	MMRADIO_VOLUME_LOCK(radio);
+	radio->local_volume = volume;
+	MMRADIO_VOLUME_UNLOCK(radio);
+
+	ret = __mmradio_set_total_volume(radio);
+
+	MMRADIO_LOG_FLEAVE();
+	return ret;
+
+}
+
+int _mmradio_get_volume(mm_radio_t *radio, float *pVolume)
+{
+	int ret = MM_ERROR_NONE;
+	float total_volume = 0.0;
+	float volume = 0.0;
+	MMRADIO_LOG_FENTER();
+
+	MMRADIO_CHECK_INSTANCE(radio);
+	MMRADIO_CHECK_STATE_RETURN_IF_FAIL(radio, MMRADIO_COMMAND_GET_VOLUME);
+
+	return_val_if_fail(pVolume, MM_ERROR_INVALID_ARGUMENT);
+
+	ret = radio_hal_get_volume(radio->hal_inf, &total_volume);
+	if (ret != MM_ERROR_NONE) {
+		MMRADIO_LOG_ERROR("radio_hal_get_volume error");
+		*pVolume = 0;
+		return ret;
+	}
+
+	MMRADIO_VOLUME_LOCK(radio);
+
+	if (radio->media_volume)
+		volume = total_volume * ((float)radio->max_media_volume / (float)radio->media_volume);
+
+	MMRADIO_LOG_DEBUG("total_volume = %f, max_media_volue = %d, media_volume = %d, volume = %f",
+		total_volume, radio->max_media_volume, radio->media_volume, volume);
+
+	/* update volume in handle */
+	if (fabs(radio->local_volume - volume) >= FLT_EPSILON) {
+		radio->local_volume = volume;
+	}
+
+	*pVolume = (float)radio->local_volume;
+	MMRADIO_VOLUME_UNLOCK(radio);
+
+	MMRADIO_LOG_FLEAVE();
+
+	return ret;
+}
+
diff --git a/src/radio_hal_interface.c b/src/radio_hal_interface.c
index 499cd57..fe7e587 100644
--- a/src/radio_hal_interface.c
+++ b/src/radio_hal_interface.c
@@ -35,34 +35,34 @@ static int __convert_error_code(int code, char *func_name)
 
 	switch (code) {
 
-	case RADIO_ERROR_NONE :
+	case RADIO_ERROR_NONE:
 		ret = MM_ERROR_NONE;
 		msg = "MM_ERROR_NONE";
 		break;
-	case RADIO_ERROR_INVALID_PARAMETER :
+	case RADIO_ERROR_INVALID_PARAMETER:
 		ret = MM_ERROR_COMMON_INVALID_ARGUMENT;
 		msg = "MM_ERROR_COMMON_INVALID_ARGUMENT";
 		break;
-	case RADIO_ERROR_INVALID_STATE :
+	case RADIO_ERROR_INVALID_STATE:
 		ret = MM_ERROR_RADIO_INVALID_STATE;
 		msg = "MM_ERROR_RADIO_INVALID_STATE";
 		break;
-	case RADIO_ERROR_OUT_OF_MEMORY :
+	case RADIO_ERROR_OUT_OF_MEMORY:
 		ret = MM_ERROR_RADIO_NO_FREE_SPACE;
 		msg = "MM_ERROR_RADIO_NO_FREE_SPACE";
 		break;
-	case RADIO_ERROR_PERMISSION_DENIED :
+	case RADIO_ERROR_PERMISSION_DENIED:
 	case RADIO_ERROR_DEVICE_NOT_PREPARED :
 		ret = MM_ERROR_RADIO_PERMISSION_DENIED;
 		msg = "MM_ERROR_RADIO_PERMISSION_DENIED";
 		break;
-	case RADIO_ERROR_DEVICE_NOT_OPENED :
+	case RADIO_ERROR_DEVICE_NOT_OPENED:
 		ret = MM_ERROR_RADIO_DEVICE_NOT_OPENED;
 		msg = "MM_ERROR_RADIO_DEVICE_NOT_OPENED";
 		break;
-	case RADIO_ERROR_NOT_SUPPORTED :
-	case RADIO_ERROR_DEVICE_NOT_SUPPORTED :
-	case RADIO_ERROR_DEVICE_NOT_FOUND :
+	case RADIO_ERROR_NOT_SUPPORTED:
+	case RADIO_ERROR_DEVICE_NOT_SUPPORTED:
+	case RADIO_ERROR_DEVICE_NOT_FOUND:
 		ret = MM_ERROR_RADIO_DEVICE_NOT_FOUND;
 		msg = "MM_ERROR_RADIO_DEVICE_NOT_FOUND";
 		break;
@@ -70,8 +70,8 @@ static int __convert_error_code(int code, char *func_name)
 		ret = MM_ERROR_RADIO_NO_ANTENNA;
 		msg = "MM_ERROR_RADIO_NO_ANTENNA";
 		break;
-	case RADIO_ERROR_UNKNOWN :
-	case RADIO_ERROR_INTERNAL :
+	case RADIO_ERROR_UNKNOWN:
+	case RADIO_ERROR_INTERNAL:
 	default:
 		ret = MM_ERROR_RADIO_INTERNAL;
 		msg = "MM_ERROR_RADIO_INTERNAL";
@@ -109,6 +109,8 @@ int radio_hal_interface_init(mm_radio_hal_interface **handle)
 		h->intf.mute = dlsym(h->dl_handle, "radio_mute");
 		h->intf.unmute = dlsym(h->dl_handle, "radio_unmute");
 		h->intf.get_signal_strength = dlsym(h->dl_handle, "radio_get_signal_strength");
+		h->intf.get_volume = dlsym(h->dl_handle, "radio_get_volume");
+		h->intf.set_volume = dlsym(h->dl_handle, "radio_set_volume");
 
 		if (h->intf.init == NULL || h->intf.deinit == NULL) {
 			MMRADIO_LOG_ERROR("could not get mandatory funtion");
@@ -347,6 +349,39 @@ int radio_hal_unmute(mm_radio_hal_interface *radio_handle)
 
 }
 
+int radio_hal_set_volume(mm_radio_hal_interface *radio_handle, float volume)
+{
+	radio_error_t ret = RADIO_ERROR_NONE;
+	MMRADIO_CHECK_ARG(radio_handle);
+	if (radio_handle->intf.set_volume) {
+		ret = radio_handle->intf.set_volume(radio_handle->rh_handle, volume);
+		if (ret != RADIO_ERROR_NONE)
+			return __convert_error_code(ret, (char *)__FUNCTION__);
+	} else {
+		MMRADIO_LOG_WARNING("radio_hal unmute is NULL");
+		return MM_ERROR_NOT_SUPPORT_API;
+	}
+	return MM_ERROR_NONE;
+
+}
+
+int radio_hal_get_volume(mm_radio_hal_interface *radio_handle, float *volume)
+{
+	radio_error_t ret = RADIO_ERROR_NONE;
+	MMRADIO_CHECK_ARG(radio_handle);
+	if (radio_handle->intf.get_volume) {
+		ret = radio_handle->intf.get_volume(radio_handle->rh_handle, volume);
+		if (ret != RADIO_ERROR_NONE)
+			return __convert_error_code(ret, (char *)__FUNCTION__);
+	} else {
+		MMRADIO_LOG_WARNING("radio_hal unmute is NULL");
+		return MM_ERROR_NOT_SUPPORT_API;
+	}
+	return MM_ERROR_NONE;
+
+}
+
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */