phb_handler_read.c

最新MTK手机软件源码

/*****************************************************************************
*  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:
 * ---------
 * phb_handler_read.c
 *
 * Project:
 * --------
 *   MAUI
 *
 * Description:
 * ------------
 *   This is startup handler of PHB module.
 *
 * Author:
 * -------
 * -------
 *
 *============================================================================
 *             HISTORY
 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *------------------------------------------------------------------------------
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 *
 *
 * removed!
 * removed!
 *
 *
 * removed!
 * removed!
 *
 *
 *------------------------------------------------------------------------------
 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *============================================================================
 ****************************************************************************/
#include "kal_release.h"        /* Basic data type */

#include "stack_common.h"
#include "stack_msgs.h"
#include "app_ltlcom.h" /* Task message communiction */
#include "app_buff_alloc.h"

#include "kal_trace.h"
#include "phb_trc.h"

#include "sim_common_enums.h"
// #include "nvram_editor_data_item.h"
#include "custom_nvram_editor_data_item.h"
#include "nvram_struct.h"
#include "nvram_enums.h"

#include "l4_common.h"
#include "ps2sim_struct.h"

#include "l4c2phb_enums.h"
#include "l4c2phb_struct.h"

/* Prerequisite of phb_context.h */
#include "phb_defs.h"
#include "phb_control_block.h"
#include "phb_data_desc.h"
#include "phb_data_entry_table.h"
#include "phb_pindex.h"
#include "phb_name_num_index.h"

#include "phb_context.h"
#include "phb_se.h"

#include "phb_common.h"
#include "phb_utils.h"
#include "phb_ilm.h"
/* SIM access */
#include "phb_sim_access.h"
/* NVRAM access */
#include "phb_nvram_access.h"

#include "phb_handler_read.h"

#include "phb_sap.h"
#include "phb_se.h"

#undef  _FILE_CODE_
#define _FILE_CODE_ _PHB_HANDLER_READ_C_

static void phb_read_err_handler(ilm_struct *ilm_ptr, control_block_type *control_block);
static void phb_read_confirm(
                phb_errno_enum result,
                kal_uint16 actual_count,
                kal_uint8 src_id,
                msg_type cnf_msg_id,
                control_block_type *control_block);
static kal_bool phb_is_read_param_valid(l4cphb_read_req_struct *l4cphb_read_req);

static void phb_read_ln_confirm(
                phb_errno_enum result,
                nvram_ef_phb_ln_struct *record2,
                kal_uint8 src_id,
                control_block_type *control_block);


