phb_handler_write.c

最新MTK手机软件源码

                /**
                  * Temporarily stores number of entries to be piggybacked.
                  * Don't forget to restore it back to control_block->total before
                  * read_fake(), if necessary.
                  */
                control_block->total_piggyback = l4cphb_write_req->total;

                /* set storage, record_index, primary_ID, and secondary_ID */
                if (phb_se_set_control_block(
                        control_block,
                        OP_WRITE,
                        phb_entry->storage,
                        phb_entry->record_index) == KAL_FALSE)
                {
                    phb_write_err_handler(NULL, control_block);
                    return;
                }

                if (l4c_is_src_from_rmmi(control_block->src_id))
                {
                    phb_entry->index = control_block->index;
                }

                /* data stores data to be written, and length is record size of storage */
                control_block->data = (kal_uint8*) & control_block->temp_entry;
                control_block->length = phb_data_desc_get_record_size(phb_data_desc_get_desc_by_ID(control_block->primary_ID));

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

            control_block->actual_count = 0;
            phb_write_confirm(PHB_ERRNO_BUSY, control_block->actual_count, control_block->src_id, control_block);
            return;
        }

    }
    /* Write confirmed */
    else if (control_block->proc_stage == WRITE_CONTINUE)
    {
        /* Piggyback is not required. */
        if (control_block->total_piggyback < 1)
        {
            phb_write_confirm(PHB_ERRNO_SUCCESS, control_block->actual_count, control_block->src_id, control_block);
        }
        /* Piggyback is required */
        else
        {
            /* Now we have to transform the state to a *FAKE* read state. */
            phb_entry_struct *phb_entry;

            /* Restore total_piggyback */
            control_block->total = control_block->total_piggyback;

            /* The just written entry is still there! */
            phb_entry = (phb_entry_struct*) & control_block->temp_entry;

            /* control_block->set_IO() need not be invoked, because type, total is already be set. */
            /* Weird error happened. Anyway, the entry is already written successfully. */
            if (phb_se_is_in_range(control_block->type, phb_entry->index, &control_block->total) == KAL_FALSE)
            {
                control_block->actual_count = 1;
                phb_write_confirm(PHB_ERRNO_SUCCESS, control_block->actual_count, control_block->src_id, control_block);
                return;
            }

            /* If any critial error occured. read_err_handler will handle it. */
            if (phb_read_fake(control_block, phb_entry) == KAL_FALSE)
            {
                return;
            }

            /* Finally, faking complete....Now continue reading */
            phb_read_continue(NULL, control_block);
            return;
        }
    }
    /* error */
    else
    {
        phb_write_err_handler(NULL, control_block);
        return;
    }
}   /* end of phb_write_handler */


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

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

   /**
    * Shall we try to recover/continue handling,
    * or just reject the request in processing?
    * Currently, the latter is adpoted.
    */
    control_block->actual_count = 0;
    phb_write_confirm(PHB_ERRNO_FAIL, control_block->actual_count, control_block->src_id, control_block);

    /*
     * if (ilm_ptr != NULL)
     * (*phb_ptr->control_block.controller)(ilm_ptr);
     */
}   /* end of phb_write_err_handler function */

#ifdef __PHB_USIM_SUPPORT__


