lcm_q921.c

abstract rtos

          ||BROADCAST_TEI == framep->frm.u_frame.tei )
        {
            link_type = Q931_DL_BROADCAST;
        }
        else if( SAPI_0 == framep->frm.u_frame.sapi )
        {
            
            link_type = Q931_DL_ISDN_1;
            m_links[phy_type][port_no*link_per_port[phy_type]+1].tei = framep->frm.u_frame.tei;
			if( g_ucPriTei != framep->frm.u_frame.tei )
			{
			    g_ucPriTei = framep->frm.u_frame.tei;

				aos_printf(MPE_LCM,"TEI FOR PRI IS %d",g_ucPriTei  );
			}
        }
        else
        {
            
            return;
        }
    }
    else
    {
        link_type = get_link_type( framep->frm.u_frame.tei );
    }
    if( link_type >= V5DL_ID_BUTT )
    {
        return;
    }
    if( NULL == m_links[phy_type] )
    {
        return;
    }
    
    linkp = &m_links[phy_type][port_no*link_per_port[phy_type]+link_type];

#if( CONFIG_BOARD_EIA == TRUE )
    if( LINK_NOT_ESTABLISHED == linkp->status && LCM_DRV_UDP4EIA == linkp->phy_type )
    {
        linkp->phy_port_no = dev_get_mpu_master_processorid();
    }
#endif

    cmd = get_cmd( mb, linkp );
	if( LCM_PRINT_L2_MSG(linkp) || LCM_PRINT_L3_MSG(linkp))
	{
	    print_frame( linkp, cmd, framep );
	}

    if( _ERR_CMD & cmd )
    {
        err_frame_handle( linkp, cmd );
        return;
    }

    if( _UI == cmd )
    {
          q921_ui_frame_handle( linkp, mb );
    }
    else if( NULL != q921_fsm[linkp->status] )
    {
        q921_fsm[linkp->status]( linkp, cmd, mb );
    }

    send_i_frame(linkp);

}

VOID lme_msg_proc( L2_LINK_S*linkp, struct msg_blk*mb)
{
    (void)linkp;
    (void)mb;
}

