phb_nvram_access.c

最新MTK手机软件源码

            kal_uint16 pdu_length;

            control_block->IO_stage = IO_WAIT;
            control_block->IO_cnf_receive = phb_nvram_delete_cnf;

         /**
          * Find the Number of bits that has to be used by the packed 
          * structure. Since the lenght is in number of bits, we have 
          * to convert that into number of octets 
          */
            pdu_length = control_block->length;

            /* Construct peer buffer */
            peer_buf_ptr = construct_peer_buff(pdu_length, 0, 0, TD_CTRL);
            pdu_ptr = get_pdu_ptr(peer_buf_ptr, &pdu_length);

            kal_mem_set(pdu_ptr, (kal_uint8) PHB_INVALID_VALUE, pdu_length);

            phb_nvram_write_record(
                control_block->primary_ID,
                control_block->record_index,
                control_block->ID,
                peer_buf_ptr);
            result = KAL_TRUE;
        }
        /* Error */
        else
        {
            result = KAL_FALSE;
        }

    }
    /* Abnormal, return false */
    else
    {
        result = KAL_FALSE;
    }

    return result;
}   /* end of phb_nvram_delete */


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

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

    ASSERT(control_block != NULL);

    nvram_write_cnf = (nvram_write_cnf_struct*) ilm_ptr->local_para_ptr;

    if ((nvram_write_cnf->result == NVRAM_IO_ERRNO_OK) || (nvram_write_cnf->result == NVRAM_IO_ERRNO_INIT))
    {
        if (control_block->IO_stage == IO_WAIT)
        {
            /* Delete complete */
            phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
            return;
        }
      /** 
       * Wrong state: currently it is not waiting. 
       * Abnormal, consume message.
       */
        else
        {
            kal_trace(TRACE_ERROR, ERROR_PHB_NVRAM_IO_STATE_DELETE);
            return;
        }
    }
    /* error occured, call error handler */
    else
    {
        /* Accessing NVRAM is not required to return error cause */

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


/*****************************************************************************
 * FUNCTION
 *  phb_nvram_prepare_data_to_write
 * DESCRIPTION
 *  Prepare data stored in given phb_entry_struct to approprieate structure
 *  for raw data to write, depending on it is written to SIM or NVRAM.
 *  
 *  Prerequisite:
 *  1. phb_entry->tel_number.addr_length must be set.
 *  2. control_block->seg_total must be set.
 *  3. control_block->length must be set.
 * PARAMETERS
 *  control_block       [?]     
 *  buffer              [?]     
 * RETURNS
 *  Return corresponding sim_file_id of data descriptor type
 *****************************************************************************/
kal_bool phb_nvram_prepare_data_to_write(control_block_type *control_block, kal_uint8 *buffer)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    phb_nvram_ef_mandatory_struct *phb_nvram_ef_mandatory = NULL;
    phb_entry_struct *phb_entry = (phb_entry_struct*) control_block->data;

    kal_uint8 alpha_id_length = 0;
    kal_uint8 tel_number_size = 0;

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

    /* Referenced control_block shall not be NULL) */
    ASSERT(control_block != NULL);

    alpha_id_length = control_block->length - NVRAM_PHB_LENGTH_AFTER_ALPHA_ID;
    kal_mem_set(buffer, 0xFF, control_block->length);

    /* Now prepare the data content */
    if (phb_entry->alpha_id.name_length > 0)
    {
        istring_type istr;

        istr.length = phb_entry->alpha_id.name_length;
        istr.charset = phb_entry->alpha_id.name_dcs;
        istr.data = &phb_entry->alpha_id.name[0];

        /* Error occured when encoding alph-id field */
        if (istring_encode_to_sim(CODING_AUTO, (istring_type*) & istr, alpha_id_length, buffer) == 0)
        {
            return KAL_FALSE;
        }
    }

    phb_nvram_ef_mandatory = (phb_nvram_ef_mandatory_struct*) & buffer[alpha_id_length];

   /**
    * Truncate requested DIALLING_NUMBER/SSC_STRING, if necessary,
    * before storing it into NVRAM.
    */
    if (phb_entry->tel_number.addr_length == 1) /* Empty number */
    {
        /* "+" character */
        if (phb_entry->tel_number.addr_bcd[L4_ADDR_BCD_TON_NPI_OFFSET] == 0x91)
        {
            phb_nvram_ef_mandatory->len = 1;
            phb_nvram_ef_mandatory->ton_npi = 0x91;
        }
        else
        {
            phb_nvram_ef_mandatory->len = 0xff;
            phb_nvram_ef_mandatory->ton_npi = 0xff;
        }
        kal_mem_set((kal_uint8*) phb_nvram_ef_mandatory->tel_number, 0xff, NVRAM_EF_TEL_NUMBER_SIZE);
    }
    else
    {
        if (phb_entry->tel_number.addr_length > NVRAM_PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN)
        {
            phb_entry->tel_number.addr_length = NVRAM_PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN;
        }

        /* LENGTH */
        phb_nvram_ef_mandatory->len = phb_entry->tel_number.addr_length;
        if (phb_nvram_ef_mandatory->len > 0)
        {
            tel_number_size = phb_nvram_ef_mandatory->len - 1;  /* amanda change */
        }
        /* TON/NPI */
        phb_nvram_ef_mandatory->ton_npi = phb_entry->tel_number.addr_bcd[L4_ADDR_BCD_TON_NPI_OFFSET];
        /* DIALLING_NUMBER/SSC_STRING */
        kal_mem_cpy(
            &phb_nvram_ef_mandatory->tel_number[0],
            (void const*)&phb_entry->tel_number.addr_bcd[L4_ADDR_BCD_TEL_NUM_OFFSET],
            tel_number_size);
    }
    phb_nvram_ef_mandatory->cap_cnf_id = phb_entry->cap_cnf_id;

    return KAL_TRUE;
}   /* end of phb_is_type_valid */