/*****************************************************************************
 * FUNCTION
 *  phb_write_usim_handler
 * DESCRIPTION
 *  This is phb_write_usim_handler function of PHB module.
 *  Handles write request from L4C.
 *  3 scenerio are allowed:
 *  read / write   index    total storage  record_index   Semantic
 *  WRITE          0xFFFF         valid    valid          Write an entry to user-specified physical location - {`storage', `record_index'}
 *  This operation is `add'.
 *  valid          ignored  0xFFFF         Write an entry to `index'th entry maintained by PHB.
 *  This opeartion is `update'.
 *  0xFFFF         valid    0xFFFF         Write an entry to `storage'. The physical location written is a free record searched by PHB.
 *  This opeartion is `add'.
 * PARAMETERS
 *  ilm_ptr             [IN]        The primitives
 *  control_block       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
void phb_write_usim_handler(ilm_struct *ilm_ptr, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

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

    if (ilm_ptr != NULL)
    {
        l4cphb_write_usim_req_struct *l4cphb_write_req;

        l4cphb_write_req = (l4cphb_write_usim_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_write_confirm(PHB_ERRNO_BUSY, 0, l4cphb_write_req->src_id, control_block);
            return;
        }

        control_block->src_id = l4cphb_write_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 == WRITE_USIM_NONE)
            {
                kal_uint8 *pdu_ptr;
                kal_uint16 pdu_length;

                phb_entry_struct *phb_entry;
                l4cphb_phb_entry_array_struct *l4cphb_phb_entry_array;
                kal_uint8 ext1_need_num = 0;

                /* USIM type only */

                /* default ext1 parent should be ADN (Phonebook) */
                control_block->ext1_parent_type = PHB_PHONEBOOK;

                /* First we have to unpack user's request */
            /**
             * Number of entries can be wriiten is exactly 1.
             * Hence, number of entries in peer buffer is expected to be 1.
             *
             * Since the entry to write is requested from L4C,
             * here a temporary l4cphb_phb_entry_array is allocated, so that user's
             * parameter can be unpacked to control_block->temp_entry.
             */

                if (ilm_ptr->peer_buff_ptr == NULL)
                {
                    /* phb_write_usim_err_handler(NULL, control_block); */
                    phb_write_usim_confirm(PHB_ERRNO_FAIL, 0, control_block->src_id, control_block);
                    return;
                }
                pdu_ptr = (kal_uint8*) get_pdu_ptr(ilm_ptr->peer_buff_ptr, &pdu_length);
                l4cphb_phb_entry_array = (l4cphb_phb_entry_array_struct*) get_32bits_aligned_val(pdu_ptr);
                phb_entry = &l4cphb_phb_entry_array->array[0];

            /**
             * After copying user's parameter from peer buffer, temporary
             * l4cphb_phb_entry_array can be freed.
             *
             * The entry to be written is stored in temp_entry!!
             */
                kal_mem_cpy(&control_block->temp_entry, (void const*)phb_entry, sizeof(phb_entry_struct));

            /**
             * Finally, the data to write is prepared in control_block->temp_entry.
             * Now the prepared data can be written.
             */
                /* This is for fectching necessary parameters from temp_entry */
                phb_entry = (phb_entry_struct*) & control_block->temp_entry;
                /* set phonebook type since control_block->type will be cleared after write anr stage */
                phb_entry->type = l4cphb_write_req->type;
                kal_mem_cpy(
                    &control_block->temp_email_entry,
                    (void const*)&l4cphb_write_req->email,
                    sizeof(phb_email_struct));
                kal_mem_cpy(&control_block->temp_anra, (void const*)&l4cphb_write_req->anra, sizeof(phb_anr_struct));
                kal_mem_cpy(&control_block->temp_anrb, (void const*)&l4cphb_write_req->anrb, sizeof(phb_anr_struct));
                kal_mem_cpy(&control_block->temp_anrc, (void const*)&l4cphb_write_req->anrc, sizeof(phb_anr_struct));
                kal_mem_cpy(&control_block->temp_sne, (void const*)&l4cphb_write_req->sne, sizeof(l4_name_struct));
                control_block->temp_group_id = l4cphb_write_req->group_type;
                control_block->hidden_info = l4cphb_write_req->hidden_info;
                if (phb_ptr->iap_length > 0)
                {
                    kal_mem_set ((kal_uint8*)control_block->temp_iap,   0xff, 
                                  phb_ptr->data_desc[DATA_DESC_IAP].record_size);
                }

                /* check if enough EXT1 */
                /* First, find out whether free records in EFext suffice */

                if (phb_se_ext_index_find(phb_entry->record_index, PHB_PHONEBOOK) == (kal_uint8) PHB_INVALID_VALUE)
                {
                    ext1_need_num +=
                        ((phb_entry->tel_number.addr_length - PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN + EF_TEL_NUMBER_SIZE -
                          1) / EF_TEL_NUMBER_SIZE);
                }
                if (phb_se_ext_index_find(phb_entry->record_index, PHB_ANRA) == (kal_uint8) PHB_INVALID_VALUE)
                {
                    ext1_need_num +=
                        ((control_block->temp_anra.tel_number.addr_length - PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN +
                          EF_TEL_NUMBER_SIZE - 1) / EF_TEL_NUMBER_SIZE);
                }
                if (phb_se_ext_index_find(phb_entry->record_index, PHB_ANRB) == (kal_uint8) PHB_INVALID_VALUE)
                {
                    ext1_need_num +=
                        ((control_block->temp_anrb.tel_number.addr_length - PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN +
                          EF_TEL_NUMBER_SIZE - 1) / EF_TEL_NUMBER_SIZE);
                }
                if (phb_se_ext_index_find(phb_entry->record_index, PHB_ANRC) == (kal_uint8) PHB_INVALID_VALUE)
                {
                    ext1_need_num +=
                        ((control_block->temp_anrc.tel_number.addr_length - PHB_EF_MAX_TON_NPI_TEL_NUMBER_LEN +
                          EF_TEL_NUMBER_SIZE - 1) / EF_TEL_NUMBER_SIZE);
                }
                if (phb_data_desc_get_free_count(DATA_DESC_EXT1) < ext1_need_num)
                {
                    /* SIM has no more space to chain long numbers */
                    control_block->cause = SIM_EF_RECORD_FULL;
                    /* phb_write_usim_err_handler(NULL, control_block); */
                    phb_write_usim_confirm(PHB_ERRNO_FAIL, 0, control_block->src_id, control_block);
                    return;
                }
                if (phb_ptr->email_type == 2 &&
                    control_block->temp_email_entry.email_length > 0 &&
                    phb_data_desc_get_free_count(DATA_DESC_EMAIL) < 1)
                {
                    /* add operation */
                    if (control_block->temp_email_entry.adn_record_index == (kal_uint16) PHB_INVALID_VALUE)
                    {
                        /* SIM has no more space to add e-mail */
                        control_block->cause = PHB_ERRNO_EMAIL_FULL;
                        /* phb_write_usim_err_handler(NULL, control_block); */
                        phb_write_usim_confirm(PHB_ERRNO_EMAIL_FULL, 0, control_block->src_id, control_block);
                        return;
                    }
                    else    /* add non-empty email or edit operation */
                    {
                        kal_uint16 email_index = phb_se_iap_index_find(
                                                    control_block->temp_email_entry.adn_record_index,
                                                    DATA_DESC_EMAIL);

                        if (email_index == (kal_uint16) PHB_INVALID_VALUE)
                        {
                            /* SIM has no more space to add e-mail */
                            control_block->cause = PHB_ERRNO_EMAIL_FULL;
                            /* phb_write_usim_err_handler(NULL, control_block); */
                            phb_write_usim_confirm(PHB_ERRNO_EMAIL_FULL, 0, control_block->src_id, control_block);
                            return;
                        }