lcm_udpdrv.c

abstract rtos

                            msg_pull( mb, sizeof(struct new_eia_msg_hdr) );
                        }
                        else
                        {
                            msg_pull( mb, sizeof(struct eia_msg_hdr) );
                        }
                        
                        if( pEia->is_eia )
                        {
                            (*eia_rcv)( LCM_DRV_UDP4EIA, pEia->port_no, mb );
                        }
#if( CONFIG_BOARD_GMPU == TRUE )                        
                        else
                        {
                            (*siptrunk_rcv)( LCM_DRV_UDP4SIPTRUNK, pEia->port_no, mb );
                        }
#endif
                    }while( mb != mb_out );

                    
                    while( pEia->rx_delay_que.qlen )
                    {
                        if( pEia->rx_serialno != MB_TX_SERIALNO(pEia->rx_delay_que.next) )
                        {
                            break;
                        }
                        mb = msg_deque( &pEia->rx_delay_que );
                        
                        DRV_EIA_DEBUG( "Que Recv 2, eiano=%d, tx_s=%u",eia_no, MB_TX_SERIALNO(mb), 0, 0 );
                        
                        if( ((struct eia_msg_hdr*)mb->data)->is_new_ver )
                        {
                            msg_pull( mb, sizeof(struct new_eia_msg_hdr) );
                        }
                        else
                        {
                            msg_pull( mb, sizeof(struct eia_msg_hdr) );
                        }

                        pEia->rx_serialno++;
                        
                        if( pEia->is_eia )
                        {
                            (*eia_rcv)( LCM_DRV_UDP4EIA, pEia->port_no, mb );
                        }
#if( CONFIG_BOARD_GMPU == TRUE )
                        else
                        {
                            (*siptrunk_rcv)( LCM_DRV_UDP4SIPTRUNK, pEia->port_no, mb );
                        }
#endif                        
                    }
                }
            }
        }
    }
    
    AOS_ASSERT( (aos_tick_get()-n_tick) <= 1 );
    
#if( CONFIG_BOARD_EIA == TRUE )
    if( (U32)(n_tick - g_ulLcmLastKeepAliveTick) >= (10*CONFIG_TICKS_PER_SECOND) )
    {
        g_ulLcmLastKeepAliveTick = n_tick;
        edrv_keepalive_send();
    }
#endif    
}

#if( CONFIG_BOARD_GMPU == TRUE )
VOID lcm_update_udp_port(U32 ulLocalUdpPort )
{
    g_lcm_rel_udp_port = (U16)ulLocalUdpPort;
}
VOID lcm_update_tcp_signal_flag(U32 disableTcpFlag )
{
    g_lcm_tcp_signal_disable = disableTcpFlag;
}



VOID edrv_keepalive_handle( U8 *ptr, U32 ip, U16 port )
{
    struct eia_msg_hdr *headp;
    EIA_TABLE_S        *pEia;
    U32                eia_no;
    
    headp = (struct eia_msg_hdr*)ptr;
    if( !headp->is_siptrunk )
    {
        if( headp->is_new_ver )
        {
            eia_no = ((struct new_eia_msg_hdr*)headp)->eia_no;
            eia_no = AOS_NTOHS(eia_no);
        }
        else
        {
            eia_no = headp->eia_no_hi;
            eia_no <<= 8;
            eia_no |= headp->eia_no_lo; 
        }

        pEia = drv_get_eia_cb(eia_no);
        if( (NULL != pEia)
         && (TRUE == pEia->status)
           )
        {
            
            if( (pEia->addr.sin_stAddr.s_ulAddr != ip)
              ||(pEia->addr.sin_usPort != AOS_HTONS(port)) )
            {
                pEia->addr.sin_stAddr.s_ulAddr = ip;
                pEia->addr.sin_usPort = AOS_HTONS(port);
            }
        }    
    }
}

#endif

