phb_handler_startup.c

最新MTK手机软件源码

            l4cphb_startup_req_struct *l4cphb_startup_req;
            l4cphb_startup_req = (l4cphb_startup_req_struct*) ilm_ptr->local_para_ptr;

         /**
          * Since startup is an implicit reset, there 2 ways to implement this:
          *
          * 1. Forbidden other operations to PHB except approve and search:
          *   In this implementation,
          *   startup handler should always uses the first control_block,
          *   and lock all control_blocks are locked temporarily;
          *   thus prevent other operations, except approve and search,
          *   from accessing PHB while it is busy.
          *
          * 2. Allow all other operations to provide maximum possible
          *   concurrency degrees.
          *
          * Curretly, solution 1 is implemented.
          * Control_blocks are all locked to interrupt all other in-processing
          * operations and reject all further requests, to prevent
          * multiple access to PHB when it is not ready.
          *
          * However, FDN is required to be approved even when PHB
          * is not ready. That means a control_block is required to
          * approve an FDN, even during startup procedure, which locks
          * all control_blocks. To solve this problem, solution 1 cannot
          * be adopted directly. The modified solution is:
          *
          * 1. Reset all control block which stops all current actions.
          * 2. Allocate one control block for startup procedure, and
          *   allows FDN approval only. All other request will be
          *   rejected even a free control block is found, since
          *   PHB state is not ready.
          */

            control_block = phb_alloc_control_block();
            ASSERT(control_block != NULL);

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

            phb_ptr->dn_type = l4cphb_startup_req->dn_type;

            kal_trace(TRACE_INFO, INFO_PHB_STARTUP_MODE, phb_ptr->dn_type);

            /* Send begin indication to MMI, MMI will clear it's variable and reload phonebook. */
            phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_STARTUP_BEGIN_IND, NULL, NULL);

            if (nvram_get_info(NVRAM_EF_PHB_LID, &phb_total, &phb_size) == NVRAM_ERRNO_SUCCESS)
            {
                phb_data_desc_set_is_support(DATA_DESC_PHB, KAL_TRUE);

            /*
             * MAX_ENTRIES_COUNT must NOT be exceeded. See comment
             * of phb_get_info_set_value() for detail.
             */
                if (phb_total > NVRAM_PHB_INDEX_MAX_ENTRIES_COUNT)
                {
                    phb_total = NVRAM_PHB_INDEX_MAX_ENTRIES_COUNT;
                }
                phb_data_desc_set(DATA_DESC_PHB, phb_total, phb_size);
            }
            else
            {
                phb_data_desc_set_is_support(DATA_DESC_PHB, KAL_FALSE);
            }

            phb_data_desc_set_is_support(
                DATA_DESC_ADN,
                (kal_bool) ((sim_service_table_query(SERVICE_ADN) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));
            phb_data_desc_set_is_support(
                DATA_DESC_FDN,
                (kal_bool) ((sim_service_table_query(SERVICE_FDN) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));
            phb_data_desc_set_is_support(
                DATA_DESC_BDN,
                (kal_bool) ((sim_service_table_query(SERVICE_BDN) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));
            phb_data_desc_set_is_support(
                DATA_DESC_MSISDN,
                (kal_bool) ((sim_service_table_query(SERVICE_MSISDN) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));
            phb_data_desc_set_is_support(
                DATA_DESC_SDN,
                (kal_bool) ((sim_service_table_query(SERVICE_SDN) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));
            phb_data_desc_set_is_support(
                DATA_DESC_EXT1,
                (kal_bool) ((sim_service_table_query(SERVICE_EXT1) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));
            phb_data_desc_set_is_support(
                DATA_DESC_EXT2,
                (kal_bool) ((sim_service_table_query(SERVICE_EXT2) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));
            phb_data_desc_set_is_support(
                DATA_DESC_EXT3,
                (kal_bool) ((sim_service_table_query(SERVICE_EXT3) == SERVICE_SUPPORT) ? KAL_TRUE : KAL_FALSE));

            control_block->proc_stage = startup_info_size_nvram;
            phb_get_info(ilm_ptr, control_block);
        }
        else
        {
            kal_trace(TRACE_ERROR, ERROR_PHB_STATE);
            return;
        }
    }
    else
    {
        kal_trace(TRACE_INFO, INFO_PHB_FILE_INFO_GOT);
        kal_trace(TRACE_INFO, INFO_PHB_INDICES_BEGIN);

        /* SIM ECC */
        if (control_block->proc_stage == startup_info_compare_digit)
        {
        #ifdef __USIM_SUPPORT__
            if (is_usim_type())
            {
                phb_ptr->ecc.num_ecc = 0;
                control_block->primary_ID = FILE_U_ECC_IDX;
            }
            else
        #endif /* __USIM_SUPPORT__ */ 
                control_block->primary_ID = FILE_ECC_IDX;
            control_block->secondary_ID = PHB_NULL_VALUE;
            phb_control_block_set(
                control_block,
                phb_read_ecc,
                phb_startup_handler,
                phb_startup_err_handler,
                startup_build_ecc_index);
        #ifdef __USIM_SUPPORT__
            if (is_usim_type() && phb_ptr->data_desc[DATA_DESC_ECC].record_num)
            {
                /* USIM ECC is linear fixed */
                control_block->record_index = 1;
                control_block->length = phb_ptr->data_desc[DATA_DESC_ECC].record_size;
                phb_control_block_set_IO(control_block, PHB_ECC, 1, phb_ptr->data_desc[DATA_DESC_ECC].record_num);
                control_block->storage = PHB_SIM;
                phb_read_ecc(NULL, control_block);
            }
            else if (!is_usim_type() && phb_ptr->ecc.num_ecc > 0)
        #else
            if (phb_ptr->ecc.num_ecc > 0)
        #endif /* __USIM_SUPPORT__ */ 
            {
            /**
             * SIM ECC is transparent,
             * hence index(para of SIM_READ_REQ means offset) must be 0
             */
                control_block->record_index = 0;
                control_block->length = phb_ptr->ecc.num_ecc;
                phb_control_block_set_IO(control_block, PHB_ECC, 0, 1);
                control_block->storage = PHB_SIM;
                phb_read_ecc(NULL, control_block);
            }
            /* This type of phone book data is not supported by storage. Continue next step */
            else
            {
                phb_startup_handler(NULL, control_block);
            }
        }

        /* SIM FDN */
      /**
       * Handling of FDN is a special case.
       * In current implementation,once reading a record of an EF failed,
       * PHB stops reading that EF and continues next step immediately.
       *
       * However, even when PHB is not ready, approval FDN should be
       * available as soon as FDN is scanned. Consider error reading FDN
       * records, building index and state transition for FDN is needed either
       * successful case (in phb_build_index())
       * or reading fail case (in phb_startup_err_handler()).
       */
        else if ((control_block->proc_stage <= startup_build_ecc_index) &&
                 (phb_ptr->data_desc[DATA_DESC_FDN].is_support))
        {
         /**
          * Once FDN index building finished, state will be transit to FDN_READY.
          * Note that PHB is not ready at this moment
          */
            control_block->primary_ID = FILE_FDN_IDX;
            control_block->secondary_ID = FILE_EXT2_IDX;
            phb_control_block_set(
                control_block,
                phb_build_index,
                phb_startup_handler,
                phb_startup_err_handler,
                startup_build_fdn_index);
            if (phb_ptr->data_desc[DATA_DESC_FDN].record_num > 0)
            {
                control_block->record_index = 1;
                control_block->data = (void*)&control_block->temp_entry;
                control_block->length = phb_ptr->data_desc[DATA_DESC_FDN].record_size;
                phb_control_block_set_IO(control_block, PHB_FDN, 1, phb_ptr->data_desc[DATA_DESC_FDN].record_num);
                control_block->storage = PHB_SIM;
                phb_build_index(NULL, control_block);
            }
            /* This type of phone book data is not supported by storage. Continue next step */
            else
            {
                phb_startup_handler(NULL, control_block);
            }
        }

        else if ((control_block->proc_stage <= startup_build_fdn_index) &&
                 (phb_ptr->data_desc[DATA_DESC_PHB].is_support))
        {
            control_block->primary_ID = NVRAM_EF_PHB_LID;
            control_block->secondary_ID = PHB_NULL_VALUE;
            phb_control_block_set(
                control_block,
                phb_build_index,
                phb_startup_handler,
                phb_startup_err_handler,
                startup_build_phb_index);
            if (phb_ptr->data_desc[DATA_DESC_PHB].record_num > 0)
            {
                control_block->record_index = 1;
                control_block->data = (void*)&control_block->temp_entry;
                control_block->length = phb_data_desc_get_record_size(DATA_DESC_PHB);
                phb_control_block_set_IO(control_block, PHB_PHONEBOOK, 1, phb_ptr->data_desc[DATA_DESC_PHB].record_num);
                control_block->storage = PHB_NVRAM;
                phb_build_index(NULL, control_block);
            }
            /* This type of phone book data is not supported by storage. Continue next step */
            else
            {
                phb_startup_handler(NULL, control_block);
            }
        }

        /* SIM ADN */
        else if ((control_block->proc_stage <= startup_build_phb_index) &&
                 (phb_ptr->data_desc[DATA_DESC_ADN].is_support))
        {
        #ifdef __USIM_SUPPORT__
            if (is_usim_type())
            {
                control_block->primary_ID = FILE_G_ADN_IDX;
                kal_mem_cpy(control_block->path, usim_ef_info[FILE_G_PHONEBOOK_IDX].full_path, 4);
                control_block->path[4] = phb_ptr->path[DATA_DESC_ADN][0];
                control_block->path[5] = phb_ptr->path[DATA_DESC_ADN][1];
                control_block->secondary_ID = FILE_G_EXT1_IDX;
            }
            else
        #endif /* __USIM_SUPPORT__ */ 
            {
                control_block->primary_ID = FILE_ADN_IDX;
                control_block->secondary_ID = FILE_EXT1_IDX;
            }
            phb_control_block_set(
                control_block,
                phb_build_index,
                phb_startup_handler,
                phb_startup_err_handler,
                startup_build_adn_index);
            if (phb_ptr->data_desc[DATA_DESC_ADN].record_num > 0)
            {
                control_block->record_index = 1;
                control_block->data = (void*)&control_block->temp_entry;
                control_block->length = phb_ptr->data_desc[DATA_DESC_ADN].record_size;
                phb_control_block_set_IO(control_block, PHB_PHONEBOOK, 1, phb_ptr->data_desc[DATA_DESC_ADN].record_num);
                control_block->storage = PHB_SIM;
                phb_build_index(NULL, control_block);
            }
            /* This type of phone book data is not supported by storage. Continue next step */
            else
            {
                phb_startup_handler(NULL, control_block);
            }
        }

        /* SIM BDN */
        else if ((control_block->proc_stage <= startup_build_adn_index) &&
                 (phb_ptr->data_desc[DATA_DESC_BDN].is_support))
        {
            control_block->primary_ID = FILE_BDN_IDX;
            control_block->secondary_ID = FILE_EXT3_IDX;
            phb_control_block_set(
                control_block,
                phb_build_index,
                phb_startup_handler,
                phb_startup_err_handler,
                startup_build_bdn_index);
            if (phb_ptr->data_desc[DATA_DESC_BDN].record_num > 0)
            {
                control_block->record_index = 1;
                control_block->data = (void*)&control_block->temp_entry;
                control_block->length = phb_ptr->data_desc[DATA_DESC_BDN].record_size;
                phb_control_block_set_IO(control_block, PHB_BDN, 1, phb_ptr->data_desc[DATA_DESC_BDN].record_num);
                control_block->storage = PHB_SIM;
                phb_build_index(NULL, control_block);
            }
            /* This type of phone book data is not supported by storage. Continue next step */
            else
            {
                phb_startup_handler(NULL, control_block);
            }
        }

        /* SIM EXT1 */
        else if ((control_block->proc_stage <= startup_build_bdn_index) &&
                 (phb_ptr->data_desc[DATA_DESC_EXT1].is_support))
        {
        #ifdef __USIM_SUPPORT__
            if (is_usim_type())
            {
                control_block->primary_ID = FILE_G_EXT1_IDX;
                kal_mem_cpy(control_block->path, usim_ef_info[FILE_G_PHONEBOOK_IDX].full_path, 4);
                control_block->path[4] = phb_ptr->path[DATA_DESC_EXT1][0];
                control_block->path[5] = phb_ptr->path[DATA_DESC_EXT1][1];
            }
            else
        #endif /* __USIM_SUPPORT__ */ 
                control_block->primary_ID = FILE_EXT1_IDX;
            control_block->secondary_ID = (kal_uint16) PHB_INVALID_VALUE;
            phb_control_block_set(
                control_block,
                phb_build_index,
                phb_startup_handler,
                phb_startup_err_handler,
                startup_build_ext1_index);
            if (phb_ptr->data_desc[DATA_DESC_EXT1].record_num > 0)
            {
                control_block->record_index = 1;
                control_block->data = (void*)&control_block->temp_entry;
                control_block->length = phb_ptr->data_desc[DATA_DESC_EXT1].record_size;
                phb