phb_sim_access.c

最新MTK手机软件源码

    else
    {
        control_block->cause = sim_file_info_cnf->result;

        phb_IO_return(control_block, ilm_ptr, KAL_FALSE);
        return;
    }
}   /* end of phb_sim_file_info_cnf */


/*****************************************************************************
 * FUNCTION
 *  phb_sim_read_record
 * DESCRIPTION
 *  This function issues SIM_READ_REQ to sim.
 * PARAMETERS
 *  file_idx            [IN]        
 *  record_index        [IN]        
 *  length              [IN]        
 *  access_id           [IN]        
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_sim_read_record(kal_uint16 file_idx, kal_uint16 record_index, kal_uint16 length, kal_uint8 access_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    sim_read_req_struct *sim_read_req;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_SIM_READ_RECORD);

    sim_read_req = (sim_read_req_struct*) construct_local_para(sizeof(sim_read_req_struct), TD_CTRL);
#ifdef __USIM_SUPPORT__
    if (is_usim_type())
    {
        data_desc_enum type = phb_data_desc_get_desc_by_ID(file_idx);

        if (type != PHB_INVALID_VALUE)
        {
            kal_mem_cpy(sim_read_req->path, usim_ef_info[FILE_G_PHONEBOOK_IDX].full_path, 4);
            sim_read_req->path[4] = phb_ptr->path[type][0];
            sim_read_req->path[5] = phb_ptr->path[type][1];
        }
    }
#endif /* __USIM_SUPPORT__ */ 

    sim_read_req->file_idx = file_idx;
    sim_read_req->para = (kal_uint8) record_index;
    sim_read_req->length = (kal_uint8) length;
    sim_read_req->access_id = (kal_uint8) access_id;

    phb_send_ilm(MOD_SIM, MSG_ID_SIM_READ_REQ, sim_read_req, NULL);
}   /* end of phb_sim_read_record */


/*****************************************************************************
 * FUNCTION
 *  phb_sim_read
 * DESCRIPTION
 *  This function issues SIM_READ_REQ to sim.
 *  Read SIM from control_block specified primary_ID, record_index, and length
 *  
 *  Prerequisite:
 *  pimary_ID, secondary_ID, record_index and length.
 * PARAMETERS
 *  control_block       [?]         
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  KAL_TRUE if success, KAL_FALSE otherwise.
 *****************************************************************************/
kal_bool phb_sim_read(control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool result = KAL_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_SIM_READ);

    ASSERT(control_block != NULL);

    if (control_block->IO_stage == IO_NONE)
    {
        control_block->IO_stage = IO_WAIT;
        control_block->IO_cnf_receive = phb_sim_read_cnf;
        phb_sim_read_record(
            control_block->primary_ID,
            control_block->record_index,
            control_block->length,
            control_block->ID);
        result = KAL_TRUE;
    }
    /* Abnormal, return false */
    else
    {
        result = KAL_FALSE;
    }

    return result;
}   /* end of phb_sim_read */


/*****************************************************************************
 * FUNCTION
 *  phb_sim_reassemble_tel_num
 * DESCRIPTION
 *  This function reassembles data read from SIM.
 * PARAMETERS
 *  data_ptr            [IN]        Must be a EFext structure in SIM!!
 *  control_block       [?]         
 * RETURNS
 *  identifier of chained extension record.
 *****************************************************************************/
static kal_uint8 phb_sim_reassemble_tel_num(ef_ext_type *data_ptr, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    phb_entry_struct *phb_entry;

    kal_uint8 len;
    kal_uint8 sim_ext_record_index;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_SIM_REASSEMBLE_TEL_NUM);

    ASSERT(control_block != NULL);

    phb_entry = (phb_entry_struct*) control_block->data;
    phb_entry->storage = PHB_SIM;

    if ((phb_entry->tel_number.addr_length + data_ptr->ext_data_length) > L4_MAX_ADDR_BCD)
    {
        len = L4_MAX_ADDR_BCD - phb_entry->tel_number.addr_length;
        sim_ext_record_index = (kal_uint8) PHB_INVALID_VALUE;   /* truncate!! */
    }
    else
    {
        len = data_ptr->ext_data_length;
        sim_ext_record_index = data_ptr->identifier;
    }
    kal_mem_cpy(
        &phb_entry->tel_number.addr_bcd[phb_entry->tel_number.addr_length],
        (void const*)data_ptr->ext_data,
        len);
    phb_entry->tel_number.addr_length += len;

    return sim_ext_record_index;
}   /* end of phb_sim_reassemble */