VOID q921_ui_frame_handle( L2_LINK_S *linkp, struct msg_blk *mb )
{
    U16 global_hdlc_no;
    struct msg_blk *newmb;
    LCM_UI_FRAME_S *ui_framep=NULL;
    Q921_FRAME_S *framep;

    if( linkp->phy_type >= LCM_DRV_BUTT )
    {
        #ifdef LCM_DEBUG
        aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:don't support ui for phy%s",
                             PHY_STRING(linkp->phy_type) );
        #endif

        return;
    }

    if( NULL == mb || NULL == mb->data )
    {
        #ifdef LCM_DEBUG
        aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:mb invalid,phy=%s,portno=%d",
                             PHY_STRING(linkp->phy_type), linkp->phy_port_no );
        #endif

        return;
    }

    
    if( LCM_DRV_HDLC == linkp->phy_type )
    {
        framep = (Q921_FRAME_S*)mb->data;
        if( SAPI_0 == framep->frm.u_frame.sapi )
        {
            send_unit_data_to_l3(linkp,mb);
        }
        else
        {
            lme_msg_proc(linkp,mb);
        }
        return;
    }
    else if( LCM_DRV_UDP4EIA == linkp->phy_type )
    {
        U8 *mpep,srcMpe,dstMpe;
        
        mpep = (U8*)msg_pull( mb, U_FRAME_LEN + 1 );
        srcMpe = *mpep;
        mpep++;
        dstMpe = *mpep;
        
        msg_pull( mb, 2*sizeof(U8) );
        msg_align(mb);
        
        ui_framep = (LCM_UI_FRAME_S*)msg_push( mb, L3_MSG_HEAD_LEN );
        ui_framep->srcProcessorId = linkp->phy_port_no;
        ui_framep->srcMpe         = srcMpe;
        ui_framep->dstProcessorId = LOCAL_PROCESSOR_ID;
        ui_framep->dstMpe         = dstMpe;
        
        ui_framep->ulSize         = mb->len - L3_MSG_HEAD_LEN;
    }
    else if( LCM_DRV_ETH == linkp->phy_type )
    {
        
        msg_pull( mb, U_FRAME_LEN + 1 );
        msg_align(mb);
        ui_framep = (LCM_UI_FRAME_S*)msg_pull( mb, 0 );

        ui_framep->srcProcessorId = ui_framep->srcProcessorId - 512 + processor_id_base;
        ui_framep->dstProcessorId = ui_framep->dstProcessorId - 512 + processor_id_base;
#if( AOS_INCLUDE_SSP_LOAD == TRUE )
            if( MPE_LOAD == ui_framep->srcMpe && MPE_LOAD == ui_framep->dstMpe )
            {
                load_convert_processorid(  &ui_framep->type );
            }
#endif           

    }
    else if( LCM_DRV_SERIAL == linkp->phy_type )
    {
#if(CONFIG_BOARD_EIA == TRUE && CONFIG_OS_VXWORKS == TRUE)        
        
        msg_pull( mb, U_FRAME_LEN + 1 );
        msg_align(mb);
        phy_console_recv_from_lcm( mb->data, mb->len );
#endif        
    	return;
    }
    else if (LCM_DRV_UDP4SIPTRUNK == linkp->phy_type )
    {
        send_unit_data_to_l3(linkp,mb);
        return;
    }
    else
    {
        aos_dmem_free(mb->head);
        msg_free(mb);
        return;
    }
    
    if( (mb->len < L3_MSG_HEAD_LEN )
      ||(mb->len > linkp->n201 )
      ||(ui_framep->ulSize != mb->len - L3_MSG_HEAD_LEN) )
    {
        #ifdef LCM_DEBUG
        aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:len invalid, phy=%s,portno=%d,len=%d",
                             PHY_STRING(linkp->phy_type), linkp->phy_port_no, mb->len );
        #endif

        return;
    }
    
    if( (LOCAL_PROCESSOR_ID != ui_framep->dstProcessorId) ||
        (AOS_SUCC != ssp_mpe_msg_verify( ui_framep->dstMpe )) )
    {
        #ifdef LCM_DEBUG
        aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:dstMpe invalid, phy=%s,portno=%d,"
                    "dstProc=%d dstMpe=%d",
                    PHY_STRING(linkp->phy_type), linkp->phy_port_no,
                    ui_framep->dstProcessorId, ui_framep->dstMpe );
        #endif

        return;
    }
        
    if( MPE_LCM == ui_framep->dstMpe && MPE_LCM == ui_framep->srcMpe )
    {
        if( TRANS_V5_MSG_TO_AN == ui_framep->type )
        {
            #ifdef LCM_DEBUG
            aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:tans v5 msg to an, from slot=%d hdlc no=%d",
                                 ui_framep->slot, ui_framep->hdlc_no );
            #endif
            
            if( TRUE == dev_get_commport_by_slot_hdlc( ui_framep->slot,
                                    ui_framep->hdlc_no, &global_hdlc_no) )
            {
                if( NULL != (newmb = msg_clone( mb )) )
                {
                    
                    msg_pull( newmb, ELEMENT_OFFSET( LCM_UI_FRAME_S, info ) );
                    
                    q921_phy_data_ind( LCM_DRV_HDLC, global_hdlc_no, newmb );
                    aos_dmem_free( (VOID*)newmb->head );
                    msg_free( newmb );
                }
            }
            else
            {
                #ifdef LCM_DEBUG
                aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:tans v5 msg to an, get commport fail" );
                #endif
            }
        }
        else if( TRANS_V5_MSG_TO_LE == ui_framep->type )
        {
            #ifdef LCM_DEBUG
            aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:tans v5 msg to le, "
                        "to slot = %d hdlc no=%d", ui_framep->slot, ui_framep->hdlc_no );
            #endif
            if( TRUE == dev_get_commport_by_slot_hdlc( ui_framep->slot,
                                    ui_framep->hdlc_no, &global_hdlc_no) )
            {
	            if( NULL != (newmb = msg_clone( mb )) )
	            {
	                
	                msg_pull( newmb, ELEMENT_OFFSET( LCM_UI_FRAME_S, info ) );
                    
	                lcm_drv_send( LCM_DRV_HDLC, global_hdlc_no, newmb );
	            }
            }
            else
            {
                #ifdef LCM_DEBUG
                aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle:tans v5 msg to le, get commport fail" );
                #endif
            }
            
        }
        else
        {
            #ifdef LCM_DEBUG
            aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle,send ui to self, mpe %d,src proc=%d,mpe=%d",
                        ui_framep->dstMpe, ui_framep->srcProcessorId, ui_framep->srcMpe );
            #endif
            
            if( NULL != (newmb=msg_clone(mb)) )
            {
                MSG_QUE_SEND( ui_framep->dstMpe, newmb, MSG_PRIO_NORMAL );
            }
        }
    }
    else
    {
	  	if( LCM_PRINT_L3_MSG(linkp) )
	  	{
	        aos_printf( MPE_LCM, "q921<-:q921_ui_frame_handle,send ui to mpe %d,src proc=%d,mpe=%d",
	                    ui_framep->dstMpe, ui_framep->srcProcessorId, ui_framep->srcMpe );
	  	}
        
        if( NULL != (newmb=msg_clone(mb)) )
        {
            MSG_QUE_SEND( ui_framep->dstMpe, newmb, MSG_PRIO_NORMAL );
        }
    }
}
VOID on_link_not_established( L2_LINK_S *linkp, U32 cmd, struct msg_blk *mb )
{
    Q921_FRAME_S *framep;

    
    AOS_ASSERT( NULL != linkp && NULL != mb );
    AOS_ASSERT( LINK_NOT_ESTABLISHED == linkp->status );

    
    framep = (Q921_FRAME_S*)mb->data;
    

    switch( cmd )
    {
        case _SABME :
            if( TRUE == able_to_establish( linkp ) )
            {
                send_u_frame( linkp, linkp->own_resp, _UA, framep->frm.u_frame.p_f, mb );
                CLEAR_EXCEPTION_COND( linkp );
                linkp->v_s = 0;
                linkp->v_a = 0;
                linkp->v_r = 0;
                send_msg_to_l3( linkp, MDL_ESTABLISH_INDICATION );
                start_t203( linkp );
                SET_LINK_STATUS( linkp, MULTIPLE_FRAME_ESTABLISHED );
            }
            else
            {
                send_u_frame( linkp, linkp->own_resp, _DM, framep->frm.u_frame.p_f, mb );
            }
            
            break;
            
        case _DISC :
            send_u_frame( linkp, linkp->own_resp, _DM, framep->frm.u_frame.p_f, mb );
            break;

        case _UA :
            mdl_error_indication( linkp, Q921_ERR_C );
            break;


        case _DM :
            if( !framep->frm.u_frame.p_f && able_to_establish(linkp) )
            {
                establish_data_link( linkp );
                CLEAR_L3_INITED(linkp);
                SET_LINK_STATUS( linkp, AWAITING_ESTABLISHMENT );
            }
            break;

        default:
            #ifdef LCM_DEBUG
            aos_printf( MPE_LCM, "q921<-:on_link_not_established,don't handle"
                        "cmd=%s at phy=%s portno=%d dl=%s",cmd_string(cmd),
                        PHY_STRING(linkp->phy_type), linkp->phy_port_no,
                        DL_STRING(linkp->link_type) );
            #endif
            break;
    }
    
}

