lcm_drv.c

abstract rtos

            aos_printf( MPE_LCM, "q921<-:lcm_recv_phy_data,trans v5 msg to an,slot=%s,hdlc=%d",
                        dev_get_local_slot(), port_no );
            #endif

            linkp_2 = &m_links[LCM_DRV_ETH][active_mpu_id-processor_id_base];

            
            ui_framep = (LCM_UI_FRAME_S*)msg_push( mb, ELEMENT_OFFSET( LCM_UI_FRAME_S, info ) );
            ui_framep->srcProcessorId = LOCAL_PROCESSOR_ID;
            ui_framep->srcMpe = MPE_LCM;
            ui_framep->dstProcessorId = active_mpu_id;
            ui_framep->dstMpe = MPE_LCM;
            ui_framep->ulSize = mb->len-L3_MSG_HEAD_LEN;

            ui_framep->type    = TRANS_V5_MSG_TO_AN;
            ui_framep->slot    = dev_get_local_slot();
            ui_framep->hdlc_no = (U8)port_no;

            q921_unit_data_request( linkp_2, mb );
            return;
        }

        {
            
            U8 slot;
            U16 commport;
            slot = dev_get_local_slot();

            dev_get_commport_by_slot_hdlc( slot, (U8)port_no, &commport );
            port_no = commport;
        }
#endif
    }
    
    else
    {
        U16 *ef_addrp;
	    if( LCM_DRV_ETH == phy_type )
	    {
	        U32 processor_id,len;
	        U8 slot = (U8)(port_no & 0xff), subc = (U8)( (port_no&0xff00)>>8 );

	        if( FALSE == dev_get_processorid_by_slot_subc( slot, subc, &processor_id ) )
	        {
	            goto lcm_recv_err_ret;
	        }

	        port_no = processor_id - processor_id_base;
	        
	        len = AOS_NTOHS(*(U16*)mb->data);
	        AOS_ASSERT_FUNC( mb->len >= len, goto lcm_recv_err_ret );
	        mb->len = len;
	        msg_pull( mb, sizeof(U16) );
	    }
#if( CONFIG_BOARD_EIA == TRUE )
	    else if ( LCM_DRV_UDP4EIA == phy_type )
	    {
	        port_no = 0;
	    }
#endif
        
        ef_addrp = (U16*)msg_push( mb, sizeof(U16) );
        *ef_addrp = dev_dl_ef_addr;
    }

    if( phy_type >= LCM_DRV_BUTT ||
        port_no >= phy_port_num[phy_type] )
    {
        goto lcm_recv_err_ret;
    }


    
    pU32 = (U32*)msg_push( mb, 2*sizeof(U32) );
    *pU32 = phy_type;
    pU32++;
    *pU32 = port_no;

    
    msg_que_tail( &lcm_phy_que, mb );
    aos_event_post( lcm_rcv_task_id, MSG_SYNC_EVENT );
    return;

lcm_recv_err_ret:
    if( NULL != mb )
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free( mb );
    }
}

VOID lcm_recv_task()
{
    U32 event;
    struct msg_blk *mb;

    for(;;)
    {
        aos_event_wait( MSG_SYNC_EVENT, AOS_WAIT_ANY, 0, &event );
        while( NULL != (mb=msg_deque( &lcm_phy_que )) )
        {
            U32 *pU32;
            
            pU32 = (U32*)mb->data;
            msg_pull( mb, 2*sizeof(U32) );

            if( LCM_DRV_HDLC == *pU32 )
            {
                
                LCM_TRACE_L2_MSG( mb, *(pU32+1), TRACE_DIRECTION_DOWN );
            }

            SYS_HANDLE_LOCK();
            q921_phy_data_ind( *pU32, *(pU32+1), mb );
            SYS_HANDLE_UNLOCK();
            
            aos_task_yield_time();

            aos_dmem_free( (VOID*)mb->head );
            msg_free( mb );
        }
    }
}

