FreeCalypso > hg > fc-magnetite
diff src/g23m-fad/tcpip/rnet/rnet_rt/rnet_rt_dti.c @ 174:90eb61ecd093
src/g23m-fad: initial import from TCS3.2/LoCosto
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Wed, 12 Oct 2016 05:40:46 +0000 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-fad/tcpip/rnet/rnet_rt/rnet_rt_dti.c Wed Oct 12 05:40:46 2016 +0000 @@ -0,0 +1,346 @@ +/* ++------------------------------------------------------------------------------ +| File: rnet_rt_dti.c ++------------------------------------------------------------------------------ +| Copyright 2003 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : DTI-based GSM/GPRS network driver for RNET_RT (a.k.a. NexGenIP) ++----------------------------------------------------------------------------- +*/ + +/* Derived from... */ +/** + * @file rnet_rt_atp.c + * + * Coding of the ATP point-to-point network interface for RNET_RT, + * + * @author Regis Feneon + * @version 0.1 + */ + +/* + * $Id: rnet_rt_atp.c,v 1.4 2002/12/05 10:02:19 rf Exp $ + * $Name: $ + * + * History: + * + * Date Author Modification + * -------------------------------------------------- + * 5/6/2002 Regis Feneon Create + * 6/9/2002 Regis Feneon Select default route + * on local interface address if no destination address + * 12/5/2002 Regis Feneon Flow control handling + * (C) Copyright 2002 by TI, All Rights Reserved + * + */ + + +#define RNET_RT_DTI_C +#define ENTITY_TCPIP + +#include "rnet_cfg.h" +#ifdef RNET_CFG_REAL_TRANSPORT + +#include "typedefs.h" +#include "vsi.h" +#include "dti.h" + +#include "rnet_rt_i.h" +#include "rnet_trace_i.h" +#include "rnet_rt_atp_i.h" +#include "atp_api.h" +#include "atp_messages.h" +#include "rnet_atp_info.h" + +#include "tcpip.h" + +static int tcpip_dtiOpen(NGifnet *netp) +{ + TRACE_FUNCTION("tcpip_dtiOpen()") ; + + /* As the connection to the network is actually initiated by the + * TCPIP_DTI_REQ from the ACI, this function is more or less a no-op. It + * must mainly fulfil NexGenIP's formal requirements. The latter are only + * derived from the corresponding ATP interface code for the moment. + */ + + /* Interface already running? */ + if (netp->if_flags & NG_IFF_RUNNING) + { + TRACE_ERROR("tcpip_dtiOpen: interface already opened") ; + return NG_EALREADY ; + } + + netp->if_flags |= NG_IFF_RUNNING ; + + /* Use NG_IFF_OACTIVE flag for flow control. */ + netp->if_flags &= ~NG_IFF_OACTIVE ; + + return NG_EOK ; +} + + +static int tcpip_dtiClose (NGifnet *netp) +{ + TRACE_FUNCTION("tcpip_dtiClose()") ; + + /* Interface should be running to be closed. */ + if (!(netp->if_flags & NG_IFF_RUNNING)) + { + TRACE_ERROR("tcpip_dtiClose: interface already closed") ; + return NG_EALREADY ; + } + + netp->if_flags &= ~NG_IFF_RUNNING ; + + return NG_EOK ; +} + + +static int tcpip_dtiOutput(NGifnet *netp, NGbuf *bufp, NGuint addr) +{ + int err = NG_EOK ; + + TRACE_FUNCTION("tcpip_dtiOutput()") ; + + /* Interface must be up and running to send data. */ + if ((netp->if_flags & (NG_IFF_RUNNING|NG_IFF_UP)) + != (NG_IFF_RUNNING|NG_IFF_UP)) + { + TRACE_ERROR("tcpip_dtiOutput: interface isn't up and running") ; + err = NG_ENETDOWN ; + } + else + { + /* Send IP packet over DTI if output is on, else discard the packet. */ + if (tcpip_data->ll[0].flowstat_ul EQ TCPIP_FLOWCTL_XON) + { + tcpip_dti_send_data_ll(bufp->buf_datap, (U16) bufp->buf_datalen) ; + } + else + { + TRACE_ERROR("tcpip_dtiOutput(): DTI connection not ready or xoff") ; + err = NG_EAGAIN ; + } + } + + ngBufOutputFree(bufp) ; + return err ; +} + + +/** This function, while copied straight from the ATP support module, is + * apparently unused by the DTI support. Everything it does -- handling + * interfaces going up and down, arriving data, flow control -- is done + * elsewhere in this DTI/GPF port of RNET. It remains to be investigated if + * this is the right thing to do, so this function will be left in place for + * the moment. + */ +static int tcpip_dtiCntl( NGifnet *netp, int cmd, int opt, void *arg) +{ + int ret; + NGbuf *bufp; + UINT32 rlen, left; + UINT8 tmpbuf[16]; + T_RNET_RT_ATP_CUSTOM_INFO *cinfo; + T_ATP_NO_COPY_INFO no_copy_info = { 0 }; /* not used */ + static const T_ATP_PORT_INFO info = { + DATA_CONFIG, + ATP_NO_RING_TYPE, + // old version received from NexGen and modified 5/Dec/2002 : 0, + ATP_RX_FLOW_UNMASK | ATP_TX_FLOW_UNMASK, + 0 + }; + + // RNET_RT_SEND_TRACE("RNET_RT: in atpCntl",RV_TRACE_LEVEL_ERROR); + + if (opt == NG_RNETIFO_HANDLE_MSG) { + /* handle ATP messages */ + switch( ((T_RV_HDR *)arg)->msg_id) { + case ATP_OPEN_PORT_IND: + + RNET_RT_SEND_TRACE("RNET_RT: receive OPEN_PORT_IND",RV_TRACE_LEVEL_ERROR); + cinfo = (T_RNET_RT_ATP_CUSTOM_INFO *) + ((T_ATP_OPEN_PORT_IND *) arg)->custom_info_p; + /* if interface is already up, or if no associated data, + open is not accepted */ + if (((netp->if_flags & (NG_IFF_UP|NG_IFF_RUNNING)) != NG_IFF_RUNNING) || + (cinfo == NULL)) { + + atp_open_port_rsp( ((T_ATP_OPEN_PORT_IND *) arg)->initiator_id, + ((T_ATP_OPEN_PORT_IND *) arg)->initiator_port_nb, + ((T_RNET_RT_ATP_IFNET *) netp)->atp_sw_id, + ((T_RNET_RT_ATP_IFNET *) netp)->atp_port_nb, + info, + no_copy_info, + NULL, + OPEN_PORT_NOK); + } + else { + + /* send confirmation to ATP client */ + ((T_RNET_RT_ATP_IFNET *) netp)->atp_client_sw_id = + ((T_ATP_OPEN_PORT_IND *) arg)->initiator_id; + ((T_RNET_RT_ATP_IFNET *) netp)->atp_client_port_nb = + ((T_ATP_OPEN_PORT_IND *) arg)->initiator_port_nb; + + no_copy_info.packet_mode = NORMAL_PACKET; /* No L2CAP packet... */ + no_copy_info.rx_mb = no_copy_info.tx_mb = RVF_INVALID_MB_ID; + + ret = atp_open_port_rsp( ((T_ATP_OPEN_PORT_IND *) arg)->initiator_id, + ((T_ATP_OPEN_PORT_IND *) arg)->initiator_port_nb, + ((T_RNET_RT_ATP_IFNET *) netp)->atp_sw_id, + ((T_RNET_RT_ATP_IFNET *) netp)->atp_port_nb, + info, + no_copy_info, + NULL, + OPEN_PORT_OK); + if (ret == RV_OK) { + + /* interface is ready to send and receive packets */ + netp->if_flags |= NG_IFF_UP; + /* set MTU */ + netp->if_mtu = cinfo->mtu; + /* Activating the link addresses */ + ngIfGenCntl( netp, NG_CNTL_SET, NG_IFO_ADDR, &cinfo->local_addr); + ngIfGenCntl( netp, NG_CNTL_SET, NG_IFO_DSTADDR, &cinfo->dest_addr); + TRACE_EVENT_P2("tcpip_dtiCntl cinfo address local=%08x dest%08x", + cinfo->local_addr, cinfo->dest_addr); + /* set default route */ + if (cinfo->dest_addr == 0) { + + (void)(ngProto_IP.pr_cntl_f( NG_CNTL_SET, NG_IPO_ROUTE_DEFAULT, + (NGuint *) &cinfo->local_addr)); + } + else { + + (void)(ngProto_IP.pr_cntl_f( NG_CNTL_SET, NG_IPO_ROUTE_DEFAULT, + (NGuint *) &cinfo->dest_addr)); + } + /* set DNS configuration */ + (void)(ngProto_RESOLV.pr_cntl_f( NG_CNTL_SET, NG_RSLVO_SERV1_IPADDR, &cinfo->dns1)); + (void)(ngProto_RESOLV.pr_cntl_f( NG_CNTL_SET, NG_RSLVO_SERV2_IPADDR, &cinfo->dns2)); + } + } + /* release custom information buffer */ + if (cinfo != NULL) { + atp_free_buffer( cinfo); + } + + break; + case ATP_PORT_CLOSED: + RNET_RT_SEND_TRACE("RNET_RT: receive PORT_CLOSED",RV_TRACE_LEVEL_ERROR); + if ((netp->if_flags & (NG_IFF_RUNNING|NG_IFF_UP)) != + (NG_IFF_RUNNING|NG_IFF_UP)) { + /* interface already down */ + break; + } + /* set interface down */ + netp->if_flags &= ~NG_IFF_UP; + /* call ip layer */ + (void)(ngProto_IP.pr_cntl_f( NG_CNTL_SET, NG_IPO_NETDOWN, netp)); + break; + case ATP_DATA_RDY: + /* allocate buffer for receiving new packet */ + RNET_RT_SEND_TRACE("RNET_RT: receive DATA_RDY",RV_TRACE_LEVEL_ERROR); + ngBufAlloc( bufp); + if (bufp != NULL) { + /* get new data */ + bufp->buf_flags |= NG_PROTO_IP; + bufp->buf_datap = ((NGubyte *) bufp) + ngBufDataOffset; + ret = atp_get_data( ((T_RNET_RT_ATP_IFNET *) netp)->atp_sw_id, + ((T_RNET_RT_ATP_IFNET *) netp)->atp_port_nb, + (UINT8 *) bufp->buf_datap, + ngBufDataMax, + &rlen, + &left); + if ((ret != RV_OK) || (rlen == 0)) { + netp->if_ierrors++; + ngBufFree( bufp); + } + else { + // rnet_debug[0] = '\0' ; + // for(rnet_ind=0;rnet_ind<48;rnet_ind++) { + // char tmp[3] ; + // sprintf(tmp, "%.2x", bufp->buf_datap[rnet_ind]); + // strcat(rnet_debug, tmp) ; + // } + + // RNET_RT_SEND_TRACE("RNET_RT: receive content",RV_TRACE_LEVEL_ERROR); + // RNET_RT_SEND_TRACE(rnet_debug, RV_TRACE_LEVEL_ERROR); + // rvf_delay(RVF_MS_TO_TICKS(100)); + + /* get length of packet */ + bufp->buf_datalen = rlen; + /* start IP processing */ + ngIfGenInput( netp, bufp, 1); + } + } + else { + /* skip packet */ + netp->if_ierrors++; + atp_get_data( ((T_RNET_RT_ATP_IFNET *) netp)->atp_sw_id, + ((T_RNET_RT_ATP_IFNET *) netp)->atp_port_nb, + tmpbuf, + sizeof( tmpbuf), + &rlen, + &left); + } + break; + case ATP_SIGNAL_CHANGED: + /* handle flow control flags */ + RNET_RT_SEND_TRACE("RNET_RT: receive SIGNAL_CHANGED",RV_TRACE_LEVEL_ERROR); + // rvf_delay(RVF_MS_TO_TICKS(1000)); + if (((T_ATP_SIGNAL_CHANGED *) arg)->mask & ATP_TX_FLOW_UNMASK) { + if (((T_ATP_SIGNAL_CHANGED *) arg)->signal & ATP_TX_FLOW_ON) { + /* enable transimissions */ + netp->if_flags &= ~NG_IFF_OACTIVE; + } + else { + /* disable transmissions */ + netp->if_flags |= NG_IFF_OACTIVE; + } + } + break; + default: + /* unknown message */ + RNET_TRACE_MEDIUM_PARAM("RNET_RT: receive default ",((T_RV_HDR *)arg)->msg_id); + + return( NG_EINVAL); + } + return( NG_EOK); + } + else { + RNET_RT_SEND_TRACE("RNET_RT: opt not handle msg", RV_TRACE_LEVEL_ERROR); + return( ngIfGenCntl( netp, cmd, opt, arg)); + } +} + +/********************************************************************/ +/* Driver entry point */ + +const NGnetdrv rnet_rt_netdrv_dti = { + "DTI", + NG_IFT_PPP, + NG_IFF_POINTOPOINT|NG_IFF_MULTICAST, + RNET_RT_DTI_MTU, + 0, + NULL, + tcpip_dtiOpen, + tcpip_dtiClose, + tcpip_dtiOutput, + NULL, + tcpip_dtiCntl +}; + +#endif /* ifdef RNET_CFG_REAL_TRANSPORT */ +