mcu/custom/service/sbp/sbp_utility.c

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2005
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/

/*****************************************************************************
 *
 * Filename:
 * ---------
 * sbp_utility.c
 *
 * Project:
 * --------
 *   MOLY
 *
 * Description:
 * ------------
 *   This file is intends for SBP definition
 *
 * Author:
 * -------
 * -------
 *
 *============================================================================
 ****************************************************************************/

#define SBP_UTILITY_C

#include "kal_general_types.h"
#include "sbp_public_utility.h"
#include "kal_public_api.h"
#include "ps_em_enum.h"
#include "nvram_interface.h"
#include "nvram_data_items.h"
#include "sbp_nvram_def.h"
#include "nvram_enums.h"
#include "nvram_editor_data_item.h"
#include "sim_ps_api.h"
#include "md_sap.h"
#include "custom_imc_config.h"
#include "custom_ltecsr_config.h"
#include "mcf_if.h"

#include "sbp_trc.h"
#include "kal_trace.h"

#if defined (__TC01_NVRAM__) || defined(__TC01__) //MOLY00294741
/*MUSE - ALPS0144925 */ /*MOLY00294741*/
/*Customer's specific Single Binary Platform (SBP) features */
nvram_ef_sbp_modem_config_struct cust_sbp_config;
#endif

#define SBP_TEST_MODE_VAL_1 8286
#define SBP_TEST_MODE_VAL_2 8287

extern sim_interface_enum l4c_gemini_get_actual_sim_id(sim_interface_enum simId);
extern ps_conf_test_mode_enum query_ps_conf_test_mode(void);

extern kal_uint8 ValCurrentActiveSimIndex();
void sbp_get_sbp_ids_from_cntxt(nvram_ef_sbp_ids_struct *sbp_ids_ptr);

typedef struct
{
    kal_uint32 sbp_id;
    kal_uint32 sbp_sub_id;
    kal_uint32 test_mode;
    kal_uint32 dsbp_mode;
    nvram_ef_sbp_dsbp_config_struct dsbp_config;
} sbp_common_context_struct;

typedef struct
{
    kal_uint32 current_sim_sbp_id;
    kal_uint32 dsbp_sim_sbp_id_mode1;   // IMS/VoLTE
    kal_uint32 dsbp_sim_sbp_id_mode2;   // All modem
    kal_uint8 modem_sbp_config[(SBP_MAX_MD_FEATURE/8)+1]; //the size depends on SBP_MAX_MD_FEATURE
#if defined (__TC01_NVRAM__) || defined(__TC01__) // __TC01_CUST_SBP__
    kal_uint8 modem_cust_sbp_config[(SBP_CUSTOM_MAX_MD_FEATURE/8)+1]; //the size depends on SBP_MAX_CUST_MD_FEATURE
#endif
    kal_uint8 modem_sbp_data_config[SBP_DATA_MAX_MD_FEATURE];
    kal_uint8 mcc[MAX_MCC_STR_LEN];
    kal_uint8 mnc[MAX_MNC_STR_LEN];
    kal_uint8 iccid[21];
} sbp_context_struct;

#ifdef __IPC_ADAPTER__
#include "ipca_nvram_def.h"
sbp_salecode_struct  sbp_salecode;
#endif

kal_uint32 default_sbp_id = SBP_ID_INVALID;
kal_uint32 default_sbp_sub_id = 0;

nvram_ef_sbp_modem_config_struct sbp_config;
nvram_ef_sbp_modem_data_config_struct sbp_data_config;
nvram_ef_sbp_custom_sbp_id_mapping_struct g_custom_sbp_id_mapping_table;
nvram_ef_sbp_mdcxp_sbp_id_list_struct g_mdcxp_sbp_id_list;

static sbp_common_context_struct sbp_common_cntxt_g;
static sbp_context_struct sbp_cntxt_g[MAX_SIM_NUM];

/*****************************************************************************
 * FUNCTION
 *  sbp_get_dsbp_mode
 *
 * DESCRIPTION
 * query dynamic SBP mode
 *
 * PARAMETERS
 *  [IN]    N/A
 * RETURNS
 *   current DSBP mode : l4bsbp_dsbp_mode_enum
 *****************************************************************************/
kal_uint8 sbp_get_dsbp_mode (void)
{
    return (kal_uint8) sbp_common_cntxt_g.dsbp_mode;
}

/*****************************************************************************
 * FUNCTION
 *  sbp_set_dsbp_mode
 *
 * DESCRIPTION
 * Set dynamic SBP mode.
 *
 * PARAMETERS
 *  dsbp_mdoe [IN]    l4bsbp_dsbp_mode_enum
 * RETURNS
 *   KAL_TRUE    : success
 *   KAL_FALSE   : fail
 *****************************************************************************/
kal_bool sbp_set_dsbp_mode (kal_uint8 dspb_mode)
{
	kal_bool result = KAL_TRUE;
#ifdef __IPC_ADAPTER__
    nvram_ef_sbp_dsbp_info_struct dsbp_info_buf;

    result = nvram_external_read_data(NVRAM_EF_SBP_DSBP_INFO_LID,
                                      1,
                                      (kal_uint8*) &dsbp_info_buf,
                                      NVRAM_EF_SBP_DSBP_INFO_SIZE);

    if (result == KAL_TRUE)
    {
        sbp_common_cntxt_g.dsbp_mode = (kal_uint32) dspb_mode;
        dsbp_info_buf.default_dsbp_mode = dspb_mode;
        result = nvram_external_write_data(NVRAM_EF_SBP_DSBP_INFO_LID,
                               		     1,
                                         (kal_uint8*) &dsbp_info_buf,
                                         NVRAM_EF_SBP_DSBP_INFO_SIZE);
    }
#else
    nvram_ef_sbp_ids_struct sbp_id_buf;

    sbp_common_cntxt_g.dsbp_mode = (kal_uint32) dspb_mode;
    // fill LID info from current context
    sbp_get_sbp_ids_from_cntxt(&sbp_id_buf);

    result = nvram_external_write_data(NVRAM_EF_SBP_IDS_LID,
                               		 1,
                                     (kal_uint8*) &sbp_id_buf,
                                     NVRAM_EF_SBP_IDS_SIZE);
#endif

	return result;
}

/*****************************************************************************
 * FUNCTION
 *  sbp_get_test_mode
 *
 * DESCRIPTION
 * query if it is under test mode or not
 *
 * PARAMETERS
 *  [IN]    N/A
 * RETURNS
 *   current SBP test mode : sbp_test_mode_enum
 *****************************************************************************/
sbp_test_mode_enum sbp_get_test_mode (void)
{
    if (sbp_common_cntxt_g.test_mode == SBP_TEST_MODE_VAL_1)
        return SBP_TEST_MODE_1;
    else if (sbp_common_cntxt_g.test_mode == SBP_TEST_MODE_VAL_2)
        return SBP_TEST_MODE_2;
    else
        return SBP_TEST_MODE_NONE;
}

/*****************************************************************************
 * FUNCTION
 *  sbp_set_test_mode
 *
 * DESCRIPTION
 * Set SBP to test mode.
 * In test mode, we read current values of nvram files instead of using default values before applying SBP settings.
 *
 * PARAMETERS
 *  test_mdoe [IN]    sbp_test_mode_enum
 * RETURNS
 *   KAL_TRUE    : success
 *   KAL_FALSE   : fail
 *****************************************************************************/
kal_bool sbp_set_test_mode (sbp_test_mode_enum test_mode)
{
    nvram_ef_sbp_ids_struct sbp_id_buf;
	kal_bool result = KAL_TRUE;

    if (test_mode == SBP_TEST_MODE_NONE)
        sbp_common_cntxt_g.test_mode = 0;
    else if (test_mode == SBP_TEST_MODE_1)
        sbp_common_cntxt_g.test_mode = SBP_TEST_MODE_VAL_1;
    else if (test_mode == SBP_TEST_MODE_2)
        sbp_common_cntxt_g.test_mode = SBP_TEST_MODE_VAL_2;

    // fill LID info from current context
    sbp_get_sbp_ids_from_cntxt(&sbp_id_buf);

    result = nvram_external_write_data(NVRAM_EF_SBP_IDS_LID,
                               		   1,
                                       (kal_uint8*) &sbp_id_buf,
                                       NVRAM_EF_SBP_IDS_SIZE);

	return result;

}

/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature()
*
* DESCRIPTION
*   This function is used to query modem configuration
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   KAL_TRUE    : if this feature is turned on
*   KAL_FALSE   : if this feature is turned off
*****************************************************************************/
kal_bool sbp_query_md_feature(sbp_md_feature_enum feature)
{
    return sbp_query_md_feature_by_ps(feature, PROTOCOL_1);
}

