lcm_q921.c

abstract rtos

        case DL_DATA_REQUEST:
        case DL_UNIT_DATA_REQUEST:
            {
                struct msg_blk *newmb;

                
                if( !linkp->is_for_dss1 )
                {
                    
                    LCM_TRACE_L3_MSG( pL3L2Prim, TRACE_DIRECTION_UP );
                }

				if(MPE_Q931 != srcMpe)
				{
					
					pL3L2Prim->sOffset = 0;
					pL3L2Prim->usLength = (U16)((L3_MSG_HEAD_S*)((U32)pL3L2Prim - ELEMENT_OFFSET(L3_MSG_HEAD_S, msg)))->ulSize;
				}
                    
                newmb = msg_clone_by_v5_data( pL3L2Prim );
                if( NULL == newmb )
                {
                    aos_printf( MPE_LCM, "q921:q921_mngt_handle,dl_data_req,msg clone fail" );
                    break;
                }

                if( DL_DATA_REQUEST == pL3L2Prim->ucPrimID )
                {
                    q921_data_request( linkp, newmb );
                }
                else
                {
                    q921_unit_data_request( linkp, newmb );
                }
                
            }
            break;
            
        case MDL_ESTABLISH_REQUEST:
            q921_establish_req( linkp );
            break;
            
        case MDL_RELEASE_REQUEST:
        case MDL_L1_FAIL_INDICATION:
            q921_release_req( linkp);
            break;
        default:
            AOS_ASSERT(0);
            break;

    }
}

VOID lcm_force_release_gdsp_link()
{
    U32 gmpu_proc_id, i;
    L2_LINK_S *linkp;

    gmpu_proc_id = dev_get_mpu_master_processorid();
    linkp = lcm_get_link_cb( LCM_DRV_ETH, V5DL_ID_DEV_MNGT, gmpu_proc_id );
    if( NULL == linkp )
    {
        return;
    }
    
    for( i = 0; i<3; i++ )
    {
        q921_release_req(linkp);
    }
}

VOID q921_timeout_handle( U32 name, L2_LINK_S *linkp )
{
    if( name >= LCM_TIMER_BUTT )
    {
        aos_printf( MPE_LCM,"q921:unknown timer, name =%d", name );
        return;
    }
    if( NULL == linkp )
    {
        return;
    }

	if( LCM_PRINT_L2_MSG(linkp) )
	{
	    aos_printf( MPE_LCM,"q921:timeout, name=%s phy=%s,portno=%d,dl=%s status=%s ",
	                TIMER_STRING( name ),
	                PHY_STRING(linkp->phy_type),
	                linkp->phy_port_no,
	                DL_STRING(linkp->link_type),
	                STATUS_STRING(linkp->status) );
	}

    switch( name )
    {
        case Q921_T200:
            switch( linkp->status )
            {
                case LINK_NOT_ESTABLISHED:
                    aos_printf( MPE_LCM, "q921:unexpected status" );
                    break;
                    
                case AWAITING_ESTABLISHMENT:
                    if( linkp->n200 == linkp->rc )
                    {
                    	discard_i_que(linkp);
           	            mdl_error_indication( linkp, Q921_ERR_G );
                        send_msg_to_l3( linkp, MDL_RELEASE_INDICATION );
                        SET_LINK_STATUS(linkp, LINK_NOT_ESTABLISHED );
                    }
                    else
                    {
                        linkp->rc++;
                        send_u_frame_2( linkp, linkp->own_cmd, _SABME, P_1 );
                        start_t200( linkp );
                    }

                    break;
                    
                case AWAITING_RELEASE:
                    if( linkp->n200 == linkp->rc )
                    {
			            mdl_error_indication( linkp, Q921_ERR_H );
                        send_msg_to_l3( linkp, MDL_RELEASE_CONFIRM );
                        SET_LINK_STATUS(linkp, LINK_NOT_ESTABLISHED );
                    }
                    else
                    {
                        linkp->rc++;
                        send_u_frame_2( linkp, linkp->own_cmd, _DISC, P_1 );
                        start_t200( linkp );
                    }
                    break;
                    
                case MULTIPLE_FRAME_ESTABLISHED:
                    linkp->rc = 0;
                    transmit_enquiry( linkp );
                    linkp->rc++;
                    SET_LINK_STATUS( linkp, TIMER_RECOVERY );
                    
                    break;
                    
                case TIMER_RECOVERY:
                    if( linkp->n200 == linkp->rc )
                    {
			            mdl_error_indication( linkp, Q921_ERR_I );
                        establish_data_link( linkp );
                        CLEAR_L3_INITED( linkp );
                        SET_LINK_STATUS( linkp, AWAITING_ESTABLISHMENT );
                    }
                    else
                    {
#if( CONFIG_BOARD_EIA == TRUE && AOS_INCLUDE_SERVICE_P2P_NN == TRUE )
                        if( LCM_DRV_UDP4EIA == linkp->phy_type
                         && 2 == linkp->rc )
                        {
                            extern U16 g_lcm_rel_udp_port;
                            p2p_trans_path_refresh( g_lcm_rel_udp_port, 
                                                    drv_eia_get_peer_ip((U16)linkp->phy_port_no), 
                                                    drv_eia_get_peer_port((U16)linkp->phy_port_no),
                                                    P2P_PATH_BREAK );
                        }
#endif
                        transmit_enquiry( linkp );
                        linkp->rc++;
                    }
                    
                    break;
                    
                default:
                    AOS_ASSERT( 0 );
                    break;
            }
            
            break;
            
        case Q921_T203:
            if( MULTIPLE_FRAME_ESTABLISHED == linkp->status )
            {
                transmit_enquiry( linkp );
                linkp->rc = 0;
                SET_LINK_STATUS( linkp, TIMER_RECOVERY );
            }
            
            break;
        default:
            AOS_ASSERT( 0 );
            break;
    }

}

