modules/network/SMSMAP/main.c

   1 /*
   2  * Copyright (c) Tord Lindstrom (pukko@home.se)
   3  * Copyright (c) adresd ( adresd_ps2dev@yahoo.com )
   4  *
   5  */
   6
   7 #include <stdio.h>
   8 #include <loadcore.h>
   9 #include <thbase.h>
  10 #include <thevent.h>
  11 #include <thsemap.h>
  12 #include <vblank.h>
  13 #include <intrman.h>
  14
  15 #include "ps2ip.h"
  16 #include "smap.h"
  17 #include "dev9.h"
  18
  19 #include "smsutils.h"
  20
  21 #define UNKN_1464   *(u16 volatile*)0xbf801464
  22
  23 #define IFNAME0 's'
  24 #define IFNAME1 'm'
  25
  26 #define TIMER_INTERVAL          (100*1000)
  27 #define TIMEOUT                         (300*1000)
  28 #define MAX_REQ_CNT                     8
  29
  30 typedef struct ip_addr IPAddr;
  31 typedef struct netif   NetIF;
  32 typedef struct SMapIF  SMapIF;
  33 typedef struct pbuf    PBuf;
  34
  35
  36 static int              iSendMutex;
  37 static int              iSendReqMutex;
  38 static int              iSendReq = 0x80000000;
  39 static int              iReqNR=0;
  40 static int              iReqCNT=0;
  41 static PBuf*    apReqQueue[MAX_REQ_CNT];
  42 static int              iTimeoutCNT=0;
  43
  44 struct SMapIF {
  45
  46  NetIF* pNetIF;
  47
  48 };
  49
  50 static SMapIF SIF;
  51
  52 NetIF NIF;
  53
  54 #define ERR_OK    0
  55 #define ERR_CONN -6
  56 #define ERR_IF  -11
  57
  58 static SMapStatus AddToQueue ( PBuf* pBuf ) {
  59
  60  int        iIntFlags;
  61  SMapStatus Ret;
  62
  63  CpuSuspendIntr ( &iIntFlags );
  64
  65  if ( !iReqCNT ) {
  66
  67   Ret = SMap_Send ( pBuf );
  68
  69   if ( Ret == SMap_TX ) {
  70
  71    iTimeoutCNT = 0;
  72    goto storeLast;
  73
  74   }  /* end if */
  75
  76  } else if ( iReqCNT < MAX_REQ_CNT ) {
  77 storeLast:
  78   apReqQueue[ ( iReqNR + iReqCNT ) % MAX_REQ_CNT ] = pBuf;
  79   ++iReqCNT;
  80   ++pBuf -> ref;
  81
  82   Ret = SMap_OK;
  83
  84  } else Ret = SMap_TX;
  85
  86  CpuResumeIntr ( iIntFlags );
  87
  88  return Ret;
  89
  90 }  /* end AddToQueue */
  91
  92 static void SendRequests ( void ) {
  93
  94  while ( iReqCNT > 0 ) {
  95
  96   PBuf*      lpReq = apReqQueue[ iReqNR ];
  97   SMapStatus lSts  = SMap_Send ( lpReq );
  98
  99   iTimeoutCNT = 0;
 100
 101   if ( lSts == SMap_TX ) return;
 102
 103   pbuf_free ( lpReq );
 104
 105   iReqNR = ( iReqNR + 1 ) % MAX_REQ_CNT;
 106   --iReqCNT;
 107
 108  }  /* end while */
 109
 110 }  /* end SendRequests */
 111
 112 static void QueueHandler ( void ) {
 113
 114  SendRequests ();
 115
 116  if ( iSendReq >= 0 ) {
 117
 118   iSignalSema ( iSendReq );
 119   iSendReq = 0x80000000;
 120
 121  }  /* end if */
 122
 123 }  /* end QueueHandler */
 124
 125 static int SMapInterrupt ( int iFlag ) {
 126
 127  int iFlags = SMap_GetIRQ ();
 128
 129  if (  iFlags & ( INTR_TXDNV | INTR_TXEND )  ) {
 130
 131   SMap_HandleTXInterrupt (  iFlags & ( INTR_TXDNV | INTR_TXEND )  );
 132
 133   QueueHandler ();
 134
 135   iFlags = SMap_GetIRQ ();
 136
 137  }  /* end if */
 138
 139  if (  iFlags & ( INTR_EMAC3 | INTR_RXDNV | INTR_RXEND )  )
 140
 141   SMap_HandleRXEMACInterrupt (  iFlags & ( INTR_EMAC3 | INTR_RXDNV | INTR_RXEND )  );
 142
 143  return 1;
 144
 145 }  /* end SMapInterrupt */
 146
 147 static unsigned int Timer ( void* pvArg ) {
 148
 149  if ( iReqCNT ) {
 150
 151   iTimeoutCNT += TIMER_INTERVAL;
 152
 153   if (  iTimeoutCNT >= TIMEOUT && iTimeoutCNT < ( TIMEOUT + TIMER_INTERVAL )  ) QueueHandler ();
 154
 155  }  /* end if */
 156
 157  return ( unsigned int )pvArg;
 158
 159 }  /* end Timer */
 160
 161 static err_t SMapLowLevelOutput ( NetIF* pNetIF, PBuf* pOutput ) {
 162
 163  while ( 1 ) {
 164
 165   int        iFlags;
 166   SMapStatus Res;
 167
 168   if (   (  Res = AddToQueue ( pOutput )  ) == SMap_OK   ) return ERR_OK;
 169   if (      Res                             == SMap_Err  ) return ERR_IF;
 170   if (      Res                             == SMap_Con  ) return ERR_CONN;
 171
 172   WaitSema ( iSendMutex );
 173
 174   CpuSuspendIntr ( &iFlags );
 175
 176   if ( iReqCNT == MAX_REQ_CNT ) {
 177
 178    iSendReq = iSendReqMutex;
 179    CpuResumeIntr ( iFlags );
 180
 181    WaitSema ( iSendReqMutex );
 182
 183   } else CpuResumeIntr ( iFlags );
 184
 185   SignalSema ( iSendMutex );
 186
 187  }  /* end while */
 188
 189 }  /* end SMapLowLevelOutput */
 190
 191 static err_t SMapOutput ( NetIF* pNetIF, PBuf* pOutput, IPAddr* pIPAddr ) {
 192
 193  PBuf* pBuf = etharp_output ( pNetIF, pIPAddr, pOutput );
 194
 195  return pBuf ? SMapLowLevelOutput ( pNetIF, pBuf ) : ERR_OK;
 196
 197 }  /* end SMapOutput */
 198
 199 static err_t SMapIFInit ( NetIF* pNetIF ) {
 200
 201  SIF.pNetIF = pNetIF;
 202  pNetIF -> state      = &NIF;
 203  pNetIF -> name[ 0 ]  = IFNAME0;
 204  pNetIF -> name[ 1 ]  = IFNAME1;
 205  pNetIF -> output     = SMapOutput;
 206  pNetIF -> linkoutput = SMapLowLevelOutput;
 207  pNetIF -> hwaddr_len = 6;
 208  pNetIF -> mtu        = 1500;
 209
 210  mips_memcpy (  pNetIF -> hwaddr, SMap_GetMACAddress (), 6  );
 211
 212  SMap_Start ();
 213
 214  return ERR_OK;
 215
 216 }  /* end SMapIFInit */
 217
 218 static int SMapInit ( IPAddr IP, IPAddr NM, IPAddr GW ) {
 219
 220  int             i;
 221  iop_sys_clock_t ClockTicks;
 222
 223  dev9IntrDisable ( INTR_BITMSK );
 224  EnableIntr ( IOP_IRQ_DEV9 );
 225  CpuEnableIntr ();
 226
 227  UNKN_1464 = 3;
 228
 229  if (   (  iSendMutex    = CreateMutex ( IOP_MUTEX_UNLOCKED )  ) < 0   ) return 0;
 230  if (   (  iSendReqMutex = CreateMutex ( IOP_MUTEX_UNLOCKED )  ) < 0   ) return 0;
 231  if     (   !SMap_Init ()                                                  ) return     0;
 232
 233  for ( i = 2; i < 7; ++i ) dev9RegisterIntrCb ( i, SMapInterrupt );
 234
 235  USec2SysClock ( TIMER_INTERVAL, &ClockTicks );
 236  SetAlarm (  &ClockTicks, Timer, ( void* )ClockTicks.lo  );
 237
 238  netif_add ( &NIF, &IP, &NM, &GW, NULL, SMapIFInit, tcpip_input );
 239  netif_set_default ( &NIF );
 240
 241  return 1;
 242
 243 }  /* end SMapInit */
 244
 245 int _start ( int iArgC,char** ppcArgV ) {
 246
 247  IPAddr IP;
 248  IPAddr NM;
 249  IPAddr GW;
 250
 251  if ( iArgC >= 4 ) {
 252
 253   IP.addr = inet_addr( ppcArgV[ 1 ] );
 254   NM.addr = inet_addr( ppcArgV[ 2 ] );
 255   GW.addr = inet_addr (ppcArgV[ 3 ] );
 256
 257  } else {
 258
 259   IP4_ADDR( &IP, 192, 168,   0, 80 );
 260   IP4_ADDR( &NM, 255, 255, 255,  0 );
 261   IP4_ADDR( &GW, 192, 168,   0,  1 );
 262
 263  }  /* end else */
 264
 265  return !SMapInit( IP, NM, GW );
 266
 267 }  /* end _start */