phb_nvram_access.c

最新MTK手机软件源码

                    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;
                }
                /* Set up phb_entry->cap_cnf_id */
                phb_entry->cap_cnf_id = phb_nvram_ef.mandatory->cap_cnf_id;
            }

            /* Incorrect LENGTH field */
            else
            {
                kal_mem_set(&phb_entry->alpha_id, 0, sizeof(l4_name_struct));
                phb_entry->tel_number.addr_length = 0;
                control_block->data = NULL;
            }

            /* read 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_READ);
            return;
        }
    }
    /* error occured, call error handler */
    else
    {
        /* Accessing NVRAM is not required to return error cause */
        control_block->IO_stage = IO_NONE;
        phb_IO_return(control_block, ilm_ptr, KAL_FALSE);
        return;
    }
}   /* end of phb_nvram_read_cnf */


/*****************************************************************************
 * FUNCTION
 *  phb_nvram_read_compare_digit_cnf
 * DESCRIPTION
 *  This is phb_nvram_read_compare_digit_cnf function of PHB module.
 * PARAMETERS
 *  ilm_ptr             [IN]        The primitives
 *  control_block       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_nvram_read_compare_digit_cnf(ilm_struct *ilm_ptr, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    nvram_read_cnf_struct *nvram_read_cnf;

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

    ASSERT(control_block != NULL);

    nvram_read_cnf = (nvram_read_cnf_struct*) ilm_ptr->local_para_ptr;

    if (control_block->IO_stage == IO_WAIT &&
        (nvram_read_cnf->result == NVRAM_IO_ERRNO_OK || nvram_read_cnf->result == NVRAM_IO_ERRNO_INIT))
    {
        kal_uint16 length;
        kal_uint8 *pdu_data = (kal_uint8*) get_pdu_ptr(ilm_ptr->peer_buff_ptr, &length);

        phb_ptr->compare_digit = *pdu_data;
        if (control_block->IO_stage == IO_WAIT)
        {
            /* success */
            phb_IO_return(control_block, ilm_ptr, KAL_TRUE);
            return;
        }
    }
    /* error occured, call error handler */
    phb_ptr->compare_digit = 7;
    /* control_block->cause = sim_file_info_cnf->result; */
    phb_IO_return(control_block, ilm_ptr, KAL_FALSE);
    return;
}   /* end of phb_nvram_read_cnf */


/*****************************************************************************
 * FUNCTION
 *  phb_nvram_read_compare_digit
 * DESCRIPTION
 *  This is phb_nvram_read_compare_digit function of PHB module.
 * PARAMETERS
 *  control_block       [?]         
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
void phb_nvram_read_compare_digit(control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    /* kal_bool result = KAL_FALSE; */

    /* kal_trace(TRACE_FUNC, FUNC_PHB_NVRAM_READ); */
    nvram_read_req_struct *nvram_read_req;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    ASSERT(control_block != NULL);

    /* if (control_block->IO_stage == IO_NONE) */

    control_block->IO_stage = IO_WAIT;
    control_block->IO_cnf_receive = phb_nvram_read_compare_digit_cnf;
    nvram_read_req = (nvram_read_req_struct*) construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL);
    nvram_read_req->file_idx = NVRAM_EF_PHB_COMPARE_DIGIT_LID;
    nvram_read_req->para = 1;
    nvram_read_req->access_id = control_block->ID;
    nvram_read_req->rec_amount = 1;
    phb_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_READ_REQ, nvram_read_req, NULL);
    /* result = KAL_TRUE; */
    /* Abnormal, return false */
    /* else */
}   /* end of phb_nvram_read */