VOID q921_self_handle( MSG_S *msgp )
{
    LCM_SELF_MSG_S *selfp;
    L2_LINK_S *linkp;
    
    AOS_ASSERT( NULL != msgp );
    
    
    selfp = (LCM_SELF_MSG_S*)msgp->pvMsgBuf;
    AOS_ASSERT( NULL != selfp );
    
    switch( selfp->prim )
    {
        
        case ACK_PENDING:

            if( selfp->phy_type >= LCM_DRV_BUTT ||
                selfp->link_type >= V5DL_ID_BUTT )
            {
                return;
            }

            linkp = lcm_get_link_cb( selfp->phy_type, selfp->link_type, selfp->phy_port_no );
            if( NULL == linkp )
            {
            	break;
            }
            
            if( (MULTIPLE_FRAME_ESTABLISHED == linkp->status) ||
                (TIMER_RECOVERY             == linkp->status) )
            {
                if( linkp->ack_pending )
                {
                    CLEAR_ACK_PENDING(linkp);
                    send_s_frame( linkp, linkp->own_resp, _RR, F_0 );
                }
            }
            break;
            
        case LCM_EFFICIENT_TEST:
        case LCM_EFFICIENT_TEST_ACK:
            lcm_test_proc((LCM_EFFICIENT_MSG_S*)selfp, msgp->srcProcessorId);
            break;
            
        default:
            break;
    }
    }

VOID err_frame_handle( L2_LINK_S *linkp, U32 cmd )
{
    AOS_ASSERT( NULL != linkp );

    
    switch( cmd )
    {
    	case _ERR_UNKNOWN_FRAME:
    		mdl_error_indication( linkp, Q921_ERR_L );    		
    		break;
    		
    	case _ERR_FRAME:
    		mdl_error_indication( linkp, Q921_ERR_N );
    		break;
    		
    	case _ERR_FRAME_TOO_LONG:
    		mdl_error_indication( linkp, Q921_ERR_O );
    		break;

    	default:
    		return;
    }
    
    if( MULTIPLE_FRAME_ESTABLISHED == linkp->status ||
        TIMER_RECOVERY == linkp->status )
    {
        establish_data_link( linkp );
        CLEAR_L3_INITED( linkp );
        SET_LINK_STATUS( linkp, AWAITING_ESTABLISHMENT );
    }
    
}

VOID q921_unit_data_request( L2_LINK_S *linkp, struct msg_blk *mb )
{
    Q921_FRAME_S *framep;
    U32 send_flg = FALSE;
    U8 *fillp;

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

        return;
    }

    if( linkp->phy_type >= LCM_DRV_BUTT )
    {
        #ifdef LCM_DEBUG
        #endif

        goto ui_free_mb;
    }

    if( LCM_DRV_HDLC != linkp->phy_type )
    {
        
        
        fillp = (U8*)msg_push( mb, 1 );
        *fillp = 0xFF;
    }
    if( mb->len > linkp->n201 )
    {
        #ifdef LCM_DEBUG
        aos_printf( MPE_LCM, "q921:q921_unit_data_request:len invalid, phy=%s,portno=%d,len=%d",
                             PHY_STRING(linkp->phy_type), linkp->phy_port_no, mb->len );
        #endif

        goto ui_free_mb;
    }


    
    framep = (Q921_FRAME_S*)msg_push( mb, U_FRAME_LEN );
    
    framep->ef_addr = linkp->ef_addr;
    
    framep->frm.u_frame.sapi = linkp->sapi;
    framep->frm.u_frame.c_r  = linkp->own_cmd;
    framep->frm.u_frame.ea_0 = 0;
    framep->frm.u_frame.tei  = linkp->tei;
    framep->frm.u_frame.ea_1 = 1;

    
    framep->frm.info[2] = _UI;
    framep->frm.u_frame.p_f = P_0;

    LCM_CUT_EFADDR_AND_SEND(linkp,mb);
    send_flg = TRUE;