#if( CONFIG_BOARD_EIA == TRUE )
VOID edrv_keepalive_send( )
{
    EIA_TABLE_S        *pEia;
    struct msg_blk     *mb;
    U_FRAME_S          *keep_alive;
    U8                 *p;

    pEia = &eia_table[0];
    if( pEia->status )
    {
        mb = msg_alloc();
        if( NULL != mb )
        {
            keep_alive = (U_FRAME_S*)aos_msg_alloc( MPE_EDRV, 10 );
            if( NULL != keep_alive )
            {
                p = (U8*)keep_alive;
                p[0] = 0xfc;
                p[1] = 0xeb;
                p[2] = 0x03;

                
                p[3] = 0xff;     
                p[4] = MPE_EDRV;
                p[5] = MPE_EDRV;
                    
                mb->head = mem_obj_head(keep_alive);
                mb->truelen = mem_obj_size(keep_alive);
                mb->end   = mb->head + mb->truelen;

                mb->data = p;
                mb->len  = 6;
                mb->tail = mb->data + mb->len;               
                
                drv_udp_send( pEia, 0, mb );
            }
            else
            {
                msg_free(mb);
            }
        }
    }
}

#endif



U32 lcm_is_ui_fram( U8 *ptr0 )
{
    struct eia_msg_hdr *headp;
    Q921_FRAME_S       *framep;
    U8                 cmd, *ptr=ptr0;

    
    headp = (struct eia_msg_hdr*)(ptr0);
    if( headp->is_new_ver )
    {
        ptr += sizeof(struct new_eia_msg_hdr);
    }
    else
    {
        ptr += sizeof(struct eia_msg_hdr);
    }
    
    if( LCM_MSG == headp->msg_type )
    {
        
        framep = (Q921_FRAME_S*)(ptr -2); 
        if( IS_U_FRAME( framep ) )
        {
            cmd = ptr[2] & 0xef;
            return _UI == cmd ? 1 :0;
        }
    }

    return 0;
}




U32 lcm_is_keepalive_frame( U8 *ptr0 )
{
    struct eia_msg_hdr *headp;
    Q921_FRAME_S       *framep;
    U8                 cmd, *ptr = ptr0;

    headp = (struct eia_msg_hdr*)(ptr0);
    if( headp->is_new_ver )
    {
        ptr += sizeof(struct new_eia_msg_hdr);
    }
    else
    {
        ptr += sizeof(struct eia_msg_hdr);
    }
    
    if( MPE_EDRV ==  ptr[4] && LCM_MSG == headp->msg_type )
    {
        
        framep = (Q921_FRAME_S*)(ptr -2); 
        if( IS_U_FRAME( framep ) )
        {
            cmd = ptr[2] & 0xef;
            return _UI == cmd ? 1 :0;
        }
    }

    return 0;
}

VOID edrv_load_config( )
{
    U32 ulLocalUdpPort;

#if( CONFIG_BOARD_GMPU == TRUE )
    
    if(DB_SUCC != db_get_sys_int_param_value(PARAM_LCM_UDPPORT, &ulLocalUdpPort) )
    {
        
        db_update_sys_int_param_value( PARAM_LCM_UDPPORT, "lcm-local-port", CONFIG_EIA_UDP_PORT );
        ulLocalUdpPort = CONFIG_EIA_UDP_PORT;
    }
    g_lcm_rel_udp_port = (U16)ulLocalUdpPort;

    
    if( DB_SUCC != db_get_sys_int_param_value( PARAM_TCP_SIGNAL_DISABLE, &g_lcm_tcp_signal_disable) )
    {
        g_lcm_tcp_signal_disable = 0;
        db_update_sys_int_param_value( PARAM_TCP_SIGNAL_DISABLE, "tcp signal disable", g_lcm_tcp_signal_disable );
    }
#endif

    
#if(CONFIG_BOARD_EIA == TRUE )
    
    if( AOS_SUCC == cfm_get_parameter(CMD_MGCP_LOCAL_PORT,&ulLocalUdpPort,sizeof(U32) ) )
    {
        if( 0 != ulLocalUdpPort && ulLocalUdpPort < U16_BUTT )
        {
            ulLocalUdpPort += 100;
        }
        else
        {
            ulLocalUdpPort = CONFIG_EIA_UDP_PORT;
        }
    }
    else
    {
        ulLocalUdpPort = CONFIG_EIA_UDP_PORT;
    }
    g_lcm_rel_udp_port = (U16)ulLocalUdpPort;
        
#endif    

}


