phb_handler_read.c

最新MTK手机软件源码

 *  Prerequisite:
 *  // 1. control_block->length is not set. Caller should ensure to set length correctly.
 *  1. length will be set by this function. Caller should not set it.
 *  2. phb_control_block_set_IO() must be called in advance.
 *  3. Caller must set control_block->total.
 *  4. The given index MUST start from 1
 *  5. phb_se_is_in_range() should be called in advance.
 *  6. control_block->cnf_msg_id must be set!!
 * PARAMETERS
 *  control_block       [?]         
 *  cached_entry        [?]         
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
kal_bool phb_read_fake(control_block_type *control_block, phb_entry_struct *cached_entry)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /* Now we have to transform the state to a *FAKE* read state. */
    l4cphb_phb_entry_array_struct *phb_entry_array;
    peer_buff_struct *peer_buf_ptr;

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

   /**
    * For write operation, the just written entry is still there!
    * It's in control_block->temp_entry and passed in as a cached_entry.
    */

    /* phb_se_is_in_range ?? */

    /* First, construct the array for piggyback reading */
    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_control_block_set(control_block, phb_read_continue, phb_read_handler, phb_read_err_handler, READ_CONTINUE);
   /**
    * Next, set_IO() is unnecessary, since it MUST be set by caller ALREADY.
    */

    /* This function is called for piggybacked write */
    if (cached_entry != NULL)
    {
        /* Copy the just written entry to array */
        kal_mem_cpy(&phb_entry_array->array[0], (void const*)cached_entry, sizeof(phb_entry_struct));

      /**
       * Since index of the just written entry is translated,
       * increment the index will make the reading from next entry of
       * the just written entry.
       */
        control_block->actual_count = 1;

        /* Reset record_index */
        control_block->record_index = (kal_uint16) PHB_INVALID_VALUE;
    }
    /* This function is called for piggybacked delete, or search */
    else
    {
        control_block->actual_count = 0;
    }

    /* Cannot but read physical storage for piggyback opeartion. */
    if (control_block->actual_count < control_block->total)
    {
      /**
       * Try to set control_block for next index; this is only needed when
       * cached_entry exists.
       */
        if (cached_entry != NULL)
        {
            control_block->index = cached_entry->index + 1;
        }

        /* Assign storage and record_index */
        /* set storage, record_index, primary_ID, and secondary_ID */
        if (phb_se_set_control_block(
                control_block,
                OP_READ,
                control_block->storage,
                control_block->record_index) == KAL_FALSE)
        {
            phb_read_err_handler(NULL, control_block);
            return KAL_FALSE;
        }

        /* Assign control_block->data */
        /* This function is called for piggybacked write */
        if (cached_entry != NULL)
        {
            /* shift next read address */
            control_block->data = (kal_uint8*) & phb_entry_array->array[1];
        }
        else
        {
            control_block->data = (kal_uint8*) & phb_entry_array->array[0];
        }

        control_block->length = phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID(control_block->primary_ID));
    }

   /**
    * If there is exactly only one to be piggybacked, which is already conveyed
    * in cache_entry, nothing is done here. Instead, read_continue() will
    * response back without reading phyiscal storage any further.
    */

    return KAL_TRUE;
}   /* end of phb_read_fake */


