Gitiles
Code Review Sign In
review.blissroms.org / platform_vendor_qcom_opensource_fm-commonsys / 1c2c4355c22213cd1dffdda725e8b3e66fc4074a / . / jni / ConfigFmThs.cpp
blob: 09529c5bcc4e512b3bdaa3c244d77234a8d8d22f [file] [log] [blame]
Venkateshwarlu Domakonda1c2c4352014-05-26 14:35:12 +0530[diff] [blame^]1/*
2 * Copyright (c) 2014, The Linux Foundation. All rights reserved.
3
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution.
11 * * Neither the name of The Linux Foundation nor
12 * the names of its contributors may be used to endorse or promote
13 * products derived from this software without specific prior written
14 * permission.
15
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 * NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
26 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#include <cstdlib>
30#include <cstring>
31#include "ConfigFmThs.h"
32#include "FmPerformanceParams.h"
33#include <utils/Log.h>
34
35static int compare_name
36(
37 const void *name1, const void *name2
38)
39{
40 char *first = (char *)name1;
41 struct NAME_MAP *second = (struct NAME_MAP *)name2;
42
43 return(strcmp(first, second->name));
44}
45
46ConfigFmThs :: ConfigFmThs
47(
48)
49{
50 keyfile = NULL;
51}
52
53ConfigFmThs :: ~ConfigFmThs
54(
55)
56{
57 free_key_file(keyfile);
58}
59
60void ConfigFmThs :: set_af_ths
61(
62 UINT fd
63)
64{
65 signed char ret = FM_SUCCESS;
66 char **keys;
67 char **keys_cpy;
68 char *key_value;
69 int value;
70 FmPerformanceParams perf_params;
71 struct NAME_MAP *found;
72
73 if(keyfile != NULL) {
74 keys_cpy = keys = get_keys(keyfile, GRPS_MAP[0].name);
75 if(keys != NULL) {
76 while(*keys != NULL) {
77 ALOGE("key found is: %s\n", *keys);
78 found = (NAME_MAP *)bsearch(*keys, AF_PARAMS_MAP,
79 MAX_AF_PARAMS, sizeof(NAME_MAP), compare_name);
80 if(found != NULL) {
81 key_value = get_value(keyfile,
82 GRPS_MAP[0].name, found->name);
83 if((key_value != NULL) && strcmp(key_value, "")) {
84 value = atoi(key_value);
85 switch(found->num) {
86 case AF_RMSSI_TH:
87 if((value >= AF_RMSSI_TH_MIN)
88 && (value <= AF_RMSSI_TH_MAX)) {
89 ALOGE("Set af rmssi th: %d\n", value);
90 ret = perf_params.SetAfRmssiTh(fd, value);
91 if(ret == FM_FAILURE) {
92 ALOGE("Error in setting Af Rmssi th\n");
93 break;
94 }
95 unsigned short th;
96 ret = perf_params.GetAfRmssiTh(fd, th);
97 if(ret == FM_SUCCESS) {
98 ALOGE("Read af rmssith: %hd\n", th);
99 }else {
100 ALOGE("Error in reading Af Rmssi th\n");
101 }
102 }
103 break;
104 case AF_RMSSI_SAMPLES:
105 if((value >= AF_RMSSI_SAMPLES_MIN)
106 && (value <= AF_RMSSI_SAMPLES_MAX)) {
107 ALOGE("Set af rmssi samples cnt: %d\n", value);
108 ret = perf_params.SetAfRmssiSamplesCnt(fd, value);
109 if(ret == FM_FAILURE) {
110 ALOGE("Error in setting af rmssi samples\n");
111 break;
112 }
113 unsigned char cnt;
114 ret = perf_params.GetAfRmssiSamplesCnt(fd, cnt);
115 if(ret == FM_SUCCESS) {
116 ALOGE("Read af rmssi samples cnt: %hhd\n", cnt);
117 }else {
118 ALOGE("Error in reading rmssi samples\n");
119 }
120 }
121 break;
122 case GOOD_CH_RMSSI_TH:
123 if((value >= GOOD_CH_RMSSI_TH_MIN)
124 && (value <= GOOD_CH_RMSSI_TH_MAX)) {
125 ALOGE("Set Good channle rmssi th: %d\n", value);
126 ret = perf_params.SetGoodChannelRmssiTh(fd, value);
127 if(ret == FM_FAILURE) {
128 ALOGE("Error in setting Good channle rmssi th\n");
129 break;
130 }
131 signed char th;
132 ret = perf_params.GetGoodChannelRmssiTh(fd, th);
133 if(ret == FM_SUCCESS) {
134 ALOGE("Read good channel rmssi th: %d\n", th);
135 }else {
136 ALOGE("Error in reading Good channle rmssi th\n");
137 }
138 }
139 break;
140 }
141 }else {
142 ALOGE("key_val for key: %s is empty\n",
143 *keys);
144 }
145 free(key_value);
146 }
147 keys++;
148 }
149 }else {
150 ALOGE("No of keys found is zero\n");
151 }
152 free_strs(keys_cpy);
153 }else {
154 ALOGE("key file is null\n");
155 }
156}
157
158void ConfigFmThs :: set_srch_ths
159(
160 UINT fd
161)
162{
163 signed char ret = FM_SUCCESS;
164 char **keys = NULL;
165 char **keys_cpy = NULL;
166 char *key_value = NULL;
167 int value;
168 FmPerformanceParams perf_params;
169 struct NAME_MAP *found = NULL;
170
171 if(keyfile != NULL) {
172 keys_cpy = keys = get_keys(keyfile, GRPS_MAP[2].name);
173 if(keys != NULL) {
174 while(*keys != NULL) {
175 found = (NAME_MAP *)bsearch(*keys, SEACH_PARAMS_MAP,
176 MAX_SRCH_PARAMS, sizeof(NAME_MAP), compare_name);
177 if(found != NULL) {
178 key_value = get_value(keyfile, GRPS_MAP[2].name, found->name);
179 ALOGE("found srch ths: %s: %s\n", found->name, key_value);
180 if((key_value != NULL) && strcmp(key_value, "")) {
181 value = atoi(key_value);
182 switch(found->num) {
183 case SINR_FIRST_STAGE:
184 if((value >= SINR_FIRST_STAGE_MIN)
185 && (value <= SINR_FIRST_STAGE_MAX)) {
186 ALOGE("Set sinr first stage: %d\n", value);
187 ret = perf_params.SetSinrFirstStage(fd, value);
188 if(ret == FM_FAILURE) {
189 ALOGE("Error in setting sinr first stage\n");
190 break;
191 }
192 signed char th;
193 ret = perf_params.GetSinrFirstStage(fd, th);
194 if(ret == FM_SUCCESS) {
195 ALOGE("Read sinr first stage: %d\n", th);
196 }else {
197 ALOGE("Error in reading sinr first stage\n");
198 }
199 }
200 break;
201 case RMSSI_FIRST_STAGE:
202 if((value >= RMSSI_FIRST_STAGE_MIN)
203 && (value <= RMSSI_FIRST_STAGE_MAX)) {
204 ALOGE("Set rmssi first stage: %d\n", value);
205 ret = perf_params.SetRmssiFirstStage(fd, value);
206 if(ret == FM_FAILURE) {
207 ALOGE("Error in setting rmssi first stage\n");
208 break;
209 }
210 signed char th;
211 ret = perf_params.GetRmssiFirstStage(fd, th);
212 if(ret == FM_SUCCESS) {
213 ALOGE("Read rmssi first stage: %d\n", th);
214 }else {
215 ALOGE("Error in reading rmssi first stage\n");
216 }
217 }
218 break;
219 case INTF_LOW_TH:
220 if((value >= INTF_LOW_TH_MIN)
221 && (value <= INTF_LOW_TH_MAX)) {
222 ALOGE("Set intf low th: %d\n", value);
223 ret = perf_params.SetIntfLowTh(fd, value);
224 if(ret == FM_FAILURE) {
225 ALOGE("Error in setting intf low th\n");
226 break;
227 }
228 unsigned char th;
229 ret = perf_params.GetIntfLowTh(fd, th);
230 if(ret == FM_SUCCESS) {
231 ALOGE("Read intf low th: %u\n", th);
232 }else {
233 ALOGE("Error in reading intf low th\n");
234 }
235 }
236 break;
237 case INTF_HIGH_TH:
238 if((value >= INTF_HIGH_TH_MIN)
239 && (value <= INTF_HIGH_TH_MAX)) {
240 ALOGE("Set intf high th: %d\n", value);
241 ret = perf_params.SetIntfHighTh(fd, value);
242 if(ret == FM_FAILURE) {
243 ALOGE("Error in setting intf high th\n");
244 break;
245 }
246 unsigned char th;
247 ret = perf_params.GetIntfHighTh(fd, th);
248 if(ret == FM_SUCCESS) {
249 ALOGE("Read intf high th: %u\n", th);
250 }else {
251 ALOGE("Error in reading intf high th\n");
252 }
253 }
254 break;
255 case CF0_TH:
256 ALOGE("Set cf0 th: %d\n", value);
257 ret = perf_params.SetCf0Th12(fd, value);
258 if(ret == FM_FAILURE) {
259 ALOGE("Error in setting cf0 th\n");
260 break;
261 }
262 int th;
263 ret = perf_params.GetCf0Th12(fd, th);
264 if(ret == FM_SUCCESS) {
265 ALOGE("Read CF012 th: %d\n", th);
266 }else {
267 ALOGE("Error in reading cf0 th\n");
268 }
269 break;
270 case SRCH_ALGO_TYPE:
271 if((value >= SRCH_ALGO_TYPE_MIN)
272 && (value <= SRCH_ALGO_TYPE_MAX)) {
273 ALOGE("Set search algo type: %d\n", value);
274 ret = perf_params.SetSrchAlgoType(fd, value);
275 if(ret == FM_FAILURE) {
276 ALOGE("Error in setting search algo type\n");
277 break;
278 }
279 unsigned char algo;
280 ret = perf_params.GetSrchAlgoType(fd, algo);
281 if(ret == FM_SUCCESS) {
282 ALOGE("Read algo type: %u\n", algo);
283 }else {
284 ALOGE("Error in reading search algo type\n");
285 }
286 }
287 break;
288 case SINR_SAMPLES:
289 if((value >= SINR_SAMPLES_CNT_MIN)
290 && (value <= SINR_SAMPLES_CNT_MAX)) {
291 ALOGE("Set sinr samples count: %d\n", value);
292 ret = perf_params.SetSinrSamplesCnt(fd, value);
293 if(ret == FM_FAILURE) {
294 ALOGE("Error in setting sinr samples count\n");
295 break;
296 }
297 unsigned char cnt;
298 ret = perf_params.GetSinrSamplesCnt(fd, cnt);
299 if(ret == FM_SUCCESS) {
300 ALOGE("Read sinr samples cnt: %u\n", cnt);
301 }else {
302 ALOGE("Error in reading sinr samples count\n");
303 }
304 }
305 break;
306 case SINR:
307 if((value >= SINR_FINAL_STAGE_MIN)
308 && (value <= SINR_FINAL_STAGE_MAX)) {
309 ALOGE("Set final stage sinr: %d\n", value);
310 ret = perf_params.SetSinrFinalStage(fd, value);
311 if(ret == FM_FAILURE) {
312 ALOGE("Error in setting final stage sinr\n");
313 break;
314 }
315 signed char th;
316 ret = perf_params.GetSinrFinalStage(fd, th);
317 if(ret == FM_SUCCESS) {
318 ALOGE("Read final stage sinr: %d\n", th);
319 }else {
320 ALOGE("Error in reading final stage sinr\n");
321 }
322 }
323 break;
324 }
325 }else {
326 ALOGE("key_value for key: %s is empty\n",
327 *keys);
328 }
329 free(key_value);
330 }
331 keys++;
332 }
333 }else {
334 ALOGE("No of keys found is zero\n");
335 }
336 free_strs(keys_cpy);
337 }else {
338 ALOGE("key file is null\n");
339 }
340}
341
342void ConfigFmThs :: set_hybrd_list
343(
344 UINT fd
345)
346{
347 signed char ret = FM_SUCCESS;
348 char **keys = NULL;
349 char **keys_cpy = NULL;
350 char *key_value = NULL;
351 char *freqs = NULL;
352 unsigned int *freqs_array = NULL;
353 signed char *sinrs_array = NULL;
354 char *sinrs = NULL;
355 int value;
356 unsigned int freq_cnt = 0;
357 unsigned int sinr_cnt = 0;
358 FmPerformanceParams perf_params;
359 struct NAME_MAP *found;
360
361 ALOGE("Inside hybrid srch list\n");
362 if(keyfile != NULL) {
363 keys_cpy = keys = get_keys(keyfile, GRPS_MAP[1].name);
364 if(keys != NULL) {
365 while(*keys != NULL) {
366 found = (NAME_MAP *)bsearch(*keys, HYBRD_SRCH_MAP,
367 MAX_HYBRID_SRCH_PARAMS, sizeof(NAME_MAP), compare_name);
368 if(found != NULL) {
369 key_value = get_value(keyfile, GRPS_MAP[1].name, found->name);
370 if((key_value != NULL) && strcmp(key_value, "")) {
371 switch(found->num) {
372 case FREQ_LIST:
373 freqs = key_value;
374 break;
375 case SINR_LIST:
376 sinrs = key_value;
377 break;
378 default:
379 free(key_value);
380 break;
381 }
382 }
383 }
384 keys++;
385 }
386 free_strs(keys_cpy);
387 }else {
388 ALOGE("No of keys found is zero\n");
389 }
390 }else {
391 ALOGE("key file is null\n");
392 }
393
394 freq_cnt = extract_comma_sep_freqs(freqs, &freqs_array, ",");
395 sinr_cnt = extract_comma_sep_sinrs(sinrs, &sinrs_array, ",");
396
397 if((freq_cnt == sinr_cnt) && (sinr_cnt > 0)) {
398 perf_params.SetHybridSrchList(fd, freqs_array, sinrs_array, freq_cnt);
399 }
400
401 free(freqs);
402 free(sinrs);
403 free(freqs_array);
404 free(sinrs_array);
405}
406
407unsigned int ConfigFmThs :: extract_comma_sep_freqs
408(
409 char *freqs,
410 unsigned int **freqs_arr,
411 const char *str
412)
413{
414 char *next_freq;
415 unsigned int freq;
416 unsigned int *freqs_new_arr;
417 unsigned int size = 0;
418 unsigned int len = 0;
419
420 next_freq = strtok(freqs, str);
421 while(next_freq != NULL) {
422 freq = atoi(next_freq);
423 ALOGD("HYBRID_SRCH freq: %u\n", freq);
424 if(size == len) {
425 size <<= 1;
426 if(size == 0)
427 size = 1;
428 freqs_new_arr = (unsigned int *)realloc(*freqs_arr,
429 size * sizeof(unsigned int));
430 if(freqs_new_arr == NULL) {
431 free(*freqs_arr);
432 *freqs_arr = NULL;
433 break;
434 }
435 *freqs_arr = freqs_new_arr;
436 }
437 (*freqs_arr)[len] = freq;
438 len++;
439 next_freq = strtok(NULL, str);
440 }
441 return len;
442}
443
444unsigned int ConfigFmThs :: extract_comma_sep_sinrs
445(
446 char *sinrs,
447 signed char **sinrs_arr,
448 const char *str
449)
450{
451 char *next_sinr;
452 signed char *sinrs_new_arr;
453 unsigned int size = 0;
454 unsigned int len = 0;
455 signed char sinr;
456
457 next_sinr = strtok(sinrs, str);
458 while(next_sinr != NULL) {
459 sinr = atoi(next_sinr);
460 ALOGD("HYBRID_SRCH sinr: %d\n", sinr);
461 if(size == len) {
462 size <<= 1;
463 if(size == 0)
464 size = 1;
465 sinrs_new_arr = (signed char *)realloc(*sinrs_arr,
466 size * sizeof(signed char));
467 if(sinrs_new_arr == NULL) {
468 free(*sinrs_arr);
469 *sinrs_arr = NULL;
470 break;
471 }
472 *sinrs_arr = sinrs_new_arr;
473 }
474 (*sinrs_arr)[len] = sinr;
475 len++;
476 next_sinr = strtok(NULL, str);
477 }
478 return len;
479}
480
481void ConfigFmThs :: SetRxSearchAfThs
482(
483 const char *file, UINT fd
484)
485{
486 int index;
487 struct NAME_MAP *found;
488 char **grps = NULL;
489 char **grps_cpy = NULL;
490
491 keyfile = get_key_file();
492
493 ALOGE("file name is: %s\n", file);
494 if(!parse_load_file(keyfile, file)) {
495 ALOGE("Error in loading threshold file\n");
496 }else {
497 grps_cpy = grps = get_grps(keyfile);
498 if(grps != NULL) {
499 while(*grps != NULL) {
500 ALOGE("Search grp: %s\n", *grps);
501 found = (NAME_MAP *)bsearch(*grps, GRPS_MAP, MAX_GRPS,
502 sizeof(NAME_MAP), compare_name);
503 if(found != NULL) {
504 ALOGE("Found group: %s\n", found->name);
505 switch(found->num) {
506 case AF_THS:
507 set_af_ths(fd);
508 break;
509 case SRCH_THS:
510 set_srch_ths(fd);
511 break;
512 case HYBRD_SRCH_LIST:
513 set_hybrd_list(fd);
514 break;
515 }
516 }
517 grps++;
518 }
519 }else {
520 ALOGE("No of groups found is zero\n");
521 }
522 free_strs(grps_cpy);
523 }
524 free_key_file(keyfile);
525 keyfile = NULL;
526}