/*****************************************************************************
 * FUNCTION
 *  phb_nvram_write_record
 * DESCRIPTION
 *  This function issues NVRAM_WRITE_REQ to nvram.
 * PARAMETERS
 *  file_idx            [IN]        
 *  record_index        [IN]        
 *  access_id           [IN]        
 *  peer_buf_ptr        [?]         
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_nvram_write_record(
                kal_uint16 file_idx,
                kal_uint16 record_index,
                kal_uint8 access_id,
                peer_buff_struct *peer_buf_ptr)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    nvram_write_req_struct *nvram_write_req;

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

    nvram_write_req = (nvram_write_req_struct*) construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL);
    nvram_write_req->file_idx = (kal_uint8) file_idx;
    nvram_write_req->para = record_index;
    nvram_write_req->access_id = access_id;

    phb_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_WRITE_REQ, nvram_write_req, peer_buf_ptr);
}   /* end of phb_nvram_write_record */


/*****************************************************************************
 * FUNCTION
 *  phb_nvram_write
 * DESCRIPTION
 *  This function issues NVRAM_WRITE_REQ to sim.
 *  
 *  Prerequisite:
 *  control_block must be constructed, phb_control_block_set_IO(), and phb_se_set_control_block().
 *  So that primary_ID, secondary_ID, index and record_index are all set.
 * PARAMETERS
 *  control_block       [?]         
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
kal_bool phb_nvram_write(control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool result = KAL_FALSE;

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

    ASSERT(control_block != NULL);

    if (control_block->IO_stage == IO_NONE)
    {
        data_desc_enum type;
        phb_entry_struct *phb_entry;

        /* Nothing to write? error! */
        if ((phb_entry = (phb_entry_struct*) control_block->data) == NULL)
        {
            result = KAL_FALSE;
        }

        else if ((control_block->primary_ID != (kal_uint16) PHB_INVALID_VALUE) &&
                 ((type = phb_data_desc_get_desc_by_ID(control_block->primary_ID)) !=
                  (data_desc_enum) PHB_INVALID_VALUE))
        {
            peer_buff_struct *peer_buf_ptr;
            kal_uint8 *pdu_ptr;
            kal_uint16 pdu_length;

            control_block->IO_stage = IO_WAIT;
            control_block->IO_cnf_receive = phb_nvram_write_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);

         /**
          * Truncate bytes exceeds maximum capacity!!
          *
          * addr_length needs not to be restored, since it just reflects 
          * what is written actually. 
          */
            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;
            }

            control_block->seg_total = 0;

            if (phb_nvram_prepare_data_to_write(control_block, pdu_ptr) == KAL_FALSE)
            {
                return KAL_FALSE;
            }

            /* Preparation of data content complete! */

            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_write */


/*****************************************************************************
 * FUNCTION
 *  phb_nvram_write_cnf
 * DESCRIPTION
 *  This function issues NVRAM_READ_REQ to sim.
 * PARAMETERS
 *  ilm_ptr             [IN]        The primitives
 *  control_block       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_nvram_write_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_WRITE_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)
        {
            /* Write 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_WRITE);
            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_write_cnf */


/*****************************************************************************
 * FUNCTION
 *  phb_nvram_delete
 * DESCRIPTION
 *  This function issues NVRAM_WRITE_REQ to sim.
 *  
 *  Prerequisite:
 *  control_block must be constructed, phb_control_block_set_IO(), and phb_se_set_control_block().
 *  So that primary_ID, secondary_ID, index and record_index are all set.
 * PARAMETERS
 *  control_block       [?]         
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
kal_bool phb_nvram_delete(control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_bool result = KAL_FALSE;

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

    ASSERT(control_block != NULL);

    if (control_block->IO_stage == IO_NONE)
    {
        data_desc_enum type;
        phb_entry_struct *phb_entry;

        phb_entry = (phb_entry_struct*) control_block->data;

        if ((control_block->primary_ID != (kal_uint16) PHB_INVALID_VALUE) &&
            ((type = phb_data_desc_get_desc_by_ID(control_block->primary_ID)) != (data_desc_enum) PHB_INVALID_VALUE))
        {
            peer_buff_struct *peer_buf_ptr;
            kal_uint8 *pdu_ptr;