/*****************************************************************************
 * FUNCTION
 *  phb_is_read_param_valid
 * DESCRIPTION
 *  2 scenerio are allowed:
 *  read / write   index    total storage  record_index   Semantic
 *  READ           valid    n     ignored  0xFFFF         From PHB maintained index, read n entries.
 *  0xFFFF   1     valid    valid          Read a entry stored in {`storage', `record_index'}.The index of that entry,
 *  maintained by PHB, is also returned in confirmation primitive.
 * PARAMETERS
 *  l4cphb_read_req     [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/
kal_bool phb_is_read_param_valid(l4cphb_read_req_struct *l4cphb_read_req)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* Is type valid ? */
    if (!phb_is_type_valid(l4cphb_read_req->type))
    {
        return KAL_FALSE;
    }

    /* Should be scenario 1 */
    /* index must be valid, total must be valid */
    if (l4cphb_read_req->record_index == (kal_uint16) PHB_INVALID_VALUE)
    {
        /* Now check whether index, total fall into valid range of that type */
        return phb_se_is_in_range(l4cphb_read_req->type, l4cphb_read_req->index, &l4cphb_read_req->total);
    }
    /* Read specific record of certain storage is required */
    else
    {
        data_desc_enum type = DATA_DESC_PHB;

        /* Using case 2 of read to read ECC, MSISDN, and SDN is forbidden!  */
        if ((l4cphb_read_req->type == PHB_ECC) ||
            (l4cphb_read_req->type == PHB_MSISDN) || (l4cphb_read_req->type == PHB_SDN))
        {
            return KAL_FALSE;
        }

        /* Total must be 1 for this operation */
        if (l4cphb_read_req->total != 1)
        {
            return KAL_FALSE;
        }

      /**
       * Since specific record is specified,
       * validity must be checked through data_desc
       */
        if (l4cphb_read_req->type == PHB_PHONEBOOK)
        {
            if (l4cphb_read_req->storage == PHB_SIM)
            {
                type = DATA_DESC_ADN;
            }
            else if (l4cphb_read_req->storage == PHB_NVRAM)
            {
                type = DATA_DESC_PHB;
            }
            else
            {
                return KAL_FALSE;
            }
        }
        else if (l4cphb_read_req->type == PHB_FDN)
        {
            type = DATA_DESC_FDN;
        }
        else if (l4cphb_read_req->type == PHB_BDN)
        {
            type = DATA_DESC_BDN;
        }
    #ifdef __PHB_USIM_SUPPORT__
        else if (l4cphb_read_req->type == PHB_GAS)
        {
            type = DATA_DESC_GAS;
        }
    #endif /* __PHB_USIM_SUPPORT__ */ 

        if (l4cphb_read_req->record_index > phb_data_desc_get_record_num(type))
        {
            return KAL_FALSE;
        }
    }
    return KAL_TRUE;
}   /* end of phb_is_read_param_valid */


