am 2c3f08c4: [FM] Move FM Radio JNI (609670e7) · Commits · e / os / android_packages_apps_FMRadio

jni/Android.mk

0 → 100644

+17 −0

Original line number	Diff line number	Diff line
		# Copyright (C) 2014 The Android Open Source Project
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

		LOCAL_PATH:= $(call my-dir)

		include $(call all-makefiles-under,$(LOCAL_PATH))

jni/fmr/Android.mk

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		# Copyright (C) 2014 The Android Open Source Project
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.

		LOCAL_PATH := $(call my-dir)

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES := \
		fmr_core.cpp \
		fmr_err.cpp \
		libfm_jni.cpp \
		common.cpp

		LOCAL_C_INCLUDES := $(JNI_H_INCLUDE) \
		frameworks/base/include/media

		LOCAL_SHARED_LIBRARIES := \
		libcutils \
		libdl \
		libmedia \

		LOCAL_MODULE := libfmjni
		include $(BUILD_SHARED_LIBRARY)

jni/fmr/common.cpp

0 → 100644

+590 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include "fmr.h"

		#ifdef LOG_TAG
		#undef LOG_TAG
		#endif
		#define LOG_TAG "FMLIB_COM"

		static int g_stopscan = 0;

		int COM_open_dev(const char pname, int fd)
		{
		int ret = 0;
		int tmp = -1;

		FMR_ASSERT(pname);
		FMR_ASSERT(fd);

		LOGI("COM_open_dev start\n");
		tmp = open(pname, O_RDWR);
		if (tmp < 0) {
		LOGE("Open %s failed, %s\n", pname, strerror(errno));
		ret = -ERR_INVALID_FD;
		}
		*fd = tmp;
		LOGI("%s, [fd=%d] [ret=%d]\n", __func__, *fd, ret);
		return ret;
		}

		int COM_close_dev(int fd)
		{
		int ret = 0;

		LOGI("COM_close_dev start\n");
		ret = close(fd);
		if (ret) {
		LOGE("%s, failed\n", __func__);
		}
		LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
		return ret;
		}

		int COM_pwr_up(int fd, int band, int freq)
		{
		int ret = 0;
		struct fm_tune_parm parm;

		LOGI("%s, [freq=%d]\n", __func__, freq);
		bzero(&parm, sizeof(struct fm_tune_parm));

		parm.band = band;
		parm.freq = freq;
		parm.hilo = FM_AUTO_HILO_OFF;
		parm.space = FM_SEEK_SPACE;

		ret = ioctl(fd, FM_IOCTL_POWERUP, &parm);
		if (ret) {
		LOGE("%s, failed\n", __func__);
		}
		LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
		return ret;
		}

		int COM_pwr_down(int fd, int type)
		{
		int ret = 0;
		LOGI("%s, [type=%d]\n", __func__, type);
		ret = ioctl(fd, FM_IOCTL_POWERDOWN, &type);
		if (ret) {
		LOGE("%s, failed\n", __func__);
		}
		LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
		return ret;
		}

		/0x20: space, 0x7E:~/
		#define ISVALID(c)((c)>=0x20 && (c)<=0x7E)
		/change any char which out of [0x20,0x7E]to space(0x20)/
		void COM_change_string(uint8_t *str, int len)
		{
		int i = 0;
		for (i=0; i<len; i++) {
		if (false == ISVALID(str[i])) {
		str[i]= 0x20;
		}
		}
		}

		int COM_get_ps(int fd, RDSData_Struct rds, uint8_t ps, int ps_len)
		{
		int ret = 0;
		char tmp_ps[9] = {0};

		FMR_ASSERT(rds);
		FMR_ASSERT(ps);
		FMR_ASSERT(ps_len);

		if (rds->event_status&RDS_EVENT_PROGRAMNAME) {
		LOGD("%s, Success,[event_status=%d]\n", __func__, rds->event_status);
		*ps = &rds->PS_Data.PS[3][0];
		*ps_len = sizeof(rds->PS_Data.PS[3]);

		COM_change_string(ps, ps_len);
		memcpy(tmp_ps, *ps, 8);
		LOGI("PS=%s\n", tmp_ps);
		} else {
		LOGE("%s, Failed,[event_status=%d]\n", __func__, rds->event_status);
		*ps = NULL;
		*ps_len = 0;
		ret = -ERR_RDS_NO_DATA;
		}

		return ret;
		}

		int COM_get_rt(int fd, RDSData_Struct rds, uint8_t rt, int rt_len)
		{
		int ret = 0;
		char tmp_rt[65] = { 0 };

		FMR_ASSERT(rds);
		FMR_ASSERT(rt);
		FMR_ASSERT(rt_len);

		if (rds->event_status&RDS_EVENT_LAST_RADIOTEXT) {
		LOGD("%s, Success,[event_status=%d]\n", __func__, rds->event_status);
		*rt = &rds->RT_Data.TextData[3][0];
		*rt_len = rds->RT_Data.TextLength;

		COM_change_string(rt, rt_len);
		memcpy(tmp_rt, *rt, 64);
		LOGI("RT=%s\n", tmp_rt);
		} else {
		LOGE("%s, Failed,[event_status=%d]\n", __func__, rds->event_status);
		*rt = NULL;
		*rt_len = 0;
		ret = -ERR_RDS_NO_DATA;
		}
		return ret;
		}

		int COM_get_pi(int fd, RDSData_Struct rds, uint16_t pi)
		{
		int ret = 0;

		FMR_ASSERT(rds);
		FMR_ASSERT(pi);

		if (rds->event_status&RDS_EVENT_PI_CODE) {
		LOGD("%s, Success,[event_status=%d] [PI=%d]\n", __func__, rds->event_status, rds->PI);
		*pi = rds->PI;
		} else {
		LOGI("%s, Failed, there's no pi,[event_status=%d]\n", __func__, rds->event_status);
		*pi = -1;
		ret = -ERR_RDS_NO_DATA;
		}

		return ret;
		}

		int COM_tune(int fd, int freq, int band)
		{
		int ret = 0;

		struct fm_tune_parm parm;

		bzero(&parm, sizeof(struct fm_tune_parm));

		parm.band = band;
		parm.freq = freq;
		parm.hilo = FM_AUTO_HILO_OFF;
		parm.space = FM_SEEK_SPACE;

		ret = ioctl(fd, FM_IOCTL_TUNE, &parm);
		if (ret) {
		LOGE("%s, failed\n", __func__);
		}
		LOGD("%s, [fd=%d] [freq=%d] [ret=%d]\n", __func__, fd, freq, ret);
		return ret;
		}

		int COM_seek(int fd, int *freq, int band, int dir, int lev)
		{
		int ret = 0;
		struct fm_seek_parm parm;

		bzero(&parm, sizeof(struct fm_tune_parm));

		parm.band = band;
		parm.freq = *freq;
		parm.hilo = FM_AUTO_HILO_OFF;
		parm.space = FM_SEEK_SPACE;
		if (dir == 1) {
		parm.seekdir = FM_SEEK_UP;
		} else if (dir == 0) {
		parm.seekdir = FM_SEEK_DOWN;
		}
		parm.seekth = lev;

		ret = ioctl(fd, FM_IOCTL_SEEK, &parm);
		if (ret == 0) {
		*freq = parm.freq;
		}
		LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
		return ret;
		}

		int COM_set_mute(int fd, int mute)
		{
		int ret = 0;
		int tmp = mute;

		LOGD("%s, start \n", __func__);
		ret = ioctl(fd, FM_IOCTL_MUTE, &tmp);
		if (ret) {
		LOGE("%s, failed\n", __func__);
		}
		LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
		return ret;
		}

		int COM_is_fm_pwrup(int fd, int *pwrup)
		{
		int ret = 0;

		ret = ioctl(fd, FM_IOCTL_IS_FM_POWERED_UP, pwrup);
		if (ret) {
		LOGE("%s, failed\n", __func__);
		}
		LOGD("%s, [fd=%d] [ret=%d]\n", __func__, fd, ret);
		return ret;
		}

		/******************************************
		* Inquiry if RDS is support in driver.
		* Parameter:
		* None
		*supt Value:
		* 1: support
		* 0: NOT support
		* -1: error
		******************************************/
		int COM_is_rdsrx_support(int fd, int *supt)
		{
		int ret = 0;
		int support = -1;

		if (fd < 0) {
		LOGE("FM isRDSsupport fail, g_fm_fd = %d\n", fd);
		*supt = -1;
		ret = -ERR_INVALID_FD;
		return ret;
		}

		ret = ioctl(fd, FM_IOCTL_RDS_SUPPORT, &support);
		if (ret) {
		LOGE("FM FM_IOCTL_RDS_SUPPORT fail, errno = %d\n", errno);
		//don't support
		*supt = 0;
		return ret;
		}
		LOGI("isRDSsupport Success,[support=%d]\n", support);
		*supt = support;
		return ret;
		}

		int COM_pre_search(int fd)
		{
		fm_s32 ret = 0;
		ret = ioctl(fd, FM_IOCTL_PRE_SEARCH, 0);
		LOGD("COM_pre_search:%d\n",ret);
		return ret;
		}

		int COM_restore_search(int fd)
		{
		fm_s32 ret = 0;
		ret = ioctl(fd, FM_IOCTL_RESTORE_SEARCH, 0);
		LOGD("COM_restore_search:%d\n",ret);
		return ret;
		}

		/soft mute tune function, usually for sw scan implement or CQI log tool/
		int COM_Soft_Mute_Tune(int fd, fm_softmute_tune_t *para)
		{
		fm_s32 ret = 0;
		//fm_s32 RSSI = 0, PAMD = 0,MR = 0, ATDC = 0;
		//fm_u32 PRX = 0;
		//fm_u16 softmuteGainLvl = 0;
		fm_softmute_tune_t value;

		value.freq = para->freq;
		ret = ioctl(fd, FM_IOCTL_SOFT_MUTE_TUNE, &value);
		if (ret) {
		LOGE("FM soft mute tune faild:%d\n",ret);
		return ret;
		}
		#if 0
		LOGD("Raw data of soft mute tune[%d]: RSSI:[%x]PAMD:[%x]MR:[%x]ATDC:[%x]PRX:[%x]SMG:[%x]",para->freq,value.RSSI,value.PAMD,value.MR,value.ATDC,value.PRX,value.SMG);
		RSSI = ((value.RSSI & 0x03FF) >= 512) ? ((value.RSSI & 0x03FF) - 1024) : (value.RSSI & 0x03FF);
		PAMD = ((value.PAMD & 0xFF) >= 128) ? ((value.PAMD & 0x00FF) - 256) : (value.PAMD & 0x00FF);
		MR = ((value.MR & 0x01FF) >= 256) ? ((value.MR & 0x01FF) - 512) : (value.MR & 0x01FF);
		ATDC =((value.ATDC & 0x0FFF) >= 2048) ? ((value.ATDC & 0x0FFF) - 4096) : (value.ATDC & 0x0FFF);
		if (ATDC < 0) {
		ATDC = (~(ATDC)) - 1;//Get abs value of ATDC
		}
		PRX = (value.PRX & 0x00FF);
		softmuteGainLvl = value.SMG;
		//check if the channel is valid according to each CQIs
		if ((RSSI >= RSSI_TH)
		&& (PAMD <= PAMD_TH)
		&& (ATDC <= ATDC_TH)
		&& (MR >= MR_TH)
		&& (PRX >= PRX_TH)
		&& (softmuteGainLvl <= softMuteGainTH)) {
		para->valid = fm_true;
		} else {
		para->valid = fm_false;
		}
		#endif
		para->valid = value.valid;
		para->rssi = value.rssi;
		//LOGI("soft mute tune[%d] valid[%d]: RSSI:[%d]PAMD:[%d]MR:[%d]ATDC:[%d]PRX:[%d]SMG:[%d]",para->freq,para->valid,RSSI,PAMD,MR,ATDC,PRX,softmuteGainLvl);
		return 0;
		}

		int COM_get_cqi(int fd, int num, char *buf, int buf_len)
		{
		int ret;
		struct fm_cqi_req cqi_req;

		//check buf
		num = (num > CQI_CH_NUM_MAX) ? CQI_CH_NUM_MAX : num;
		num = (num < CQI_CH_NUM_MIN) ? CQI_CH_NUM_MIN : num;
		cqi_req.ch_num = (uint16_t)num;
		cqi_req.buf_size = cqi_req.ch_num * sizeof(struct fm_cqi);
		if (!buf \|\| (buf_len < cqi_req.buf_size)) {
		LOGE("get cqi, invalid buf\n");
		return -1;
		}
		cqi_req.cqi_buf = buf;

		//get cqi from driver
		ret = ioctl(fd, FM_IOCTL_CQI_GET, &cqi_req);
		if (ret < 0) {
		LOGE("get cqi, failed %d\n", ret);
		return -1;
		}

		return 0;
		}

		int COM_turn_on_off_rds(int fd, int onoff)
		{
		int ret = 0;
		uint16_t rds_on = -1;

		LOGD("Rdsset start\n");
		if (onoff == FMR_RDS_ON) {
		rds_on = 1;
		ret = ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
		if (ret) {
		LOGE("FM_IOCTL_RDS_ON failed\n");
		return ret;
		}
		LOGD("Rdsset Success,[rds_on=%d]\n", rds_on);
		} else {
		rds_on = 0;
		ret = ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
		if (ret) {
		LOGE("FM_IOCTL_RDS_OFF failed\n");
		return ret;
		}
		LOGD("Rdsset Success,[rds_on=%d]\n", rds_on);
		}
		return ret;
		}

		int COM_get_chip_id(int fd, int *chipid)
		{
		int ret = 0;
		uint16_t tmp = 0;

		FMR_ASSERT(chipid);

		ret = ioctl(fd, FM_IOCTL_GETCHIPID, &tmp);
		*chipid = (int)tmp;
		if (ret) {
		LOGE("%s, failed\n", __func__);
		}
		LOGD("%s, [fd=%d] [chipid=%x] [ret=%d]\n", __func__, fd, *chipid, ret);
		return ret;
		}

		int COM_read_rds_data(int fd, RDSData_Struct rds, uint16_t rds_status)
		{
		int ret = 0;
		uint16_t event_status;
		//char tmp_ps[9] = {0};
		//char tmp_rt[65] = { 0 };

		FMR_ASSERT(rds);
		FMR_ASSERT(rds_status);

		if (read(fd, rds, sizeof(RDSData_Struct)) == sizeof(RDSData_Struct)) {
		event_status = rds->event_status;
		//memcpy(tmp_ps, &rds->PS_Data.PS[3][0], 8);
		//memcpy(tmp_rt, &rds->RT_Data.TextData[3][0], 64);
		LOGI("event_status = 0x%x\n", event_status);
		//memset(tmp_ps, 0, 9);
		//memset(tmp_rt, 0, 65);
		*rds_status = event_status;
		return ret;
		} else {
		//LOGE("readrds get no event\n");
		ret = -ERR_RDS_NO_DATA;
		}
		return ret;
		}

		int COM_active_af(int fd, RDSData_Struct rds, int band, uint16_t cur_freq, uint16_t ret_freq)
		{
		int ret = 0;
		int i = 0;
		struct fm_tune_parm parm;
		uint16_t rds_on = 0;
		uint16_t set_freq, sw_freq, org_freq, PAMD_Value, AF_PAMD_LBound, AF_PAMD_HBound;
		uint16_t PAMD_Level[25];
		uint16_t PAMD_DB_TBL[5] = {// 5dB, 10dB, 15dB, 20dB, 25dB,
		// 13, 17, 21, 25, 29};
		8, 12, 15, 18, 20};
		FMR_ASSERT(rds);
		FMR_ASSERT(ret_freq);

		sw_freq = cur_freq; //current freq
		org_freq = cur_freq;
		parm.band = band;
		parm.freq = sw_freq;
		parm.hilo = FM_AUTO_HILO_OFF;
		parm.space = FM_SPACE_DEFAULT;

		if (!(rds->event_status&RDS_EVENT_AF)) {
		LOGE("activeAF failed\n");
		*ret_freq = 0;
		ret = -ERR_RDS_NO_DATA;
		return ret;
		}

		AF_PAMD_LBound = PAMD_DB_TBL[0]; //5dB
		AF_PAMD_HBound = PAMD_DB_TBL[1]; //15dB
		ioctl(fd, FM_IOCTL_GETCURPAMD, &PAMD_Value);
		LOGI("current_freq=%d,PAMD_Value=%d\n", cur_freq, PAMD_Value);

		if (PAMD_Value < AF_PAMD_LBound) {
		rds_on = 0;
		ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
		//make sure rds->AF_Data.AF_Num is valid
		rds->AF_Data.AF_Num = (rds->AF_Data.AF_Num > 25)? 25 : rds->AF_Data.AF_Num;
		for (i=0; i<rds->AF_Data.AF_Num; i++) {
		set_freq = rds->AF_Data.AF[1][i]; //method A or B
		if (set_freq != org_freq) {
		parm.freq = set_freq;
		ioctl(fd, FM_IOCTL_TUNE, &parm);
		usleep(250*1000);
		ioctl(fd, FM_IOCTL_GETCURPAMD, &PAMD_Level[i]);
		LOGI("next_freq=%d,PAMD_Level=%d\n", parm.freq, PAMD_Level[i]);
		if (PAMD_Level[i] > PAMD_Value) {
		PAMD_Value = PAMD_Level[i];
		sw_freq = set_freq;
		}
		}
		}
		LOGI("PAMD_Value=%d, sw_freq=%d\n", PAMD_Value, sw_freq);
		if ((PAMD_Value > AF_PAMD_HBound)&&(sw_freq != 0)) {
		parm.freq = sw_freq;
		ioctl(fd, FM_IOCTL_TUNE, &parm);
		cur_freq = parm.freq;
		} else {
		parm.freq = org_freq;
		ioctl(fd, FM_IOCTL_TUNE, &parm);
		cur_freq = parm.freq;
		}
		rds_on = 1;
		ioctl(fd, FM_IOCTL_RDS_ONOFF, &rds_on);
		} else {
		LOGD("RDS_EVENT_AF old freq:%d\n", org_freq);
		}
		*ret_freq = cur_freq;

		return ret;
		}

		int COM_ana_switch(int fd, int antenna)
		{
		int ret = 0;

		ret = ioctl(fd, FM_IOCTL_ANA_SWITCH, &antenna);
		if (ret < 0) {
		LOGE("%s: fail, ret = %d\n", __func__, ret);
		}

		LOGD("%s: [ret = %d]\n", __func__, ret);
		return ret;
		}

		/* COM_is_dese_chan -- check if gived channel is a de-sense channel or not
		* @fd - fd of "dev/fm"
		* @freq - gived channel
		* return value: 0, not a dese chan; 1, a dese chan; else error NO.
		*/
		int COM_is_dese_chan(int fd, int freq)
		{
		int ret = 0;
		int tmp = freq;

		ret = ioctl(fd, FM_IOCTL_IS_DESE_CHAN, &freq);
		if (ret < 0) {
		LOGE("%s, failed,ret=%d\n", __func__,ret);
		return ret;
		} else {
		LOGD("[fd=%d] %d --> dese=%d\n", fd, tmp, freq);
		return freq;
		}
		}

		/* COM_desense_check -- check if gived channel is a de-sense channel or not
		* @fd - fd of "dev/fm"
		* @freq - gived channel
		* @rssi-freq's rssi
		* return value: 0, is desense channel and rssi is less than threshold; 1, not desense channel or it is but rssi is more than threshold.
		*/
		int COM_desense_check(int fd, int freq, int rssi)
		{
		int ret = 0;
		fm_desense_check_t parm;

		parm.freq = freq;
		parm.rssi = rssi;
		ret = ioctl(fd, FM_IOCTL_DESENSE_CHECK, &parm);
		if (ret < 0) {
		LOGE("%s, failed,ret=%d\n", __func__,ret);
		return ret;
		} else {
		LOGD("[fd=%d] %d --> dese=%d\n", fd,freq,ret);
		return ret;
		}
		}

		void FM_interface_init(struct fm_cbk_tbl *cbk_tbl)
		{
		//Basic functions.
		cbk_tbl->open_dev = COM_open_dev;
		cbk_tbl->close_dev = COM_close_dev;
		cbk_tbl->pwr_up = COM_pwr_up;
		cbk_tbl->pwr_down = COM_pwr_down;
		cbk_tbl->tune = COM_tune;
		cbk_tbl->set_mute = COM_set_mute;
		cbk_tbl->is_rdsrx_support = COM_is_rdsrx_support;
		cbk_tbl->turn_on_off_rds = COM_turn_on_off_rds;
		cbk_tbl->get_chip_id = COM_get_chip_id;
		//For RDS RX.
		cbk_tbl->read_rds_data = COM_read_rds_data;
		cbk_tbl->get_ps = COM_get_ps;
		cbk_tbl->get_rt = COM_get_rt;
		cbk_tbl->active_af = COM_active_af;
		//FM short antenna
		cbk_tbl->ana_switch = COM_ana_switch;
		cbk_tbl->desense_check = COM_desense_check;
		//soft mute tune
		cbk_tbl->soft_mute_tune = COM_Soft_Mute_Tune;
		cbk_tbl->pre_search = COM_pre_search;
		cbk_tbl->restore_search = COM_restore_search;
		return;
		}

