tcp_ip.c

用于嵌入式系统的TCP/IP协议栈

  /*-------------------------------------------------------------------*/
  /* If requested, report on packet routing.                           */
  /*-------------------------------------------------------------------*/
  if (type & TCP_DIAG_ROUTE)
    RtDump();

  /*-------------------------------------------------------------------*/
  /* Release exclusive access to protocol internals.                   */
  /*-------------------------------------------------------------------*/
  semPost(Net.IntSem);
}

/***********************************************************************/
/* TriMedia Porting Definitions                                        */
/***********************************************************************/
#define TARGETTCP_EVENT         2
#define TCP_PRI                 200

/***********************************************************************/
/* AssertError()                                                       */
/*                                                                     */
/***********************************************************************/
void AssertError(int line, char *file)
{
  for (;;)
  {
    printf("assert() error in %s on line %d\n", file, line);
    assert(FALSE);
    taskSleep(400);
  }
}

/***********************************************************************/
/*     printIP: Output IP address in dotted format to stdout           */
/*                                                                     */
/*       Input: ip_addr = IP address                                   */
/*                                                                     */
/*     Returns: number of characters output                            */
/*                                                                     */
/*        Note: address is assumed to be in network order              */
/*                                                                     */
/***********************************************************************/
int printIP(ui32 ip_addr)
{
  ui8 b1, b2, b3, b4;

  ip_addr = ntohl(ip_addr);
  b1 = (ui8)(ip_addr >> 24);
  b2 = (ui8)(ip_addr >> 16);
  b3 = (ui8)(ip_addr >> 8);
  b4 = (ui8)(ip_addr);

  return printf("%u.%u.%u.%u", b1, b2, b3, b4);
}

/***********************************************************************/
/*    printEth: Output Ethernet address in colon format to stdout      */
/*                                                                     */
/*       Input: eth_addr = pointer to Ethernet address                 */
/*                                                                     */
/***********************************************************************/
void printEth(void *eth_addr)
{
  int i;
  ui8 *p = eth_addr;

  for (i = 0; i < 5; ++i)
    printf("%02X:", *p++);
  printf("%02X", *p);
}

#include <psos.h>
#include <sys_conf.h>
#define ROUTER_STACK ((1<<20)+SC_STACK_OVF_CHECK)
#define TIMER_STACK  ((1<<10)+SC_STACK_OVF_CHECK)

/***********************************************************************/
/*  taskCreate: pSOS+ implementation                                   */
/*                                                                     */
/***********************************************************************/
static TASK taskCreate(const char name[8], ui8 stack_size, ui8 priority,
                       void (*funcp)(ui32 msg), ui32 msg, ui32 flags)
{
  ui32 t_create(char name[4], ui32 prio, ui32 sstack, ui32 ustack,
                ui32 flags, ui32 *tid);
  ui32 t_start(ui32 tid, ui32 mode, void (*start_addr)(), ui32 targs[]);
  ui32 tid, rc;

  /*-------------------------------------------------------------------*/
  /* Call t_create() to create task.                                   */
  /*-------------------------------------------------------------------*/
  if (rc = t_create((char *)name, TCP_PRI, ROUTER_STACK, 0, 0, &tid))
  {
    errno = rc;
    return 0;
  }

  /*-------------------------------------------------------------------*/
  /* Call t_start() to start task.                                     */
  /*-------------------------------------------------------------------*/
  if (rc = t_start(tid, T_SUPV, funcp, 0))
  {
    errno = rc;
    return 0;
  }

  /*-------------------------------------------------------------------*/
  /* Return task identifier.                                           */
  /*-------------------------------------------------------------------*/
  return tid;
}

/***********************************************************************/
/*   semCreate: pSOS+ implementation                                   */
/*                                                                     */
/***********************************************************************/
static SEM semCreate(const char name[8], int init_count, int mode)
{
  ui32 sm_create(char name[4], ui32 count, ui32 flags, ui32 *smid);
  ui32 sem, rc = sm_create((char *)name, init_count, SM_FIFO, &sem);

  /*-------------------------------------------------------------------*/
  /* Return -1 and set errno if error, else return identifier.         */
  /*-------------------------------------------------------------------*/
  if (rc)
  {
    errno = rc;
    return 0;
  }
  else
  {
    return sem;
  }
}