/*****************************************************************************
 * FUNCTION
 *  phb_read_ln_handler
 * DESCRIPTION
 *  This is phb_read_ln_handler function of PHB module.
 *  Handles read last number request from L4C.
 * PARAMETERS
 *  ilm_ptr             [IN]        The primitives
 *  control_block       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
void phb_read_ln_handler(ilm_struct *ilm_ptr, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (ilm_ptr != NULL)
    {
        /* Cannot allocate, means that PHB is still operating. Reject request! */
        if (control_block == NULL)
        {
            l4cphb_read_ln_req_struct *msg_ptr = NULL;

            msg_ptr = (l4cphb_read_ln_req_struct*) ilm_ptr->local_para_ptr;
            control_block = phb_alloc_control_block();

            if (control_block == NULL)
            {
                phb_read_ln_confirm(PHB_ERRNO_BUSY, NULL, msg_ptr->src_id, control_block);
                return;
            }
            /* Retain msg_id */
            control_block->cnf_msg_id = ilm_ptr->msg_id;
            control_block->src_id = msg_ptr->src_id;
        }

        /* if (phb_ptr->state == PHB_STATE_READY) */
        {
            if (control_block->proc_stage == READ_LN_NONE)
            {
                l4cphb_read_ln_req_struct *msg_ptr = NULL;

                msg_ptr = (l4cphb_read_ln_req_struct*) ilm_ptr->local_para_ptr;

                control_block->proc_stage = READ_LN_READ;
                control_block->IO_cnf_receive = phb_read_ln_handler;

                control_block->type = msg_ptr->type;
                control_block->src_id = msg_ptr->src_id;

                if (msg_ptr->type == PHB_LND)
                {
                    control_block->seg_total = PHB_TOT_LND_LIDS;
                    control_block->secondary_ID = PHB_LND_LID_START;
                }
                else if (msg_ptr->type == PHB_LNM)
                {
                    control_block->seg_total = PHB_TOT_LNM_LIDS;
                    control_block->secondary_ID = PHB_LNM_LID_START;
                }
                else if (msg_ptr->type == PHB_LNR)
                {
                    control_block->seg_total = PHB_TOT_LNR_LIDS;
                    control_block->secondary_ID = PHB_LNR_LID_START;
                }
                else
                {
                    phb_read_ln_confirm(PHB_ERRNO_FAIL, NULL, control_block->src_id, control_block);
                    return;
                }
            #if (MAX_PHB_LN_ENTRY > 20)
                ASSERT(msg_ptr->seq_id <= 3);
                control_block->secondary_ID += (msg_ptr->seq_id - 1) * 2;
                control_block->actual_count = (kal_uint16) phb_get_ln_total_entry((kal_uint8) control_block->type);
                if (control_block->actual_count < (msg_ptr->seq_id - 1) * PHB_MAX_LN_ENTRIES * 2)
                {
                    ASSERT(0);
                }
                else
                {
                    control_block->actual_count -= ((msg_ptr->seq_id - 1) * PHB_MAX_LN_ENTRIES * 2);
                    control_block->seg_total =
                        (control_block->actual_count + PHB_MAX_LN_ENTRIES - 1) / PHB_MAX_LN_ENTRIES;
                }
            #endif /* (MAX_PHB_LN_ENTRY > 20) */ 

                phb_read_ln_from_nvram(control_block);
                return;
            }
            else if (control_block->proc_stage == READ_LN_READ)
            {
                kal_uint16 length;
                nvram_read_cnf_struct *msg_ptr = NULL;
                nvram_ef_phb_ln_struct *pdu_data;

                msg_ptr = (nvram_read_cnf_struct*) ilm_ptr->local_para_ptr;
                control_block->IO_stage = IO_NONE;

                if (msg_ptr->result == NVRAM_IO_ERRNO_OK)
                {
                    control_block->IO_cnf_receive = phb_read_ln_handler;

                    pdu_data = (nvram_ef_phb_ln_struct*) get_pdu_ptr(ilm_ptr->peer_buff_ptr, &length);

                    /* keep first read data in control_block->data */
                    hold_peer_buff(ilm_ptr->peer_buff_ptr);
                    control_block->data = (kal_uint8*) ilm_ptr->peer_buff_ptr;
                    control_block->total = pdu_data->no_entry;

                    /* if (control_block->type == PHB_LND) */
                    {
                        if ((control_block->seg_total > 1) && (pdu_data->no_entry >= PHB_MAX_LN_ENTRIES))
                        {
                            control_block->secondary_ID++;
                            control_block->proc_stage = READ_LN_READ_CONTINUE;

                            phb_read_ln_from_nvram(control_block);
                        }
                        else
                        {
                            phb_read_ln_confirm(PHB_ERRNO_SUCCESS, NULL, control_block->src_id, control_block);
                        }
                        return;
                    }
                    /* else if (control_block->type == PHB_LNM ||
                       control_block->type == PHB_LNR)
                       {
                       if (pdu_data->no_entry < PHB_MAX_LN_ENTRIES)
                       {
                       phb_read_ln_confirm (PHB_ERRNO_SUCCESS, NULL,
                       control_block->src_id, control_block);
                       return;
                       }
                       control_block->secondary_ID ++;
                       control_block->proc_stage = READ_LN_READ_CONTINUE;
                       
                       phb_read_ln_from_nvram (control_block);
                       return;
                       }
                       else
                       {
                       // error
                       } */
                }
                else
                {
                    phb_read_ln_confirm(PHB_ERRNO_READ_FAIL, NULL, control_block->src_id, control_block);
                }
            }
            else if (control_block->proc_stage == READ_LN_READ_CONTINUE)
            {
                kal_uint16 length;
                nvram_read_cnf_struct *msg_ptr = NULL;
                nvram_ef_phb_ln_struct *pdu_data;