phb_sim_access.c

最新MTK手机软件源码

                            sim_ext_record_index,
                            phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID (control_block->secondary_ID)),
                            control_block->ID);
                    }
                    /* read complete */
                    else
                    {
                        phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
                        return;
                    }
                }

                /* Illegal length, do recovery. */
                else
                {
                    phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
                    return;
                }
            }
         /** 
          * Wrong state: this CNF is not for us. 
          * Abnormal, consume message.
          */
            else
            {
                kal_trace(TRACE_ERROR, ERROR_PHB_SIM_IO_STATE_READ);
                return;
            }
        }
    #ifdef __PHB_USIM_SUPPORT__
        else if (control_block->IO_stage == IO_ANR_REASSEMBLY)
        {
            if (sim_read_cnf->file_idx == control_block->secondary_ID)
            {
                kal_uint8 sim_ext_record_index;
                phb_entry_struct *phb_entry;
                ef_ext_type *ef_ext;

                /* sim_read_cnf->data is a EFext */
                ef_ext = (ef_ext_type*) sim_read_cnf->data;

                if (ef_ext->ext_data_length <= PHB_EF_EXT_MAX_TEL_NUMBER_LEN)
                {
                    sim_ext_record_index = phb_sim_reassemble_tel_num(ef_ext, control_block);

                    phb_entry = (phb_entry_struct*) control_block->data;
                    /* need reassembly? */
                    if ((control_block->secondary_ID != (kal_uint16) PHB_NULL_VALUE) &&
                        (sim_ext_record_index != (kal_uint8) PHB_INVALID_VALUE) &&
                        (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 */
                        (ef_ext->ext_data_length == PHB_EF_EXT_MAX_TEL_NUMBER_LEN))
                    {
                        control_block->IO_stage = IO_ANR_REASSEMBLY;
                        control_block->IO_cnf_receive = phb_sim_read_cnf;
                        /* control_block->record_index = sim_ext_record_index; */
                        phb_sim_read_record(
                            control_block->secondary_ID,
                            sim_ext_record_index,
                            phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID (control_block->secondary_ID)),
                            control_block->ID);
                    }
                    /* read complete */
                    else
                    {
                        phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
                        return;
                    }
                }

                /* Illegal length, do recovery. */
                else
                {
                    phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
                    return;
                }
            }
            /* Wrong state: this CNF is not for us. Abnormal, consume message. */
            else
            {
                kal_trace(TRACE_ERROR, ERROR_PHB_SIM_IO_STATE_READ);
                return;
            }
        }
    #endif /* __PHB_USIM_SUPPORT__ */ 

      /** 
       * Wrong state: currently it is not waiting. 
       * Abnormal, consume message.
       */
        else
        {
            kal_trace(TRACE_ERROR, ERROR_PHB_SIM_IO_STATE_READ);
            return;
        }
    }
    /* error occured, call error handler */
    else
    {
        control_block->cause = sim_read_cnf->result;
        control_block->IO_stage = IO_NONE;
        phb_IO_return(control_block, ilm_ptr, KAL_FALSE);
        return;
    }
}   /* end of phb_sim_read_cnf */


/*****************************************************************************
 * FUNCTION
 *  phb_sim_write_record
 * DESCRIPTION
 *  This function issues SIM_READ_REQ to sim.
 *  
 *  Prerequisite:
 *  data must not be NULL.
 * PARAMETERS
 *  file_idx            [IN]        
 *  record_index        [IN]        
 *  data                [?]         
 *  length              [IN]        
 *  access_id           [IN]        
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_sim_write_record(
                kal_uint16 file_idx,
                kal_uint16 record_index,
                kal_uint8 *data,
                kal_uint16 length,
                kal_uint8 access_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    sim_write_req_struct *sim_write_req;

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

    sim_write_req = (sim_write_req_struct*) construct_local_para(sizeof(sim_write_req_struct), TD_CTRL);
    sim_write_req->file_idx = file_idx;
    sim_write_req->para = (kal_uint8) record_index;

    /* Clean data before write to SIM */
    kal_mem_set(&sim_write_req->data[0], (kal_uint8) PHB_INVALID_VALUE, MAX_DATA_LEN);

    if (data != NULL)
    {
        /* Set data */
        kal_mem_cpy(&sim_write_req->data[SIM_WRITE_OFFSET], (void const*)data, length);
    }
#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_write_req->path, usim_ef_info[FILE_G_PHONEBOOK_IDX].full_path, 4);
            sim_write_req->path[4] = phb_ptr->path[type][0];
            sim_write_req->path[5] = phb_ptr->path[type][1];
        }
    }
#endif /* __USIM_SUPPORT__ */ 

    sim_write_req->length = (kal_uint8) length;
    sim_write_req->access_id = access_id;

    phb_send_ilm(MOD_SIM, MSG_ID_SIM_WRITE_REQ, sim_write_req, NULL);
}   /* end of phb_sim_write_record */