U32 lcm_add_drv( U32 phy_type, U32 mtu, LCM_PHY_SND send_func, LCM_PHY_RCV *recvp )
{
    if( phy_type >= LCM_DRV_BUTT )
    {
        return AOS_FAIL;
    }

    if( NULL == send )
    {
        return AOS_FAIL;
    }

    if( mtu < I_FRAME_LEN )
    {
        return AOS_FAIL;
    }

    if( NULL == recvp )
    {
        return AOS_FAIL;
    }
    lcm_phy_drv[phy_type].is_use_mbuf = FALSE;
    lcm_phy_drv[phy_type].tx.mb_send = send_func;
    lcm_phy_drv[phy_type].mtu  = mtu;
    *recvp = lcm_recv_phy_data;

    return AOS_SUCC;
}

U32 lcm_add_drv_2( U32 phy_type, U32 mtu, LCM_MBUF_SND send_func, LCM_MBUF_RCV *recvp )
{
    if( phy_type >= LCM_DRV_BUTT )
    {
        return AOS_FAIL;
    }

    if( NULL == send )
    {
        return AOS_FAIL;
    }

    if( mtu < I_FRAME_LEN )
    {
        return AOS_FAIL;
    }

    if( NULL == recvp )
    {
        return AOS_FAIL;
    }
    lcm_phy_drv[phy_type].is_use_mbuf = TRUE;
    lcm_phy_drv[phy_type].tx.mbuf_send = send_func;
    lcm_phy_drv[phy_type].mtu  = mtu;
    *recvp = lcm_recv_phy_data_with_mbuf;

    return AOS_SUCC;
}

U32 lcm_set_link_paras( U32 phy_type, U32 n200, U32 t200_len, U32 t203_len )
{
    if( phy_type >= LCM_DRV_BUTT )
    {
        return AOS_FAIL;
    }
    lcm_phy_drv[phy_type].n200 = n200;
    lcm_phy_drv[phy_type].t200_len = t200_len;
    lcm_phy_drv[phy_type].t203_len = t203_len;

    return AOS_SUCC;
}

VOID lcm_recv_phy_data_with_mbuf( U32 phy_type, U32 port_no, MBUF_S* mbuf )
{
    struct msg_blk *newmb;

    if( NULL == mbuf )
    {
        return;
    }

    if( NULL != mbuf->pstNextMBuf || 1 != mbuf->ulDataBlockNumber )
    {
        mbuf_destroy(mbuf);
        return;
    }

    newmb = msg_alloc();
    if( NULL == newmb )
    {
        mbuf_destroy(mbuf);
        return;
    }
    newmb->head    = mbuf->stDataBlockDescriptor.pucDataBlock;
    newmb->truelen = mbuf->stDataBlockDescriptor.ulDataBlockLength;
    newmb->end     = newmb->head + newmb->truelen;

    newmb->data = mbuf->stDataBlockDescriptor.pucData;
    newmb->len  = mbuf->stDataBlockDescriptor.ulDataLength;
    newmb->tail = newmb->data + newmb->len;

    
    aos_dmem_free( (VOID*)mbuf );

    lcm_recv_phy_data( phy_type, port_no, newmb );

}

