phb_handler_delete.c

最新MTK手机软件源码

    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    local_para_struct *local_param_ptr = NULL;

    l4cphb_delete_cnf_struct *l4cphb_delete_cnf;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    kal_trace(TRACE_FUNC, FUNC_PHB_DELETE_CNF, result, actual_count, src_id);

    l4cphb_delete_cnf = (l4cphb_delete_cnf_struct*) construct_local_para(sizeof(l4cphb_delete_cnf_struct), TD_CTRL);
    l4cphb_delete_cnf->total = actual_count;
    l4cphb_delete_cnf->src_id = src_id;

    local_param_ptr = (local_para_struct*) l4cphb_delete_cnf;

    /* If result is PHB_ERRNO_BUSY, reject newly received request */
    l4cphb_delete_cnf->result = result;

    /* Confirm to in-processing operation */
    if (result != PHB_ERRNO_BUSY)
    {
        /* Field `cause' is meaningful when I/O occured by using control blocks */
        l4cphb_delete_cnf->cause = control_block->cause;
        l4cphb_delete_cnf->old_index = control_block->candidate;

        phb_free_control_block(control_block);
    }

    phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_DELETE_CNF, local_param_ptr, NULL);
}   /* end of phb_delete_confirm */


/*****************************************************************************
 * FUNCTION
 *  phb_delete_ln_handler
 * DESCRIPTION
 *  This is phb_delete_ln_handler function of PHB module.
 *  Handles delete last number request from L4C.
 * PARAMETERS
 *  ilm_ptr             [IN]        The primitives
 *  control_block       [?]         
 * RETURNS
 *  void
 *****************************************************************************/