#ifdef __CDMA2000_RAT__
/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_for_c2k()
*
* DESCRIPTION
*   This function is used to query modem configuration and used by C2K team only
*   The function will judge current active PS using C2K's API and return the corresponding setting.
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   KAL_TRUE    : if this feature is turned on
*   KAL_FALSE   : if this feature is turned off
*****************************************************************************/
kal_bool sbp_query_md_feature_for_c2k(sbp_md_feature_enum feature)
{
    protocol_id_enum ps_id = ValCurrentActiveSimIndex();

    if (ps_id >= MAX_SIM_NUM)
    {
    #ifndef __L1_STANDALONE__
        MD_TRC_ERROR_SBP_INVALID_PS_ID(ps_id);
    #endif
        return KAL_FALSE;
    }

    return sbp_query_md_feature_by_ps(feature, ps_id);
}
#endif

/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_by_ps()
*
* DESCRIPTION
*   This function is used to query modem configuration according to the PS ID
*
* PARAMETERS
*   feature [IN]    modem feature
*   ps_id [IN]      PS ID
*
* RETURNS
*   KAL_TRUE    : if this feature is turned on
*   KAL_FALSE   : if this feature is turned off
*****************************************************************************/
kal_bool sbp_query_md_feature_by_ps(sbp_md_feature_enum feature, protocol_id_enum ps_id)
{
    kal_uint8 *bitmask_ptr;
    kal_uint32 byte_offset;
    kal_uint8 bit_offset;
    kal_bool result;
#ifndef __L1_STANDALONE__
    static sbp_md_feature_enum latest_queried_sbp[MAX_SIM_NUM];
#endif


    if (feature >= SBP_MAX_MD_FEATURE)
    {
        DEBUG_ASSERT(0);
        return KAL_FALSE;
    }
    if (ps_id >=MAX_SIM_NUM)
    {
#ifndef __L1_STANDALONE__
        MD_TRC_ERROR_SBP_INVALID_PS_ID(ps_id);
#endif
        return KAL_FALSE;
    }
    
    byte_offset = feature / 8;
    bit_offset = feature % 8;
    bitmask_ptr = &(sbp_cntxt_g[ps_id].modem_sbp_config[byte_offset]);

    result = (((*bitmask_ptr) & (0x01 << bit_offset)) != 0)? KAL_TRUE : KAL_FALSE;

    //For GCF or other test modes, you may overwrite the result.
    result = sbp_md_feature_overwrite(feature, result);

#ifndef __L1_STANDALONE__
    if (latest_queried_sbp[ps_id] != feature)
    {
        MD_TRC_INFO_SBP_FEATURE(ps_id, feature, result);
        latest_queried_sbp[ps_id] = feature;
    }
#endif

    return result;
}


/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_no_overwrite()
*
* DESCRIPTION
*   This function is used to query modem configuration without overwrite
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   KAL_TRUE    : if this feature is turned on
*   KAL_FALSE   : if this feature is turned off
*****************************************************************************/
kal_bool sbp_query_md_feature_no_overwrite(sbp_md_feature_enum feature)
{
    return sbp_query_md_feature_no_overwrite_by_ps(feature, PROTOCOL_1);
}

/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_no_overwrite_by_ps()
*
* DESCRIPTION
*   This function is used to query modem configuration without overwrite according to the PS ID
*
* PARAMETERS
*   feature [IN]    modem feature
*   ps_id [IN]      PS ID
*
* RETURNS
*   KAL_TRUE    : if this feature is turned on
*   KAL_FALSE   : if this feature is turned off
*****************************************************************************/
kal_bool sbp_query_md_feature_no_overwrite_by_ps(sbp_md_feature_enum feature, protocol_id_enum ps_id)
{
    kal_uint8 *bitmask_ptr;
    kal_uint32 byte_offset;
    kal_uint8 bit_offset;
    kal_bool result;

#ifndef __L1_STANDALONE__
    static sbp_md_feature_enum latest_queried_sbp[MAX_SIM_NUM];
#endif

    if (feature >= SBP_MAX_MD_FEATURE)
    {
        DEBUG_ASSERT(0);
        return KAL_FALSE;
    }
    if (ps_id >=MAX_SIM_NUM)
    {
#ifndef __L1_STANDALONE__
        MD_TRC_ERROR_SBP_INVALID_PS_ID(ps_id);
#endif
        return KAL_FALSE;
    }

    byte_offset = feature / 8;
    bit_offset = feature % 8;
    bitmask_ptr = &(sbp_cntxt_g[ps_id].modem_sbp_config[byte_offset]);

    result = (((*bitmask_ptr) & (0x01 << bit_offset)) != 0)? KAL_TRUE : KAL_FALSE;
    
#ifndef __L1_STANDALONE__
    if (latest_queried_sbp[ps_id] != feature)
    {
        MD_TRC_INFO_SBP_FEATURE(ps_id, feature, result);
        latest_queried_sbp[ps_id] = feature;
    }
#endif


    return result;
}


