lcm_l3.c

abstract rtos

        (AOS_SUCC != ssp_mpe_msg_verify(rcv_mpe)) )
    {
    #ifdef     LCM_DEBUG
        aos_printf( MPE_LCM, "q921->:send_data_to_l3:can't find recv mpe,phy=%s,portno=%d,dl=%s",
                    PHY_STRING(linkp->phy_type),
                    linkp->phy_port_no,
                    DL_STRING(linkp->link_type));
    #endif
        return;
    }

  	
    if( MPE_DEV != rcv_mpe )
    {
        newmb = msg_clone(mb);
        if( NULL == newmb )
        {
            return;
        }
        
        msg_pull( newmb, I_FRAME_LEN );
        msg_align( mb );

        
        pDlMsg = (DL_MSG_S*)msg_push( newmb, ELEMENT_OFFSET( DL_MSG_S, ucInfo ) );
        pDlMsg->ucPrimID   = DL_DATA_INDICATION;
        pDlMsg->ucPhyType  = linkp->phy_type;
        pDlMsg->usCommPort = (U16)linkp->phy_port_no;
        pDlMsg->ucV5DLType = linkp->link_type;
        
        pDlMsg->usLength   = (U16)newmb->len;
        
	    pDlMsg->sOffset    = 0;  
		
        
        pL3Msg = (L3_MSG_HEAD_S*)msg_push(newmb,L3_MSG_HEAD_LEN);
        pL3Msg->srcProcessorId = LOCAL_PROCESSOR_ID;
        pL3Msg->srcMpe         = MPE_LCM;
        pL3Msg->dstProcessorId = LOCAL_PROCESSOR_ID;
        pL3Msg->dstMpe         = rcv_mpe;
        
        pL3Msg->ulSize         = newmb->len - L3_MSG_HEAD_LEN;

        
        if( !linkp->is_for_dss1 && !linkp->is_for_siptrunk )
        {
            LCM_TRACE_L3_MSG( pDlMsg, TRACE_DIRECTION_DOWN );
        }
        
        MSG_QUE_SEND( rcv_mpe, newmb, MSG_PRIO_NORMAL );
    }
    else
    {
        
        if( LCM_DRV_UDP4EIA == linkp->phy_type )
        {
            U8 *mpep,srcMpe,dstMpe;
            
            mpep = (U8*)msg_pull( mb, I_FRAME_LEN );
            srcMpe = *mpep;
            mpep++;
            dstMpe = *mpep;
            
            msg_pull( mb, 2*sizeof(U8) );
            msg_align( mb );
            
            pL3Msg = (L3_MSG_HEAD_S*)msg_push( mb, L3_MSG_HEAD_LEN );
            pL3Msg->srcProcessorId = linkp->phy_port_no;
            pL3Msg->srcMpe         = srcMpe;
            pL3Msg->dstProcessorId = LOCAL_PROCESSOR_ID;
            pL3Msg->dstMpe         = dstMpe;
            
            
            pL3Msg->ulSize         = mb->len - L3_MSG_HEAD_LEN;
            
        }
        else if( LCM_DRV_ETH == linkp->phy_type )
        {
            pL3Msg = (L3_MSG_HEAD_S*)msg_pull( mb, I_FRAME_LEN );
            
            pL3Msg->srcProcessorId = pL3Msg->srcProcessorId - 512 + processor_id_base;
            pL3Msg->dstProcessorId = pL3Msg->dstProcessorId - 512 + processor_id_base;

#if( AOS_INCLUDE_SSP_LOAD == TRUE )
            if( MPE_LOAD == pL3Msg->srcMpe && MPE_LOAD == pL3Msg->dstMpe )
            {
                load_convert_processorid(  pL3Msg->msg );
            }
#endif           
        }
        else if( LCM_DRV_SERIAL == linkp->phy_type )
        {
            msg_pull( mb, I_FRAME_LEN );
            msg_pull( mb, sizeof(U16) );
            msg_align( mb );
            pL3Msg = (L3_MSG_HEAD_S*)msg_pull( mb, 0 );
            pL3Msg->srcProcessorId = U1000_PROCESSOR_ID;
            
            pL3Msg->dstProcessorId = LOCAL_PROCESSOR_ID;

            
            pL3Msg->srcMpe = AOS_HTONL(pL3Msg->srcMpe);
            pL3Msg->dstMpe = AOS_HTONL(pL3Msg->dstMpe);
            pL3Msg->ulSize = AOS_HTONL(pL3Msg->ulSize);
        }
        else
        {
        	return;
        }

        #ifdef     LCM_DEBUG
        aos_printf( MPE_LCM, "q921->:send_data_to_l3:dstProc=%d,dstMpe=%d,"
                    "srcProc=%d,srcMpe=%d,size=%d",
                    pL3Msg->dstProcessorId,pL3Msg->dstMpe,
                    pL3Msg->srcProcessorId,pL3Msg->srcMpe,pL3Msg->ulSize );
        #endif

        if( LOCAL_PROCESSOR_ID != pL3Msg->dstProcessorId )
        {
            #ifdef     LCM_DEBUG
            aos_printf( MPE_LCM, "q921->:send_data_to_l3:proc error" );
            #endif
            return;
        }
        if( AOS_SUCC != ssp_mpe_msg_verify(pL3Msg->dstMpe) )
        {
            #ifdef     LCM_DEBUG
            aos_printf( MPE_LCM, "q921->:send_data_to_l3:mpe error" );
            #endif
            return;
        }
        
        if( pL3Msg->ulSize != (mb->len -L3_MSG_HEAD_LEN) )
        
        {
            #ifdef     LCM_DEBUG
            aos_printf( MPE_LCM, "q921->:send_data_to_l3:size error" );
            #endif
            return;
        }

        newmb = msg_clone(mb);
        if( NULL == newmb )
        {
            #ifdef     LCM_DEBUG
            aos_printf( MPE_LCM, "q921->:send_data_to_l3:mb clone fail" );
            #endif
            return;
        }
        
        MSG_QUE_SEND( pL3Msg->dstMpe, newmb, MSG_PRIO_NORMAL );
    }
}