ui_free_mb:

    if( FALSE == send_flg )
    {
        aos_dmem_free( (VOID*)mb->head );
        msg_free( mb );
    }
}

VOID q921_data_request( L2_LINK_S *linkp, struct msg_blk *mb )
{
    U32 send_flg = FALSE;;
    
    AOS_ASSERT( NULL != linkp && NULL != mb && NULL != mb->data );

    
    
    if( mb->len > linkp->n201 )
    {
        #ifdef LCM_DEBUG
        aos_printf( MPE_LCM, "q921:q921_data_request:len invalid, phy=%s,portno=%d,len=%d",
                             PHY_STRING(linkp->phy_type), linkp->phy_port_no, mb->len );
        #endif

        goto i_free_mb;
    }

    
    msg_push( mb, I_FRAME_LEN );

    if( LINK_NOT_ESTABLISHED == linkp->status )
    {
        #ifdef LCM_DEBUG
        aos_printf( MPE_LCM, "q921:link not established,can't send information" );
        #endif
    }

    switch( linkp->status )
    {
        case AWAITING_ESTABLISHMENT:
            if( !linkp->own_l3_init )
            {
                put_in_i_que( linkp, mb );
                send_flg = TRUE;
            }
            else
            {
            	#ifdef LCM_DEBUG
                aos_printf( MPE_LCM, "q921:can't send information" );
            	#endif
            	 
            }
            
            break;
            
        case MULTIPLE_FRAME_ESTABLISHED:
        case TIMER_RECOVERY:
            put_in_i_que( linkp, mb );
            send_flg = TRUE;
            break;
            
        default:
        	#ifdef LCM_DEBUG
            aos_printf( MPE_LCM, "q921:can't send information" );
        	#endif
        	
            break;
    }
    
i_free_mb:
    if( FALSE == send_flg )
    {
        aos_dmem_free((VOID*)mb->head);
        
        msg_free(mb);
    }
    
}

VOID q921_establish_req( L2_LINK_S *linkp )
{
    AOS_ASSERT( NULL != linkp );
    
    
    switch( linkp->status )
    {
        case LINK_NOT_ESTABLISHED:
            establish_data_link( linkp );
            SET_L3_INITED(linkp);
            SET_LINK_STATUS( linkp, AWAITING_ESTABLISHMENT );
            break;
            
        case AWAITING_ESTABLISHMENT:
            discard_i_que( linkp );
            SET_L3_INITED( linkp );
            break;
            
        case AWAITING_RELEASE:
            break;
            
        case MULTIPLE_FRAME_ESTABLISHED:
        case TIMER_RECOVERY:
            discard_i_que( linkp );
            establish_data_link( linkp );
            SET_L3_INITED(linkp);
            SET_LINK_STATUS( linkp, AWAITING_ESTABLISHMENT );
            break;
            
        default:
            AOS_ASSERT( 0 );
            break;
    }
    
}

VOID q921_release_req( L2_LINK_S *linkp )
{
    AOS_ASSERT( NULL != linkp );

    switch( linkp->status )
    {
        case LINK_NOT_ESTABLISHED:
            send_msg_to_l3( linkp, MDL_RELEASE_CONFIRM );
            break;
            
        case AWAITING_ESTABLISHMENT:
            discard_i_que(linkp);
            send_msg_to_l3( linkp, MDL_RELEASE_CONFIRM );
            stop_t200( linkp );
            SET_LINK_STATUS(linkp, LINK_NOT_ESTABLISHED );
            break;

        case AWAITING_RELEASE:
            break;
            
        case MULTIPLE_FRAME_ESTABLISHED:
            stop_t203( linkp );
        
        case TIMER_RECOVERY:
        
            discard_i_que(linkp);
            linkp->rc = 0;
            if( LCM_DRV_HDLC == linkp->phy_type )
            {
                
                
                
#if( CONFIG_BOARD_GMPU == TRUE && ( AOS_INCLUDE_SERVICE_V5 == TRUE ))                
                if( !linkp->is_for_dss1 
					&&TRUE == v5_is_dm_send_allowed( (U16)linkp->phy_port_no ) )
                {
                    
                    
                    send_u_frame_2( linkp, linkp->own_resp, _DM, F_0 );
                }
#endif