openblt/Target/Source/net.c

/************************************************************************************//**
* \file         Source\net.c
* \brief        Bootloader TCP/IP network communication interface source file.
* \ingroup      Core
* \internal
*----------------------------------------------------------------------------------------
*                          C O P Y R I G H T
*----------------------------------------------------------------------------------------
*   Copyright (c) 2014  by Feaser    http://www.feaser.com    All rights reserved
*
*----------------------------------------------------------------------------------------
*                            L I C E N S E
*----------------------------------------------------------------------------------------
* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with OpenBLT.
* If not, see <http://www.gnu.org/licenses/>.
*
* A special exception to the GPL is included to allow you to distribute a combined work 
* that includes OpenBLT without being obliged to provide the source code for any 
* proprietary components. The exception text is included at the bottom of the license
* file <license.html>.
* 
* \endinternal
****************************************************************************************/

/****************************************************************************************
* Include files
****************************************************************************************/
#include "boot.h"                                /* bootloader generic header          */
#if (BOOT_COM_NET_ENABLE > 0)
#include "netdev.h"
#include "uip.h"
#include "uip_arp.h"
#endif


#if (BOOT_COM_NET_ENABLE > 0)
/****************************************************************************************
* Macro definitions
****************************************************************************************/
/** \brief Delta time for the uIP periodic timer. */
#define NET_UIP_PERIODIC_TIMER_MS   (500)
/** \brief Delta time for the uIP ARP timer. */
#define NET_UIP_ARP_TIMER_MS        (10000)
/** \brief Macro for accessing the Ethernet header information in the buffer */
#define NET_UIP_HEADER_BUF          ((struct uip_eth_hdr *)&uip_buf[0])


/****************************************************************************************
* Hook functions
****************************************************************************************/
#if (BOOT_COM_NET_IPADDR_HOOK_ENABLE > 0)
extern void NetIpAddressHook(blt_int8u *ipAddrArray);
#endif
#if (BOOT_COM_NET_NETMASK_HOOK_ENABLE > 0)
extern void NetNetworkMaskHook(blt_int8u *netMaskArray);
#endif
#if (BOOT_COM_NET_GATEWAY_HOOK_ENABLE > 0)
extern void NetGatewayAddressHook(blt_int8u *gatewayAddrArray);
#endif


/****************************************************************************************
* Function prototypes
****************************************************************************************/
static void NetServerTask(void);


/****************************************************************************************
* Local data declarations
****************************************************************************************/
/** \brief Holds the time out value of the uIP periodic timer. */
static blt_int32u periodicTimerTimeOut;
/** \brief Holds the time out value of the uIP ARP timer. */
static blt_int32u ARPTimerTimeOut;


/************************************************************************************//**
** \brief     Initializes the TCP/IP network communication interface.
** \return    none.
**
****************************************************************************************/
void NetInit(void)
{
  uip_ipaddr_t ipaddr;
  #if (BOOT_COM_NET_IPADDR_HOOK_ENABLE > 0)
  blt_int8u ipAddrArray[4];
  #endif
  #if (BOOT_COM_NET_NETMASK_HOOK_ENABLE > 0)
  blt_int8u netMaskArray[4];
  #endif
  #if (BOOT_COM_NET_GATEWAY_HOOK_ENABLE > 0)
  blt_int8u gatewayAddrArray[4];
  #endif

  /* initialize the network device */
  netdev_init();
  /* initialize the timer variables */
  periodicTimerTimeOut = TimerGet() + NET_UIP_PERIODIC_TIMER_MS;
  ARPTimerTimeOut = TimerGet() + NET_UIP_ARP_TIMER_MS;
  /* initialize the uIP TCP/IP stack. */
  uip_init();
  /* set the IP address */
  #if (BOOT_COM_NET_IPADDR_HOOK_ENABLE > 0)
  NetIpAddressHook(ipAddrArray);
  uip_ipaddr(ipaddr, ipAddrArray[0], ipAddrArray[1], ipAddrArray[2], ipAddrArray[3]);
  #else
  uip_ipaddr(ipaddr, BOOT_COM_NET_IPADDR0, BOOT_COM_NET_IPADDR1, BOOT_COM_NET_IPADDR2,
             BOOT_COM_NET_IPADDR3);
  #endif
  uip_sethostaddr(ipaddr);
  /* set the network mask */
  #if (BOOT_COM_NET_NETMASK_HOOK_ENABLE > 0)
  NetNetworkMaskHook(netMaskArray);
  uip_ipaddr(ipaddr, netMaskArray[0], netMaskArray[1], netMaskArray[2], netMaskArray[3]);
  #else
  uip_ipaddr(ipaddr, BOOT_COM_NET_NETMASK0, BOOT_COM_NET_NETMASK1, BOOT_COM_NET_NETMASK2,
             BOOT_COM_NET_NETMASK3);
  #endif
  uip_setnetmask(ipaddr);
  /* set the gateway address */
  #if (BOOT_COM_NET_GATEWAY_HOOK_ENABLE > 0)
  NetGatewayAddressHook(gatewayAddrArray);
  uip_ipaddr(ipaddr, gatewayAddrArray[0], gatewayAddrArray[1], gatewayAddrArray[2], gatewayAddrArray[3]);
  #else
  uip_ipaddr(ipaddr, BOOT_COM_NET_GATEWAY0, BOOT_COM_NET_GATEWAY1, BOOT_COM_NET_GATEWAY2,
             BOOT_COM_NET_GATEWAY3);
  #endif
  uip_setdraddr(ipaddr);
  /* start listening on the configured port for XCP transfers on TCP/IP */
  uip_listen(HTONS(BOOT_COM_NET_PORT));
  /* initialize the MAC and set the MAC address */
  netdev_init_mac();  
} /*** end of NetInit ***/