#ifdef __PHB_USIM_SUPPORT__
/*****************************************************************************
 * FUNCTION
 *  phb_sim_write_anr_segmented_record
 * DESCRIPTION
 *  This function prepares data content for the segmented part of telephone numbers then
 *  invokes sim_write_record() to write a record.
 *  
 *  Prerequisites:
 *  control_block->phb_entry must not NULL.
 *  control_block->seg_total and control_block->seg_len must be set correctly.
 * PARAMETERS
 *  control_block       [?]         
 *  anr_entry           [?]         
 *  phb_type            [IN]        
 *  chained_id          [IN]        
 * RETURNS
 *  KAL_TRUE if success, KAL_FALSE otherwise.
 *****************************************************************************/
static kal_bool phb_sim_write_anr_segmented_record(
                    control_block_type *control_block,
                    phb_anr_struct *anr_entry,
                    phb_type_enum phb_type,
                    kal_uint8 chained_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    ef_ext_type ef_ext_buffer;

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

    ASSERT(control_block != NULL);

    /* phb_entry is ensured non-NULL by caller */

    control_block->IO_stage = IO_ANR_SEGMENTATION;
    control_block->IO_cnf_receive = phb_sim_write_cnf;

    /* find if this ADN has ext1 record to write first */
    control_block->seg_record_index = phb_se_ext_index_find(control_block->record_index, phb_type);

    if (control_block->seg_record_index == (kal_uint8) PHB_INVALID_VALUE || control_block->seg_record_index == 0)
    {
        control_block->seg_record_index = (kal_uint8) phb_data_desc_find_next_free(DATA_DESC_EXT1);
        if (control_block->seg_record_index == (kal_uint8) PHB_INVALID_VALUE)
        {
            /* Error: cannot find a free record to write */
            return KAL_FALSE;
        }
    }

    /* Now prepare the data content in ext_buffer */
    kal_mem_set(&ef_ext_buffer, (kal_uint8) PHB_INVALID_VALUE, sizeof(ef_ext_type));
    ef_ext_buffer.record_type = EF_EXT_TYPE_ADDITIONAL_DATA;
    ef_ext_buffer.ext_data_length = control_block->seg_len;
    ef_ext_buffer.identifier = chained_id;

    kal_mem_cpy(
        ef_ext_buffer.ext_data,
        (void const*)&anr_entry->tel_number.addr_bcd[anr_entry->tel_number.addr_length - control_block->seg_total - control_block->seg_len],
        control_block->seg_len);
    phb_sim_write_record(
        control_block->secondary_ID,
        control_block->seg_record_index,
        (kal_uint8*) & ef_ext_buffer,
        sizeof(ef_ext_buffer),
        control_block->ID);
    return KAL_TRUE;
}   /* end of phb_sim_write_segmented_record */
#endif /* __PHB_USIM_SUPPORT__ */ 


/*****************************************************************************
 * FUNCTION
 *  phb_sim_write_segmented_record
 * DESCRIPTION
 *  This function prepares data content for the segmented part of telephone numbers then
 *  invokes sim_write_record() to write a record.
 *  
 *  Prerequisites:
 *  control_block->phb_entry must not NULL.
 *  control_block->seg_total and control_block->seg_len must be set correctly.
 * PARAMETERS
 *  control_block       [?]         
 *  type                [IN]        
 *  chained_id          [IN]        
 * RETURNS
 *  KAL_TRUE if success, KAL_FALSE otherwise.
 *****************************************************************************/
static kal_bool phb_sim_write_segmented_record(
                    control_block_type *control_block,
                    data_desc_enum type,
                    kal_uint8 chained_id)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    phb_entry_struct *phb_entry;
    ef_ext_type ef_ext_buffer;

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

    ASSERT(control_block != NULL);

    /* phb_entry is ensured non-NULL by caller */
    phb_entry = (phb_entry_struct*) control_block->data;

    control_block->IO_stage = IO_SEGMENTATION;
    control_block->IO_cnf_receive = phb_sim_write_cnf;

    /* find if this ADN has ext1 record to write first */
    control_block->seg_record_index = phb_se_get_ext_index(control_block->type, phb_entry);
    if (control_block->seg_record_index == (kal_uint8) PHB_INVALID_VALUE || control_block->seg_record_index == 0)
    {
        control_block->seg_record_index = (kal_uint8) phb_data_desc_find_next_free(type);
        if (control_block->seg_record_index == (kal_uint8) PHB_INVALID_VALUE)
        {
            /* Error: cannot find a free record to write */
            return KAL_FALSE;
        }
    }

    /* Now prepare the data content in ext_buffer */
    kal_mem_set(&ef_ext_buffer, (kal_uint8) PHB_INVALID_VALUE, sizeof(ef_ext_type));
    ef_ext_buffer.record_type = EF_EXT_TYPE_ADDITIONAL_DATA;
    ef_ext_buffer.ext_data_length = control_block->seg_len;
    ef_ext_buffer.identifier = chained_id;

    kal_mem_cpy(
        ef_ext_buffer.ext_data,
        (void const*)&phb_entry->tel_number.addr_bcd[phb_entry->tel_number.addr_length - control_block->seg_total - control_block->seg_len],
        control_block->seg_len);
    phb_sim_write_record(
        control_block->secondary_ID,
        control_block->seg_record_index,
        (kal_uint8*) & ef_ext_buffer,
        sizeof(ef_ext_buffer),
        control_block->ID);
    return KAL_TRUE;