phb_handler_delete.c

最新MTK手机软件源码

static void phb_delete_ln_confirm(phb_errno_enum result, kal_uint8 src_id, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    l4cphb_write_ln_cnf_struct *param_ptr;
    peer_buff_struct *peer_buff_ptr = NULL;
    l4cphb_phb_ln_entry_array_struct *pdu_stream_ptr;
    nvram_ef_phb_ln_struct *record1, *record2 = NULL;
    kal_uint16 length;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    param_ptr = (l4cphb_write_ln_cnf_struct*)
        construct_local_para((kal_uint16) sizeof(l4cphb_write_ln_cnf_struct), TD_CTRL);

    param_ptr->src_id = src_id;
    param_ptr->result = result;
    param_ptr->cause = 0;
    param_ptr->total = 0;

    if ((result == PHB_ERRNO_SUCCESS) && (control_block->total_piggyback > 0))
    {
        param_ptr->total = control_block->total_piggyback;

        pdu_stream_ptr = (l4cphb_phb_ln_entry_array_struct*)
            l4cphb_alloc_ln_peer_buf(&peer_buff_ptr, param_ptr->total);

        /* pdu_stream_ptr->no_array = param_ptr->total;
           pdu_stream_ptr->array = (phb_ln_entry_struct *)get_ctrl_buffer
           (sizeof (phb_ln_entry_struct) * param_ptr->total); */

        record1 = (nvram_ef_phb_ln_struct*) get_pdu_ptr((peer_buff_struct*) control_block->data, &length);

        if (control_block->seg_total > 1)
        {
            record2 = (nvram_ef_phb_ln_struct*) get_pdu_ptr(control_block->peer_buf_ptr, &length);
        }

        if (control_block->seg_record_index >= PHB_MAX_LN_ENTRIES)
        {
            /* from file 2 */
            kal_mem_cpy(
                pdu_stream_ptr->array,
                &record2->array[control_block->seg_record_index - PHB_MAX_LN_ENTRIES],
                sizeof(phb_ln_entry_struct) * param_ptr->total);
        }
        else if (control_block->seg_record_index + param_ptr->total <= PHB_MAX_LN_ENTRIES)
        {
            /* from file 1 */
            kal_mem_cpy(
                pdu_stream_ptr->array,
                &record1->array[control_block->seg_record_index],
                sizeof(phb_ln_entry_struct) * param_ptr->total);
        }
        else
        {
            /* across 2 file */
            kal_uint8 count = record1->no_entry - control_block->seg_record_index;

            kal_mem_cpy(
                pdu_stream_ptr->array,
                &record1->array[control_block->seg_record_index],
                sizeof(phb_ln_entry_struct) * count);
            kal_mem_cpy(
                &pdu_stream_ptr->array[count],
                &record2->array[0],
                sizeof(phb_ln_entry_struct) * param_ptr->total - count);
        }

    }

    phb_send_ilm(MOD_L4C, MSG_ID_L4CPHB_DELETE_LN_CNF, param_ptr, peer_buff_ptr);
    /* if (peer_buff_ptr != NULL)
       free_ctrl_buffer (pdu_stream_ptr->array); */

    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);
        }
        phb_free_control_block(control_block);
    }

#ifdef __PHB_RECORD_LN_TYPE_SEQ__
    if (result == PHB_ERRNO_SUCCESS)
    {
        phb_write_ln_type_seq_handler(NULL, NULL);
    }
#endif /* __PHB_RECORD_LN_TYPE_SEQ__ */ 

}   /* end of phb_delete_ln_confirm */

#ifdef __PHB_RECORD_LN_TYPE_SEQ__