VOID send_unit_data_to_l3( L2_LINK_S *linkp, struct msg_blk *mb )
{
    struct msg_blk *newmb;
    L3_MSG_HEAD_S* pL3Msg;
    DL_MSG_S *pDlMsg;
       
    AOS_ASSERT_FUNC( NULL != linkp && NULL != mb, return );

    if( AOS_SUCC != ssp_mpe_msg_verify(MPE_Q931) )
    {
        #ifdef     LCM_DEBUG
        aos_printf( MPE_LCM, "q921->:send_data_to_l3:can't find recv mpe,phy=%s,portno=%d,dl=%s",
                    PHY_STRING(linkp->phy_type),
                    linkp->phy_port_no,
                    DL_STRING(linkp->link_type));
        #endif
        return;
    }

    
    if( !linkp->is_for_dss1 && !linkp->is_for_siptrunk )
    {
        return;
    }

    newmb = msg_clone(mb);
    if( NULL == newmb )
    {
        return;
    }

    if( LCM_DRV_HDLC == linkp->phy_type )
    {
        
        msg_pull( newmb, U_FRAME_LEN );
    }
    else
    {
        
        msg_pull( newmb, U_FRAME_LEN + 1 );
    }

    msg_align(newmb);

    
    pDlMsg = (DL_MSG_S*)msg_push( newmb, ELEMENT_OFFSET( DL_MSG_S, ucInfo ) );
    pDlMsg->ucPrimID   = DL_UNIT_DATA_INDICATION;
    pDlMsg->ucPhyType  = linkp->phy_type;
    pDlMsg->usCommPort = (U16)linkp->phy_port_no;
    pDlMsg->ucV5DLType = linkp->link_type;
    
    pDlMsg->usLength   = (U16)newmb->len;
    
    pDlMsg->sOffset    = 0;
	
    
    pL3Msg = (L3_MSG_HEAD_S*)msg_push(newmb,L3_MSG_HEAD_LEN);
    pL3Msg->srcProcessorId = LOCAL_PROCESSOR_ID;
    pL3Msg->srcMpe         = MPE_LCM;
    pL3Msg->dstProcessorId = LOCAL_PROCESSOR_ID;
    pL3Msg->dstMpe         = linkp->is_for_dss1 ? MPE_Q931 : MPE_FAXD;
    
    pL3Msg->ulSize         = newmb->len - L3_MSG_HEAD_LEN;

    MSG_QUE_SEND( MPE_Q931, newmb, MSG_PRIO_NORMAL );
}

U32 lcm_is_u1000_connected()
{
    L2_LINK_S *linkp;

    
    linkp = lcm_get_link_cb( LCM_DRV_SERIAL, V5DL_ID_DEV_MNGT, 0 );
    if( NULL == linkp )
    {
        return FALSE;
    }
    	
    return  ((MULTIPLE_FRAME_ESTABLISHED == linkp->status) ||
             (TIMER_RECOVERY == linkp->status)||
    	     (!linkp->own_l3_init && (AWAITING_ESTABLISHMENT == linkp->status)) );

}

VOID com_send_console_msg( S8 *msg, U32 len )
{
    U8              *datap;
    struct msg_blk *mb;
    L2_LINK_S      *linkp;

    linkp = lcm_get_link_cb( LCM_DRV_SERIAL, V5DL_ID_DEV_MNGT, 0 );
    if( NULL == linkp )
    {
        return;
    }

    mb = msg_alloc4drv( len + 32 );
    if( NULL == mb )
    {
        return;
    }
    
    datap = msg_put( mb, len );
    aos_memcpy( datap, msg, len );
        
    q921_unit_data_request( linkp, mb );
    
}

AOS_INLINE static U32 get_rcv_mpe( L2_LINK_S *linkp )
{
    MPE rcv_mpe;
    
    if( !linkp->is_for_dss1 )
    {
        switch( linkp->link_type )
        {
            case V5DL_ID_PSTN:
            case V5DL_ID_BCC:
            case V5DL_ID_CTRL:
            case V5DL_ID_LINKC:
            case V5DL_ID_PROT1:
            case V5DL_ID_PROT2:
                rcv_mpe = MPE_V5MNGT;
                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;        
    }
    
    return rcv_mpe;
}

S8 *lcm_get_prim_string( U32 prim )
{
    return PRIM_STRING( prim );
}
    
#ifdef __cplusplus
}
#endif