| /* |
| * Copyright (c) 2014, The Linux Foundation. All rights reserved. |
| |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * * Neither the name of The Linux Foundation nor |
| * the names of its contributors may be used to endorse or promote |
| * products derived from this software without specific prior written |
| * permission. |
| |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| * NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include <cstdlib> |
| #include <cstring> |
| #include "ConfigFmThs.h" |
| #include "FmPerformanceParams.h" |
| #include <utils/Log.h> |
| |
| static int compare_name |
| ( |
| const void *name1, const void *name2 |
| ) |
| { |
| char *first = (char *)name1; |
| struct NAME_MAP *second = (struct NAME_MAP *)name2; |
| |
| return(strcmp(first, second->name)); |
| } |
| |
| ConfigFmThs :: ConfigFmThs |
| ( |
| ) |
| { |
| keyfile = NULL; |
| } |
| |
| ConfigFmThs :: ~ConfigFmThs |
| ( |
| ) |
| { |
| free_key_file(keyfile); |
| } |
| |
| void ConfigFmThs :: set_af_ths |
| ( |
| UINT fd |
| ) |
| { |
| signed char ret = FM_SUCCESS; |
| char **keys; |
| char **keys_cpy; |
| char *key_value; |
| int value; |
| FmPerformanceParams perf_params; |
| struct NAME_MAP *found; |
| |
| if(keyfile != NULL) { |
| keys_cpy = keys = get_keys(keyfile, GRPS_MAP[0].name); |
| if(keys != NULL) { |
| while(*keys != NULL) { |
| ALOGE("key found is: %s\n", *keys); |
| found = (NAME_MAP *)bsearch(*keys, AF_PARAMS_MAP, |
| MAX_AF_PARAMS, sizeof(NAME_MAP), compare_name); |
| if(found != NULL) { |
| key_value = get_value(keyfile, |
| GRPS_MAP[0].name, found->name); |
| if((key_value != NULL) && strcmp(key_value, "")) { |
| value = atoi(key_value); |
| switch(found->num) { |
| case AF_RMSSI_TH: |
| if((value >= AF_RMSSI_TH_MIN) |
| && (value <= AF_RMSSI_TH_MAX)) { |
| ALOGE("Set af rmssi th: %d\n", value); |
| ret = perf_params.SetAfRmssiTh(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting Af Rmssi th\n"); |
| break; |
| } |
| unsigned short th; |
| ret = perf_params.GetAfRmssiTh(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read af rmssith: %hd\n", th); |
| }else { |
| ALOGE("Error in reading Af Rmssi th\n"); |
| } |
| } |
| break; |
| case AF_RMSSI_SAMPLES: |
| if((value >= AF_RMSSI_SAMPLES_MIN) |
| && (value <= AF_RMSSI_SAMPLES_MAX)) { |
| ALOGE("Set af rmssi samples cnt: %d\n", value); |
| ret = perf_params.SetAfRmssiSamplesCnt(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting af rmssi samples\n"); |
| break; |
| } |
| unsigned char cnt; |
| ret = perf_params.GetAfRmssiSamplesCnt(fd, cnt); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read af rmssi samples cnt: %hhd\n", cnt); |
| }else { |
| ALOGE("Error in reading rmssi samples\n"); |
| } |
| } |
| break; |
| case GOOD_CH_RMSSI_TH: |
| if((value >= GOOD_CH_RMSSI_TH_MIN) |
| && (value <= GOOD_CH_RMSSI_TH_MAX)) { |
| ALOGE("Set Good channle rmssi th: %d\n", value); |
| ret = perf_params.SetGoodChannelRmssiTh(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting Good channle rmssi th\n"); |
| break; |
| } |
| signed char th; |
| ret = perf_params.GetGoodChannelRmssiTh(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read good channel rmssi th: %d\n", th); |
| }else { |
| ALOGE("Error in reading Good channle rmssi th\n"); |
| } |
| } |
| break; |
| } |
| }else { |
| ALOGE("key_val for key: %s is empty\n", |
| *keys); |
| } |
| free(key_value); |
| } |
| keys++; |
| } |
| }else { |
| ALOGE("No of keys found is zero\n"); |
| } |
| free_strs(keys_cpy); |
| }else { |
| ALOGE("key file is null\n"); |
| } |
| } |
| |
| void ConfigFmThs :: set_srch_ths |
| ( |
| UINT fd |
| ) |
| { |
| signed char ret = FM_SUCCESS; |
| char **keys = NULL; |
| char **keys_cpy = NULL; |
| char *key_value = NULL; |
| int value; |
| FmPerformanceParams perf_params; |
| struct NAME_MAP *found = NULL; |
| |
| if(keyfile != NULL) { |
| keys_cpy = keys = get_keys(keyfile, GRPS_MAP[2].name); |
| if(keys != NULL) { |
| while(*keys != NULL) { |
| found = (NAME_MAP *)bsearch(*keys, SEACH_PARAMS_MAP, |
| MAX_SRCH_PARAMS, sizeof(NAME_MAP), compare_name); |
| if(found != NULL) { |
| key_value = get_value(keyfile, GRPS_MAP[2].name, found->name); |
| ALOGE("found srch ths: %s: %s\n", found->name, key_value); |
| if((key_value != NULL) && strcmp(key_value, "")) { |
| value = atoi(key_value); |
| switch(found->num) { |
| case SINR_FIRST_STAGE: |
| if((value >= SINR_FIRST_STAGE_MIN) |
| && (value <= SINR_FIRST_STAGE_MAX)) { |
| ALOGE("Set sinr first stage: %d\n", value); |
| ret = perf_params.SetSinrFirstStage(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting sinr first stage\n"); |
| break; |
| } |
| signed char th; |
| ret = perf_params.GetSinrFirstStage(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read sinr first stage: %d\n", th); |
| }else { |
| ALOGE("Error in reading sinr first stage\n"); |
| } |
| } |
| break; |
| case RMSSI_FIRST_STAGE: |
| if((value >= RMSSI_FIRST_STAGE_MIN) |
| && (value <= RMSSI_FIRST_STAGE_MAX)) { |
| ALOGE("Set rmssi first stage: %d\n", value); |
| ret = perf_params.SetRmssiFirstStage(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting rmssi first stage\n"); |
| break; |
| } |
| signed char th; |
| ret = perf_params.GetRmssiFirstStage(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read rmssi first stage: %d\n", th); |
| }else { |
| ALOGE("Error in reading rmssi first stage\n"); |
| } |
| } |
| break; |
| case INTF_LOW_TH: |
| if((value >= INTF_LOW_TH_MIN) |
| && (value <= INTF_LOW_TH_MAX)) { |
| ALOGE("Set intf low th: %d\n", value); |
| ret = perf_params.SetIntfLowTh(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting intf low th\n"); |
| break; |
| } |
| unsigned char th; |
| ret = perf_params.GetIntfLowTh(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read intf low th: %u\n", th); |
| }else { |
| ALOGE("Error in reading intf low th\n"); |
| } |
| } |
| break; |
| case INTF_HIGH_TH: |
| if((value >= INTF_HIGH_TH_MIN) |
| && (value <= INTF_HIGH_TH_MAX)) { |
| ALOGE("Set intf high th: %d\n", value); |
| ret = perf_params.SetIntfHighTh(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting intf high th\n"); |
| break; |
| } |
| unsigned char th; |
| ret = perf_params.GetIntfHighTh(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read intf high th: %u\n", th); |
| }else { |
| ALOGE("Error in reading intf high th\n"); |
| } |
| } |
| break; |
| case CF0_TH: |
| ALOGE("Set cf0 th: %d\n", value); |
| ret = perf_params.SetCf0Th12(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting cf0 th\n"); |
| break; |
| } |
| int th; |
| ret = perf_params.GetCf0Th12(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read CF012 th: %d\n", th); |
| }else { |
| ALOGE("Error in reading cf0 th\n"); |
| } |
| break; |
| case SRCH_ALGO_TYPE: |
| if((value >= SRCH_ALGO_TYPE_MIN) |
| && (value <= SRCH_ALGO_TYPE_MAX)) { |
| ALOGE("Set search algo type: %d\n", value); |
| ret = perf_params.SetSrchAlgoType(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting search algo type\n"); |
| break; |
| } |
| unsigned char algo; |
| ret = perf_params.GetSrchAlgoType(fd, algo); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read algo type: %u\n", algo); |
| }else { |
| ALOGE("Error in reading search algo type\n"); |
| } |
| } |
| break; |
| case SINR_SAMPLES: |
| if((value >= SINR_SAMPLES_CNT_MIN) |
| && (value <= SINR_SAMPLES_CNT_MAX)) { |
| ALOGE("Set sinr samples count: %d\n", value); |
| ret = perf_params.SetSinrSamplesCnt(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting sinr samples count\n"); |
| break; |
| } |
| unsigned char cnt; |
| ret = perf_params.GetSinrSamplesCnt(fd, cnt); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read sinr samples cnt: %u\n", cnt); |
| }else { |
| ALOGE("Error in reading sinr samples count\n"); |
| } |
| } |
| break; |
| case SINR: |
| if((value >= SINR_FINAL_STAGE_MIN) |
| && (value <= SINR_FINAL_STAGE_MAX)) { |
| ALOGE("Set final stage sinr: %d\n", value); |
| ret = perf_params.SetSinrFinalStage(fd, value); |
| if(ret == FM_FAILURE) { |
| ALOGE("Error in setting final stage sinr\n"); |
| break; |
| } |
| signed char th; |
| ret = perf_params.GetSinrFinalStage(fd, th); |
| if(ret == FM_SUCCESS) { |
| ALOGE("Read final stage sinr: %d\n", th); |
| }else { |
| ALOGE("Error in reading final stage sinr\n"); |
| } |
| } |
| break; |
| } |
| }else { |
| ALOGE("key_value for key: %s is empty\n", |
| *keys); |
| } |
| free(key_value); |
| } |
| keys++; |
| } |
| }else { |
| ALOGE("No of keys found is zero\n"); |
| } |
| free_strs(keys_cpy); |
| }else { |
| ALOGE("key file is null\n"); |
| } |
| } |
| |
| void ConfigFmThs :: set_hybrd_list |
| ( |
| UINT fd |
| ) |
| { |
| signed char ret = FM_SUCCESS; |
| char **keys = NULL; |
| char **keys_cpy = NULL; |
| char *key_value = NULL; |
| char *freqs = NULL; |
| unsigned int *freqs_array = NULL; |
| signed char *sinrs_array = NULL; |
| char *sinrs = NULL; |
| int value; |
| unsigned int freq_cnt = 0; |
| unsigned int sinr_cnt = 0; |
| FmPerformanceParams perf_params; |
| struct NAME_MAP *found; |
| |
| ALOGE("Inside hybrid srch list\n"); |
| if(keyfile != NULL) { |
| keys_cpy = keys = get_keys(keyfile, GRPS_MAP[1].name); |
| if(keys != NULL) { |
| while(*keys != NULL) { |
| found = (NAME_MAP *)bsearch(*keys, HYBRD_SRCH_MAP, |
| MAX_HYBRID_SRCH_PARAMS, sizeof(NAME_MAP), compare_name); |
| if(found != NULL) { |
| key_value = get_value(keyfile, GRPS_MAP[1].name, found->name); |
| if((key_value != NULL) && strcmp(key_value, "")) { |
| switch(found->num) { |
| case FREQ_LIST: |
| freqs = key_value; |
| break; |
| case SINR_LIST: |
| sinrs = key_value; |
| break; |
| default: |
| free(key_value); |
| break; |
| } |
| } |
| } |
| keys++; |
| } |
| free_strs(keys_cpy); |
| }else { |
| ALOGE("No of keys found is zero\n"); |
| } |
| }else { |
| ALOGE("key file is null\n"); |
| } |
| |
| freq_cnt = extract_comma_sep_freqs(freqs, &freqs_array, ","); |
| sinr_cnt = extract_comma_sep_sinrs(sinrs, &sinrs_array, ","); |
| |
| if((freq_cnt == sinr_cnt) && (sinr_cnt > 0)) { |
| perf_params.SetHybridSrchList(fd, freqs_array, sinrs_array, freq_cnt); |
| } |
| |
| free(freqs); |
| free(sinrs); |
| free(freqs_array); |
| free(sinrs_array); |
| } |
| |
| unsigned int ConfigFmThs :: extract_comma_sep_freqs |
| ( |
| char *freqs, |
| unsigned int **freqs_arr, |
| const char *str |
| ) |
| { |
| char *next_freq; |
| char *saveptr = NULL; |
| unsigned int freq; |
| unsigned int *freqs_new_arr; |
| unsigned int size = 0; |
| unsigned int len = 0; |
| |
| next_freq = strtok_r(freqs, str, &saveptr); |
| while(next_freq != NULL) { |
| freq = atoi(next_freq); |
| ALOGD("HYBRID_SRCH freq: %u\n", freq); |
| if(size == len) { |
| size <<= 1; |
| if(size == 0) |
| size = 1; |
| freqs_new_arr = (unsigned int *)realloc(*freqs_arr, |
| size * sizeof(unsigned int)); |
| if(freqs_new_arr == NULL) { |
| free(*freqs_arr); |
| *freqs_arr = NULL; |
| break; |
| } |
| *freqs_arr = freqs_new_arr; |
| } |
| (*freqs_arr)[len] = freq; |
| len++; |
| next_freq = strtok_r(NULL, str, &saveptr); |
| } |
| return len; |
| } |
| |
| unsigned int ConfigFmThs :: extract_comma_sep_sinrs |
| ( |
| char *sinrs, |
| signed char **sinrs_arr, |
| const char *str |
| ) |
| { |
| char *next_sinr; |
| char *saveptr = NULL; |
| signed char *sinrs_new_arr; |
| unsigned int size = 0; |
| unsigned int len = 0; |
| signed char sinr; |
| |
| next_sinr = strtok_r(sinrs, str, &saveptr); |
| while(next_sinr != NULL) { |
| sinr = atoi(next_sinr); |
| ALOGD("HYBRID_SRCH sinr: %d\n", sinr); |
| if(size == len) { |
| size <<= 1; |
| if(size == 0) |
| size = 1; |
| sinrs_new_arr = (signed char *)realloc(*sinrs_arr, |
| size * sizeof(signed char)); |
| if(sinrs_new_arr == NULL) { |
| free(*sinrs_arr); |
| *sinrs_arr = NULL; |
| break; |
| } |
| *sinrs_arr = sinrs_new_arr; |
| } |
| (*sinrs_arr)[len] = sinr; |
| len++; |
| next_sinr = strtok_r(NULL, str, &saveptr); |
| } |
| return len; |
| } |
| |
| void ConfigFmThs :: SetRxSearchAfThs |
| ( |
| const char *file, UINT fd |
| ) |
| { |
| int index; |
| struct NAME_MAP *found; |
| char **grps = NULL; |
| char **grps_cpy = NULL; |
| |
| keyfile = get_key_file(); |
| |
| ALOGE("file name is: %s\n", file); |
| if(!parse_load_file(keyfile, file)) { |
| ALOGE("Error in loading threshold file\n"); |
| }else { |
| grps_cpy = grps = get_grps(keyfile); |
| if(grps != NULL) { |
| while(*grps != NULL) { |
| ALOGE("Search grp: %s\n", *grps); |
| found = (NAME_MAP *)bsearch(*grps, GRPS_MAP, MAX_GRPS, |
| sizeof(NAME_MAP), compare_name); |
| if(found != NULL) { |
| ALOGE("Found group: %s\n", found->name); |
| switch(found->num) { |
| case AF_THS: |
| set_af_ths(fd); |
| break; |
| case SRCH_THS: |
| set_srch_ths(fd); |
| break; |
| case HYBRD_SRCH_LIST: |
| set_hybrd_list(fd); |
| break; |
| } |
| } |
| grps++; |
| } |
| }else { |
| ALOGE("No of groups found is zero\n"); |
| } |
| free_strs(grps_cpy); |
| } |
| free_key_file(keyfile); |
| keyfile = NULL; |
| } |