/*****************************************************************************
 * FUNCTION
 *  phb_read_ln_from_nvram
 * DESCRIPTION
 *  
 * PARAMETERS
 *  control_block       [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void phb_read_ln_from_nvram(control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    nvram_read_req_struct *param_ptr;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    control_block->IO_stage = IO_WAIT;
    param_ptr = (nvram_read_req_struct*) construct_local_para((kal_uint16) sizeof(nvram_read_req_struct), TD_CTRL);

    param_ptr->file_idx = NVRAM_EF_PHB_LN_ENTRY_LID;
    param_ptr->para = control_block->secondary_ID;
    param_ptr->access_id = control_block->ID;

    phb_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_READ_REQ, param_ptr, NULL);
}


/*****************************************************************************
 * FUNCTION
 *  phb_write_ln_to_nvram
 * DESCRIPTION
 *  
 * PARAMETERS
 *  pdu_data            [?]     
 *  control_block       [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void phb_write_ln_to_nvram(nvram_ef_phb_ln_struct *pdu_data, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint16 len;
    nvram_write_req_struct *param_ptr;
    peer_buff_struct *peer_buff_ptr = NULL;
    nvram_ef_phb_ln_struct *pdu_stream_ptr, *record;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    control_block->IO_stage = IO_WAIT;

    param_ptr = (nvram_write_req_struct*) construct_local_para((kal_uint16) sizeof(nvram_write_req_struct), TD_CTRL);

    param_ptr->file_idx = NVRAM_EF_PHB_LN_ENTRY_LID;
    param_ptr->para = control_block->secondary_ID;
    param_ptr->access_id = control_block->ID;

    peer_buff_ptr = (peer_buff_struct*) construct_peer_buff(
                                            sizeof(nvram_ef_phb_ln_struct),
                                            0,  /* no header */
                                            0,  /* no tail */
                                            TD_DL);

    pdu_stream_ptr = (nvram_ef_phb_ln_struct*) get_pdu_ptr(peer_buff_ptr, &len);

    if (pdu_data != NULL)
    {
        kal_mem_cpy(pdu_stream_ptr, pdu_data, sizeof(nvram_ef_phb_ln_struct));
    }
    else
    {
        record = (nvram_ef_phb_ln_struct*) get_pdu_ptr((peer_buff_struct*) control_block->data, &len);
        kal_mem_cpy(pdu_stream_ptr, record, sizeof(nvram_ef_phb_ln_struct));
    }

    phb_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_WRITE_REQ, param_ptr, peer_buff_ptr);
}

#ifdef __PHB_RECORD_LN_TYPE_SEQ__


/*****************************************************************************
 * FUNCTION
 *  phb_write_ln_type_seq_to_nvram
 * DESCRIPTION
 *  
 * PARAMETERS
 *  control_block       [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void phb_write_ln_type_seq_to_nvram(control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    /* nvram_ef_phb_ln_type_seq_struct *pdu_data = NULL; */
    kal_uint16 len;
    kal_uint8 i;
    nvram_write_req_struct *param_ptr;
    peer_buff_struct *peer_buff_ptr = NULL;
    nvram_ef_phb_ln_type_seq_struct *record;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    control_block->IO_stage = IO_WAIT;

    param_ptr = (nvram_write_req_struct*) construct_local_para((kal_uint16) sizeof(nvram_write_req_struct), TD_CTRL);

    param_ptr->file_idx = NVRAM_EF_PHB_LN_TYPE_SEQ_LID;
    param_ptr->para = 1;
    param_ptr->access_id = control_block->ID;

    peer_buff_ptr = (peer_buff_struct*) construct_peer_buff(
                                            sizeof(nvram_ef_phb_ln_type_seq_struct),
                                            0,  /* no header */
                                            0,  /* no tail */
                                            TD_DL);

    /* control_block->data = (kal_uint8 *)peer_buff_ptr; */

    //record = (nvram_ef_phb_ln_type_seq_struct *)
    //   get_pdu_ptr ((peer_buff_struct *)control_block->data, &len);
    record = (nvram_ef_phb_ln_type_seq_struct*) get_pdu_ptr(peer_buff_ptr, &len);

    for (i = 0; i < PHB_TOTAL_LN_ENTRIES; i++)
    {
        record->type_seq[i] = phb_ln_type_seq[i];
    }
    phb_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_WRITE_REQ, param_ptr, peer_buff_ptr);
}


/*****************************************************************************
 * FUNCTION
 *  phb_read_ln_type_seq_from_nvram
 * DESCRIPTION
 *  
 * PARAMETERS
 *  control_block       [?]     
 * RETURNS
 *  void
 *****************************************************************************/
void phb_read_ln_type_seq_from_nvram(control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    nvram_read_req_struct *param_ptr;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    control_block->IO_stage = IO_WAIT;
    param_ptr = (nvram_read_req_struct*) construct_local_para((kal_uint16) sizeof(nvram_read_req_struct), TD_CTRL);

    param_ptr->file_idx = NVRAM_EF_PHB_LN_TYPE_SEQ_LID;
    param_ptr->para = control_block->secondary_ID;
    param_ptr->access_id = control_block->ID;

    phb_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_READ_REQ, param_ptr, NULL);
}
#endif /* __PHB_RECORD_LN_TYPE_SEQ__ */