fm-framework: Allow user to get/set AF jump, Search thresholds

Implement api to allow user to set/get AF jump RMSSI Threshold,
AF jump RMSSI Samples, Good channel RMSSI Threshold, Search Algo
type, SINR First Stage, RMSSI First Stage

Change-Id: Id67dc9f4f1e1580f5efedac7f77124bf69941efc
CRs-Fixed: 460621

2 files changed, 258 insertions, 2 deletions

diff --git a/qcom/fmradio/FmReceiver.java b/qcom/fmradio/FmReceiver.java
index 969656b..3d179af 100644
--- a/qcom/fmradio/FmReceiver.java
+++ b/qcom/fmradio/FmReceiver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009,2012, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2009,2012-2013, 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:
@@ -290,6 +290,13 @@ public class FmReceiver extends FmTransceiver
    private static final int RT_OR_ERT_IND = 1;
    private static final int ENCODE_TYPE_IND = 1;
    private static final int ERT_DIR_IND = 2;
+
+  /**
+    * Search Algo type
+    */
+   private static final int SEARCH_MPXDCC = 0;
+   private static final int SEARCH_SINR_INT = 1;
+
    /**
     * Constructor for the receiver Object
     */
@@ -1744,6 +1751,142 @@ public class FmReceiver extends FmTransceiver
      return threshold;
    }
 