/*****************************************************************************
 * FUNCTION
 *  phb_shift_left_ln_type_seq
 * DESCRIPTION
 *  
 * PARAMETERS
 *  del_seq_index       [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_shift_left_ln_type_seq(kal_uint8 del_seq_index)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    if (del_seq_index >= PHB_TOTAL_LN_ENTRIES - 1)
    {
        phb_ln_type_seq[PHB_TOTAL_LN_ENTRIES - 1] = 0xff;
    }
    else
    {
        while (del_seq_index < PHB_TOTAL_LN_ENTRIES - 1 && phb_ln_type_seq[del_seq_index + 1] != 0xff)
        {
            phb_ln_type_seq[del_seq_index] = phb_ln_type_seq[del_seq_index + 1];
            del_seq_index++;
        }
        /* last one should be 0xff */
        phb_ln_type_seq[del_seq_index] = 0xff;
    }
}


/*****************************************************************************
 * FUNCTION
 *  phb_delete_ln_type_seq
 * DESCRIPTION
 *  
 * PARAMETERS
 *  del_seq_index       [IN]        
 *  type                [IN]        
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_delete_ln_type_seq(kal_uint8 del_seq_index, kal_uint8 type)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 i = 0;
    kal_uint8 j = 0;
    kal_uint8 del_index = (PHB_TOTAL_LN_ENTRIES - 1);

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    //kal_uint8 update_type = phb_ln_type_seq[0];
    //kal_uint8 tmp_type;
    if (del_seq_index > 0)
    {
        for (del_index = PHB_TOTAL_LN_ENTRIES - 1; del_seq_index > 0; del_index--)
        {
            if (phb_ln_type_seq[del_index] == type)
            {
                del_seq_index--;
            }
        }
        del_index++;
        phb_shift_left_ln_type_seq(del_index);
    }
    else
    {
        while (i < del_index && phb_ln_type_seq[i] != 0xff)
        {
            if (phb_ln_type_seq[i] == type)
            {
                phb_ln_type_seq[i] = 0xff;
                j = i;
                phb_shift_left_ln_type_seq(i);
                while (phb_ln_type_seq[j] == type)
                {
                    phb_shift_left_ln_type_seq(j);
                }
            }
            i++;
        }
    }
}
#endif /* __PHB_RECORD_LN_TYPE_SEQ__ */ 


/*****************************************************************************
 * FUNCTION
 *  phb_delete_ln
 * DESCRIPTION
 *  
 * PARAMETERS
 *  record              [?]     
 *  control_block       [?]     
 * RETURNS
 *  
 *****************************************************************************/
static kal_bool phb_delete_ln(nvram_ef_phb_ln_struct *record, control_block_type *control_block)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 total, i;
    kal_uint16 len;
    nvram_ef_phb_ln_struct *record0 = NULL;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    record0 = (nvram_ef_phb_ln_struct*) get_pdu_ptr((peer_buff_struct*) control_block->data, &len);

    if (record != NULL)
    {
        total = record0->no_entry + record->no_entry;
    }
    else
    {
        total = record0->no_entry;
    }

    if (total - 1 < control_block->seg_record_index)
    {
        return KAL_FALSE;
    }

#if (MAX_PHB_LN_ENTRY > 20)
#ifdef __PHB_RECORD_LN_TYPE_SEQ__
    if (first_round)
    {
        phb_delete_ln_type_seq(
            (kal_uint8) (phb_get_ln_total_entry((kal_uint8) control_block->type) - control_block->index),
            (kal_uint8) control_block->type);
    }
