lcm_comdrv.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif 

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

#if(CONFIG_BOARD_EIA == TRUE)

#define MAX_COM_LEN  300

#if(CONFIG_OS_WINDOWS == TRUE)
extern U32 sim_com_init();
extern VOID sim_com_tx( struct msg_blk *mb );   
#endif
extern VOID  phy_console_send_u1000(U32 channel, S8 *Buf_ptr,U32 ulLen);
extern VOID  ippbx_msg_assemble( U32 phy_type, U32 port_no, struct msg_blk* mb );

LCM_PHY_RCV com_recv_func  = NULL;

U8 com_pool[MAX_COM_LEN*2];
U8 *com_pool_head = com_pool;
U32 com_cur_len=0;
U32 frm_cur_len=0;


typedef enum com_rcv_state
{
    RCVING_7E,
    RCVING_LEN,
    RCVING_DATA
}COM_RCV_STATE_E;

COM_RCV_STATE_E com_state = RCVING_7E;

VOID com_data_input( U8 *datap, U32 len );
VOID com_data_output( U32 port, struct msg_blk *mb );


U32 lcm_com_init( )
{
    U32 result = AOS_SUCC;

#if(CONFIG_OS_WINDOWS == TRUE)            
    result = sim_com_init();
    if( AOS_SUCC != result )
    {
        return result;
    }
#endif

    if( !isIpPbxBoard() )
    {
        result = lcm_add_drv( LCM_DRV_SERIAL, MAX_COM_LEN, com_data_output, &com_recv_func );
    }
#ifdef _EIA2000V3    
    else
    {
        com_recv_func = ippbx_msg_assemble;
    }
#endif    
    return result;
}


VOID com_data_input( U8 *datap, U32 len )
{
    U8  FCS;
    U32 i;

    if( NULL == com_recv_func )
    {
        return;
    }

    while( len )
    {
        switch( com_state )
        {
            case RCVING_7E:
                if( 0x7e == *datap )
                {
                    com_cur_len++;
                    if( 4 == com_cur_len )
                    {
                        com_state   = RCVING_LEN;
                        com_cur_len = 0;
                    }
                }
                else
                {
                    com_cur_len = 0;
                }
                datap++;
                len--;
                break;
                
            case RCVING_LEN:
                com_pool_head[com_cur_len] = *datap;
                com_cur_len ++;
				datap++;
                len--;
                if( 2 == com_cur_len )
                {
                    frm_cur_len = AOS_NTOHS( *(U16*)com_pool_head );
                    if( frm_cur_len > MAX_COM_LEN ||
                        frm_cur_len < 3 )
                    {
                        com_state     = RCVING_7E;
                        com_cur_len   = 0;
                    }
                    else
                    {
                        com_state     = RCVING_DATA;
                    }
                }

                break;
                
                
            case RCVING_DATA:
                if( com_pool_head + com_cur_len + len >= (U8*)com_pool + 2 *MAX_COM_LEN )
                {
                    aos_memmove( com_pool, com_pool_head, com_cur_len );
                    com_pool_head = com_pool;
                }
                aos_memmove( com_pool_head+com_cur_len, datap, len );
                com_cur_len += len;
				datap +=len;
                len   = 0;
                
                if( com_cur_len < frm_cur_len + 3 )
                {
                    break;
                }

                FCS = com_pool_head[2];
                for( i=1; i<frm_cur_len; i++ )
                {
                    FCS ^= com_pool_head[2+i];
                }
                if( FCS == com_pool_head[2+i] )
                {
                    struct msg_blk *mb;
                    U8 *msgp;

                    msgp = aos_msg_alloc( MPE_DRV, frm_cur_len );
                    if(NULL != msgp) 
                    {
                        aos_memcpy( (VOID*)msgp, (VOID*)&com_pool_head[2], frm_cur_len );
                        
                        MSG_CREATE_BY_DATA( mb, mem_obj_head(msgp),mem_obj_size(msgp),msgp,frm_cur_len );
                        if(NULL!=mb)
                        {
                            
                             com_recv_func (LCM_DRV_SERIAL,0, mb);
                        }
                        else
                        {
                            aos_msg_free(msgp);
                        }
                    }

                }
                
                datap = com_pool_head+frm_cur_len + 3;
                len = com_cur_len-frm_cur_len -3;

                
                com_pool_head = com_pool;
                com_cur_len   = 0;
                frm_cur_len   = 0;
                com_state     = RCVING_7E;
                
                break;
                
            default:
                AOS_ASSERT(0);
        }
    }
    
}

VOID com_data_output( U32 port, struct msg_blk *mb )
{
    U32   i;
    U8    FCS;
    U16   frm_len;
    U32   preamble=AOS_HTONL(0x7e7e7e7e);
        
    (void)port;

    FCS = mb->data[0];
    for( i=1; i<mb->len; i++ )
    {
        FCS ^= *(mb->data+i);
    }
    frm_len = (U16)(mb->len);
    frm_len =  AOS_HTONS(frm_len);
    
    aos_memcpy( msg_push(mb,sizeof(U16)),(U8*)&frm_len, 2);
    aos_memcpy( msg_push(mb,sizeof(U32)),(U8*)&preamble,4);
    *(U8*)msg_put(mb,sizeof(U8))    = FCS;

    
#if(CONFIG_OS_WINDOWS == TRUE)

    sim_com_tx( mb );

#else

    phy_console_send_u1000( 0, mb->data, mb->len );
    
    aos_dmem_free( mb->head );
    msg_free( mb );

#endif

    return;
}

#endif

#ifdef __cplusplus
}
#endif