lcm_que.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif 



#include "syscfg.h"
#include "aos.h"

#include "../ker/ssp_msg.h"





U32 m_ulLcmqBufId;





U32 m_lcmque_init(  )
{
    U32 result;
    
    result = mem_buf_create( "lcmqbuf", sizeof(struct msg_blk),&m_ulLcmqBufId );
    if( AOS_SUCC != result )
    {
        return result;
    }
    
    return AOS_SUCC;
}

VOID msg_que_init( struct msg_blk_que *que )
{
    AOS_ASSERT( NULL != que );
    
    que->prev = (struct msg_blk*)que;
    que->next = (struct msg_blk*)que;
    que->qlen = 0;
#if(CONFIG_OS_VXWORKS == TRUE)
    que->lock = FALSE;
#elif(CONFIG_OS_WINDOWS == TRUE)
    que->lock = TRUE;
#else
    #error not supported
#endif
}


VOID msg_lock_que_init( struct msg_blk_que *que )
{
    AOS_ASSERT( NULL != que );
    
    que->prev = (struct msg_blk*)que;
    que->next = (struct msg_blk*)que;
    que->qlen = 0;
    que->lock = TRUE;
}

VOID msg_que_head( struct msg_blk_que *que, struct msg_blk *newmb )
{
    U32 lockKey;
    
    struct msg_blk *prev, *next;
    AOS_ASSERT( NULL != que && NULL != newmb );
    
    if( que->lock )
    {
        lockKey = aos_int_lock();
    }

    que->qlen++;
    prev = (struct msg_blk *)que;
    next = prev->next;
    newmb->next = next;
    newmb->prev = prev;
    next->prev = newmb;
    prev->next = newmb;

    if( que->lock )
    {
        
        aos_int_unlock( lockKey );
        
    }
}

VOID msg_que_tail( struct msg_blk_que *que, struct msg_blk *newmb )
{
    U32 lockKey;
    struct msg_blk *prev, *next;
    
    AOS_ASSERT( NULL != que && NULL != newmb );

    if( que->lock )
    {
        lockKey = aos_int_lock();
    }

    que->qlen++;
    next = (struct msg_blk *)que;
    prev = next->prev;
    newmb->next = next;
    newmb->prev = prev;
    next->prev = newmb;
    prev->next = newmb;

    if( que->lock )
    {
        
        aos_int_unlock( lockKey );
        
    }
}
struct msg_blk *msg_deque( struct msg_blk_que *que )
{
    U32 lockKey;
    struct msg_blk *next, *prev, *result;

    AOS_ASSERT( NULL != que );

    if( que->lock )
    {
        lockKey = aos_int_lock();
    }

    prev = (struct msg_blk *) que;
    next = prev->next;
    result = NULL;
    if (next != prev) {
        result = next;
        next = next->next;
        que->qlen--;
        next->prev = prev;
        prev->next = next;
        result->next = NULL;
        result->prev = NULL;
    }

    if( que->lock )
    {
        
        aos_int_unlock( lockKey );
        
    }
    
    return result;
}

struct msg_blk *msg_remove_tail( struct msg_blk_que *que )
{
    U32 lockKey;
    struct msg_blk *next, *prev, *result;

    AOS_ASSERT( NULL != que );

    if( que->lock )
    {
        lockKey = aos_int_lock();
    }

    next = (struct msg_blk *) que;
    prev = next->prev;

    result = NULL;
    if (next != prev) {
        result = prev;
        prev = prev->prev;
        que->qlen--;
        next->prev = prev;
        prev->next = next;
        result->next = NULL;
        result->prev = NULL;
    }

    if( que->lock )
    {
        
        aos_int_unlock( lockKey );
        
    }
    
    return result;
}


U8 *msg_put( struct msg_blk * mb, U32 len )
{
    U8 *tmp = mb->tail;
    mb->tail += len;
    mb->len  += len;
    AOS_ASSERT_FUNC( mb->tail <= mb->end, aos_task_show_call_stack(0) );
    return tmp;
}

U8 *msg_push( struct msg_blk * mb, U32 len )
{
    mb->data -= len;
    mb->len  += len;
    AOS_ASSERT( mb->head <= mb->data );
    return mb->data;
}

U8 *msg_pull( struct msg_blk * mb, U32 len )
{
    AOS_ASSERT_FUNC(mb->len >= len, aos_task_show_call_stack(0));
    mb->data += len;
    mb->len  -= len;
    AOS_ASSERT( mb->head <= mb->data );
    return mb->data;
}

U32 msg_headroom( struct msg_blk * mb )
{
    return (U32)(mb->data - mb->head);
}

U32 msg_tailroom( struct msg_blk * mb )
{
    return (U32)(mb->end - mb->tail);
}

struct msg_blk *msg_alloc_x(S8 *file, U32 line )
{
    U32 lockKey;
    struct msg_blk *newmb;

    if(file == NULL)
    {
        return NULL;
    }
    