/***********************************************************************/
/*   semDelete: pSOS+ implementation                                   */
/*                                                                     */
/***********************************************************************/
void semDelete(SEM sem)
{
  unsigned long sm_delete(ui32 smid);
  ui32 rc = sm_delete(sem);

  TcpAssert((rc == 0) || (rc == 0x44));
}

/***********************************************************************/
/*     semPost: pSOS+ implementation                                   */
/*                                                                     */
/***********************************************************************/
void semPost(SEM sem)
{
  ui32 sm_v(ui32 smid);
  ui32 rc = sm_v(sem);

  TcpAssert(rc == 0);
}

/***********************************************************************/
/*     semPend: pSOS+ implementation                                   */
/*                                                                     */
/***********************************************************************/
int semPend(SEM sem, ui32 wait_opt)
{
  ui32 sm_p(ui32 smid, ui32 flags, ui32 timeout);
  ui32 rc;

  /*-------------------------------------------------------------------*/
  /* Use SM_WAIT or SM_NOWAIT, depending on wait_opt value.            */
  /*-------------------------------------------------------------------*/
  if (wait_opt)
    rc = sm_p(sem, SM_WAIT, wait_opt);
  else
    rc = sm_p(sem, SM_NOWAIT, 0);

  /*-------------------------------------------------------------------*/
  /* Return -1 and set errno if an error occurred, else return 0.      */
  /*-------------------------------------------------------------------*/
  if (rc)
  {
    errno = rc;
    return -1;
  }
  else
    return 0;
}

/***********************************************************************/
/* RunningTask substitute                                              */
/*                                                                     */
/***********************************************************************/
TASK t_ident_call(void)
{
  ui32 tid;

  t_ident(0, 0, &tid);
  return tid;
}

/***********************************************************************/
/* taskLock(), taskSleep() and taskWake()                              */
/*                                                                     */
/***********************************************************************/
void taskLock(void)
{
  ui32 events_r;

  /*-------------------------------------------------------------------*/
  /* Prepare for following taskSleep() by clearing pre-existing event. */
  /*-------------------------------------------------------------------*/
  ev_receive(TARGETTCP_EVENT, EV_NOWAIT | EV_ANY, 0, &events_r);
}

void taskSleep(ui32 wait_opt)
{
  ui32 events_r;

  ev_receive(TARGETTCP_EVENT, EV_WAIT | EV_ANY, wait_opt, &events_r);
}

void taskWake(TASK tid)
{
  ui32 rc;

  rc = ev_send(tid, TARGETTCP_EVENT);
  TcpAssert(rc == 0);
}

/***********************************************************************/
/* tmrCreate() and tmrCallAfter()                                      */
/*                                                                     */
/***********************************************************************/
static void tcp_timer(ui32 ticks)
{
  for (;;)
  {
    timer(ticks);
    tm_wkafter(ticks);
  }
}

static int tmrCallAfter(int ticks, int (*func)(ui32 arg), ui32 arg,
                                                               TMR timer)
{
  ui32 targs[4], rc;

  /*-------------------------------------------------------------------*/
  /* Start the timer task with the passed in parameters.               */
  /*-------------------------------------------------------------------*/
  targs[0] = ticks;
  targs[1] = (ui32)func;
  targs[2] = arg;
  rc = t_start(timer, T_SUPV | T_NOPREEMPT | T_NOISR, tcp_timer, targs);
  TcpAssert(rc == 0);
  return 0;
}

static TMR tmrCreate(const char name[8])
{
  ui32 rc, tid;

  /*-------------------------------------------------------------------*/
  /* Create the timer task.                                            */
  /*-------------------------------------------------------------------*/
  rc = t_create((char *)name, TCP_PRI + 1, TIMER_STACK, 0, 0, &tid);
  TcpAssert(rc == 0);

  return tid;
}

#include <tm1/tmInterrupts.h>
/***********************************************************************/
/*     isrMask: Uses TriMedia "intClearIEN()"                          */
/*                                                                     */
/***********************************************************************/
static uint Ien;
void isrMask(void)
{
  Ien = intClearIEN();
}

/***********************************************************************/
/*   isrUnmask: Uses TriMedia "intRestoreIEN()"                        */
/*                                                                     */
/***********************************************************************/
void isrUnmask(void)
{
  intRestoreIEN(Ien);
}

ui32 OsTicksPerSec = KC_TICKS2SEC;
ui32 DefGateway;