/************************************************************************************//**
** \brief     Transmits a packet formatted for the communication interface.
** \param     data Pointer to byte array with data that it to be transmitted.
** \param     len  Number of bytes that are to be transmitted.
** \return    none.
**
****************************************************************************************/
void NetTransmitPacket(blt_int8u *data, blt_int8u len)
{
  uip_tcp_appstate_t *s;
  blt_int16u cnt;
  
  /* get pointer to application state */
  s = &(uip_conn->appstate);

  /* add the dto counter first */
  *(blt_int32u*)&(s->dto_data[0]) = s->dto_counter;
  /* copy the actual XCP response */
  for (cnt=0; cnt<len; cnt++)
  {
    s->dto_data[cnt+4] = data[cnt];
  }
  /* set the length of the TCP/IP packet */
  s->dto_len = len + 4;
  /* submit it for transmission */
  uip_send(s->dto_data, s->dto_len);
  /* update dto counter for the next transmission */
  s->dto_counter++;
} /*** end of NetTransmitPacket ***/


/************************************************************************************//**
** \brief     Receives a communication interface packet if one is present.
** \param     data Pointer to byte array where the data is to be stored.
** \return    BLT_TRUE if a packet was received, BLT_FALSE otherwise.
**
****************************************************************************************/
blt_bool NetReceivePacket(blt_int8u *data)
{
  /* run the TCP/IP server task function, which will handle the reception and 
   * transmission of XCP packets
   */
  NetServerTask();
  
  /* packet reception and transmission is completely handled by the NetServerTask so 
   * always return BLT_FALSE here.
   */
  return BLT_FALSE;
} /*** end of NetReceivePacket ***/


/************************************************************************************//**
** \brief     The uIP network application that implements XCP on TCP/IP. Note that this
**            application make use of the fact that XCP is request/response based. So
**            no new request will come in when a response is pending for transmission,
**            if so, the transmission of the pending response is aborted.
** \return    none.
**
****************************************************************************************/
void NetApp(void)
{
  uip_tcp_appstate_t *s;
  blt_int8u *newDataPtr;

  /* get pointer to application state */
  s = &(uip_conn->appstate);
  
  if (uip_connected()) 
  {
    /* init the dto counter and reset the pending dto data length */
    s->dto_counter = 1;
    s->dto_len = 0;
    return;
  }

  if (uip_acked()) 
  {
    /* dto sent so set the pending dto data length to zero */
    s->dto_len = 0;
  }

  if (uip_rexmit()) 
  {
    /* retransmit the currently pending dto response */
    if (s->dto_len > 0)
    {
      /* resend the last pending dto response */
      uip_send(s->dto_data, s->dto_len);
    }
  }  

  if (uip_newdata()) 
  {
    /* XCP is request/response. this means is a new request comes in when a response
     * transmission is still pending, the XCP master either re-initialized or sent
     * the request again because of a response time-out. Either way the pending response
     * should be cancelled before handling the new request.
     */
    s->dto_len = 0;
    /* the first 4 bytes contain a counter value in which we are not really interested */
    newDataPtr = uip_appdata;
    XcpPacketReceived(&newDataPtr[4]);
  }
} /*** end of NetApp ***/


/************************************************************************************//**
** \brief     Runs the TCP/IP server task.
** \return    none.
**
****************************************************************************************/
static void NetServerTask(void)
{
  blt_int32u connection;
  blt_int32u packetLen;
  
  /* check for an RX packet and read it. */
  packetLen = netdev_read();
  if(packetLen > 0)
  {
    /* set uip_len for uIP stack usage */
    uip_len = (blt_int16u)packetLen;

    /* process incoming IP packets here. */
    if(NET_UIP_HEADER_BUF->type == htons(UIP_ETHTYPE_IP))
    {
      uip_arp_ipin();
      uip_input();
      /* if the above function invocation resulted in data that
       * should be sent out on the network, the global variable
       * uip_len is set to a value > 0.
       */
      if(uip_len > 0)
      {
        uip_arp_out();
        netdev_send();
        uip_len = 0;
      }
    }
    /* process incoming ARP packets here. */
    else if(NET_UIP_HEADER_BUF->type == htons(UIP_ETHTYPE_ARP))
    {
      uip_arp_arpin();

      /* if the above function invocation resulted in data that
       * should be sent out on the network, the global variable
       * uip_len is set to a value > 0.
       */
      if(uip_len > 0)
      {
        netdev_send();
        uip_len = 0;
      }
    }
  }
  
  /* process TCP/IP Periodic Timer here. */
  if (TimerGet() >= periodicTimerTimeOut)
  {
    periodicTimerTimeOut += NET_UIP_PERIODIC_TIMER_MS;
    for (connection = 0; connection < UIP_CONNS; connection++)
    {
      uip_periodic(connection);
      /* If the above function invocation resulted in data that
       * should be sent out on the network, the global variable
       * uip_len is set to a value > 0.
       */
      if(uip_len > 0)
      {
        uip_arp_out();
        netdev_send();
        uip_len = 0;
      }
    }
  }
  
  /* process ARP Timer here. */
  if (TimerGet() >= ARPTimerTimeOut)
  {
      ARPTimerTimeOut += NET_UIP_ARP_TIMER_MS;
      uip_arp_timer();
  }
} /*** end of NetServerTask ***/
#endif /* BOOT_COM_NET_ENABLE > 0 */


/*********************************** end of net.c **************************************/