void drv_udp_add( EIA_TABLE_S *pEia, SOCKADDRIN_S *pFrom, U32 tcpflag, U32 tcpSeq, U32 tcpAck, U32 new_lcm_ver )
{
    struct msg_blk *mb;

    pEia->status    = TRUE;
    pEia->is_rcving = FALSE;
#if( _CPU_MIPS )
    aos_memcpy( &pEia->addr, pFrom, sizeof(*pFrom) );
#else
    pEia->addr      = *pFrom;
#endif
    pEia->rx_timestamp  = 0;
    pEia->rx_serialno= 0;
    pEia->tx_serialno= 0;
    if( tcpflag )
    {
        pEia->is_tcp_mode = 1;
        pEia->tcpSeq = tcpSeq;
        pEia->tcpAck = tcpAck;
    }
    else
    {
        pEia->is_tcp_mode = 0;
        pEia->tcpSeq = 0;
        pEia->tcpAck = 0;
    }
    pEia->is_new_ver = new_lcm_ver;
    

    
    while( NULL != (mb=msg_deque(&pEia->rx_delay_que)) )
    {
        aos_dmem_free( mb->head );
        msg_free( mb );
    }

    msg_que_init( &pEia->rx_delay_que );

}

void drv_udp_delete( EIA_TABLE_S *pEia )
{
    struct msg_blk *mb;

    pEia->status = FALSE;
    pEia->is_rcving = FALSE;

    pEia->rx_timestamp = 0;
    pEia->rx_serialno  = 0;
    pEia->tx_serialno  = 0;
    pEia->is_tcp_mode  = 0;
    pEia->is_tcp_connected = 0;
    pEia->tcpSeq       = 0;
    pEia->tcpAck       = 0;
#if( CONFIG_BOARD_EIA == TRUE )
    pEia->tcpSynCnt    = 0;
#endif  
    
    aos_memset( &pEia->addr, 0, sizeof( SOCKADDRIN_S ) );
    
    while( NULL != (mb=msg_deque(&pEia->rx_delay_que)) )
    {
        aos_dmem_free( mb->head );
        msg_free( mb );
    }

    msg_que_init( &pEia->rx_delay_que );
}

#if( CONFIG_BOARD_EIA == TRUE )
void lcm_udpate_tcp_ack( U32 ack )
{
    EIA_TABLE_S *pEia = &eia_table[0];
    
    if( pEia->is_tcp_mode 
      && ( (S32)(ack - pEia->tcpAck) > 0 ) )
    {
        pEia->tcpAck = ack;
    }
}
#endif

VOID drv_eia_debug_msg( U32 subcmd, U32 para )
{
    switch( subcmd )
    {
        case 1:
            if( U32_BUTT == para )
            {
                aos_printf( MPE_EDRV, "enable print of all eia" );
            }
            else
            {
                aos_printf( MPE_EDRV, "enable print of eia=%d", para );
            }
            m_ulEiaNo = para;
            break;
            
        case 2:
            aos_printf( MPE_EDRV, "disable print of eia=%d", para );
            m_ulEiaNo = U16_BUTT;
            break;
            
        case 3:
            aos_printf( MPE_EDRV," set eia drv delay time to %u ms", para );
            m_ulMaxDelayTick = para/(1000/CONFIG_TICKS_PER_SECOND);
            break;

        case 4:
            aos_printf( MPE_EDRV,"eia drv delay time is %u ms", m_ulMaxDelayTick*10 );
            break;

        case 0:    
        default:
            aos_printf( MPE_EDRV, "cmd 20 1 eiano to enable print, -1 for all" );
            aos_printf( MPE_EDRV, "cmd 20 2 eiano to disable print" );
            aos_printf( MPE_EDRV, "cmd 20 3 time(in ms) to set delay time" );
            aos_printf( MPE_EDRV, "cmd 20 4 to show delay time" );
            break;
    }
}

#endif

#ifdef __cplusplus
}
#endif