VOID on_awaiting_estblishment( L2_LINK_S *linkp, U32 cmd, struct msg_blk *mb )
{
    Q921_FRAME_S *framep;

    
    AOS_ASSERT( NULL != linkp && NULL != mb );
    AOS_ASSERT( AWAITING_ESTABLISHMENT == linkp->status );

    
    framep = (Q921_FRAME_S*)mb->data;
        
    switch( cmd )
    {
        case _SABME:
            send_u_frame( linkp, linkp->own_resp, _UA, framep->frm.u_frame.p_f, mb );
            break;

        case _DISC:
            send_u_frame( linkp, linkp->own_resp, _DM, framep->frm.u_frame.p_f, mb );
            break;

        case _UA:
            if( framep->frm.u_frame.p_f )
            {
                if( linkp->own_l3_init )
                {
                    send_msg_to_l3( linkp, MDL_ESTABLISH_CONFIRM );
                }
                else
                {
                    if( linkp->v_s != linkp->v_a )
                    {
                        discard_i_que( linkp );
                        send_msg_to_l3( linkp, MDL_ESTABLISH_INDICATION );
                    }
                }

                stop_t200( linkp );
                start_t203(linkp );
                linkp->v_s = 0;
                linkp->v_a = 0;
                linkp->v_r = 0;
                SET_LINK_STATUS(linkp, MULTIPLE_FRAME_ESTABLISHED );
            }
            else
            {
                mdl_error_indication( linkp, Q921_ERR_D );
                #ifdef LCM_DEBUG
                aos_printf( MPE_LCM, "q921<-:on_awaiting_estblishment,recv an "
                            "unexpected UA with F=0 at phy=%s portno=%d",
                            PHY_STRING(linkp->phy_type), linkp->phy_port_no );
                #endif
            }

            break;
            
        case _DM:
            if( framep->frm.u_frame.p_f )
            {
                discard_i_que(linkp);
                send_msg_to_l3( linkp, MDL_RELEASE_INDICATION );
                stop_t200( linkp );
                SET_LINK_STATUS( linkp, LINK_NOT_ESTABLISHED );
            }
            break;
            
        default:
            #ifdef LCM_DEBUG
            aos_printf( MPE_LCM, "q921<-:on_awaiting_estblishment,don't handle"
                        "cmd=%s at phy=%s portno=%d, dl=%s",cmd_string(cmd),
                        PHY_STRING(linkp->phy_type), linkp->phy_port_no,
                        DL_STRING(linkp->link_type) );

            #endif
            
            break;
    }
    
}