/*****************************************************************************
 * FUNCTION
 *  phb_sim_read_cnf
 * DESCRIPTION
 *  This function issues SIM_FILE_INFO_REQ to sim.
 * PARAMETERS
 *  ilm_ptr             [IN]        The primitives
 *  control_block       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_sim_read_cnf(ilm_struct *ilm_ptr, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    sim_read_cnf_struct *sim_read_cnf;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_SIM_READ_CNF);

    ASSERT(control_block != NULL);

    sim_read_cnf = (sim_read_cnf_struct*) ilm_ptr->local_para_ptr;

    if (sim_read_cnf->result == SIM_CMD_SUCCESS)
    {
        /* success */
        if (control_block->IO_stage == IO_WAIT)
        {
        #ifdef __USIM_SUPPORT__
            /* Reading ECC or PBR. Return to return_location for reading pbr */
            if (control_block->primary_ID == FILE_ECC_IDX ||
                control_block->primary_ID == FILE_U_ECC_IDX || control_block->primary_ID == FILE_G_PBR_IDX)
        #else /* __USIM_SUPPORT__ */ 
            /* Reading ECC. Return to return_location for reading ecc */
            if (control_block->primary_ID == FILE_ECC_IDX)
        #endif /* __USIM_SUPPORT__ */ 
            {
                control_block->data = (kal_uint8*) sim_read_cnf->data;
                phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
                return;
            }
            else if ((control_block->primary_ID == FILE_EXT1_IDX) ||
        #ifdef __PHB_USIM_SUPPORT
                     (control_block->primary_ID == FILE_G_EXT1_IDX) ||
        #endif 
                     (control_block->primary_ID == FILE_EXT2_IDX) ||
                     (control_block->primary_ID == FILE_EXT3_IDX) || (control_block->primary_ID == FILE_EXT4_IDX))
            {
                kal_uint16 len;
                ef_ext_type *ef_ext;

                ef_ext = (ef_ext_type*) sim_read_cnf->data;
                if ((len = sim_read_cnf->length) > sizeof(ef_ext))
                {
                    len = sizeof(ef_ext_type);
                }

                if (!is_empty((kal_uint8*) ef_ext, len))
                {
                    control_block->data = (kal_uint8*) ef_ext;
                }
                else
                {
                    control_block->data = NULL;
                }

                phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
            }
        #ifdef __PHB_USIM_SUPPORT__
            else if (control_block->primary_ID == FILE_G_ANR_IDX)
            {
                kal_uint8 anr_alpha_id_length = 1;
                kal_uint8 *pdu_ptr;
                kal_uint16 pdu_length;

                phb_ef_struct phb_ef;
                phb_entry_struct *phb_entry;

                pdu_ptr = sim_read_cnf->data;
                pdu_length = sim_read_cnf->length;

                phb_entry = (phb_entry_struct*) control_block->data;

                /* phb_ef.alpha_id = (kal_uint8*)pdu_ptr; */
                phb_ef.mandatory = (phb_ef_mandatory_struct*) ((kal_uint8*) pdu_ptr + anr_alpha_id_length);

                /* Clean area for storing data read from stroage. */
                kal_mem_set(phb_entry, (kal_uint8) PHB_INVALID_VALUE, sizeof(phb_entry_struct));

                phb_entry->index = control_block->index;
                phb_entry->record_index = control_block->record_index;
                phb_entry->storage = PHB_SIM;

                phb_entry->type = PHB_ANR;

                if (!is_empty(pdu_ptr, pdu_length))
                {
                    kal_uint8 sim_ext_record_index;

                    /* Set up phb_entry->tel_number */
                    if (phb_ef.mandatory->len > 0 && phb_ef.mandatory->len != 0xff && phb_ef.mandatory->len <= (EF_TEL_NUMBER_SIZE + 1) && !(phb_ef.mandatory->len == 1 && phb_ef.mandatory->ton_npi != 0x91))  /* only accept + if length 1 */
                    {
                        phb_entry->tel_number.addr_length = phb_ef.mandatory->len;
                        phb_entry->tel_number.addr_bcd[L4_ADDR_BCD_TON_NPI_OFFSET] = phb_ef.mandatory->ton_npi;
                        kal_mem_cpy(
                            &phb_entry->tel_number.addr_bcd[L4_ADDR_BCD_TEL_NUM_OFFSET],
                            (void const*)&phb_ef.mandatory->tel_number,
                            /* TON_NPI_SIZE + */ phb_ef.mandatory->len - L4_ADDR_BCD_TEL_NUM_OFFSET);

                        phb_entry->tel_number.addr_bcd[phb_ef.mandatory->len] = 0xff;
                    }
                    else
                    {
                        kal_mem_set(&phb_entry->tel_number, 0, sizeof(l4_addr_bcd_struct));
                        phb_entry->tel_number.addr_bcd[L4_ADDR_BCD_TEL_NUM_OFFSET] = 0xff;
                    }

                    /* Empty Record!! - If Number field is empty, regard it as an empty record!! */
                    if (phb_entry->tel_number.addr_length == 0)
                    {
                        kal_mem_set(&phb_entry->alpha_id, 0, sizeof(l4_name_struct));
                        control_block->data = NULL;

                        phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
                        return;
                    }

                    /* Need reassembly? */
                    sim_ext_record_index = phb_ef.mandatory->ext_id;
                    control_block->seg_record_index = (kal_uint8) PHB_INVALID_VALUE;
                    if ((control_block->secondary_ID != PHB_NULL_VALUE) &&
                        (sim_ext_record_index != (kal_uint8) PHB_INVALID_VALUE) &&
                        (sim_ext_record_index > 0) &&
                        (sim_ext_record_index <= phb_data_desc_get_record_num(phb_data_desc_get_desc_by_ID(control_block->secondary_ID))) &&
                        (phb_entry->tel_number.addr_length < L4_MAX_ADDR_BCD) &&
                        /* Only when address length is equal to PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN should need reassembly */
                        (phb_ef.mandatory->len == PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN))
                    {

                        if ((phb_ptr->state != PHB_STATE_READY) &&
                            (control_block->proc_stage == startup_build_anr_index))
                        {
                            control_block->seg_record_index = sim_ext_record_index;
                            phb_data_desc_mark_free(
                                phb_data_desc_get_desc_by_ID(control_block->secondary_ID),
                                sim_ext_record_index,
                                KAL_FALSE);
                        }

                        control_block->IO_stage = IO_REASSEMBLY;
                        control_block->IO_cnf_receive = phb_sim_read_cnf;

                  /**
                   * control_block->record_index MUST NOT be modified;
                   * that is counter of current read primary_ID!!!
                   */