+   public int getAFJumpRmssiTh() {
+      int state = getFMState();
+      /* Check current state of FM device */
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "getAFJumpThreshold: Device currently busy in executing another command.");
+          return ERROR;
+      }
+      return mControl.getAFJumpRmssiTh(sFd);
+   }
+
+   public boolean setAFJumpRmssiTh(int th) {
+      int state = getFMState();
+      /* Check current state of FM device */
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "setAFJumpThreshold: Device currently busy in executing another command.");
+          return false;
+      }
+      return mControl.setAFJumpRmssiTh(sFd, th);
+   }
+
+   public int getAFJumpRmssiSamples() {
+      int state = getFMState();
+      /* Check current state of FM device */
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "getAFJumpRmssiSamples: Device currently busy in executing another command.");
+          return ERROR;
+      }
+      return mControl.getAFJumpRmssiSamples(sFd);
+   }
+
+   public boolean setAFJumpRmssiSamples(int samples) {
+      int state = getFMState();
+      /* Check current state of FM device */
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "setAFJumpRmssiSamples: Device currently busy in executing another command.");
+          return false;
+      }
+      return mControl.setAFJumpRmssiSamples(sFd, samples);
+   }
+
+   public int getGdChRmssiTh() {
+      int state = getFMState();
+      /* Check current state of FM device */
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "getGdChRmssiTh: Device currently busy in executing another command.");
+          return ERROR;
+      }
+      return mControl.getGdChRmssiTh(sFd);
+   }
+
+   public boolean setGdChRmssiTh(int th) {
+      int state = getFMState();
+      /* Check current state of FM device */
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "setGdChRmssiTh: Device currently busy in executing another command.");
+          return false;
+      }
+      return mControl.setGdChRmssiTh(sFd, th);
+   }
+
+   public int getSearchAlgoType() {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "getSearchAlgoType: Device currently busy in executing another command.");
+          return Integer.MAX_VALUE;
+      }
+      return mControl.getSearchAlgoType(sFd);
+   }
+
+   public boolean setSearchAlgoType(int searchType) {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "setSearchAlgoType: Device currently busy in executing another command.");
+          return false;
+      }
+      if((searchType != SEARCH_MPXDCC) && (searchType != SEARCH_SINR_INT)) {
+          Log.d(TAG, "Search Algo is invalid");
+          return false;
+      }else {
+          return mControl.setSearchAlgoType(sFd, searchType);
+      }
+   }
+
+   public int getSinrFirstStage() {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "getSinrFirstStage: Device currently busy in executing another command.");
+          return Integer.MAX_VALUE;
+      }
+      return mControl.getSinrFirstStage(sFd);
+   }
+
+   public boolean setSinrFirstStage(int sinr) {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "setSinrFirstStage: Device currently busy in executing another command.");
+          return false;
+      }
+      return mControl.setSinrFirstStage(sFd, sinr);
+   }
+
+   public int getRmssiFirstStage() {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "getRmssiFirstStage: Device currently busy in executing another command.");
+          return Integer.MAX_VALUE;
+      }
+      return mControl.getRmssiFirstStage(sFd);
+   }
+
+   public boolean setRmssiFirstStage(int rmssi) {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "setRmssiFirstStage: Device currently busy in executing another command.");
+          return false;
+      }
+      return mControl.setRmssiFirstStage(sFd, rmssi);
+   }
+
+   public int getCFOMeanTh() {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "getCF0Th12: Device currently busy in executing another command.");
+          return Integer.MAX_VALUE;
+      }
+      return mControl.getCFOMeanTh(sFd);
+   }
+
+   public boolean setCFOMeanTh(int th) {
+      int state = getFMState();
+      if ((state == FMState_Turned_Off) || (state == FMState_Srch_InProg)) {
+          Log.d(TAG, "setRmssiFirstStage: Device currently busy in executing another command.");
+          return false;
+      }
+      return mControl.setCFOMeanTh(sFd, th);
+   }
 
    /*==============================================================
    FUNCTION:  setRdsGroupOptions
diff --git a/qcom/fmradio/FmRxControls.java b/qcom/fmradio/FmRxControls.java
index 5c2d42c..ff3366e 100644
--- a/qcom/fmradio/FmRxControls.java
+++ b/qcom/fmradio/FmRxControls.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009-2012, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2009-2013, 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:
@@ -87,6 +87,13 @@ class FmRxControls
    private static final int V4L2_CID_PRIVATE_SPUR_FREQ                     = V4L2_CID_PRIVATE_BASE + 0x31;
    private static final int V4L2_CID_PRIVATE_SPUR_FREQ_RMSSI               = V4L2_CID_PRIVATE_BASE + 0x32;
    private static final int V4L2_CID_PRIVATE_SPUR_SELECTION                = V4L2_CID_PRIVATE_BASE + 0x33;
+   private static final int V4L2_CID_PRIVATE_AF_RMSSI_TH                   = V4L2_CID_PRIVATE_BASE + 0x36;
+   private static final int V4L2_CID_PRIVATE_AF_RMSSI_SAMPLES              = V4L2_CID_PRIVATE_BASE + 0x37;
+   private static final int V4L2_CID_PRIVATE_GOOD_CH_RMSSI_TH              = V4L2_CID_PRIVATE_BASE + 0x38;
+   private static final int V4L2_CID_PRIVATE_SRCHALGOTYPE                  = V4L2_CID_PRIVATE_BASE + 0x39;
+   private static final int V4L2_CID_PRIVATE_CF0TH12                       = V4L2_CID_PRIVATE_BASE + 0x3A;
+   private static final int V4L2_CID_PRIVATE_SINRFIRSTSTAGE                = V4L2_CID_PRIVATE_BASE + 0x3B;
+   private static final int V4L2_CID_PRIVATE_RMSSIFIRSTSTAGE               = V4L2_CID_PRIVATE_BASE + 0x3C;
 
    private static final int V4L2_CTRL_CLASS_USER = 0x980000;
    private static final int V4L2_CID_BASE        = V4L2_CTRL_CLASS_USER | 0x900;
@@ -547,4 +554,110 @@ class FmRxControls
    public int configureSpurTable(int fd) {
       return FmReceiverJNI.configureSpurTable(fd);
    }
+
+   public int getAFJumpRmssiTh(int fd) {
+      return FmReceiverJNI.getControlNative(fd, V4L2_CID_PRIVATE_AF_RMSSI_TH);
+   }
+
+   public boolean setAFJumpRmssiTh(int fd, int th) {
+      int re;
+      re = FmReceiverJNI.setControlNative(fd, V4L2_CID_PRIVATE_AF_RMSSI_TH, th);
+      if (re < 0) {
+           Log.e(TAG, "Error in setting AF jmp Rmssi Threshold");
+           return false;
+      } else {
+           return true;
+      }
+   }
+
+   public int getAFJumpRmssiSamples(int fd) {
+      return FmReceiverJNI.getControlNative(fd, V4L2_CID_PRIVATE_AF_RMSSI_SAMPLES);
+   }
+
+   public boolean setAFJumpRmssiSamples(int fd, int samples) {
+      int re;
+      re = FmReceiverJNI.setControlNative(fd, V4L2_CID_PRIVATE_AF_RMSSI_SAMPLES, samples);
+      if (re < 0) {
+           Log.e(TAG, "Error in setting AF jmp Rmssi Samples");
+           return false;
+      } else {
+           return true;
+      }
+   }
+
+   public int getGdChRmssiTh(int fd) {
+      return FmReceiverJNI.getControlNative(fd, V4L2_CID_PRIVATE_GOOD_CH_RMSSI_TH);
+   }
+
+   public boolean setGdChRmssiTh(int fd, int th) {
+      int re;
+      re = FmReceiverJNI.setControlNative(fd, V4L2_CID_PRIVATE_GOOD_CH_RMSSI_TH, th);
+      if (re < 0) {
+           Log.e(TAG, "Error in setting Good channel Rmssi Threshold");
+           return false;
+      } else {
+           return true;
+      }
+   }
+
+   public int getSearchAlgoType(int fd) {
+      return FmReceiverJNI.getControlNative(fd, V4L2_CID_PRIVATE_SRCHALGOTYPE);
+   }
+
+   public boolean setSearchAlgoType(int fd, int saerchType) {
+      int ret;
+      ret = FmReceiverJNI.setControlNative(fd, V4L2_CID_PRIVATE_SRCHALGOTYPE, saerchType);
+      if(ret < 0) {
+         Log.e(TAG, "Error in setting Search Algo type");
+         return false;
+      }else {
+         return true;
+      }
+   }
+
+   public int getSinrFirstStage(int fd) {
+      return FmReceiverJNI.getControlNative(fd, V4L2_CID_PRIVATE_SINRFIRSTSTAGE);
+   }
+
+   public boolean setSinrFirstStage(int fd, int sinr) {
+      int ret;
+      ret = FmReceiverJNI.setControlNative(fd, V4L2_CID_PRIVATE_SINRFIRSTSTAGE, sinr);
+      if(ret < 0) {
+         Log.e(TAG, "Error in setting Sinr First Stage Threshold");
+         return false;
+      }else {
+         return true;
+      }
+   }
+
+   public int getRmssiFirstStage(int fd) {
+      return FmReceiverJNI.getControlNative(fd, V4L2_CID_PRIVATE_RMSSIFIRSTSTAGE);
+   }
+
+   public boolean setRmssiFirstStage(int fd, int rmssi) {
+      int ret;
+      ret = FmReceiverJNI.setControlNative(fd, V4L2_CID_PRIVATE_RMSSIFIRSTSTAGE, rmssi);
+      if(ret < 0) {
+         Log.e(TAG, "Error in setting Rmssi First stage Threshold");
+         return false;
+      }else {
+         return true;
+      }
+   }
+
+   public int getCFOMeanTh(int fd) {
+      return FmReceiverJNI.getControlNative(fd, V4L2_CID_PRIVATE_CF0TH12);
+   }
+
+   public boolean setCFOMeanTh(int fd, int th) {
+      int ret;
+      ret = FmReceiverJNI.setControlNative(fd, V4L2_CID_PRIVATE_CF0TH12, th);
+      if(ret < 0) {
+         Log.e(TAG, "Error in setting Mean CFO Threshold");
+         return false;
+      }else {
+         return true;
+      }
+   }
+
 }