VOID on_awaiting_release( L2_LINK_S *linkp, U32 cmd, struct msg_blk *mb )
{
    Q921_FRAME_S *framep;

    
    AOS_ASSERT( NULL != linkp && NULL != mb );
    AOS_ASSERT( AWAITING_RELEASE == linkp->status );

    
    framep = (Q921_FRAME_S*)mb->data;
    
    
    switch( cmd )
    {
        case _SABME:
            send_u_frame( linkp, linkp->own_resp, _DM, framep->frm.u_frame.p_f, mb );
            break;
            
        case _DISC:
            send_u_frame( linkp, linkp->own_resp, _UA, framep->frm.u_frame.p_f, mb );
            break;

        case _UA:
        case _DM:
            if( framep->frm.u_frame.p_f )
            {
                send_msg_to_l3( linkp, MDL_RELEASE_CONFIRM );
                stop_t200( linkp );
                SET_LINK_STATUS( linkp, LINK_NOT_ESTABLISHED );
            }
            else
            {
                
                if( _UA == cmd )
                {
	                mdl_error_indication( linkp, Q921_ERR_D );
                }
                
                #ifdef LCM_DEBUG
                aos_printf( MPE_LCM, "q921<-:on_awaiting_estblishment,unexpectd %s cmd"
                            "at phy=%s portno=%d, dl=%s",
                            cmd_string(cmd),
                            PHY_STRING(linkp->phy_type), linkp->phy_port_no,
                            DL_STRING(linkp->link_type) );

                #endif
            }
            break;
            
        default:
            break;
    }
    
}

VOID on_multi_frame_estblished( L2_LINK_S *linkp, U32 cmd, struct msg_blk *mb )
{
    Q921_FRAME_S *framep;

    
    AOS_ASSERT( NULL != linkp && NULL != mb );
    AOS_ASSERT( MULTIPLE_FRAME_ESTABLISHED == linkp->status );

    
    framep = (Q921_FRAME_S*)mb->data;