lcm_l3.c

abstract rtos

#ifdef __cplusplus
extern "C"{
#endif 


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

#include "trace/trace_pub.h"
#if( CONFIG_BOARD_GMPU == TRUE )                
#include "v5_pub.h"
#endif


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


#include "lcm_q921.h"
#include "lcm_if.h"

extern VOID load_convert_processorid( VOID *pMsg );

    

AOS_INLINE static U32 get_rcv_mpe( L2_LINK_S *linkp );



U32 lcm_send_data( U32 prim, struct msg_blk *mb )
{
    U32 phy_type, portno;
    L2_LINK_S *linkp;
    L3_MSG_HEAD_S *msgp;

    U8 srcMpe, dstMpe, *headp;
    AOS_ASSERT( (DL_UNIT_DATA_REQUEST == prim || DL_DATA_REQUEST == prim) );
    AOS_ASSERT( (NULL != mb) && (NULL != mb->data) );

    
    msgp = (L3_MSG_HEAD_S*)mb->data;
    

    if( TRUE == dev_card_is_eia( msgp->srcProcessorId ) )
    {
    	if( U1000_PROCESSOR_ID != msgp->dstProcessorId ) 
    	{
    		
	        phy_type = LCM_DRV_UDP4EIA;
	        portno   = 0;
	        
	        srcMpe = (U8)msgp->srcMpe;
	        dstMpe = (U8)msgp->dstMpe;
	        
	        msg_pull( mb, L3_MSG_HEAD_LEN );
	        
	        headp = msg_push( mb, 2*sizeof(U8) );
	        *headp++ = srcMpe;
	        *headp   = dstMpe;
    	}
    	else
    	{
    	    U16 *fp;
    		
            phy_type = LCM_DRV_SERIAL;
            portno   = 0;

            
            msgp->srcProcessorId = AOS_HTONL(msgp->srcProcessorId);
            msgp->srcMpe = AOS_HTONL(msgp->srcMpe);
            msgp->dstProcessorId = AOS_HTONL(msgp->dstProcessorId);
            msgp->dstMpe = AOS_HTONL(msgp->dstMpe);
            msgp->ulSize = AOS_HTONL(msgp->ulSize);

            fp  = (U16*)msg_push( mb, sizeof(U16) );
            *fp = 0;
    	}
    }
    else if( TRUE == dev_card_is_in_local_frame( msgp->srcProcessorId ) )
    {
        if( TRUE == dev_card_is_eia( msgp->dstProcessorId ) )
        {
            phy_type = LCM_DRV_UDP4EIA;
            portno   = msgp->dstProcessorId;
            
            srcMpe = (U8)msgp->srcMpe;
            dstMpe = (U8)msgp->dstMpe;
            
            msg_pull( mb, L3_MSG_HEAD_LEN );
            
            headp = msg_push( mb, 2*sizeof(U8) );
            *headp++ = srcMpe;
            *headp   = dstMpe;
        }
        else if( TRUE == dev_card_is_in_local_frame( msgp->dstProcessorId ) )
        {
            phy_type = LCM_DRV_ETH;
            portno = msgp->dstProcessorId - processor_id_base;
            msgp->dstProcessorId = portno + 512;
            msgp->srcProcessorId = msgp->srcProcessorId - processor_id_base + 512;

#if( AOS_INCLUDE_SSP_LOAD == TRUE )
            if( MPE_LOAD == msgp->srcMpe && MPE_LOAD == msgp->dstMpe )
            {
                load_convert_processorid(  msgp->msg );
            }
#endif

        }
        else
        {
            return MSG_DST_PROCESSORID_INVALID;
        }
    }
    else
    {
        return MSG_SRC_PROCESSORID_INVALID;
    }

    if( NULL == m_links[phy_type] )
    {
    	return MSG_LCM_LINK_NULL;
    }

    
    linkp = &m_links[phy_type][portno];

    if( DL_DATA_REQUEST == prim )
    {
        q921_data_request( linkp, mb );
    }
    else
    {
        q921_unit_data_request( linkp, mb );        
    }
    
    return AOS_SUCC;
}

U32 lcm_is_dl_established( U32 phy_type, U32 port, U32 dl )
{
    L2_LINK_S *linkp;

    linkp = lcm_get_link_cb( phy_type, dl, port );
    return ( NULL!= linkp ) && (MULTIPLE_FRAME_ESTABLISHED == linkp->status ||
        TIMER_RECOVERY == linkp->status);
}

VOID send_msg_to_self( L2_LINK_S *linkp, U16 prim )
{
    LCM_SELF_MSG_S *selfp;
    MSG_S msg;
        
    AOS_ASSERT( NULL != linkp );

    selfp = (LCM_SELF_MSG_S*)aos_msg_alloc( MPE_LCM, sizeof(LCM_SELF_MSG_S) );
    if( NULL == selfp )
    {
        aos_printf( MPE_LCM, "q921->:send_msg_to_self,msg alloc fail" );
        return;
    }

    selfp->prim        = prim;
    selfp->phy_type    = linkp->phy_type;
    selfp->phy_port_no = linkp->phy_port_no;
    selfp->link_type   = linkp->link_type;
    
    msg.srcProcessorId = LOCAL_PROCESSOR_ID;
    msg.srcMpe         = MPE_LCM;
    msg.dstProcessorId = LOCAL_PROCESSOR_ID;
    msg.dstMpe         = MPE_LCM;
    msg.ulSize         = sizeof( LCM_SELF_MSG_S );
    msg.msgPrio        = MSG_PRIO_NORMAL;
    msg.pvMsgBuf       = (VOID*)selfp;
    
    aos_msg_send( &msg );
    
}

VOID send_msg_to_l3( L2_LINK_S *linkp, U32 prim )
{
    MPE rcv_mpe;
    DL_MSG_S* pDlMsg;
    MSG_S msg;
    
    AOS_ASSERT( (NULL != linkp) && (LCM_PRIM_BUTT > prim) );
    
    if(LCM_PRINT_MNGT(linkp))
    {
	    aos_printf( MPE_LCM, "q921->:send_msg_to_l3:phy=%s,portno=%d,dl=%s,prim=%s",
	                PHY_STRING(linkp->phy_type),
	                linkp->phy_port_no,
	                DL_STRING(linkp->link_type),
	                PRIM_STRING(prim) );
    }
    
	if( LCM_DRV_SERIAL == linkp->phy_type )
	{
		
		return;
	}    

    rcv_mpe = get_rcv_mpe(linkp);

    if( MPE_BUTT == rcv_mpe )
    {
#ifdef     LCM_DEBUG
        aos_printf( MPE_LCM, "q921->:send_msg_to_l3:can't find recv mpe,fail, phy=%s,portno=%d,dl=%s,prim=%s",
                PHY_STRING(linkp->phy_type),
                linkp->phy_port_no,
                DL_STRING(linkp->link_type),
                PRIM_STRING(prim) );
#endif
        
        return;
    }

    pDlMsg = (DL_MSG_S*)aos_msg_alloc( MPE_LCM, sizeof(DL_MSG_S ) );
    if( NULL == pDlMsg )
    {
#ifdef     LCM_DEBUG
    aos_printf( MPE_LCM, "q921->:send_msg_to_l3:alloc msg fail, phy=%s,portno=%d,dl=%s,prim=%s",
                PHY_STRING(linkp->phy_type),
                linkp->phy_port_no,
                DL_STRING(linkp->link_type),
                PRIM_STRING(prim) );
#endif
        return;
    }

    pDlMsg->ucPrimID = (U8)prim;
    pDlMsg->ucPhyType= (U8)linkp->phy_type;
    pDlMsg->usCommPort = (U16)linkp->phy_port_no;
    pDlMsg->ucV5DLType = linkp->link_type;
	pDlMsg->usLength   = (U16)ELEMENT_OFFSET(DL_MSG_S, ucInfo);
    pDlMsg->sOffset    = 0;  
		
    msg.srcProcessorId = LOCAL_PROCESSOR_ID;
    msg.srcMpe         = MPE_LCM;
    msg.dstProcessorId = LOCAL_PROCESSOR_ID;
    msg.dstMpe         = rcv_mpe;
    msg.ulSize         = ELEMENT_OFFSET(DL_MSG_S, ucInfo);
    msg.msgPrio        = MSG_PRIO_NORMAL;
    msg.pvMsgBuf       = pDlMsg;
    
    aos_msg_send(&msg);
    
}

VOID send_data_to_l3( L2_LINK_S *linkp, struct msg_blk *mb )
{
    MPE rcv_mpe;
    struct msg_blk *newmb;
    L3_MSG_HEAD_S* pL3Msg;
    DL_MSG_S *pDlMsg;
       
    AOS_ASSERT( NULL != linkp && NULL != mb );

  	if( LCM_PRINT_L3_MSG(linkp) )
  	{
	    aos_printf( MPE_LCM, "q921->:send_data_to_l3:phy=%s,portno=%d,dl=%s",
	                PHY_STRING(linkp->phy_type),
	                linkp->phy_port_no,
	                DL_STRING(linkp->link_type) );
  	}

    if( !linkp->is_for_dss1 )
    {
        switch( linkp->link_type )
        {
            case V5DL_ID_PSTN:
                rcv_mpe = MPE_V5PSTN;
                break;
            case V5DL_ID_BCC:
                rcv_mpe = MPE_V5BCC;
                break;
                
            case V5DL_ID_CTRL:
                rcv_mpe = MPE_V5CTRL;
                break;

            case V5DL_ID_LINKC:
                rcv_mpe = MPE_V5LINKC;
                break;

            case V5DL_ID_PROT1:
                rcv_mpe = MPE_V5PROT;
                break;

            case V5DL_ID_PROT2:
                rcv_mpe = MPE_V5PROT;
                break;
                
            case V5DL_ID_DEV_MNGT:
                if( !linkp->is_for_siptrunk )
                {
                    rcv_mpe = MPE_DEV;
                }
                else
                {
                    rcv_mpe = MPE_FAXD; 
                }
                break;

            default:
                rcv_mpe = MPE_BUTT;
                break;
        }        
    }
    else
    {
        rcv_mpe = MPE_Q931;
    }
    
    if( (MPE_BUTT == rcv_mpe) ||