/*****************************************************************************
 * FUNCTION
 *  phb_read_handler
 * DESCRIPTION
 *  This is phb_read_handler function of PHB module.
 *  Read SOP:
 *  phb_control_block_set_param(),
 *  phb_control_block_set(),
 *  phb_control_block_set_IO(),
 *  se_control_block()
 * PARAMETERS
 *  ilm_ptr             [IN]        The primitives
 *  control_block       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
void phb_read_handler(ilm_struct *ilm_ptr, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

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

    if (ilm_ptr != NULL)
    {
        l4cphb_read_req_struct *l4cphb_read_req;

        l4cphb_read_req = (l4cphb_read_req_struct*) ilm_ptr->local_para_ptr;

        /* Cannot allocate, means that PHB is still operating. Reject request! */
        control_block = phb_alloc_control_block();
        if (control_block == NULL)
        {
            phb_read_confirm(PHB_ERRNO_BUSY, 0, l4cphb_read_req->src_id, ilm_ptr->msg_id, control_block);
            return;
        }

        control_block->src_id = l4cphb_read_req->src_id;
        /* Retain msg_id */
        control_block->cnf_msg_id = ilm_ptr->msg_id;

        if (phb_ptr->state == PHB_STATE_READY)
        {
            if (control_block->proc_stage == READ_NONE)
            {
                l4cphb_phb_entry_array_struct *phb_entry_array;
                phb_entry_struct *phb_entry;
                peer_buff_struct *peer_buf_ptr;

                /* Invalid parameters */
                if (phb_is_read_param_valid(l4cphb_read_req) == KAL_FALSE)
                {
                    control_block->actual_count = 0;
                    control_block->cause = PHB_ERRNO_READ_EMPTY;
                    phb_read_confirm(
                        PHB_ERRNO_READ_EMPTY,
                        control_block->actual_count,
                        control_block->src_id,
                        control_block->cnf_msg_id,
                        control_block);
                    return;
                }

                /* If request total is 0, or nothing can be read, return READ_SUCCESS with total = 0 */
                if (l4cphb_read_req->total == 0)
                {
                    control_block->actual_count = 0;
                    control_block->cause = PHB_ERRNO_READ_EMPTY;
                    phb_read_confirm(
                        PHB_ERRNO_READ_EMPTY,
                        control_block->actual_count,
                        control_block->src_id,
                        control_block->cnf_msg_id,
                        control_block);
                    return;
                }

            /**
             * Read SOP:
             * phb_control_block_set_param(),
             * phb_control_block_set(),
             * phb_control_block_set_IO(),
             * se_control_block()
             */
                control_block->total = l4cphb_read_req->total;
                phb_entry_array =
                    (l4cphb_phb_entry_array_struct*) l4cphb_alloc_peer_buf(&peer_buf_ptr, control_block->total);
                control_block->need_free_peer = KAL_TRUE;
                phb_control_block_set_param(control_block, READ_CONTINUE, NULL, peer_buf_ptr);

                phb_entry = &phb_entry_array->array[0];

                if (l4cphb_read_req->type == PHB_ECC)
                {
                    kal_uint8 i;
                    kal_uint8 index = (kal_uint8) l4cphb_read_req->index - 1;
                    phb_entry_struct *phb_entry_ith = phb_entry;

                    control_block->type = PHB_ECC;
                    control_block->total = 0;

                    /* phb_ptr->ecc.num_ecc now contains number of records */
                    for (i = index; (i < phb_ptr->ecc.num_ecc) && (control_block->total < l4cphb_read_req->total); ++i)
                    {
                        kal_uint16 len;

                        phb_entry_ith->storage = PHB_SIM;

                        len = bcd_len(&phb_ptr->ecc.ecc[i * NUM_OF_BYTE_ECC], NUM_OF_BYTE_ECC);
                        len = (len + 1) >> 1;

                        phb_entry_ith->tel_number.addr_length = len + L4_ADDR_BCD_TON_NPI_SIZE;
                        phb_entry_ith->tel_number.addr_bcd[L4_ADDR_BCD_TON_NPI_OFFSET] = TON_NPI_DEFAULT;
                        kal_mem_cpy(
                            &phb_entry_ith->tel_number.addr_bcd[L4_ADDR_BCD_TEL_NUM_OFFSET],
                            (void const*)&phb_ptr->ecc.ecc[i * NUM_OF_BYTE_ECC],
                            len);

                        ++control_block->total;
                        phb_entry_ith->tel_number.addr_bcd[phb_entry_ith->tel_number.addr_length] = 0xff;
                        ++phb_entry_ith;
                    }
                    phb_entry_array->no_array = (kal_uint8) (control_block->actual_count = control_block->total);

                    phb_read_confirm(
                        PHB_ERRNO_READ_SUCCESS,
                        control_block->actual_count,
                        control_block->src_id,
                        control_block->cnf_msg_id,
                        control_block);
                    return;
                }
                else
                {
                    phb_control_block_set(
                        control_block,
                        phb_read_continue,
                        phb_read_handler,
                        phb_read_err_handler,
                        READ_NONE);
                    /* This function sets actual_count */
                    phb_control_block_set_IO(
                        control_block,
                        l4cphb_read_req->type,
                        l4cphb_read_req->index,
                        l4cphb_read_req->total);

                    /* Set proc_stage, storage, record_index, primary_ID, and secondary_ID */
                    if (phb_se_set_control_block(
                            control_block,
                            OP_READ,
                            l4cphb_read_req->storage,
                            l4cphb_read_req->record_index) == KAL_FALSE)
                    {
                        phb_read_err_handler(NULL, control_block);
                        return;
                    }
                    control_block->data = (kal_uint8*) phb_entry;
                    control_block->length = phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID(control_block->primary_ID));

                    phb_read_continue(NULL, control_block);
                }
            }
            /* error */
            else
            {
                phb_read_err_handler(NULL, control_block);
                return;
            }
        }
        /* error */
        else
        {
            kal_trace(TRACE_ERROR, ERROR_PHB_STATE);

            control_block->actual_count = 0;
            phb_read_confirm(
                PHB_ERRNO_NOT_READY,
                control_block->actual_count,
                control_block->src_id,
                control_block->cnf_msg_id,
                control_block);
            return;
        }

    }
    else
    {
        if (control_block->proc_stage == READ_CONTINUE)
        {
            phb_read_confirm(
                PHB_ERRNO_READ_SUCCESS,
                control_block->actual_count,
                control_block->src_id,
                control_block->cnf_msg_id,
                control_block);
        }
        else if (control_block->proc_stage == READ_CONTINUE_SPECIFIC)
        {
            if (control_block->data == NULL)
            {
                phb_read_confirm(
                    PHB_ERRNO_READ_EMPTY,
                    control_block->actual_count,
                    control_block->src_id,
                    control_block->cnf_msg_id,
                    control_block);
            }
            else
            {
                phb_read_confirm(
                    PHB_ERRNO_READ_SUCCESS,
                    control_block->actual_count,
                    control_block->src_id,
                    control_block->cnf_msg_id,