    lockKey = aos_int_lock();
    newmb = (struct msg_blk*)mem_buf_alloc( m_ulLcmqBufId, MPE_TASK, 0, file,line );
    aos_int_unlock(lockKey);
    
    if( NULL != newmb )
    {
        newmb->prev = NULL;
        newmb->next = NULL;
        newmb->head = NULL;        
        newmb->data = NULL;        
        newmb->tail = NULL;        
        newmb->end = NULL;        
        newmb->truelen= 0;
        newmb->len= 0;
    }
    
    return newmb;
}

struct msg_blk *msg_alloc4drv( U32 size )
{
    MSG_HEAD_S *msgp;
    struct msg_blk *mb;

    mb = msg_alloc();
    if( NULL == mb )
    {
        return NULL;
    }

    size += ELEMENT_OFFSET( MSG_HEAD_S, EFAddr );
    
    msgp = (MSG_HEAD_S*)aos_dmem_alloc( MPE_LCM, SID_MSG, size + 4 );
    if( NULL == msgp )
    {
        msg_free( mb );
        return NULL;
    }
    msgp->status = MSG_ALLOCATED;
    
    mb->head = (U8*)msgp;
    mb->truelen = size;
    mb->end   = mb->head+size;

    mb->data = mb->head + ELEMENT_OFFSET( MSG_HEAD_S, EFAddr );
    mb->len  = 0;
    mb->tail  = mb->data;
    
    return mb;
}

struct msg_blk *msg_clone_x( struct msg_blk *oldmb, S8 *file, U32 line )
{
    struct msg_blk *newmb;
    U32 lockKey;
    
    if( NULL == oldmb )
    {
        return NULL;
    }

    if(file == NULL)
    {
        return NULL;
    }

    lockKey = aos_int_lock();
    newmb = (struct msg_blk*)mem_buf_alloc( m_ulLcmqBufId, MPE_TASK, 0, file, line );
    if( NULL != newmb )
    {
        newmb->prev = NULL;
        newmb->next = NULL;
        newmb->head = oldmb->head;        
        newmb->data = oldmb->data;        
        newmb->tail = oldmb->tail;
        newmb->end  = oldmb->end;
        newmb->truelen= oldmb->truelen;
        newmb->len  = oldmb->len;
        mem_buf_inc_ref((VOID*)oldmb->head);
    }
    aos_int_unlock(lockKey);
    
    return newmb;
}

struct msg_blk *msg_clone_by_v5_data( VOID*datap )
{
    struct msg_blk *newmb;
    U32 lockKey;
    
    if( NULL == datap )
    {
        return NULL;
    }

    lockKey = aos_int_lock();
    
    newmb = (struct msg_blk*)mem_buf_alloc( m_ulLcmqBufId, MPE_TASK, 0, __FILE__, __LINE__ );
    if( NULL != newmb )
    {
		DL_MSG_S *pDlMsg = (DL_MSG_S*)datap;
        newmb->prev = NULL;
        newmb->next = NULL;
        newmb->head = mem_obj_head(datap);
        newmb->truelen= mem_obj_size(datap);
        newmb->end = (U8*)((U32)newmb->head+newmb->truelen);

        
        newmb->data = (U8*)((U32)datap + ELEMENT_OFFSET(DL_MSG_S,ucInfo) + (U32)pDlMsg->sOffset);
        newmb->len  = (U32)(pDlMsg->usLength - ELEMENT_OFFSET(DL_MSG_S,ucInfo) - pDlMsg->sOffset);
        newmb->tail = (U8*)((U32)newmb->data+newmb->len);

        mem_buf_inc_ref((VOID*)newmb->head);
    }

    aos_int_unlock(lockKey);
    
    return newmb;
    

}

VOID msg_free( struct msg_blk *mb )
{
    U32 lockKey;
    
    AOS_ASSERT( NULL != mb );
    
    lockKey = aos_int_lock();
    mem_buf_free((VOID *)mb, __FILE__, __LINE__ );
    aos_int_unlock(lockKey);
}

struct msg_blk *msg_que_head_ptr( struct msg_blk_que *que )
{
    U32 lockKey = 0;
    struct msg_blk *next, *prev;

    AOS_ASSERT( NULL != que );

    if( que->lock )
    {
        lockKey = aos_int_lock();
    }

    prev = (struct msg_blk *) que;
    next = prev->next;
    if (next == prev) 
    {
        next= NULL;
    }
    if( que->lock )
    {
        aos_int_unlock(lockKey);
    }

    return next;
}

#if( CONFIG_MANUAL_ALIGN == TRUE )
VOID msg_align( struct msg_blk * mb )
{
    U8 *p;

    if( (U32)mb->data & 3 )
    {
        
        p = (U8*)(( ((U32)mb->data >> 2) + 1 ) << 2);
        aos_memcpy( p, mb->data, mb->len );
        mb->data = p;
        mb->tail = p + mb->len;

        AOS_ASSERT_FUNC( mb->head <= mb->data, aos_printf( 0,"Head=%x,Data=%x", mb->head,mb->data ) );
    }
}
#endif


#ifdef __cplusplus
}
#endif