/*****************************************************************************
* FUNCTION
*   sbp_set_md_feature()
*
* DESCRIPTION
*   This function is used to set modem configuration
*
* PARAMETERS
*   feature         [IN]    modem feature
*   is_turned_on    [IN]
*   sbp_feature_ptr [IN/OUT]
*
* RETURNS
*   KAL_TRUE if success; otherwise KAL_FALSE
*****************************************************************************/
kal_bool sbp_set_md_feature(sbp_md_feature_enum feature,
                            kal_bool is_turned_on, 
                            nvram_ef_sbp_modem_config_struct *sbp_feature_ptr)
{
    kal_uint8 *bitmask_ptr;
    kal_uint32 byte_offset;
    kal_uint8 bit_offset;
    

    if (feature >= SBP_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        byte_offset = feature / 8;
        bit_offset = feature % 8;
        bitmask_ptr = &(sbp_feature_ptr->modem_sbp_config[byte_offset]);
        if (is_turned_on == KAL_TRUE)
        {
            *bitmask_ptr = ((*bitmask_ptr) | (0x01 << bit_offset));
        }
        else
        {
            *bitmask_ptr = ((*bitmask_ptr) & ~(0x01 << bit_offset));
        }
    }
    
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_set_md_feature_by_ps()
*
* DESCRIPTION
*   This function is used to set modem configuration by PS
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   feature         [IN]    modem feature
*   is_turned_on    [IN]
*   sbp_feature_ptr [IN/OUT]
*
* RETURNS
*   KAL_TRUE if success; otherwise KAL_FALSE
*****************************************************************************/
kal_bool sbp_set_md_feature_by_ps(sbp_md_feature_enum feature,
                            kal_bool is_turned_on, 
                            protocol_id_enum ps_id)
{
    kal_uint8 *bitmask_ptr;
    kal_uint32 byte_offset;
    kal_uint8 bit_offset;

    if (feature >= SBP_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        byte_offset = feature / 8;
        bit_offset = feature % 8;
        bitmask_ptr = &(sbp_cntxt_g[ps_id].modem_sbp_config[byte_offset]);
        if (is_turned_on == KAL_TRUE)
        {
            *bitmask_ptr = ((*bitmask_ptr) | (0x01 << bit_offset));
        }
        else
        {
            *bitmask_ptr = ((*bitmask_ptr) & ~(0x01 << bit_offset));
        }

#ifndef __L1_STANDALONE__
        MD_TRC_INFO_SBP_SET_FEATURE(ps_id, feature, is_turned_on);
#endif
    }
    
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_general_set_md_feature()
*
* DESCRIPTION
*   This function is used to set modem configuration.
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   feature         [IN]    modem feature
*   is_turned_on    [IN]
*
* RETURNS
*   KAL_TRUE if success; otherwise KAL_FALSE
*****************************************************************************/
kal_bool sbp_general_set_md_feature(sbp_md_feature_enum feature, kal_bool is_turned_on)
{
    kal_uint8 i;

    if (feature >= SBP_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        for (i=0; i<MAX_SIM_NUM; i++)
            sbp_set_md_feature_by_ps( feature, is_turned_on, i);
    }

    return KAL_TRUE;
}



/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_data()
*
* DESCRIPTION
*   This function is used to query modem configuration data
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_uint8 sbp_query_md_feature_data(sbp_md_feature_data_enum feature)
{

    return sbp_query_md_feature_data_by_ps(feature, PROTOCOL_1);
}

#ifdef __CDMA2000_RAT__
/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_data_for_c2k()
*
* DESCRIPTION
*   This function is used to query modem configuration and used by C2K team only
*   The function will judge current active PS using C2K's API and return the corresponding setting.
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_uint8 sbp_query_md_feature_data_for_c2k(sbp_md_feature_data_enum feature)
{
    protocol_id_enum ps_id = ValCurrentActiveSimIndex();

    if (ps_id >= MAX_SIM_NUM)
    {
        #ifndef __L1_STANDALONE__
        MD_TRC_ERROR_SBP_INVALID_PS_ID(ps_id);
        #endif
        
        return 0;
    }

    return sbp_query_md_feature_data_by_ps(feature, ps_id);
}
#endif


/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_data_by_ps()
*
* DESCRIPTION
*   This function is used to query modem configuration data
*
* PARAMETERS
*   feature [IN]    modem feature
*   ps_id [IN]      PS ID
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_uint8 sbp_query_md_feature_data_by_ps(sbp_md_feature_data_enum feature, protocol_id_enum ps_id)
{
    kal_uint8 result;
#ifndef __L1_STANDALONE__
    static sbp_md_feature_data_enum latest_queried_sbp[MAX_SIM_NUM];
#endif

    if (feature >= SBP_DATA_MAX_MD_FEATURE)
    {
        DEBUG_ASSERT(0);
        return 0;
    }
    if (ps_id >=MAX_SIM_NUM)
    {
#ifndef __L1_STANDALONE__
        MD_TRC_ERROR_SBP_INVALID_PS_ID(ps_id);
#endif
        return 0;
    }
    
    result = sbp_cntxt_g[ps_id].modem_sbp_data_config[feature];

    //For GCF or other test modes, you may overwrite the result.
    result = sbp_md_feature_data_overwrite(feature, result);

#ifndef __L1_STANDALONE__
    if (latest_queried_sbp[ps_id] != feature)
    {
        MD_TRC_INFO_SBP_DATA(ps_id, feature, result);
        latest_queried_sbp[ps_id] = feature;
    }
#endif

    return result;
}

/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_data_no_overwrite()
*
* DESCRIPTION
*   This function is used to query modem configuration data without overwrite
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_uint8 sbp_query_md_feature_data_no_overwrite(sbp_md_feature_data_enum feature)
{
    return sbp_query_md_feature_data_no_overwrite_by_ps(feature, PROTOCOL_1);
}

/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_data_no_overwrite_by_ps()
*
* DESCRIPTION
*   This function is used to query modem configuration data without overwrite
*
* PARAMETERS
*   feature [IN]    modem feature
*   ps_id [IN]      PS ID
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_uint8 sbp_query_md_feature_data_no_overwrite_by_ps(sbp_md_feature_data_enum feature, protocol_id_enum ps_id)
{
    kal_uint8 result;
#ifndef __L1_STANDALONE__
    static sbp_md_feature_data_enum latest_queried_sbp[MAX_SIM_NUM];
#endif

    if (feature >= SBP_DATA_MAX_MD_FEATURE)
    {
        DEBUG_ASSERT(0);
        return 0;
    }
    if (ps_id >=MAX_SIM_NUM)
    {
#ifndef __L1_STANDALONE__
        MD_TRC_ERROR_SBP_INVALID_PS_ID(ps_id);
#endif
        return 0;
    }
    
    result = sbp_cntxt_g[ps_id].modem_sbp_data_config[feature];


#ifndef __L1_STANDALONE__
    if (latest_queried_sbp[ps_id] != feature)
    {
        MD_TRC_INFO_SBP_DATA(ps_id, feature, result);
        latest_queried_sbp[ps_id] = feature;
    }
#endif

    return result;
}


/*****************************************************************************
* FUNCTION
*   sbp_set_md_feature_data()
*
* DESCRIPTION
*   This function is used to set modem configuration data
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_bool sbp_set_md_feature_data(sbp_md_feature_data_enum feature, 
                                 kal_uint8 data, 
                                 nvram_ef_sbp_modem_data_config_struct *sbp_data_ptr)
{
    if (feature >= SBP_DATA_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        sbp_data_ptr->modem_sbp_data_config[feature] = data;
    }
    
    return KAL_TRUE;
}


/*****************************************************************************
* FUNCTION
*   sbp_set_md_feature_data_by_ps()
*
* DESCRIPTION
*   This function is used to set modem configuration data by PS
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_bool sbp_set_md_feature_data_by_ps(sbp_md_feature_data_enum feature, 
        kal_uint8 data, 
        protocol_id_enum ps_id)
{
    if (feature >= SBP_DATA_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        sbp_cntxt_g[ps_id].modem_sbp_data_config[feature]= data;

#ifndef __L1_STANDALONE__
        MD_TRC_INFO_SBP_SET_DATA(ps_id, feature, data);
#endif
    }
    
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_general_set_md_feature_data()
*
* DESCRIPTION
*   This function is used to set modem configuration data
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   feature [IN]    modem feature
*
* RETURNS
*   the unsigned byte value for the feature
*****************************************************************************/
kal_bool sbp_general_set_md_feature_data(sbp_md_feature_data_enum feature, kal_uint8 data)
{
    kal_uint8 i;

    if (feature >= SBP_DATA_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        for (i=0; i< MAX_SIM_NUM; i++)
            sbp_set_md_feature_data_by_ps(feature, data, i);
    }
    
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_query_id()
*
* DESCRIPTION
*   This function is used to query SBP ID received by modem
*
* PARAMETERS
*   [IN]    N/A
*
* RETURNS
*   the unsigned 4-byte value for the SBP ID
*****************************************************************************/
kal_uint32 sbp_query_id(void)
{
    return sbp_common_cntxt_g.sbp_id;
}

/*****************************************************************************
* FUNCTION
*   sbp_query_sub_id()
*
* DESCRIPTION
*   This function is used to query SBP Sub ID received by modem
*
* PARAMETERS
*   [IN]    N/A
* RETURNS
*   the unsigned 4-byte value for the SBP Sub ID
*****************************************************************************/
kal_uint32 sbp_query_sub_id(void)
{
    return sbp_common_cntxt_g.sbp_sub_id;
}

/*****************************************************************************
* FUNCTION
*    sbp_get_sbp_ids_from_cntxt
*
* DESCRIPTION
*   This function is used to get NVRAM_EF_SBP_IDS_LID information from current context
*
* PARAMETERS
*   param      [IN]    sbp_ids_ptr
* RETURNS
*   void
*
*****************************************************************************/
void sbp_get_sbp_ids_from_cntxt(nvram_ef_sbp_ids_struct *sbp_ids_ptr)
{
    kal_uint8 i;

    sbp_ids_ptr->sbp_id = sbp_common_cntxt_g.sbp_id;
    sbp_ids_ptr->test_mode = sbp_common_cntxt_g.test_mode;
    sbp_ids_ptr->dsbp_mode = sbp_common_cntxt_g.dsbp_mode;
    for (i=0; i<MAX_SIM_NUM; i++)
    {
        sbp_ids_ptr->sim_sbp_id_info[i].sim_sbp_id = sbp_cntxt_g[i].dsbp_sim_sbp_id_mode2;
        kal_mem_cpy(sbp_ids_ptr->sim_sbp_id_info[i].mcc, sbp_cntxt_g[i].mcc , MAX_MCC_STR_LEN);
        kal_mem_cpy(sbp_ids_ptr->sim_sbp_id_info[i].mnc, sbp_cntxt_g[i].mnc, MAX_MNC_STR_LEN);
        kal_mem_cpy(sbp_ids_ptr->sim_sbp_id_info[i].iccid, sbp_cntxt_g[i].iccid, 21);
    }
}

/*****************************************************************************
* FUNCTION
*   sbp_init_contexts()
*
* DESCRIPTION
*   This function is used to init SBP Contexts
*
* PARAMETERS
*   [IN]    N/A
*
* RETURNS
*   KAL_TRUE or KAL_FALSE
*****************************************************************************/
kal_bool sbp_init_contexts()
{
    kal_uint8 i;
    nvram_ef_sbp_ids_struct sbp_id_buf;
    nvram_ef_sbp_dsbp_config_struct dsbp_config_buf;

#ifdef __IPC_ADAPTER__
    nvram_ipc_factory_common_struct ipc_nvram_buf;
    nvram_ef_sbp_dsbp_info_struct dsbp_info_buf;
    kal_bool result;
#endif

    nvram_external_read_data(NVRAM_EF_SBP_DSBP_CONFIG_LID,
            1,
            (kal_uint8*)&dsbp_config_buf,
            NVRAM_EF_SBP_DSBP_CONFIG_SIZE);

    nvram_external_read_data(NVRAM_EF_SBP_IDS_LID, 
            1, 
            (kal_uint8*)&sbp_id_buf, 
            NVRAM_EF_SBP_IDS_SIZE);

    nvram_external_read_data(NVRAM_EF_SBP_CUSTOM_SBP_ID_MAPPING_LID, 
            1, 
            (kal_uint8*)&g_custom_sbp_id_mapping_table, 
            NVRAM_EF_SBP_CUSTOM_SBP_ID_MAPPING_SIZE);

    nvram_external_read_data(NVRAM_EF_SBP_MDCXP_SBP_ID_LIST_LID, 
            1, 
            (kal_uint8*)&g_mdcxp_sbp_id_list, 
            NVRAM_EF_SBP_MDCXP_SBP_ID_LIST_SIZE);

    // prepare SBP Context
    sbp_common_cntxt_g.sbp_id = sbp_id_buf.sbp_id;
    sbp_common_cntxt_g.sbp_sub_id= 0;
    sbp_common_cntxt_g.test_mode = sbp_id_buf.test_mode;
    sbp_common_cntxt_g.dsbp_mode = sbp_id_buf.dsbp_mode;
    kal_mem_cpy(&sbp_common_cntxt_g.dsbp_config, &dsbp_config_buf, NVRAM_EF_SBP_DSBP_CONFIG_SIZE);

    for (i=0; i<MAX_SIM_NUM; i++)
    {
        sbp_cntxt_g[i].current_sim_sbp_id = SBP_ID_INVALID;
        sbp_cntxt_g[i].dsbp_sim_sbp_id_mode1 = SBP_ID_INVALID;
        sbp_cntxt_g[i].dsbp_sim_sbp_id_mode2 = sbp_id_buf.sim_sbp_id_info[i].sim_sbp_id;
        kal_mem_cpy(sbp_cntxt_g[i].mcc, sbp_id_buf.sim_sbp_id_info[i].mcc, MAX_MCC_STR_LEN);
        kal_mem_cpy(sbp_cntxt_g[i].mnc, sbp_id_buf.sim_sbp_id_info[i].mnc, MAX_MNC_STR_LEN);
        kal_mem_cpy(sbp_cntxt_g[i].iccid, sbp_id_buf.sim_sbp_id_info[i].iccid, 21);
    }

    if (default_sbp_id == SBP_ID_INVALID)
        default_sbp_id = sbp_id_buf.sbp_id;

#ifdef __IPC_ADAPTER__
    nvram_external_read_data(NVRAM_EF_IPC_FACTORY_COMMON_LID,
            1,
            (kal_uint8*) &ipc_nvram_buf,
            NVRAM_EF_IPC_FACTORY_COMMON_SIZE);

    memcpy( (void *) sbp_salecode.csc_salecode, (void *) &ipc_nvram_buf.sellout_product_code[11], 3);
    memcpy( (void *) sbp_salecode.network_code, (void *) ipc_nvram_buf.network_code, 3);     // For SIM Slot 0
    memcpy( (void *) sbp_salecode.network_code_2, (void *) ipc_nvram_buf.network_code_2, 3); // For SIM Slot 1

    result = nvram_external_read_data(NVRAM_EF_SBP_DSBP_INFO_LID,
            1,
            (kal_uint8*) &dsbp_info_buf,
            NVRAM_EF_SBP_DSBP_INFO_SIZE);

    if (result == KAL_TRUE && 
        dsbp_info_buf.default_dsbp_mode <= 2)
    {
        sbp_common_cntxt_g.dsbp_mode = dsbp_info_buf.default_dsbp_mode;
    }
#endif

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_module_clean
*
* DESCRIPTION
*   This function cleans up user sensative informatino for SBP
*
* PARAMETERS
*   [IN]    N/A
* RETURNS
*   void
*
*****************************************************************************/
void sbp_module_clean(void)
{
    kal_uint8 i;

    for (i=0; i<MAX_SIM_NUM; i++)
    {
        kal_mem_set(sbp_cntxt_g[i].iccid, 0, 21);
    }
}

/*****************************************************************************
* FUNCTION
*   sbp_set_sbp_id()
*
* DESCRIPTION
*   This function is used to set SBP ID into SBP contexts and its NVRAM
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   [IN]    N/A
*
* RETURNS
*   KAL_TRUE or KAL_FALSE
*****************************************************************************/
kal_bool sbp_set_sbp_id(kal_uint32 sbp_id)
{
    nvram_ef_sbp_ids_struct sbp_id_buf;

    sbp_common_cntxt_g.sbp_id = sbp_id;
    // Currently, SBP sub ID in the conext will be always the same with default SBP Sub ID form CCCI.
    sbp_common_cntxt_g.sbp_sub_id = default_sbp_sub_id;     

    // fill LID info from current context
    sbp_get_sbp_ids_from_cntxt(&sbp_id_buf);

    nvram_external_write_data(NVRAM_EF_SBP_IDS_LID,
            1,
            (kal_uint8*)&sbp_id_buf,
            NVRAM_EF_SBP_IDS_SIZE);


    return KAL_TRUE;
}

/*****************************************************************************
 * FUNCTION
 *  sbp_convert_mcc_mnc_string_from_imsi
 * DESCRIPTION
 *  get mcc, mnc from imsi with string format
 * PARAMETERS
 *  imsi
 * RETURNS
 *  KAL_TRUE
 *****************************************************************************/
kal_bool sbp_convert_mcc_mnc_string_from_imsi(kal_uint8* mcc_ptr, kal_uint32 mcc_size, kal_uint8 *mnc_ptr, kal_uint32 mnc_size, kal_uint8* imsi_ptr, kal_uint8 mnc_len)
{
    if (!mcc_ptr || !mnc_ptr || !imsi_ptr)
    {
        return KAL_FALSE;
    }

    if ((mcc_size < MAX_MCC_STR_LEN) || (mnc_size < MAX_MNC_STR_LEN ))
    {
        return KAL_FALSE;
    }

    if ((mnc_len != 2) && (mnc_len != 3))
    {
        return KAL_FALSE;
    }
    
    /* get mcc/mnc and convert to ASCII */
    mcc_ptr[0] = (imsi_ptr[0] >> 4) + 48;   //mcc1
    mcc_ptr[1] = (imsi_ptr[1] & 0x0F) + 48; //mcc2
    mcc_ptr[2] = (imsi_ptr[1] >> 4) + 48;   //mcc3
    mcc_ptr[3] = 0;
    
    mnc_ptr[0] = (imsi_ptr[2] & 0x0F) + 48; //mnc1
    mnc_ptr[1] = (imsi_ptr[2] >> 4) + 48;   //mnc2
    if (mnc_len == 3)
    {
        mnc_ptr[2] = (imsi_ptr[3] & 0x0F) + 48; //mnc3
    }

    mnc_ptr[mnc_len] = 0;
    mnc_ptr[3] = 0;

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_get_sim_sbp_id_for_all()
*
* DESCRIPTION
*   get SIM SBP ID which trigger DSBP for all modem (IMS/VoLTE + PS/L1)
*
* PARAMETERS
*   ps_id   [IN]    protocol ID
*
* RETURNS
*   the unsigned 4-byte value for the SIM SBP ID
*
*****************************************************************************/
kal_uint32 sbp_get_sim_sbp_id_for_all(protocol_id_enum ps_id)
{
    return sbp_cntxt_g[ps_id].dsbp_sim_sbp_id_mode2;
}

/*****************************************************************************
* FUNCTION
*   sbp_get_current_sim_sbp_id()
*
* DESCRIPTION
*   get SIM SBP ID which trigger DSBP for IMS/VoLTE
*
* PARAMETERS
*   ps_id   [IN]    protocol ID
*
* RETURNS
*   the unsigned 4-byte value for the SIM SBP ID
*
*****************************************************************************/
kal_uint32 sbp_get_current_sim_sbp_id(protocol_id_enum ps_id)
{
    return sbp_cntxt_g[ps_id].current_sim_sbp_id;     
}

/*****************************************************************************
* FUNCTION
*   sbp_get_sim_sbp_id()
*
* DESCRIPTION
*   get SIM SBP ID which trigger DSBP for IMS/VoLTE
*
* PARAMETERS
*   ps_id   [IN]    protocol ID
*
* RETURNS
*   the unsigned 4-byte value for the SIM SBP ID
*
*****************************************************************************/
kal_uint32 sbp_get_sim_sbp_id(protocol_id_enum ps_id)
{
    return sbp_cntxt_g[ps_id].dsbp_sim_sbp_id_mode1;     
}

/*****************************************************************************
* FUNCTION
*   sbp_set_sim_sbp_id_for_all()
*
* DESCRIPTION
*   set SIM SBP ID which trigger DSBP for all modem (IMS/VoLTE + PS/L1)
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*   sim_sbp_id  [IN]    SIM SBP ID
*   mcc  [IN]    MCC
*   mnc  [IN]    MNC
*   iccid  [IN]   ICCID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_set_sim_sbp_id_for_all(protocol_id_enum ps_id, kal_uint32 sim_sbp_id, kal_uint8 *mcc, kal_uint8 *mnc, kal_uint8 *iccid)
{
    nvram_ef_sbp_ids_struct *nvram_ef_sbp_ids_ptr;
    kal_bool result = KAL_FALSE;

    nvram_ef_sbp_ids_ptr = (nvram_ef_sbp_ids_struct *) get_ctrl_buffer(sizeof(nvram_ef_sbp_ids_struct));

    if (nvram_ef_sbp_ids_ptr == NULL)
    {
        return KAL_FALSE;
    }

    sbp_cntxt_g[ps_id].dsbp_sim_sbp_id_mode2 = sim_sbp_id;

     // read VDM ims_reconfig_enable setting first
     /* to use ps_id instead of l4c_gemini_get_actual_sim_id(ps_id),
        SIM SBP ID NVRAM LID is combined with protocol stack, not SIM slot
     */

     // fill LID info from current context
     sbp_get_sbp_ids_from_cntxt(nvram_ef_sbp_ids_ptr);

     // update LID info with new sim_sbp_id_info
     nvram_ef_sbp_ids_ptr->sim_sbp_id_info[ps_id].sim_sbp_id = sim_sbp_id;

     // For mode2, update both sbp context and NVRAM after DSBP completion
     if (mcc == NULL)
     {
        kal_mem_set(nvram_ef_sbp_ids_ptr->sim_sbp_id_info[ps_id].mcc, 0, MAX_MCC_STR_LEN);
        kal_mem_set(sbp_cntxt_g[ps_id].mcc, 0, MAX_MCC_STR_LEN);
     }
     else
     {
        kal_mem_cpy(nvram_ef_sbp_ids_ptr->sim_sbp_id_info[ps_id].mcc, mcc, MAX_MCC_STR_LEN);
        kal_mem_cpy(sbp_cntxt_g[ps_id].mcc, mcc, MAX_MCC_STR_LEN);
     }
     if (mnc == NULL)
     {
        kal_mem_set(nvram_ef_sbp_ids_ptr->sim_sbp_id_info[ps_id].mnc, 0, MAX_MNC_STR_LEN);
        kal_mem_set(sbp_cntxt_g[ps_id].mnc, 0, MAX_MNC_STR_LEN);
     }
     else
     {
        kal_mem_cpy(nvram_ef_sbp_ids_ptr->sim_sbp_id_info[ps_id].mnc, mnc, MAX_MNC_STR_LEN);
        kal_mem_cpy(sbp_cntxt_g[ps_id].mnc, mnc, MAX_MNC_STR_LEN);
     }
     if (iccid == NULL)
     {
        kal_mem_set(nvram_ef_sbp_ids_ptr->sim_sbp_id_info[ps_id].iccid, 0, 21);
        kal_mem_set(sbp_cntxt_g[ps_id].iccid, 0, 21);
     }
     else
     {
        kal_mem_cpy(nvram_ef_sbp_ids_ptr->sim_sbp_id_info[ps_id].iccid, iccid, 21);
        kal_mem_cpy(sbp_cntxt_g[ps_id].iccid, iccid, 21);
     }

     result = nvram_external_write_data(NVRAM_EF_SBP_IDS_LID,
                                        1,
                                        (kal_uint8*)nvram_ef_sbp_ids_ptr,
                                        NVRAM_EF_SBP_IDS_SIZE);

     // Free allocated buffer
     free_ctrl_buffer(nvram_ef_sbp_ids_ptr);

     return result;
}

/*****************************************************************************
* FUNCTION
*   sbp_set_current_sim_sbp_id()
*
* DESCRIPTION
*   set SIM SBP ID for current PS
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*   sim_sbp_id  [IN]    SIM SBP ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_set_current_sim_sbp_id(protocol_id_enum ps_id, kal_uint32 sim_sbp_id)
{
    sbp_cntxt_g[ps_id].current_sim_sbp_id = sim_sbp_id;

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_set_sim_sbp_id()
*
* DESCRIPTION
*   set SIM SBP ID which trigger DSBP for IMS/VoLTE
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*   sim_sbp_id  [IN]    SIM SBP ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_set_sim_sbp_id(protocol_id_enum ps_id, kal_uint32 sim_sbp_id, kal_uint8 *mcc, kal_uint8 *mnc, kal_uint8 *iccid)
{
    // For mode1, update sbp context after DSBP completion
    // (but not update NVRAM, mode1 info does not persist after pwr cycle)
    sbp_cntxt_g[ps_id].dsbp_sim_sbp_id_mode1 = sim_sbp_id;

    if (mcc == NULL)
       kal_mem_set(sbp_cntxt_g[ps_id].mcc, 0, MAX_MCC_STR_LEN);
    else
       kal_mem_cpy(sbp_cntxt_g[ps_id].mcc, mcc, MAX_MCC_STR_LEN);
    if (mnc == NULL)
       kal_mem_set(sbp_cntxt_g[ps_id].mnc, 0, MAX_MNC_STR_LEN);
    else
       kal_mem_cpy(sbp_cntxt_g[ps_id].mnc, mnc, MAX_MNC_STR_LEN);
    if (iccid == NULL)
       kal_mem_set(sbp_cntxt_g[ps_id].iccid, 0, 21);
    else
       kal_mem_cpy(sbp_cntxt_g[ps_id].iccid, iccid, 21);

     return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_get_sbp_feature_raw_config()
*
* DESCRIPTION
*   Get SBP Feature Raw Data according to the ps_id
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_get_sbp_feature_raw_config(protocol_id_enum ps_id, kal_uint8 *raw_config)
{
    kal_mem_cpy(raw_config, sbp_cntxt_g[ps_id].modem_sbp_config, (SBP_MAX_MD_FEATURE/8)+1);
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_set_sbp_feature_raw_config()
*
* DESCRIPTION
*   Set SBP Feature Raw Data according to the ps_id
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
void sbp_set_sbp_feature_raw_config(protocol_id_enum ps_id, kal_uint8 *raw_config)
{
    kal_mem_cpy(sbp_cntxt_g[ps_id].modem_sbp_config, raw_config, (SBP_MAX_MD_FEATURE/8)+1);

}


/*****************************************************************************
* FUNCTION
*   sbp_get_sbp_data_raw_config()
*
* DESCRIPTION
*   Get SBP Data Raw Data according to the ps_id
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_get_sbp_data_raw_config(protocol_id_enum ps_id, kal_uint8 *raw_config)
{
    kal_mem_cpy(raw_config, sbp_cntxt_g[ps_id].modem_sbp_data_config, SBP_DATA_MAX_MD_FEATURE);
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_set_sbp_data_raw_config()
*
* DESCRIPTION
*   Get SBP Data Raw Data according to the ps_id
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
void sbp_set_sbp_data_raw_config(protocol_id_enum ps_id, kal_uint8 *raw_config)
{
    kal_mem_cpy(sbp_cntxt_g[ps_id].modem_sbp_data_config, raw_config, SBP_DATA_MAX_MD_FEATURE);

}


/*****************************************************************************
* FUNCTION
*   sbp_update_features_to_nvram()
*
* DESCRIPTION
*   This function is used to store current config of features from SBP contexts into NVRAM_EF_SBP_MODEM_CONFIG_LID
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_update_features_to_nvram()
{
    nvram_ef_sbp_modem_config_struct sbp_local_config;

    sbp_local_config.sbp_mode = SBP_ID_INVALID;
    kal_mem_cpy(sbp_local_config.modem_sbp_config, sbp_cntxt_g[SIM1].modem_sbp_config, (SBP_MAX_MD_FEATURE/8)+1);

    nvram_external_write_data(NVRAM_EF_SBP_MODEM_CONFIG_LID, 
            1, 
            (kal_uint8*)&sbp_local_config, 
            NVRAM_EF_SBP_MODEM_CONFIG_SIZE);

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_update_data_to_nvram()
*
* DESCRIPTION
*   This function is used to store current config of data from SBP contexts into NVRAM_EF_SBP_MODEM_DATA_CONFIG_LID
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_update_data_to_nvram()
{
    nvram_ef_sbp_modem_data_config_struct sbp_local_config;

    sbp_local_config.sbp_mode = SBP_ID_INVALID;
    kal_mem_cpy(sbp_local_config.modem_sbp_data_config, sbp_cntxt_g[SIM1].modem_sbp_data_config, SBP_DATA_MAX_MD_FEATURE);

    nvram_external_write_data(NVRAM_EF_SBP_MODEM_DATA_CONFIG_LID, 
            1, 
            (kal_uint8*)&sbp_local_config, 
            NVRAM_EF_SBP_MODEM_DATA_CONFIG_SIZE);

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_update_specific_feature_to_nvram()
*
* DESCRIPTION
*   This function is used to write a single SBP feature to NVRAM, keeping all other features the same
*
* PARAMETERS
*   feature         [IN]    modem feature
*   is_turned_on    [IN]
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_update_specific_feature_to_nvram(sbp_md_feature_enum feature, kal_bool is_turned_on)
{
    nvram_ef_sbp_modem_config_struct sbp_local_config;

    nvram_external_read_data(NVRAM_EF_SBP_MODEM_CONFIG_LID,
                 1,
                 (kal_uint8*)&sbp_local_config,
                 NVRAM_EF_SBP_MODEM_CONFIG_SIZE);

    sbp_set_md_feature(feature, is_turned_on, (nvram_ef_sbp_modem_config_struct*)&sbp_local_config);

    nvram_external_write_data(NVRAM_EF_SBP_MODEM_CONFIG_LID, 
            1, 
            (kal_uint8*)&sbp_local_config, 
            NVRAM_EF_SBP_MODEM_CONFIG_SIZE);

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_update_specific_data_to_nvram()
*
* DESCRIPTION
*   This function is used to write a single SBP feature data to NVRAM, keeping all other feature data the same
*
* PARAMETERS
*   feature [IN]    modem feature data
*   data [IN]       value of feature data
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_update_specific_data_to_nvram(sbp_md_feature_data_enum feature, kal_uint8 data)
{
    nvram_ef_sbp_modem_data_config_struct sbp_local_config;

    nvram_external_read_data(NVRAM_EF_SBP_MODEM_DATA_CONFIG_LID,
                 1,
                 (kal_uint8*)&sbp_local_config,
                 NVRAM_EF_SBP_MODEM_DATA_CONFIG_SIZE);

    sbp_set_md_feature_data(feature, data, (nvram_ef_sbp_modem_data_config_struct*)&sbp_local_config);

    nvram_external_write_data(NVRAM_EF_SBP_MODEM_DATA_CONFIG_LID, 
            1, 
            (kal_uint8*)&sbp_local_config, 
            NVRAM_EF_SBP_MODEM_DATA_CONFIG_SIZE);

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_reload_config()
*
* DESCRIPTION
*   This function is used to reload SBP related feature/data configuration
*   Please don't use this API if you don't get the permission from SBP FPM.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
void sbp_reload_config()
{
    kal_bool result;
    kal_uint8 i;
    nvram_ef_sbp_modem_config_struct sbp_feature_buf;
    nvram_ef_sbp_modem_data_config_struct sbp_data_buf;
#if defined (__TC01_NVRAM__) || defined(__TC01__) // __TC01_CUST_SBP__
    nvram_ef_sbp_modem_config_struct sbp_cust_feature_buf;
#endif

    /* load SBP file */
    result = nvram_external_read_data(NVRAM_EF_SBP_MODEM_CONFIG_LID, 
            1, 
            (kal_uint8*)&sbp_feature_buf, 
            NVRAM_EF_SBP_MODEM_CONFIG_SIZE);
    if (result == KAL_TRUE)
    {
        for (i=0; i<MAX_SIM_NUM; i++)
        {
            kal_mem_cpy(&sbp_cntxt_g[i].modem_sbp_config, sbp_feature_buf.modem_sbp_config, (SBP_MAX_MD_FEATURE/8)+1);
        }
    }
    else
    {
        kal_sys_trace("Reload SBP features settings from NVRAM fail");
    }
        

    result = nvram_external_read_data(NVRAM_EF_SBP_MODEM_DATA_CONFIG_LID, 
            1, 
            (kal_uint8*)&sbp_data_buf, 
            NVRAM_EF_SBP_MODEM_DATA_CONFIG_SIZE);

    if (result == KAL_TRUE)
    {
        for (i=0; i<MAX_SIM_NUM; i++)
        {
            kal_mem_cpy(&sbp_cntxt_g[i].modem_sbp_data_config, sbp_data_buf.modem_sbp_data_config, SBP_DATA_MAX_MD_FEATURE);
        }
    }
    else
    {
        kal_sys_trace("Reload SBP data settings from NVRAM fail");
    }

#if defined (__TC01_NVRAM__) || defined(__TC01__) // __TC01_CUST_SBP__
    result = nvram_external_read_data(NVRAM_EF_SBP_MODEM_CONFIG_LID, 
            NVRAM_CUST_SBP_IDX, 
            (kal_uint8*)&sbp_cust_feature_buf, 
            NVRAM_EF_SBP_MODEM_CONFIG_SIZE);
    if (result == KAL_TRUE)
    {
        for (i=0; i<MAX_SIM_NUM; i++)
        {
            kal_mem_cpy(&sbp_cntxt_g[i].modem_cust_sbp_config, sbp_cust_feature_buf.modem_sbp_config, (SBP_CUSTOM_MAX_MD_FEATURE/8)+1);
        }
    }
    else
    {
        kal_sys_trace("Reload Custom SBP features settings from NVRAM fail");
    }
#endif
    
}


/*****************************************************************************
* FUNCTION
*   sbp_get_reconfig_param()
*
* DESCRIPTION
*   This function is used to get MCC/MNC/ICCID information, which is used to compute SIM SBP ID
*   from SBP contexts
*   Please don't use this API if there is no permission from SBP FW owner
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*   param      [IN]    sbp_reconfig_custom_param_struct
* RETURNS
*   void
*
*****************************************************************************/
void sbp_get_reconfig_param(protocol_id_enum ps_id, sbp_reconfig_custom_param_struct *param)
{
    kal_mem_cpy(param->mcc, sbp_cntxt_g[ps_id].mcc, MAX_MCC_STR_LEN);
    kal_mem_cpy(param->mnc, sbp_cntxt_g[ps_id].mnc, MAX_MNC_STR_LEN);
    kal_mem_cpy(param->iccid, sbp_cntxt_g[ps_id].iccid, 21);
}

/*****************************************************************************
* FUNCTION
*    sbp_get_last_dsbp_sim_info()
*
* DESCRIPTION
*   This function is used to get MCC/MNC/ICCID of last completed DSBP
*   For mode2 device, this will include SIM info from last power up
*   For mode1 device, only include SIM info in current sbp context
*
* PARAMETERS
*   ps_id      [IN]    protocol ID
*   param      [IN]    mcc, mnc, iccid
* RETURNS
*   void
*
*****************************************************************************/
void sbp_get_last_dsbp_sim_info(protocol_id_enum ps_id, kal_uint8 *mcc, kal_uint8 *mnc, kal_uint8 *iccid)
{
    kal_mem_cpy(mcc, sbp_cntxt_g[ps_id].mcc, MAX_MCC_STR_LEN);
    kal_mem_cpy(mnc, sbp_cntxt_g[ps_id].mnc, MAX_MNC_STR_LEN);
    kal_mem_cpy(iccid, sbp_cntxt_g[ps_id].iccid, 21);

    MD_TRC_INFO_SBP_LAST_DSBP_SIM_INFO(ps_id, sbp_cntxt_g[ps_id].mcc, sbp_cntxt_g[ps_id].mnc);
}

/*****************************************************************************
* FUNCTION
*    sbp_get_last_mode2_dsbp_sim_info()
*
* DESCRIPTION
*   This function is used to get SIM_SBP_ID/MCC/MNC/ICCID of last completed mode2 DSBP
*   Can be used in DSBP callback function to compare with last mode2 DSBP result
*   As part of mode2 design, this includes info from SIM insert of last power cycle
*
* PARAMETERS
*   ps_id      [IN]    protocol ID
*   param      [IN]    sim_sbp_id, mcc, mnc, iccid
* RETURNS
*   void
*
*****************************************************************************/
void sbp_get_last_mode2_dsbp_sim_info(protocol_id_enum ps_id, kal_uint32 *sim_sbp_id, kal_uint8 *mcc, kal_uint8 *mnc, kal_uint8 *iccid)
{
    *sim_sbp_id = sbp_cntxt_g[ps_id].dsbp_sim_sbp_id_mode2;
    kal_mem_cpy(mcc, sbp_cntxt_g[ps_id].mcc, MAX_MCC_STR_LEN);
    kal_mem_cpy(mnc, sbp_cntxt_g[ps_id].mnc, MAX_MNC_STR_LEN);
    kal_mem_cpy(iccid, sbp_cntxt_g[ps_id].iccid, 21);
}

/*****************************************************************************
* FUNCTION
*   sbp_update_custom_config_to_nvram
*
* DESCRIPTION
*   This function updates sbp feature/data custom config to nvram
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*   is_erase    [IN]    reset the feature/data item or not
* RETURNS
*   void
*
*****************************************************************************/
kal_bool sbp_update_custom_config_to_nvram(sbp_custom_config_struct *sbp_custom_config_ptr, kal_bool is_erase)
{
    kal_bool result = KAL_FALSE;
    nvram_ef_sbp_custom_modem_config_struct   *sbp_custom_modem_config_nv_ptr;
    sbp_custom_config_struct                  *sbp_custom_config_nv_ptr;
    kal_uint32 i = 0;

    sbp_custom_modem_config_nv_ptr = (nvram_ef_sbp_custom_modem_config_struct *) get_ctrl_buffer(
                                      sizeof(nvram_ef_sbp_custom_modem_config_struct));

    if (sbp_custom_modem_config_nv_ptr == NULL)
    {
        return KAL_FALSE;
    }

    result = nvram_external_read_data(NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_LID, 
                                      1,
                                      (kal_uint8*)sbp_custom_modem_config_nv_ptr, 
                                      NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_SIZE);

    if (result == KAL_TRUE)
    {
        // Erase any duplicate entry
        for (i = 0; i < SBP_MAX_CUSTOM_CONFIG; i++)
        {
            sbp_custom_config_nv_ptr = &sbp_custom_modem_config_nv_ptr->sbp_custom_config[i];
            if (sbp_custom_config_nv_ptr->sbp_id == sbp_custom_config_ptr->sbp_id &&
                sbp_custom_config_nv_ptr->sbp_cust_cfg_type == sbp_custom_config_ptr->sbp_cust_cfg_type &&
                sbp_custom_config_nv_ptr->sbp_cust_cfg_feature == sbp_custom_config_ptr->sbp_cust_cfg_feature)
            {
                sbp_custom_config_nv_ptr->sbp_id = 0;
                sbp_custom_config_nv_ptr->sbp_cust_cfg_type = 0;
                sbp_custom_config_nv_ptr->sbp_cust_cfg_feature = 0;
                sbp_custom_config_nv_ptr->sbp_cust_cfg_feature_val = 0;
            }
        }

        // For update, find empty index so we can update to nvram
        if (is_erase == KAL_FALSE)
        {
            for (i = 0; i < SBP_MAX_CUSTOM_CONFIG; i++)
            {
                sbp_custom_config_nv_ptr = &sbp_custom_modem_config_nv_ptr->sbp_custom_config[i];

                if (sbp_custom_config_nv_ptr->sbp_id == 0 &&
                    sbp_custom_config_nv_ptr->sbp_cust_cfg_type == 0 &&
                    sbp_custom_config_nv_ptr->sbp_cust_cfg_feature == 0 &&
                    sbp_custom_config_nv_ptr->sbp_cust_cfg_feature_val == 0)
                {
                    sbp_custom_config_nv_ptr->sbp_id = sbp_custom_config_ptr->sbp_id;
                    sbp_custom_config_nv_ptr->sbp_cust_cfg_type = sbp_custom_config_ptr->sbp_cust_cfg_type;
                    sbp_custom_config_nv_ptr->sbp_cust_cfg_feature = sbp_custom_config_ptr->sbp_cust_cfg_feature;
                    sbp_custom_config_nv_ptr->sbp_cust_cfg_feature_val = sbp_custom_config_ptr->sbp_cust_cfg_feature_val;
                    break;
                }
            }
            // all indices are not empty, update fail
            if (i == SBP_MAX_CUSTOM_CONFIG)
            {
                MD_TRC_INFO_SBP_UPDATE_NVRAM_NO_EMPTY_FAIL();
                result = KAL_FALSE;
            }
        }

        if (result == KAL_TRUE)
        {
            nvram_external_write_data(NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_LID, 
                1,
                (kal_uint8*)sbp_custom_modem_config_nv_ptr, 
                NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_SIZE);
        }
    }
    else
    {
        MD_TRC_INFO_SBP_UPDATE_NVRAM_ACCESS_FAIL();
    }

    // Free allocated buffer
    free_ctrl_buffer(sbp_custom_modem_config_nv_ptr);

    return result;
}

/*****************************************************************************
* FUNCTION
*   sbp_get_custom_config_nv_with_mcf
*
* DESCRIPTION
*   This function reads NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_LID and applies MCF OTA by OP change
*   This funciton uses latest DSBP SIM info and shall not be used during DSBP
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   void
*
*****************************************************************************/
kal_bool sbp_get_custom_config_nv_with_mcf(protocol_id_enum ps_id, nvram_ef_sbp_custom_modem_config_struct * sbp_custom_modem_config_nv_ptr)
{
    mcf_tlvota_sbp_tag_t sbp_tag;
    kal_bool result = KAL_FALSE;

    result = nvram_external_read_data(NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_LID, 
                     1,
                     (kal_uint8*)sbp_custom_modem_config_nv_ptr, 
                     NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_SIZE);

    if (result == KAL_TRUE)
    {
        // get SBP tag from latest mode2 info
        memset(&sbp_tag.mcc,'\0',sizeof(kal_uint8)*MAX_MCC_STR_LEN);
        memset(&sbp_tag.mnc,'\0',sizeof(kal_uint8)*MAX_MNC_STR_LEN);

        sbp_tag.sbp_id = sbp_get_sim_sbp_id_for_all(ps_id);  // MCF OTA by OP uses mode2 DSBP
        memcpy(&sbp_tag.mcc, &sbp_cntxt_g[ps_id].mcc, sizeof(kal_uint8)*MAX_MCC_STR_LEN);
        memcpy(&sbp_tag.mnc, &sbp_cntxt_g[ps_id].mnc, sizeof(kal_uint8)*MAX_MNC_STR_LEN);

        mcf_read_tlvota_buffer_sbp_tag(ps_id, sbp_tag, NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_LID,
                (kal_uint8 *)sbp_custom_modem_config_nv_ptr, NVRAM_EF_SBP_CUSTOM_MODEM_CONFIG_SIZE);
    }

    return result;
}

/*****************************************************************************
* FUNCTION
*   sbp_get_max_custom_config
*
* DESCRIPTION
*   This function gets MAX custom config NV entries
*
* PARAMETERS
*   [IN]    N/A
* RETURNS
*   void
*
*****************************************************************************/
kal_uint16 sbp_get_max_custom_config(void)
{
    return SBP_MAX_CUSTOM_CONFIG;
}

/*****************************************************************************
* FUNCTION
*    sbp_get_dsbp_config
*
* DESCRIPTION
*   This function is used to get dsbp config
*
* PARAMETERS
*   void
* RETURNS
*   nvram_ef_sbp_dsbp_config_struct
*
*****************************************************************************/
nvram_ef_sbp_dsbp_config_struct* sbp_get_dsbp_config()
{
    return &sbp_common_cntxt_g.dsbp_config;
}

/*****************************************************************************
* FUNCTION
*   nvram_custom_config_refresh_sbp_id_mapping_when_mcf_ota_start
*
* DESCRIPTION
*   This function is used to re-read NVRAM and update the globle custom sbp_id mapping table
*   when MCF default OTA triggered.
*
* PARAMETERS
*   [IN]    N/A
* RETURNS
*   void
*
*****************************************************************************/
void nvram_custom_config_refresh_sbp_id_mapping_when_mcf_ota_start(void)
{
    nvram_external_read_data(NVRAM_EF_SBP_CUSTOM_SBP_ID_MAPPING_LID, 
            1, 
            (kal_uint8*)&g_custom_sbp_id_mapping_table, 
            NVRAM_EF_SBP_CUSTOM_SBP_ID_MAPPING_SIZE);

    nvram_external_read_data(NVRAM_EF_SBP_MDCXP_SBP_ID_LIST_LID, 
            1, 
            (kal_uint8*)&g_mdcxp_sbp_id_list, 
            NVRAM_EF_SBP_MDCXP_SBP_ID_LIST_SIZE);
}

/*****************************************************************************
* FUNCTION
*    sbp_get_md_cxp_sbp_id
*
* DESCRIPTION
*   This function is used to get trigger modem CXP (device) sbp_id
*
* PARAMETERS
*   kal_uint32 sim_sbp_id
* RETURNS
*   kal_uint32 md_cxp_sbp_id
*
*****************************************************************************/
kal_uint32 sbp_get_md_cxp_sbp_id(kal_uint32 sim_sbp_id)
{
    kal_uint8 i;
	
	for (i=0; i < SBP_MAX_MDCXP_SBP_ID_NUM; i++)
	{
	    if (g_mdcxp_sbp_id_list.sbp_id_list[i] == sim_sbp_id)
		{
			// sim_sbp_id found in list
			return sim_sbp_id;
		}
	}
	// sim_sbp_id not found in list, treat as OM
	return 0;
}

/*****************************************************************************
* FUNCTION
*    sbp_set_md_cxp_sbp_id
*
* DESCRIPTION
*   This function is used to add trigger modem CXP (device) sbp_id
*
* PARAMETERS
*   kal_uint32 sbp_id
* RETURNS
*
*****************************************************************************/
void sbp_set_md_cxp_sbp_id(kal_uint32 sbp_id)
{
    kal_uint8 i;
	
	for (i=0; i < SBP_MAX_MDCXP_SBP_ID_NUM; i++)
	{
	    if (g_mdcxp_sbp_id_list.sbp_id_list[i] == 0)
		{
			g_mdcxp_sbp_id_list.sbp_id_list[i] = sbp_id;
			return ;
		}
	}
	return ;
}

/*****************************************************************************
* FUNCTION
*    sbp_get_custom_sbp_id_mapping_table
*
* DESCRIPTION
*   This function is used to get the globle custom sbp_id mapping table
*
* PARAMETERS
*   void
* RETURNS
*   nvram_ef_sbp_custom_sbp_id_mapping_struct
*
*****************************************************************************/
nvram_ef_sbp_custom_sbp_id_mapping_struct* sbp_get_custom_sbp_id_mapping_table(void)
{
    return &g_custom_sbp_id_mapping_table;
}

#if defined (__TC01_NVRAM__) || defined(__TC01__) // __TC01_CUST_SBP__
/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_custom()
*
* DESCRIPTION
*   clone sbp_query_md_feature() for customer's SBP.
*
* PARAMETERS
*   feature [IN]    customer's modem feature
*
* RETURNS
*   KAL_TRUE    : if this feature is turned on
*   KAL_FALSE   : if this feature is turned off
*****************************************************************************/
kal_bool sbp_query_md_feature_custom(sbp_md_feature_custom_enum feature)
{
    return sbp_query_md_feature_by_ps_custom(feature, PROTOCOL_1);
}

/*****************************************************************************
* FUNCTION
*   sbp_query_md_feature_by_ps_custom()
*
* DESCRIPTION
*   clone sbp_query_md_feature_by_ps() for customer's SBP.
*
* PARAMETERS
*   feature [IN]    customer's modem feature
*   ps_id [IN]      PS ID
*
* RETURNS
*   KAL_TRUE    : if this feature is turned on
*   KAL_FALSE   : if this feature is turned off
*****************************************************************************/
kal_bool sbp_query_md_feature_by_ps_custom(sbp_md_feature_custom_enum feature, protocol_id_enum ps_id)
{
    kal_uint8 *bitmask_ptr;
    kal_uint32 byte_offset;
    kal_uint8 bit_offset;
    kal_bool result;

#ifndef __L1_STANDALONE__
    static sbp_md_feature_custom_enum latest_queried_sbp[MAX_SIM_NUM];
#endif

    if (feature >= SBP_CUSTOM_MAX_MD_FEATURE)
    {
        ASSERT(0);
    }
    if (ps_id >=MAX_SIM_NUM)
    {
#ifndef __L1_STANDALONE__
		MD_TRC_ERROR_SBP_INVALID_PS_ID(ps_id);
#endif
        return KAL_FALSE;
    }
    
    byte_offset = feature / 8;
    bit_offset = feature % 8;
    bitmask_ptr = &(sbp_cntxt_g[ps_id].modem_cust_sbp_config[byte_offset]);

    result = (((*bitmask_ptr) & (0x01 << bit_offset)) != 0)? KAL_TRUE : KAL_FALSE;

#ifndef __L1_STANDALONE__
    if (latest_queried_sbp[ps_id] != feature)
    {
//        kal_brief_trace(TRACE_GROUP_1, INFO_CUSTOM_SBP_FEATURE, ps_id, feature, result);
        latest_queried_sbp[ps_id] = feature;
    }
#endif

    return result;
}


/*****************************************************************************
* FUNCTION
*   sbp_set_md_feature_custom()
*
* DESCRIPTION
*   clone sbp_set_md_feature() for customer's SBP.
*
* PARAMETERS
*   feature         [IN]    customer's modem feature
*   is_turned_on    [IN]
*   sbp_feature_ptr [IN/OUT]
*
* RETURNS
*   KAL_TRUE if success; otherwise KAL_FALSE
*****************************************************************************/
kal_bool sbp_set_md_feature_custom(sbp_md_feature_custom_enum feature,
                            kal_bool is_turned_on, 
                            nvram_ef_sbp_modem_config_struct *sbp_feature_ptr)
{
    kal_uint8 *bitmask_ptr;
    kal_uint32 byte_offset;
    kal_uint8 bit_offset;
    

    if (feature >= SBP_CUSTOM_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        byte_offset = feature / 8;
        bit_offset = feature % 8;
        bitmask_ptr = &(sbp_feature_ptr->modem_sbp_config[byte_offset]);
        if (is_turned_on == KAL_TRUE)
        {
            *bitmask_ptr = ((*bitmask_ptr) | (0x01 << bit_offset));
        }
        else
        {
            *bitmask_ptr = ((*bitmask_ptr) & ~(0x01 << bit_offset));
        }
    }
    
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_set_md_feature_by_ps_custom()
*
* DESCRIPTION
*   clone sbp_set_md_feature_by_ps() for customer's SBP.
*
* PARAMETERS
*   feature         [IN]    customer's modem feature
*   is_turned_on    [IN]
*   sbp_feature_ptr [IN/OUT]
*
* RETURNS
*   KAL_TRUE if success; otherwise KAL_FALSE
*****************************************************************************/
kal_bool sbp_set_md_feature_by_ps_custom(sbp_md_feature_custom_enum feature,
                            kal_bool is_turned_on, 
                            protocol_id_enum ps_id)
{
    kal_uint8 *bitmask_ptr;
    kal_uint32 byte_offset;
    kal_uint8 bit_offset;

    if (feature >= SBP_CUSTOM_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        byte_offset = feature / 8;
        bit_offset = feature % 8;
        bitmask_ptr = &(sbp_cntxt_g[ps_id].modem_cust_sbp_config[byte_offset]);
        if (is_turned_on == KAL_TRUE)
        {
            *bitmask_ptr = ((*bitmask_ptr) | (0x01 << bit_offset));
        }
        else
        {
            *bitmask_ptr = ((*bitmask_ptr) & ~(0x01 << bit_offset));
        }

#ifndef __L1_STANDALONE__
//        kal_brief_trace(TRACE_INFO, INFO_CUSTOM_SBP_SET_FEATURE, ps_id, feature, is_turned_on);
#endif
    }
    
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_general_set_md_feature_custom()
*
* DESCRIPTION
*   clone sbp_general_set_md_feature() for customer's SBP.
*
* PARAMETERS
*   feature         [IN]    customer's modem feature
*   is_turned_on    [IN]
*
* RETURNS
*   KAL_TRUE if success; otherwise KAL_FALSE
*****************************************************************************/
kal_bool sbp_general_set_md_feature_custom(sbp_md_feature_custom_enum feature, kal_bool is_turned_on)
{
    kal_uint8 i;

    if (feature >= SBP_CUSTOM_MAX_MD_FEATURE)
    {
        return KAL_FALSE;
    }
    else
    {
        for (i=0; i<MAX_SIM_NUM; i++)
            sbp_set_md_feature_by_ps_custom( feature, is_turned_on, i);
    }

    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_update_features_to_nvram_custom()
*
* DESCRIPTION
*   clone sbp_update_features_to_nvram() for customer's SBP.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_update_features_to_nvram_custom()
{
    nvram_ef_sbp_modem_config_struct sbp_local_config;

    sbp_local_config.sbp_mode = SBP_ID_INVALID;
    kal_mem_cpy(sbp_local_config.modem_sbp_config, sbp_cntxt_g[SIM1].modem_cust_sbp_config, (SBP_CUSTOM_MAX_MD_FEATURE/8)+1);

    nvram_external_write_data(NVRAM_EF_SBP_MODEM_CONFIG_LID, 
            NVRAM_CUST_SBP_IDX, 
            (kal_uint8*)&sbp_local_config, 
            NVRAM_EF_SBP_MODEM_CONFIG_SIZE);

    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
*   sbp_get_sbp_feature_raw_config_custom()
*
* DESCRIPTION
*  clone sbp_get_sbp_feature_raw_config() for customer's SBP.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
kal_bool sbp_get_sbp_feature_raw_config_custom(protocol_id_enum ps_id, kal_uint8 *raw_config)
{
    kal_mem_cpy(raw_config, sbp_cntxt_g[ps_id].modem_cust_sbp_config, (SBP_CUSTOM_MAX_MD_FEATURE/8)+1);
    return KAL_TRUE;
}

/*****************************************************************************
* FUNCTION
*   sbp_set_sbp_feature_raw_config_custom()
*
* DESCRIPTION
*   clone sbp_set_sbp_feature_raw_config() for customer's SBP.
*
* PARAMETERS
*   ps_id       [IN]    protocol ID
*
* RETURNS
*   KAL_TRUE    - success
*   KAL_FALSE   - failure
*
*****************************************************************************/
void sbp_set_sbp_feature_raw_config_custom(protocol_id_enum ps_id, kal_uint8 *raw_config)
{
    kal_mem_cpy(sbp_cntxt_g[ps_id].modem_cust_sbp_config, raw_config, (SBP_CUSTOM_MAX_MD_FEATURE/8)+1);

}

#endif  /* (__TC01_NVRAM__) || defined(__TC01__)*/

#ifdef __IPC_ADAPTER__
/*****************************************************************************
* FUNCTION
*    sbp_get_salecode()
*
* DESCRIPTION
*   This function is used to get salecode of this ps_id
*   If network code is present, network code is given
*   otherwise, csc_salecode is given
*
* PARAMETERS
*   ps_id      [IN]    protocol ID
*   param      [IN]    salecode
* RETURNS
*   void
*
*****************************************************************************/
void sbp_get_salecode(kal_char *salecode, protocol_id_enum ps_id)
{
    kal_uint8 sim_id;
    sim_id = l4c_gemini_get_actual_sim_id(ps_id);

    if (sim_id == SIM1)
    {
        if (sbp_salecode.network_code[0] == 0 && sbp_salecode.network_code[1] == 0 && sbp_salecode.network_code[2] == 0)
        {
            memcpy( (void *) salecode, (void *) sbp_salecode.csc_salecode, 3);
        }
        else
        {
            memcpy( (void *) salecode, (void *) sbp_salecode.network_code, 3);
        }
    }
    else if (sim_id == SIM2)
    {
        if (sbp_salecode.network_code_2[0] == 0 && sbp_salecode.network_code_2[1] == 0 && sbp_salecode.network_code_2[2] == 0)
        {
            memcpy( (void *) salecode, (void *) sbp_salecode.csc_salecode, 3);
        }
        else
        {
            memcpy( (void *) salecode, (void *) sbp_salecode.network_code_2, 3);
        }
    }
}

void sbp_get_csc_salecode(kal_char *salecode)
{
    memcpy( (void *) salecode, (void *) sbp_salecode.csc_salecode, 3);
}

void sbp_get_network_code_salecode(kal_char *salecode, protocol_id_enum ps_id)
{
    kal_uint8 sim_id;
    sim_id = l4c_gemini_get_actual_sim_id(ps_id);

    if (sim_id == SIM1)
    {
        memcpy( (void *) salecode, (void *) sbp_salecode.network_code, 3);
    }
    else if (sim_id == SIM2)
    {
        memcpy( (void *) salecode, (void *) sbp_salecode.network_code_2, 3);
    }
}
#endif  /* __IPC_ADAPTER__ */