U32 lcm_is_rapid_pkt( MBUF_S* pMBuf )
{
    IP_S            *ip;
    UDPHDR_S        *udp;
    TCPHDR_S        *tcp;
	U16				dst_port;
    U32             dstip;

	ip = MBUF_MTOD(pMBuf, IP_S*);

    aos_memcpy((U8*) &dstip, (U8*)&(ip->ip_stDst.s_ulAddr),4);

    if( dstip != AOS_HTONL(0x7F000001)
     && dstip != if_get_out_ip_by_ifindex( MBUF_GET_RECEIVE_IFNET_INDEX(pMBuf) )
     && AOS_HTONL(0x7F000001) != if_get_out_ip_by_ifindex( MBUF_GET_RECEIVE_IFNET_INDEX(pMBuf) ) )
    {
         return FALSE;
    }


	if (ip->ip_chHLen < 5)
	{
		
		return FALSE;
	}

    
    if( AOS_NTOHS(ip->ip_usOff) &(~IP_DF) )
    {
        return FALSE;
    }

    if( LCM_IS_UDP_PKT(ip) )
    {
    	udp = (UDPHDR_S*)((U8*)ip + ip->ip_chHLen * 4);
    	dst_port = AOS_NTOHS(udp->uh_usDPort);
    }
    else if( LCM_IS_TCP_PKT(ip) )
    {
    	tcp = (TCPHDR_S*)((U8*)ip + ip->ip_chHLen * 4);
        dst_port = AOS_NTOHS(tcp->usDstPort);
    }
    else
    {
        return FALSE;
    }

    if( IS_MGCP_STACK_UDPPORT(dst_port) )
    {
		MBUF_ASSIGN_RECEIVE_IFNET_INDEX(pMBuf, MPE_MGCP_STACK );
        return TRUE;
    }
#if (AOS_INCLUDE_SERVICE_ROUTE_SRV_SERVER == TRUE || AOS_INCLUDE_SERVICE_ROUTE_SRV_CLIENT == TRUE)
    else if( LCM_IS_UDP_PKT(ip) && IS_RS_UDPPORT(dst_port) )
    {
		MBUF_ASSIGN_RECEIVE_IFNET_INDEX(pMBuf, MPE_RS );
        return TRUE;
    }
#endif
    else if( IS_LCM_UDPPORT(dst_port) )
	{
  		MBUF_ASSIGN_RECEIVE_IFNET_INDEX(pMBuf, MPE_EDRV);
		return TRUE;
	}
	else if(IS_SIP_UDPPORT(dst_port))
	{
		MBUF_ASSIGN_RECEIVE_IFNET_INDEX(pMBuf, MPE_SIP);
		return TRUE;
	}
    else if( IS_APING_UDPPORT(dst_port) )
    {
        MBUF_ASSIGN_RECEIVE_IFNET_INDEX(pMBuf, MPE_APING);
        return TRUE;
    }
    else if (LCM_IS_UDP_PKT(ip) && IS_RC_PORT(dst_port))
    {
        MBUF_ASSIGN_RECEIVE_IFNET_INDEX(pMBuf, MPE_SST);
        return TRUE;
    }

	return FALSE;
}

VOID lcm_init_rapid_pkt_list( )
{
    U32 s;

    s = aos_int_lock();
    MBUF_QUE_INIT( &lcm_rapid_pkt_list, LCM_RAPID_PKT_LIST_SIZE );
    aos_int_unlock(s);
}