jni/fmr/fm.h

0 → 100644

+547 −0

File added.

Preview size limit exceeded, changes collapsed.

jni/fmr/fmr.h

0 → 100644

+230 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2014 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef __FMR_H__
		#define __FMR_H__

		#include <jni.h>
		#include <utils/Log.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <sys/ioctl.h>
		#include <sys/types.h>
		#include <sys/stat.h>
		#include <fcntl.h>
		#include <unistd.h>
		#include <termios.h>
		#include <pthread.h>
		#include <signal.h>
		#include <errno.h>
		#include <dlfcn.h>

		#include "fm.h"

		#define FM_LIB_USE_XLOG

		#ifdef FM_LIB_USE_XLOG
		#include <cutils/xlog.h>
		#undef LOGV
		#define LOGV(...) XLOGV(__VA_ARGS__)
		#undef LOGD
		#define LOGD(...) XLOGD(__VA_ARGS__)
		#undef LOGI
		#define LOGI(...) XLOGI(__VA_ARGS__)
		#undef LOGW
		#define LOGW(...) XLOGW(__VA_ARGS__)
		#undef LOGE
		#define LOGE(...) XLOGE(__VA_ARGS__)
		#endif

		#define CUST_LIB_NAME "libfmcust.so"
		#define FM_DEV_NAME "/dev/fm"

		#define FM_RDS_PS_LEN 8

		struct fm_fake_channel
		{
		int freq;
		int rssi_th;
		int reserve;
		};

		struct fm_fake_channel_t
		{
		int size;
		struct fm_fake_channel *chan;
		};

		struct CUST_cfg_ds
		{
		int16_t chip;
		int32_t band;
		int32_t low_band;
		int32_t high_band;
		int32_t seek_space;
		int32_t max_scan_num;
		int32_t seek_lev;
		int32_t scan_sort;
		int32_t short_ana_sup;
		int32_t rssi_th_l2;
		struct fm_fake_channel_t *fake_chan;
		};

		struct fm_cbk_tbl {
		//Basic functions.
		int (open_dev)(const char pname, int *fd);
		int (*close_dev)(int fd);
		int (*pwr_up)(int fd, int band, int freq);
		int (*pwr_down)(int fd, int type);
		int (seek)(int fd, int freq, int band, int dir, int lev);
		int (scan)(int fd, uint16_t tbl, int *num, int band, int sort);
		int (*stop_scan)(int fd);
		int (*tune)(int fd, int freq, int band);
		int (*set_mute)(int fd, int mute);
		int (is_rdsrx_support)(int fd, int supt);
		int (*turn_on_off_rds)(int fd, int onoff);
		int (get_chip_id)(int fd, int chipid);
		//FOR RDS RX.
		int (read_rds_data)(int fd, RDSData_Struct rds, uint16_t *rds_status);
		int (get_ps)(int fd, RDSData_Struct rds, uint8_t *ps, int ps_len);
		int (get_rt)(int fd, RDSData_Struct rds, uint8_t *rt, int rt_len);
		int (active_af)(int fd, RDSData_Struct rds, int band, uint16_t cur_freq, uint16_t *ret_freq);
		//FM long/short antenna switch
		int (*ana_switch)(int fd, int antenna);
		int (soft_mute_tune)(int fd, fm_softmute_tune_t para);
		int (*desense_check)(int fd, int freq, int rssi);
		int (*pre_search)(int fd);
		int (*restore_search)(int fd);
		};

		typedef int (CUST_func_type)(struct CUST_cfg_ds );
		typedef void (init_func_type)(struct fm_cbk_tbl );

		struct fmr_ds {
		int fd;
		int err;
		uint16_t cur_freq;
		uint16_t backup_freq;
		void *priv;
		void *custom_handler;
		struct CUST_cfg_ds cfg_data;
		struct fm_cbk_tbl tbl;
		CUST_func_type get_cfg;
		void *init_handler;
		init_func_type init_func;
		RDSData_Struct rds;
		struct fm_hw_info hw_info;
		fm_bool scan_stop;
		};

		enum fmr_err_em {
		ERR_SUCCESS = 1000, // kernel error begin at here
		ERR_INVALID_BUF,
		ERR_INVALID_PARA,
		ERR_STP,
		ERR_GET_MUTEX,
		ERR_FW_NORES,
		ERR_RDS_CRC,
		ERR_INVALID_FD, // native error begin at here
		ERR_UNSUPPORT_CHIP,
		ERR_LD_LIB,
		ERR_FIND_CUST_FNUC,
		ERR_UNINIT,
		ERR_NO_MORE_IDX,
		ERR_RDS_NO_DATA,
		ERR_UNSUPT_SHORTANA,
		ERR_MAX
		};

		enum fmr_rds_onoff {
		FMR_RDS_ON,
		FMR_RDS_OFF,
		FMR_MAX
		};

		typedef enum {
		FM_LONG_ANA = 0,
		FM_SHORT_ANA
		} fm_antenna_type;


		#define CQI_CH_NUM_MAX 255
		#define CQI_CH_NUM_MIN 0


		/**************** Function declaration ****************/
		//fmr_err.cpp
		char *FMR_strerr();
		void FMR_seterr(int err);

		//fmr_core.cpp
		int FMR_init(void);
		int FMR_get_cfgs(int idx);
		int FMR_open_dev(int idx);
		int FMR_close_dev(int idx);
		int FMR_pwr_up(int idx, int freq);
		int FMR_pwr_down(int idx, int type);
		int FMR_seek(int idx, int start_freq, int dir, int *ret_freq);
		int FMR_scan(int idx, uint16_t tbl, int num);
		int FMR_stop_scan(int idx);
		int FMR_tune(int idx, int freq);
		int FMR_set_mute(int idx, int mute);
		int FMR_is_rdsrx_support(int idx, int *supt);
		int FMR_turn_on_off_rds(int idx, int onoff);
		int FMR_get_chip_id(int idx, int *chipid);
		int FMR_read_rds_data(int idx, uint16_t *rds_status);
		int FMR_get_ps(int idx, uint8_t *ps, int ps_len);
		int FMR_get_rssi(int idx, int *rssi);
		int FMR_get_rt(int idx, uint8_t *rt, int rt_len);
		int FMR_active_af(int idx, uint16_t *ret_freq);

		int FMR_ana_switch(int idx, int antenna);
		int FMR_Pre_Search(int idx);
		int FMR_Restore_Search(int idx);

		//common part
		int COM_open_dev(const char pname, int fd);
		int COM_close_dev(int fd);
		int COM_pwr_up(int fd, int band, int freq);
		int COM_pwr_down(int fd, int type);
		int COM_seek(int fd, int *freq, int band, int dir, int lev);
		int COM_Soft_Mute_Tune(int fd, fm_softmute_tune_t *para);

		int COM_stop_scan(int fd);
		int COM_tune(int fd, int freq, int band);
		int COM_set_mute(int fd, int mute);
		int COM_is_rdsrx_support(int fd, int *supt);
		int COM_turn_on_off_rds(int fd, int onoff);
		int COM_get_chip_id(int fd, int *chipid);
		int COM_read_rds_data(int fd, RDSData_Struct rds, uint16_t rds_status);
		int COM_get_ps(int fd, RDSData_Struct rds, uint8_t ps, int ps_len);
		int COM_get_rt(int fd, RDSData_Struct rds, uint8_t rt, int rt_len);
		int COM_active_af(int fd, RDSData_Struct rds, int band, uint16_t cur_freq, uint16_t ret_freq);

		int COM_ana_switch(int fd, int antenna);
		int COM_desense_check(int fd, int freq, int rssi);
		int COM_pre_search(int fd);
		int COM_restore_search(int fd);
		void FM_interface_init(struct fm_cbk_tbl *cbk_tbl);

		#define FMR_ASSERT(a) { \
		if ((a) == NULL) { \
		LOGE("%s,invalid buf\n", __func__);\
		return -ERR_INVALID_BUF; \
		} \
		}
		#endif