#endif /* __PHB_RECORD_LN_TYPE_SEQ__ */ 
    if (!first_round)   /* need use shiftedEntry */
    {
        phb_ln_entry_struct buffer_entry;

        kal_mem_cpy(&buffer_entry, &shifted_entry, sizeof(phb_ln_entry_struct));
        if (record == NULL)
        {
            /* del entry in file 1 */
            i = control_block->seg_record_index;
            phb_ln_delete_entry(i, record0);
            control_block->seg_total = 0;
            kal_mem_cpy(&record0->array[PHB_MAX_LN_ENTRIES - 1], &shifted_entry, sizeof(phb_ln_entry_struct));
            record0->no_entry++;
        }
        else if (record->no_entry > 0)
        {
            /* del entry in file 1 and push one entry from file 2 to file 1 */
            i = control_block->seg_record_index;
            if (control_block->seg_total > 1)   /* at least 2 (one is itself) */
            {
                kal_mem_cpy(&shifted_entry, &record0->array[0], sizeof(phb_ln_entry_struct));
                phb_ln_delete_entry(0, record0);
            }
            else
            {
                phb_ln_delete_entry(i, record0);
            }
            kal_mem_cpy(&record0->array[PHB_MAX_LN_ENTRIES - 1], &record->array[0], sizeof(phb_ln_entry_struct));
            record0->no_entry++;
            phb_ln_delete_entry(0, record);
            kal_mem_cpy(&record->array[PHB_MAX_LN_ENTRIES - 1], &buffer_entry, sizeof(phb_ln_entry_struct));
            record->no_entry++;
        }
        else
        {
            /* del entry in file 1 */
            i = control_block->seg_record_index;
            phb_ln_delete_entry(i, record0);
            control_block->seg_total = 0;
            kal_mem_cpy(&record0->array[PHB_MAX_LN_ENTRIES - 1], &shifted_entry, sizeof(phb_ln_entry_struct));
            record0->no_entry++;
        }

    }
    else if (control_block->seg_record_index >= PHB_MAX_LN_ENTRIES)
#else /* (MAX_PHB_LN_ENTRY > 20) */ 

#ifdef __PHB_RECORD_LN_TYPE_SEQ__
    phb_delete_ln_type_seq((kal_uint8) (total - control_block->seg_record_index), control_block->type);
#endif 

    if (control_block->seg_record_index >= PHB_MAX_LN_ENTRIES)
#endif /* (MAX_PHB_LN_ENTRY > 20) */ /* MAX_PHB_LN_ENTRY > 20 */
    {
        /* del entry in file2 */
        i = control_block->seg_record_index - PHB_MAX_LN_ENTRIES;
        phb_ln_delete_entry(i, record);
    }
    else if (record == NULL)
    {
        /* del entry in file 1 */
        i = control_block->seg_record_index;
        phb_ln_delete_entry(i, record0);
    }
    else if (record->no_entry > 0)
    {
        /* del entry in file 1 and push one entry from file 2 to file 1 */
        i = control_block->seg_record_index;
    #if (MAX_PHB_LN_ENTRY > 20)
        if (control_block->seg_total > 1)   /* at least 2 (one is itself) */
        {
            kal_mem_cpy(&shifted_entry, &record0->array[0], sizeof(phb_ln_entry_struct));
            phb_ln_delete_entry(0, record0);
        }
        else
    #endif /* (MAX_PHB_LN_ENTRY > 20) */ 
            phb_ln_delete_entry(i, record0);
        kal_mem_cpy(&record0->array[PHB_MAX_LN_ENTRIES - 1], &record->array[0], sizeof(phb_ln_entry_struct));
        record0->no_entry++;
        phb_ln_delete_entry(0, record);
    }
    else
    {
        /* del entry in file 1 */
        i = control_block->seg_record_index;
        phb_ln_delete_entry(i, record0);
    }

    if ((total - control_block->seg_record_index - 1) < control_block->total_piggyback)
    {
        control_block->total_piggyback = total - control_block->seg_record_index - 1;
    }

    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  phb_ln_delete_entry
 * DESCRIPTION
 *  
 * PARAMETERS
 *  index       [IN]        
 *  record      [?]         
 * RETURNS
 *  void
 *****************************************************************************/
static void phb_ln_delete_entry(kal_uint8 index, nvram_ef_phb_ln_struct *record)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 i;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (i = index + 1; i < record->no_entry; i++)
    {
        kal_mem_cpy(&record->array[i - 1], &record->array[i], sizeof(phb_ln_entry_struct));
    }
    record->no_entry--;
    return;
}