U32 lcm_rapid_recv_from_eth( MBUF_S* pstMBuf )
{
    U32         s;
    MPE         dstMpe;
    IP_S        *ip;
    UDPHDR_S    *udp = NULL;
    TCPHDR_S    *tcp = NULL;
    U16         src_port,payload_len;
    U8          *payload;
#if( CONFIG_BOARD_GMPU == TRUE )
	U32          src_ip;
#endif

    if( FALSE == m_ulMsgEnable )
    {
        mbuf_destroy(pstMBuf);
        return AOS_SUCC;
    }

    dstMpe = (U16)MBUF_GET_RECEIVE_IFNET_INDEX(pstMBuf);

#if( CONFIG_BOARD_GMPU == TRUE )
    if( FALSE == g_blIsDbMaster )
    {
        if( MPE_MGCP_STACK == dstMpe || MPE_SIP == dstMpe ||
            MPE_EDRV == dstMpe )
        {
            mbuf_destroy(pstMBuf);
            return AOS_SUCC;
        }
    }
#endif

    ip = MBUF_MTOD(pstMBuf, IP_S*);
    if( LCM_IS_UDP_PKT(ip) )
    {
    	udp = (UDPHDR_S*)((U8*)ip + ip->ip_chHLen * 4); 
        src_port = AOS_NTOHS(udp->uh_usSPort);
        payload = (U8*)(udp+1);
        payload_len = (U16)(AOS_NTOHS(udp->uh_sULen) - sizeof(UDPHDR_S));
    }
    else
    {
#if( CONFIG_BOARD_GMPU == TRUE )
        if( g_lcm_tcp_signal_disable )
        {
            mbuf_destroy(pstMBuf);
            return AOS_SUCC;
        }
#endif
        tcp = (TCPHDR_S*)((U8*)ip + ip->ip_chHLen * 4); 

        payload_len = AOS_NTOHS(ip->ip_usLen) - ip->ip_chHLen * 4 - tcp->ucOffset * 4;

        if( 0 == payload_len )
        {
            goto rapid_enque;
        }

        src_port = AOS_NTOHS(tcp->usSrcPort);
        payload = (U8*)((U8*)tcp + tcp->ucOffset* 4);
    }

    switch(dstMpe)
    {

#if( CONFIG_BOARD_GMPU == TRUE )
        
        case MPE_EDRV:
            
            if(payload_len > 10)
            {
                U8 *ptr;
                if( LCM_IS_UDP_PKT(ip) )
                {
                    ptr = (U8*)(udp + 1);
                }
                else
                {
                    ptr = (U8*)(tcp + 1);
                }

                if( lcm_is_keepalive_frame(ptr) )
                {
                    aos_memcpy( &src_ip, &ip->ip_stSrc.s_ulAddr, 4 );
                    edrv_keepalive_handle( payload, src_ip, src_port );
                    mbuf_destroy(pstMBuf);
                    return AOS_SUCC;
                }
            }
			break;
#endif
        default:
            break;
    }

rapid_enque:

    #if CONFIG_BOARD_EIA == TRUE
        if(FALSE == rtp_check_packet_valid(ip))
        {
            S8 buf[121], *str;
            U8 *addr;

            for(str = buf, addr = (U8*)ip; str < &buf[120]; str+=3, addr++)
            {
                aos_sprintf(str,"%02X ",*addr);
            }

            ssp_assert( buf, "lcm_drv.c", __LINE__ );
            mbuf_destroy(pstMBuf);
            return AOS_SUCC;
        }
    #endif

    s = aos_int_lock();
  	if(!MBUF_QUE_IS_FULL(&lcm_rapid_pkt_list))
  	{
        MBUF_QUE_ENQUEUE( &lcm_rapid_pkt_list,pstMBuf );
  	}
    else
    {
        mbuf_destroy(pstMBuf);
    }
    aos_int_unlock(s);

    return AOS_SUCC;
}