void phb_delete_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_delete_ln_req_struct *msg_ptr;

            msg_ptr = (l4cphb_delete_ln_req_struct*) ilm_ptr->local_para_ptr;
        #if (MAX_PHB_LN_ENTRY > 20)
            first_round = KAL_TRUE;
        #endif 
            control_block = phb_alloc_control_block();

            if (control_block == NULL)
            {
                phb_delete_ln_confirm(PHB_ERRNO_BUSY, 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 == DEL_LN_NONE)
            {
                l4cphb_delete_ln_req_struct *msg_ptr = (l4cphb_delete_ln_req_struct*) ilm_ptr->local_para_ptr;

            #if (MAX_PHB_LN_ENTRY > 20)
                kal_uint8 no_skip;
                kal_uint8 seg_total;

                if (msg_ptr->index == 0xff)
                {
                    no_skip = 0;
                }
                else
                {
                    no_skip = msg_ptr->index / PHB_MAX_LN_ENTRIES;      /* 0-based */
                }
                seg_total = ((phb_get_ln_total_entry(msg_ptr->type) + PHB_MAX_LN_ENTRIES - 1)
                             / PHB_MAX_LN_ENTRIES) - no_skip;
                control_block->index = msg_ptr->index;
            #endif /* (MAX_PHB_LN_ENTRY > 20) */ 

                /* save req info */
                control_block->IO_cnf_receive = phb_delete_ln_handler;
                control_block->seg_record_index = msg_ptr->index;
                control_block->src_id = msg_ptr->src_id;
                control_block->type = msg_ptr->type;

                if (control_block->type == PHB_LND)
                {
                    control_block->seg_total = PHB_TOT_LND_LIDS;
                    control_block->secondary_ID = PHB_LND_LID_START;
                }
                else if (control_block->type == PHB_LNM)
                {
                    control_block->seg_total = PHB_TOT_LNM_LIDS;
                    control_block->secondary_ID = PHB_LNM_LID_START;
                }
                else if (control_block->type == PHB_LNR)
                {
                    control_block->seg_total = PHB_TOT_LNR_LIDS;
                    control_block->secondary_ID = PHB_LNR_LID_START;
                }
                else
                {
                    phb_delete_ln_confirm(PHB_ERRNO_FAIL, control_block->src_id, control_block);
                }

                if (msg_ptr->index == 0xff)
                {
                    /* delete all */
                    control_block->total_piggyback = 0;
                    control_block->data = get_ctrl_buffer(sizeof(nvram_ef_phb_ln_struct));
                    kal_mem_set(control_block->data, 0, sizeof(nvram_ef_phb_ln_struct));

                    if (control_block->seg_total > 1)
                    {
                        control_block->proc_stage = DEL_LN_WRITE_CONTINUE;
                    }
                    else
                    {
                        control_block->proc_stage = DEL_LN_WRITE;
                    }

                    phb_write_ln_to_nvram((nvram_ef_phb_ln_struct*) control_block->data, control_block);
                #ifdef __PHB_RECORD_LN_TYPE_SEQ__
                    phb_delete_ln_type_seq(0, (kal_uint8) control_block->type);
                #endif 

                    free_ctrl_buffer(control_block->data);
                    return;
                }
            #if (MAX_PHB_LN_ENTRY > 20)
                control_block->seg_total = seg_total;
                if (seg_total <= 2)
                {
                    control_block->secondary_ID += no_skip;
                }
                else    /* need backward read */
                {
                    control_block->secondary_ID +=
                        (PHB_TOT_LNM_LIDS - (PHB_TOT_LNM_LIDS - seg_total) - 1 - 1 + no_skip);
                }
                control_block->seg_record_index -= (PHB_MAX_LN_ENTRIES * no_skip);
            #endif /* (MAX_PHB_LN_ENTRY > 20) */ 

                control_block->proc_stage = DEL_LN_READ;
                control_block->total_piggyback = msg_ptr->total;

                phb_read_ln_from_nvram(control_block);
                return;
            }
            else if (control_block->proc_stage == DEL_LN_READ)
            {
                kal_bool updated;
                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)
                {
                    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;

                    /* if (control_block->type != PHB_LND)
                       {
                       control_block->secondary_ID ++;
                       control_block->proc_stage = DEL_LN_READ_CONTINUE;
                       
                       phb_read_ln_from_nvram (control_block);
                       return;
                       }
                       else
                       { */
                    if (control_block->seg_total > 1)
                    {
                        control_block->secondary_ID++;
                        control_block->seg_total--;
                        control_block->proc_stage = DEL_LN_READ_CONTINUE;

                        phb_read_ln_from_nvram(control_block);
                        return;
                    }
                    else
                    {
                        control_block->proc_stage = DEL_LN_WRITE;
                        updated = phb_delete_ln(NULL, control_block);

                        if (updated == KAL_TRUE)
                        {
                            /* write LND file */
                            phb_write_ln_to_nvram(NULL, control_block);
                            return;
                        }
                    }
                    /* } */
                }
                phb_delete_ln_confirm(PHB_ERRNO_READ_FAIL, control_block->src_id, control_block);
            }
            else if (control_block->proc_stage == DEL_LN_READ_CONTINUE)
            {
                kal_bool updated;
                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)
                {
                    pdu_data = (nvram_ef_phb_ln_struct*) get_pdu_ptr(ilm_ptr->peer_buff_ptr, &length);

                    /* keep second read data in control_block->peer_buf_ptr */
                    hold_peer_buff(ilm_ptr->peer_buff_ptr);
                    control_block->peer_buf_ptr = ilm_ptr->peer_buff_ptr;

                    updated = phb_delete_ln(pdu_data, control_block);

                    if (updated == KAL_TRUE)
                    {
                        control_block->proc_stage = DEL_LN_WRITE_CONTINUE;

                        /* write second file */
                        phb_write_ln_to_nvram(pdu_data, control_block);
                        return;
                    }
                }
                phb_delete_ln_confirm(PHB_ERRNO_FAIL, control_block->src_id, control_block);
            }
            else if (control_block->proc_stage == DEL_LN_WRITE_CONTINUE)
            {
                nvram_write_cnf_struct *msg_ptr = NULL;

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

                if (msg_ptr->result == NVRAM_IO_ERRNO_OK)
                {
                    if (control_block->seg_record_index == 0xff)
                    {
                        /* delete all */
                        control_block->data = get_ctrl_buffer(sizeof(nvram_ef_phb_ln_struct));
                        kal_mem_set(control_block->data, 0, sizeof(nvram_ef_phb_ln_struct));

                        control_block->secondary_ID++;
                        control_block->seg_total--;
                        if (control_block->seg_total <= 1)
                        {
                            control_block->proc_stage = DEL_LN_WRITE;
                        }
                        phb_write_ln_to_nvram((nvram_ef_phb_ln_struct*) control_block->data, control_block);

                        free_ctrl_buffer(control_block->data);
                        return;
                    }
                    control_block->proc_stage = DEL_LN_WRITE;
                    control_block->secondary_ID--;

                    /* write first file */
                    phb_write_ln_to_nvram(NULL, control_block);
                    return;
                }
                else
                {
                    /* error */
                    phb_delete_ln_confirm(PHB_ERRNO_FAIL, control_block->src_id, control_block);
                }
            }
            else if (control_block->proc_stage == DEL_LN_WRITE)
            {
                nvram_write_cnf_struct *msg_ptr = NULL;

                msg_ptr = (nvram_write_cnf_struct*) ilm_ptr->local_para_ptr;
                control_block->IO_stage = IO_NONE;
            #if (MAX_PHB_LN_ENTRY > 20)
                if (control_block->seg_total > 1)
                {
                    control_block->seg_total--;
                    if (control_block->seg_total == 1)
                    {
                        control_block->secondary_ID -= 1;
                    }
                    else
                    {
                        control_block->secondary_ID -= 2;
                    }
                    control_block->proc_stage = DEL_LN_READ;
                    if (control_block != NULL)
                    {
                        if (control_block->data != NULL)
                        {
                            free_peer_buff((peer_buff_struct*) control_block->data);
                        }
                        if (control_block->peer_buf_ptr != NULL)
                        {
                            free_peer_buff(control_block->peer_buf_ptr);
                        }
                    }
                    first_round = KAL_FALSE;
                    phb_read_ln_from_nvram(control_block);
                    return;
                }
            #endif /* (MAX_PHB_LN_ENTRY > 20) */ /* MAX_PHB_LN_ENTRY > 20 */

                if (msg_ptr->result == NVRAM_IO_ERRNO_OK)
                {
                    phb_delete_ln_confirm(PHB_ERRNO_SUCCESS, control_block->src_id, control_block);
                }
                else
                {
                    phb_delete_ln_confirm(PHB_ERRNO_FAIL, control_block->src_id, control_block);
                }
            }
            else
                /* wrong state */
            {
                phb_delete_ln_confirm(PHB_ERRNO_FAIL, control_block->src_id, control_block);
            }
        }
        /* else
           phb_delete_ln_confirm (PHB_ERRNO_BUSY,
           control_block->src_id, control_block); */
    }
    else
    {
        phb_delete_ln_confirm(PHB_ERRNO_FAIL, control_block->src_id, control_block);
    }
}


/*****************************************************************************
 * FUNCTION
 *  phb_delete_ln_confirm
 * DESCRIPTION
 *  This is phb_delete_ln_confirm function of PHB module.
 * PARAMETERS
 *  result              [IN]        
 *  src_id              [IN]        
 *  control_block       [?]         
 *  ilm_ptr(?)          [IN]        The primitives
 * RETURNS
 *  void
 *****************************************************************************/