VOID lcm_rapid_eth_recv_task()
{
    MBUF_S          *pstMBuf;
    IP_S            *ip;
    UDPHDR_S        *udp;
    TCPHDR_S        *tcp;
    MPE              dstMpe;
    SOCKADDRIN_S     addr;
    struct msg_blk  *mb;
    L3_MSG_HEAD_S   *pL3Msg;
    U32              s, count, tcpflag = 0;
    U32              tcpSeq, tcpAck, *pU32;

    for( count = LCM_RAPID_PKT_LIST_SIZE; count > 0; count-- )
    {
        s = aos_int_lock();
        MBUF_QUE_DEQUEUE( &lcm_rapid_pkt_list,pstMBuf );
        aos_int_unlock(s);
        if( NULL == pstMBuf )
        {
            break;
        }

#if( CONFIG_BOARD_GDSP == TRUE )
        mbuf_destroy(pstMBuf);
#else
    	dstMpe = (U16)MBUF_GET_RECEIVE_IFNET_INDEX(pstMBuf);

        mb = msg_alloc();
        if( NULL == mb )
        {
            mbuf_destroy(pstMBuf);
            break;
        }

    	dstMpe = (U16)MBUF_GET_RECEIVE_IFNET_INDEX(pstMBuf);
    	ip = MBUF_MTOD(pstMBuf, IP_S*);

        addr.sin_chLen    = sizeof(SOCKADDRIN_S);
        addr.sin_chFamily = AF_INET;
        aos_memcpy((U8*) &(addr.sin_stAddr.s_ulAddr),  (U8*)&(ip->ip_stSrc.s_ulAddr), 4);
        *(U32*)(&addr.sin_chZero_a)    = 0;
        *(U32*)(&addr.sin_chZero_a[4]) = 0;

        mb->head    = pstMBuf->stDataBlockDescriptor.pucDataBlock;
        mb->truelen = pstMBuf->stDataBlockDescriptor.ulDataBlockLength;
        mb->end     = mb->head + mb->truelen;

        if( LCM_IS_UDP_PKT(ip) )
        {
            tcpflag = 0;
        	udp = (UDPHDR_S*)((U8*)ip + ip->ip_chHLen * 4); 
            mb->data = (U8*)udp + sizeof(UDPHDR_S);
            mb->len  = (U32)(AOS_NTOHS(udp->uh_sULen) - sizeof(UDPHDR_S));
            tcpSeq   = 0;
            tcpAck   = 0;
            addr.sin_usPort   = udp->uh_usSPort;
        }
        else
        {
            tcp = (TCPHDR_S*)((U8*)ip + ip->ip_chHLen * 4); 
            mb->data = (U8*)tcp + tcp->ucOffset* 4;
            mb->len  = AOS_NTOHS(ip->ip_usLen) - ip->ip_chHLen * 4 - tcp->ucOffset * 4;
            aos_memcpy( &tcpSeq, &tcp->seqSeqNumber, sizeof(U32) );
            aos_memcpy( &tcpAck, &tcp->seqAckNumber, sizeof(U32) );
            tcpSeq = AOS_NTOHL(tcpSeq);
            tcpAck = AOS_NTOHL(tcpAck);
            addr.sin_usPort   = tcp->usSrcPort;

            tcpflag = tcp->ucFlags;
            if( !tcpflag )
            {
                AOS_ASSERT(0);
                tcpflag = LCM_TCP_ACK;
            }
        }
        mb->tail = mb->data + mb->len;

        msg_align(mb);

        if( MPE_MGCP_STACK == dstMpe || MPE_SIP == dstMpe
        || MPE_P2P_MNGT == dstMpe || MPE_SST == dstMpe || MPE_RS == dstMpe)
        {
        	aos_memcpy( msg_push(mb,sizeof(SOCKADDRIN_S)),&addr,sizeof(SOCKADDRIN_S) );
            pU32 = (U32*)msg_push(mb,3*sizeof(U32));
            if( !tcpflag )
            {
                aos_memset( (U8*)pU32, 0, 3*sizeof(U32) );
            }
            else
            {
                aos_memcpy( pU32++, &tcpflag, sizeof(U32) );
                aos_memcpy( pU32++, &tcpSeq, sizeof(U32) );
                aos_memcpy( pU32, &tcpAck, sizeof(U32) );
            }

            pL3Msg = (L3_MSG_HEAD_S*)msg_push( mb, L3_MSG_HEAD_LEN );
            pL3Msg->srcProcessorId  = LOCAL_PROCESSOR_ID;
            pL3Msg->srcMpe  = dstMpe;
            pL3Msg->dstProcessorId  = LOCAL_PROCESSOR_ID;
            pL3Msg->dstMpe  = dstMpe;
            pL3Msg->ulSize  = mb->len - L3_MSG_HEAD_LEN;

    		mb->tail[0] = 0;

            MSG_QUE_SEND( dstMpe, mb, MSG_PRIO_NORMAL );
        }
#if( CONFIG_BOARD_GMPU == TRUE ) || (CONFIG_BOARD_EIA == TRUE )
        else if( MPE_APING != dstMpe )
        {
            if( LCM_TCP_PUSH_ACK == tcpflag || !tcpflag )
            {