git.sur5r.net Git - freertos/blob - Demo/WizNET_DEMO_GCC_ARM7/TCP.c

   1 /*\r
   2     FreeRTOS V7.0.1 - Copyright (C) 2011 Real Time Engineers Ltd.\r
   3         \r
   4 \r
   5     ***************************************************************************\r
   6      *                                                                       *\r
   7      *    FreeRTOS tutorial books are available in pdf and paperback.        *\r
   8      *    Complete, revised, and edited pdf reference manuals are also       *\r
   9      *    available.                                                         *\r
  10      *                                                                       *\r
  11      *    Purchasing FreeRTOS documentation will not only help you, by       *\r
  12      *    ensuring you get running as quickly as possible and with an        *\r
  13      *    in-depth knowledge of how to use FreeRTOS, it will also help       *\r
  14      *    the FreeRTOS project to continue with its mission of providing     *\r
  15      *    professional grade, cross platform, de facto standard solutions    *\r
  16      *    for microcontrollers - completely free of charge!                  *\r
  17      *                                                                       *\r
  18      *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *\r
  19      *                                                                       *\r
  20      *    Thank you for using FreeRTOS, and thank you for your support!      *\r
  21      *                                                                       *\r
  22     ***************************************************************************\r
  23 \r
  24 \r
  25     This file is part of the FreeRTOS distribution.\r
  26 \r
  27     FreeRTOS is free software; you can redistribute it and/or modify it under\r
  28     the terms of the GNU General Public License (version 2) as published by the\r
  29     Free Software Foundation AND MODIFIED BY the FreeRTOS exception.\r
  30     >>>NOTE<<< The modification to the GPL is included to allow you to\r
  31     distribute a combined work that includes FreeRTOS without being obliged to\r
  32     provide the source code for proprietary components outside of the FreeRTOS\r
  33     kernel.  FreeRTOS is distributed in the hope that it will be useful, but\r
  34     WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
  35     or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for\r
  36     more details. You should have received a copy of the GNU General Public\r
  37     License and the FreeRTOS license exception along with FreeRTOS; if not it\r
  38     can be viewed here: http://www.freertos.org/a00114.html and also obtained\r
  39     by writing to Richard Barry, contact details for whom are available on the\r
  40     FreeRTOS WEB site.\r
  41 \r
  42     1 tab == 4 spaces!\r
  43 \r
  44     http://www.FreeRTOS.org - Documentation, latest information, license and\r
  45     contact details.\r
  46 \r
  47     http://www.SafeRTOS.com - A version that is certified for use in safety\r
  48     critical systems.\r
  49 \r
  50     http://www.OpenRTOS.com - Commercial support, development, porting,\r
  51     licensing and training services.\r
  52 */\r
  53 \r
  54 /*\r
  55         Changes from V3.2.3\r
  56         \r
  57         + Modified char* types to compile without warning when using GCC V4.0.1.\r
  58         + Corrected the address to which the MAC address is written.  Thanks to\r
  59           Bill Knight for this correction.\r
  60 \r
  61         Changes from V3.2.4\r
  62 \r
  63         + Changed the default MAC address to something more realistic.\r
  64 \r
  65 */\r
  66 \r
  67 /* Standard includes. */\r
  68 #include <stdlib.h>\r
  69 #include <string.h>\r
  70 \r
  71 /* Scheduler include files. */\r
  72 #include "FreeRTOS.h"\r
  73 #include "task.h"\r
  74 #include "semphr.h"\r
  75 #include "tcp.h"\r
  76 #include "serial.h"\r
  77 \r
  78 /* Application includes. */\r
  79 #include "i2c.h"\r
  80 #include "html_pages.h"\r
  81 \r
  82 /*-----------------------------------------------------------*/\r
  83 \r
  84 /* Hardwired i2c address of the WIZNet device. */\r
  85 #define tcpDEVICE_ADDRESS                               ( ( unsigned char ) 0x00 )\r
  86 \r
  87 /* Constants used to configure the Tx and Rx buffer sizes within the WIZnet\r
  88 device. */\r
  89 #define tcp8K_RX                                                ( ( unsigned char ) 0x03 )\r
  90 #define tcp8K_TX                                                ( ( unsigned char ) 0x03 )\r
  91 \r
  92 /* Constants used to generate the WIZnet internal buffer addresses. */\r
  93 #define tcpSINGLE_SOCKET_ADDR_MASK              ( ( unsigned long ) 0x1fff )\r
  94 #define tcpSINGLE_SOCKET_ADDR_OFFSET    ( ( unsigned long ) 0x4000 )\r
  95 \r
  96 /* Bit definitions of the commands that can be sent to the command register. */\r
  97 #define tcpRESET_CMD                                    ( ( unsigned char ) 0x80 )\r
  98 #define tcpSYS_INIT_CMD                                 ( ( unsigned char ) 0x01 )\r
  99 #define tcpSOCK_STREAM                                  ( ( unsigned char ) 0x01 )\r
 100 #define tcpSOCK_INIT                                    ( ( unsigned char ) 0x02 )\r
 101 #define tcpLISTEN_CMD                                   ( ( unsigned char ) 0x08 )\r
 102 #define tcpRECEIVE_CMD                                  ( ( unsigned char ) 0x40 )\r
 103 #define tcpDISCONNECT_CMD                               ( ( unsigned char ) 0x10 )\r
 104 #define tcpSEND_CMD                                             ( ( unsigned char ) 0x20 )\r
 105 \r
 106 /* Constants required to handle the interrupts. */\r
 107 #define tcpCLEAR_EINT0                                  ( 1 )\r
 108 #define i2cCLEAR_ALL_INTERRUPTS                 ( ( unsigned char ) 0xff )\r
 109 #define i2cCHANNEL_0_ISR_ENABLE                 ( ( unsigned char ) 0x01 )\r
 110 #define i2cCHANNEL_0_ISR_DISABLE                ( ( unsigned char ) 0x00 )\r
 111 #define tcpWAKE_ON_EINT0                                ( 1 )\r
 112 #define tcpENABLE_EINT0_FUNCTION                ( ( unsigned long ) 0x01 )\r
 113 #define tcpEINT0_VIC_CHANNEL_BIT                ( ( unsigned long ) 0x4000 )\r
 114 #define tcpEINT0_VIC_CHANNEL                    ( ( unsigned long ) 14 )\r
 115 #define tcpEINT0_VIC_ENABLE                             ( ( unsigned long ) 0x0020 )\r
 116 \r
 117 /* Various delays used in the driver. */\r
 118 #define tcpRESET_DELAY                                  ( ( portTickType ) 16 / portTICK_RATE_MS )\r
 119 #define tcpINIT_DELAY                                   ( ( portTickType ) 500 / portTICK_RATE_MS  )\r
 120 #define tcpLONG_DELAY                                   ( ( portTickType ) 500 / portTICK_RATE_MS  )\r
 121 #define tcpSHORT_DELAY                                  ( ( portTickType ) 5 / portTICK_RATE_MS )\r
 122 #define tcpCONNECTION_WAIT_DELAY                ( ( portTickType ) 100 / portTICK_RATE_MS )\r
 123 #define tcpNO_DELAY                                             ( ( portTickType ) 0 )\r
 124 \r
 125 /* Length of the data to read for various register reads. */\r
 126 #define tcpSTATUS_READ_LEN                              ( ( unsigned long ) 1 )\r
 127 #define tcpSHADOW_READ_LEN                              ( ( unsigned long ) 1 )\r
 128         \r
 129 /* Register addresses within the WIZnet device. */\r
 130 #define tcpCOMMAND_REG                                  ( ( unsigned short ) 0x0000 )\r
 131 #define tcpGATEWAY_ADDR_REG                             ( ( unsigned short ) 0x0080 )\r
 132 #define tcpSUBNET_MASK_REG                              ( ( unsigned short ) 0x0084 )\r
 133 #define tcpSOURCE_HA_REG                                ( ( unsigned short ) 0x0088 )\r
 134 #define tpcSOURCE_IP_REG                                ( ( unsigned short ) 0x008E )\r
 135 #define tpcSOCKET_OPT_REG                               ( ( unsigned short ) 0x00A1 )\r
 136 #define tcpSOURCE_PORT_REG                              ( ( unsigned short ) 0x00AE )\r
 137 #define tcpTX_WRITE_POINTER_REG                 ( ( unsigned short ) 0x0040 )\r
 138 #define tcpTX_READ_POINTER_REG                  ( ( unsigned short ) 0x0044 )\r
 139 #define tcpTX_ACK_POINTER_REG                   ( ( unsigned short ) 0x0018 )\r
 140 #define tcpTX_MEM_SIZE_REG                              ( ( unsigned short ) 0x0096 )\r
 141 #define tcpRX_MEM_SIZE_REG                              ( ( unsigned short ) 0x0095 )\r
 142 #define tcpINTERRUPT_STATUS_REG                 ( ( unsigned short ) 0x0004 )\r
 143 #define tcpTX_WRITE_SHADOW_REG                  ( ( unsigned short ) 0x01F0 )\r
 144 #define tcpTX_ACK_SHADOW_REG                    ( ( unsigned short ) 0x01E2 )\r
 145 #define tcpISR_MASK_REG                                 ( ( unsigned short ) 0x0009 )\r
 146 #define tcpINTERRUPT_REG                                ( ( unsigned short ) 0x0008 )\r
 147 #define tcpSOCKET_STATE_REG                             ( ( unsigned short ) 0x00a0 )\r
 148 \r
 149 /* Constants required for hardware setup. */\r
 150 #define tcpRESET_ACTIVE_LOW                     ( ( unsigned long ) 0x20 )\r
 151 #define tcpRESET_ACTIVE_HIGH                    ( ( unsigned long ) 0x10 )\r
 152 \r
 153 /* Constants defining the source of the WIZnet ISR. */\r
 154 #define tcpISR_SYS_INIT                                 ( ( unsigned char ) 0x01 )\r
 155 #define tcpISR_SOCKET_INIT                              ( ( unsigned char ) 0x02 )\r
 156 #define tcpISR_ESTABLISHED                              ( ( unsigned char ) 0x04 )\r
 157 #define tcpISR_CLOSED                                   ( ( unsigned char ) 0x08 )\r
 158 #define tcpISR_TIMEOUT                                  ( ( unsigned char ) 0x10 )\r
 159 #define tcpISR_TX_COMPLETE                              ( ( unsigned char ) 0x20 )\r
 160 #define tcpISR_RX_COMPLETE                              ( ( unsigned char ) 0x40 )\r
 161 \r
 162 /* Constants defining the socket status bits. */\r
 163 #define tcpSTATUS_ESTABLISHED                   ( ( unsigned char ) 0x06 )\r
 164 #define tcpSTATUS_LISTEN                                ( ( unsigned char ) 0x02 )\r
 165 \r
 166 /* Misc constants. */\r
 167 #define tcpNO_STATUS_BITS                               ( ( unsigned char ) 0x00 )\r
 168 #define i2cNO_ADDR_REQUIRED                             ( ( unsigned short ) 0x0000 )\r
 169 #define i2cNO_DATA_REQUIRED                             ( 0x0000 )\r
 170 #define tcpISR_QUEUE_LENGTH                             ( ( unsigned portBASE_TYPE ) 10 )\r
 171 #define tcpISR_QUEUE_ITEM_SIZE                  ( ( unsigned portBASE_TYPE ) 0 )\r
 172 #define tcpBUFFER_LEN                                   ( 4 * 1024 )\r
 173 #define tcpMAX_REGISTER_LEN                             ( 4 )\r
 174 #define tcpMAX_ATTEMPTS_TO_CHECK_BUFFER ( 6 )\r
 175 #define tcpMAX_NON_LISTEN_STAUS_READS   ( 5 )\r
 176 \r
 177 /* Message definitions.  The IP address, MAC address, gateway address, etc.\r
 178 is set here! */\r
 179 const unsigned char const ucDataGAR[]                           = { 172, 25, 218, 3 };  /* Gateway address. */\r
 180 const unsigned char const ucDataMSR[]                           = { 255, 255, 255, 0 }; /* Subnet mask.         */\r
 181 const unsigned char const ucDataSIPR[]                          = { 172, 25, 218, 201 };/* IP address.          */\r
 182 const unsigned char const ucDataSHAR[]                          = { 00, 23, 30, 41, 15, 26 }; /* MAC address - DO NOT USE THIS ON A PUBLIC NETWORK! */\r
 183 \r
 184 /* Other fixed messages. */\r
 185 const unsigned char const ucDataReset[]                         = { tcpRESET_CMD }; \r
 186 const unsigned char const ucDataInit[]                          = { tcpSYS_INIT_CMD }; \r
 187 const unsigned char const ucDataProtocol[]                      = { tcpSOCK_STREAM };\r
 188 const unsigned char const ucDataPort[]                          = { 0xBA, 0xCC };\r
 189 const unsigned char const ucDataSockInit[]                      = { tcpSOCK_INIT };\r
 190 const unsigned char const ucDataTxWritePointer[]        = { 0x11, 0x22, 0x00, 0x00 };\r
 191 const unsigned char const ucDataTxAckPointer[]          = { 0x11, 0x22, 0x00, 0x00 };\r
 192 const unsigned char const ucDataTxReadPointer[]         = { 0x11, 0x22, 0x00, 0x00 };\r
 193 const unsigned char const ucDataListen[]                        = { tcpLISTEN_CMD };\r
 194 const unsigned char const ucDataReceiveCmd[]            = { tcpRECEIVE_CMD };\r
 195 const unsigned char const ucDataSetTxBufSize[]          = { tcp8K_TX };\r
 196 const unsigned char const ucDataSetRxBufSize[]          = { tcp8K_RX };\r
 197 const unsigned char const ucDataSend[]                          = { tcpSEND_CMD };\r
 198 const unsigned char const ucDataDisconnect[]            = { tcpDISCONNECT_CMD };\r
 199 const unsigned char const ucDataEnableISR[]                     = { i2cCHANNEL_0_ISR_ENABLE };\r
 200 const unsigned char const ucDataDisableISR[]            = { i2cCHANNEL_0_ISR_DISABLE };\r
 201 const unsigned char const ucDataClearInterrupt[]        = { i2cCLEAR_ALL_INTERRUPTS };\r
 202 \r
 203 static xSemaphoreHandle xMessageComplete = NULL;\r
 204 xQueueHandle xTCPISRQueue = NULL;\r
 205 \r
 206 /* Dynamically generate and send an html page. */\r
 207 static void prvSendSamplePage( void );\r
 208 \r
 209 /* Read a register from the WIZnet device via the i2c interface. */\r
 210 static void prvReadRegister( unsigned char *pucDestination, unsigned short usAddress, unsigned long ulLength );\r
 211 \r
 212 /* Send the entire Tx buffer (the Tx buffer within the WIZnet device). */\r
 213 static void prvFlushBuffer( unsigned long ulTxAddress );\r
 214 \r
 215 /* Write a string to the WIZnet Tx buffer. */\r
 216 static void prvWriteString( const char * const pucTxBuffer, long lTxLen, unsigned long *pulTxAddress );\r
 217 \r
 218 /* Convert a number to a string. */\r
 219 void ultoa( unsigned long ulVal, char *pcBuffer, long lIgnore );\r
 220 \r
 221 /*-----------------------------------------------------------*/\r
 222 \r
 223 void ultoa( unsigned long ulVal, char *pcBuffer, long lIgnore )\r
 224 {\r
 225 unsigned long lNibble;\r
 226 long lIndex;\r
 227 \r
 228         /* Simple routine to convert an unsigned long value into a string in hex \r
 229         format. */\r
 230 \r
 231         /* For each nibble in the number we are converting. */\r
 232         for( lIndex = 0; lIndex < ( sizeof( ulVal ) * 2 ); lIndex++ )\r
 233         {\r
 234                 /* Take the top four bits of the number. */\r
 235                 lNibble = ( ulVal >> 28 );\r
 236 \r
 237                 /* We are converting it to a hex string, so is the number in the range\r
 238                 0-10 or A-F? */\r
 239                 if( lNibble < 10 )\r
 240                 {\r
 241                         pcBuffer[ lIndex ] = '0' + lNibble;\r
 242                 }\r
 243                 else\r
 244                 {\r
 245                         lNibble -= 10;\r
 246                         pcBuffer[ lIndex ] = 'A' + lNibble;\r
 247                 }\r
 248 \r
 249                 /* Shift off the top nibble so we use the next nibble next time around. */\r
 250                 ulVal <<= 4;\r
 251         }       \r
 252 \r
 253         /* Mark the end of the string with a null terminator. */\r
 254         pcBuffer[ lIndex ] = 0x00;\r
 255 }\r
 256 /*-----------------------------------------------------------*/\r
 257 \r
 258 static void prvReadRegister( unsigned char *pucDestination, unsigned short usAddress, unsigned long ulLength )\r
 259 {\r
 260 unsigned char ucRxBuffer[ tcpMAX_REGISTER_LEN ];\r
 261 \r
 262         /* Read a register value from the WIZnet device. */\r
 263 \r
 264         /* First write out the address of the register we want to read. */\r
 265         i2cMessage( ucRxBuffer, i2cNO_DATA_REQUIRED, tcpDEVICE_ADDRESS, usAddress, i2cWRITE, NULL, portMAX_DELAY );\r
 266         \r
 267         /* Then read back from that address. */\r
 268         i2cMessage( ( unsigned char * ) pucDestination, ulLength, tcpDEVICE_ADDRESS, i2cNO_ADDR_REQUIRED, i2cREAD, xMessageComplete, portMAX_DELAY );\r
 269 \r
 270         /* I2C messages are queued so use the semaphore to wait for the read to \r
 271         complete - otherwise we will leave this function before the I2C \r
 272         transactions have completed. */\r
 273         xSemaphoreTake( xMessageComplete, tcpLONG_DELAY );\r
 274 }\r
 275 /*-----------------------------------------------------------*/\r
 276 \r
 277 void vTCPHardReset( void )\r
 278 {\r
 279         /* Physical reset of the WIZnet device by using the GPIO lines to hold the \r
 280         WIZnet reset lines active for a few milliseconds. */\r
 281 \r
 282         /* Make sure the interrupt from the WIZnet is disabled. */\r
 283         VICIntEnClear |= tcpEINT0_VIC_CHANNEL_BIT;\r
 284 \r
 285         /* If xMessageComplete is NULL then this is the first time that this \r
 286         function has been called and the queue and semaphore used in this file\r
 287         have not yet been created. */\r
 288         if( xMessageComplete == NULL )\r
 289         {\r
 290                 /* Create and obtain the semaphore used when we want to wait for an i2c\r
 291                 message to be completed. */\r
 292                 vSemaphoreCreateBinary( xMessageComplete );\r
 293                 xSemaphoreTake( xMessageComplete, tcpNO_DELAY );\r
 294 \r
 295                 /* Create the queue used to communicate between the WIZnet and TCP tasks. */\r
 296                 xTCPISRQueue = xQueueCreate( tcpISR_QUEUE_LENGTH, tcpISR_QUEUE_ITEM_SIZE );\r
 297         }\r
 298 \r
 299         /* Use the GPIO to reset the network hardware. */\r
 300         GPIO_IOCLR = tcpRESET_ACTIVE_LOW;\r
 301         GPIO_IOSET = tcpRESET_ACTIVE_HIGH;\r
 302 \r
 303         /* Delay with the network hardware in reset for a short while. */\r
 304         vTaskDelay( tcpRESET_DELAY );\r
 305 \r
 306         GPIO_IOCLR = tcpRESET_ACTIVE_HIGH;\r
 307         GPIO_IOSET = tcpRESET_ACTIVE_LOW;\r
 308 \r
 309         vTaskDelay( tcpINIT_DELAY );\r
 310 \r
 311         /* Setup the EINT0 to interrupt on required events from the WIZnet device.\r
 312         First enable the EINT0 function of the pin. */\r
 313         PCB_PINSEL1 |= tcpENABLE_EINT0_FUNCTION;\r
 314         \r
 315         /* We want the TCP comms to wake us from power save. */\r
 316         SCB_EXTWAKE = tcpWAKE_ON_EINT0;\r
 317 \r
 318         /* Install the ISR into the VIC - but don't enable it yet! */\r
 319         portENTER_CRITICAL();\r
 320         {\r
 321                 extern void ( vEINT0_ISR_Wrapper )( void );\r
 322 \r
 323                 VICIntSelect &= ~( tcpEINT0_VIC_CHANNEL_BIT );\r
 324                 VICVectAddr3 = ( long ) vEINT0_ISR_Wrapper;\r
 325 \r
 326                 VICVectCntl3 = tcpEINT0_VIC_CHANNEL | tcpEINT0_VIC_ENABLE;\r
 327         }\r
 328         portEXIT_CRITICAL();\r
 329 \r
 330         /* Enable interrupts in the WIZnet itself. */\r
 331         i2cMessage( ucDataEnableISR, sizeof( ucDataEnableISR ), tcpDEVICE_ADDRESS, tcpISR_MASK_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 332 \r
 333         vTaskDelay( tcpLONG_DELAY );\r
 334 }\r
 335 /*-----------------------------------------------------------*/\r
 336 \r
 337 long lTCPSoftReset( void )\r
 338 {\r
 339 unsigned char ucStatus;\r
 340 extern volatile long lTransactionCompleted;\r
 341 \r
 342         /* Send a message to the WIZnet device to tell it set all it's registers\r
 343         back to their default states.  Then setup the WIZnet device as required. */\r
 344 \r
 345         /* Reset the internal WIZnet registers. */\r
 346         i2cMessage( ucDataReset,        sizeof( ucDataReset ),  tcpDEVICE_ADDRESS, tcpCOMMAND_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 347 \r
 348         /* Now we can configure the protocol.   Here the MAC address, gateway \r
 349         address, subnet mask and IP address are configured. */\r
 350         i2cMessage( ucDataSHAR,         sizeof( ucDataSHAR ),   tcpDEVICE_ADDRESS, tcpSOURCE_HA_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 351         i2cMessage( ucDataGAR,          sizeof( ucDataGAR ),    tcpDEVICE_ADDRESS, tcpGATEWAY_ADDR_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 352         i2cMessage( ucDataMSR,          sizeof( ucDataMSR ),    tcpDEVICE_ADDRESS, tcpSUBNET_MASK_REG,  i2cWRITE, NULL, portMAX_DELAY );\r
 353         i2cMessage( ucDataSIPR,         sizeof( ucDataSIPR ),   tcpDEVICE_ADDRESS, tpcSOURCE_IP_REG,    i2cWRITE, NULL, portMAX_DELAY );\r
 354         \r
 355         /* Next the memory buffers are configured to give all the WIZnet internal\r
 356         memory over to a single socket.  This gives the socket the maximum internal\r
 357         Tx and Rx buffer space. */\r
 358         i2cMessage( ucDataSetTxBufSize, sizeof( ucDataSetTxBufSize ), tcpDEVICE_ADDRESS, tcpTX_MEM_SIZE_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 359         i2cMessage( ucDataSetRxBufSize, sizeof( ucDataSetRxBufSize ), tcpDEVICE_ADDRESS, tcpRX_MEM_SIZE_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 360 \r
 361         /* Send the sys init command so the above parameters take effect. */\r
 362         i2cMessage( ucDataInit,         sizeof( ucDataInit ),   tcpDEVICE_ADDRESS, tcpCOMMAND_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 363 \r
 364         /* Seems to like a little wait here. */\r
 365         vTaskDelay( tcpINIT_DELAY );\r
 366 \r
 367         /* Read back the status to ensure the system initialised ok. */\r
 368         prvReadRegister( &ucStatus, tcpINTERRUPT_STATUS_REG, tcpSTATUS_READ_LEN );\r
 369 \r
 370         /* We should find that the sys init was successful. */\r
 371         if( ucStatus != tcpISR_SYS_INIT )\r
 372         {\r
 373                 return ( long ) pdFAIL;\r
 374         }\r
 375 \r
 376         /* No i2c errors yet. */\r
 377         portENTER_CRITICAL();\r
 378                 lTransactionCompleted = pdTRUE;\r
 379         portEXIT_CRITICAL();\r
 380 \r
 381         return ( long ) pdPASS;\r
 382 }\r
 383 /*-----------------------------------------------------------*/\r
 384 \r
 385 long lTCPCreateSocket( void )\r
 386 {\r
 387 unsigned char ucStatus;\r
 388 \r
 389         /* Create and configure a socket. */\r
 390 \r
 391         /* Setup and init the socket.  Here the port number is set and the socket\r
 392         is initialised. */\r
 393         i2cMessage( ucDataProtocol, sizeof( ucDataProtocol),tcpDEVICE_ADDRESS, tpcSOCKET_OPT_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 394         i2cMessage( ucDataPort,         sizeof( ucDataPort),    tcpDEVICE_ADDRESS, tcpSOURCE_PORT_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 395         i2cMessage( ucDataSockInit, sizeof( ucDataSockInit),tcpDEVICE_ADDRESS, tcpCOMMAND_REG, i2cWRITE, xMessageComplete, portMAX_DELAY );\r
 396 \r
 397         /* Wait for the Init command to be sent. */\r
 398         if( !xSemaphoreTake( xMessageComplete, tcpLONG_DELAY ) )\r
 399         {\r
 400                 /* For some reason the message was not transmitted within our block\r
 401                 period. */\r
 402                 return ( long ) pdFAIL;\r
 403         }\r
 404 \r
 405         /* Allow the socket to initialise. */\r
 406         vTaskDelay( tcpINIT_DELAY );\r
 407 \r
 408         /* Read back the status to ensure the socket initialised ok. */\r
 409         prvReadRegister( &ucStatus, tcpINTERRUPT_STATUS_REG, tcpSTATUS_READ_LEN );\r
 410         \r
 411         /* We should find that the socket init was successful. */\r
 412         if( ucStatus != tcpISR_SOCKET_INIT )\r
 413         {\r
 414                 return ( long ) pdFAIL;\r
 415         }\r
 416 \r
 417 \r
 418         /* Setup the Tx pointer registers to indicate that the Tx buffer is empty. */\r
 419         i2cMessage( ucDataTxReadPointer, sizeof( ucDataTxReadPointer ), tcpDEVICE_ADDRESS, tcpTX_READ_POINTER_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 420         vTaskDelay( tcpSHORT_DELAY );\r
 421         i2cMessage( ucDataTxWritePointer, sizeof( ucDataTxWritePointer ), tcpDEVICE_ADDRESS, tcpTX_WRITE_POINTER_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 422         vTaskDelay( tcpSHORT_DELAY );\r
 423         i2cMessage( ucDataTxAckPointer,   sizeof( ucDataTxAckPointer ),   tcpDEVICE_ADDRESS, tcpTX_ACK_POINTER_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 424         vTaskDelay( tcpSHORT_DELAY );\r
 425 \r
 426         return ( long ) pdPASS;\r
 427 }\r
 428 /*-----------------------------------------------------------*/\r
 429 \r
 430 void vTCPListen( void )\r
 431 {\r
 432 unsigned char ucISR;\r
 433 \r
 434         /* Start a passive listen on the socket. */\r
 435 \r
 436         /* Enable interrupts in the WizNet device after ensuring none are \r
 437         currently pending. */\r
 438         while( SCB_EXTINT & tcpCLEAR_EINT0 )\r
 439         {\r
 440                 /* The WIZnet device is still asserting and interrupt so tell it to \r
 441                 clear. */\r
 442                 i2cMessage( ucDataClearInterrupt, sizeof( ucDataClearInterrupt ), tcpDEVICE_ADDRESS, tcpINTERRUPT_REG, i2cWRITE, xMessageComplete, portMAX_DELAY );\r
 443                 xSemaphoreTake( xMessageComplete, tcpLONG_DELAY );\r
 444 \r
 445                 vTaskDelay( 1 );\r
 446                 SCB_EXTINT = tcpCLEAR_EINT0;\r
 447         }\r
 448 \r
 449         while( xQueueReceive( xTCPISRQueue, &ucISR, tcpNO_DELAY ) )\r
 450         {\r
 451                 /* Just clearing the queue used by the ISR routine to tell this task\r
 452                 that the WIZnet device needs attention. */\r
 453         }\r
 454 \r
 455         /* Now all the pending interrupts have been cleared we can enable the \r
 456         processor interrupts. */\r
 457         VICIntEnable |= tcpEINT0_VIC_CHANNEL_BIT;\r
 458 \r
 459         /* Then start listening for incoming connections. */\r
 460         i2cMessage( ucDataListen, sizeof( ucDataListen ), tcpDEVICE_ADDRESS, tcpCOMMAND_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 461 }\r
 462 /*-----------------------------------------------------------*/\r
 463 \r
 464 long lProcessConnection( void )\r
 465 {\r
 466 unsigned char ucISR, ucState, ucLastState = 2, ucShadow;\r
 467 extern volatile long lTransactionCompleted;\r
 468 long lSameStateCount = 0, lDataSent = pdFALSE;\r
 469 unsigned long ulWritePointer, ulAckPointer;\r
 470 \r
 471         /* No I2C errors can yet have occurred. */\r
 472         portENTER_CRITICAL();\r
 473                 lTransactionCompleted = pdTRUE;\r
 474         portEXIT_CRITICAL();\r
 475 \r
 476         /* Keep looping - processing interrupts, until we have completed a \r
 477         transaction.   This uses the WIZnet in it's simplest form.  The socket\r
 478         accepts a connection - we process the connection - then close the socket.\r
 479         We then go back to reinitialise everything and start again. */\r
 480         while( lTransactionCompleted == pdTRUE )\r
 481         {\r
 482                 /* Wait for a message on the queue from the WIZnet ISR.  When the \r
 483                 WIZnet device asserts an interrupt the ISR simply posts a message\r
 484                 onto this queue to wake this task. */\r
 485                 if( xQueueReceive( xTCPISRQueue, &ucISR, tcpCONNECTION_WAIT_DELAY ) )\r
 486                 {\r
 487                         /* The ISR posted a message on this queue to tell us that the\r
 488                         WIZnet device asserted an interrupt.  The ISR cannot process\r
 489                         an I2C message so cannot tell us what caused the interrupt so\r
 490                         we have to query the device here.  This task is the highest\r
 491                         priority in the system so will run immediately following the ISR. */\r
 492                         prvReadRegister( &ucISR, tcpINTERRUPT_STATUS_REG, tcpSTATUS_READ_LEN );\r
 493 \r
 494                         /* Once we have read what caused the ISR we can clear the interrupt\r
 495                         in the WIZnet. */\r
 496                         i2cMessage( ucDataClearInterrupt, sizeof( ucDataClearInterrupt ), tcpDEVICE_ADDRESS, tcpINTERRUPT_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 497 \r
 498                         /* Now we can clear the processor interrupt and re-enable ready for\r
 499                         the next. */\r
 500                         SCB_EXTINT = tcpCLEAR_EINT0;\r
 501                         VICIntEnable |= tcpEINT0_VIC_CHANNEL_BIT;\r
 502         \r
 503                         /* Process the interrupt ... */\r
 504 \r
 505                         if( ucISR & tcpISR_ESTABLISHED )\r
 506                         {\r
 507                                 /* A connection has been established - respond by sending\r
 508                                 a receive command. */\r
 509                                 i2cMessage( ucDataReceiveCmd, sizeof( ucDataReceiveCmd ), tcpDEVICE_ADDRESS, tcpCOMMAND_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 510                         }\r
 511                 \r
 512                         if( ucISR & tcpISR_RX_COMPLETE )\r
 513                         {\r
 514                                 /* We message has been received.  This will be an HTTP get \r
 515                                 command.  We only have one page to send so just send it without\r
 516                                 regard to what the actual requested page was. */\r
 517                                 prvSendSamplePage();\r
 518                         }\r
 519                 \r
 520                         if( ucISR & tcpISR_TX_COMPLETE )\r
 521                         {\r
 522                                 /* We have a TX complete interrupt - which oddly does not \r
 523                                 indicate that the message being sent is complete so we cannot\r
 524                                 yet close the socket.  Instead we read the position of the Tx\r
 525                                 pointer within the WIZnet device so we know how much data it\r
 526                                 has to send.  Later we will read the ack pointer and compare \r
 527                                 this to the Tx pointer to ascertain whether the transmission \r
 528                                 has completed. */\r
 529 \r
 530                                 /* First read the shadow register. */\r
 531                                 prvReadRegister( &ucShadow, tcpTX_WRITE_SHADOW_REG, tcpSHADOW_READ_LEN );\r
 532                         \r
 533                                 /* Now a short delay is required. */\r
 534                                 vTaskDelay( tcpSHORT_DELAY );\r
 535 \r
 536                                 /* Then we can read the real register. */\r
 537                                 prvReadRegister( ( unsigned char * ) &ulWritePointer, tcpTX_WRITE_POINTER_REG, sizeof( ulWritePointer ) );\r
 538 \r
 539                                 /* We cannot do anything more here but need to remember that \r
 540                                 this interrupt has occurred. */\r
 541                                 lDataSent = pdTRUE;\r
 542                         }\r
 543                 \r
 544                         if( ucISR & tcpISR_CLOSED )\r
 545                         {\r
 546                                 /* The socket has been closed so we can leave this function. */\r
 547                                 lTransactionCompleted = pdFALSE;\r
 548                         }\r
 549                 }\r
 550                 else\r
 551                 {\r
 552                         /* We have not received an interrupt from the WIZnet device for a \r
 553                         while.  Read the socket status and check that everything is as\r
 554                         expected. */\r
 555                         prvReadRegister( &ucState, tcpSOCKET_STATE_REG, tcpSTATUS_READ_LEN );\r
 556                         \r
 557                         if( ( ucState == tcpSTATUS_ESTABLISHED ) && ( lDataSent > 0 ) ) \r
 558                         {\r
 559                                 /* The socket is established and we have already received a Tx\r
 560                                 end interrupt.  We must therefore be waiting for the Tx buffer\r
 561                                 inside the WIZnet device to be empty before we can close the\r
 562                                 socket. \r
 563 \r
 564                                 Read the Ack pointer register to see if it has caught up with\r
 565                                 the Tx pointer register.  First we have to read the shadow \r
 566                                 register. */\r
 567                                 prvReadRegister( &ucShadow, tcpTX_ACK_SHADOW_REG, tcpSHADOW_READ_LEN );\r
 568                                 vTaskDelay( tcpSHORT_DELAY );\r
 569                                 prvReadRegister( ( unsigned char * ) &ulAckPointer, tcpTX_ACK_POINTER_REG, sizeof( ulWritePointer ) );\r
 570 \r
 571                                 if( ulAckPointer == ulWritePointer )\r
 572                                 {\r
 573                                         /* The Ack and write pointer are now equal and we can \r
 574                                         safely close the socket. */\r
 575                                         i2cMessage( ucDataDisconnect, sizeof( ucDataDisconnect ), tcpDEVICE_ADDRESS, tcpCOMMAND_REG, i2cWRITE, NULL, portMAX_DELAY );\r
 576                                 }\r
 577                                 else\r
 578                                 {\r
 579                                         /* Keep a count of how many times we encounter the Tx\r
 580                                         buffer still containing data. */\r
 581                                         lDataSent++;\r
 582                                         if( lDataSent > tcpMAX_ATTEMPTS_TO_CHECK_BUFFER )\r
 583                                         {\r
 584                                                 /* Assume we cannot complete sending the data and \r
 585                                                 therefore cannot safely close the socket.  Start over. */\r
 586                                                 vTCPHardReset();\r
 587                                                 lTransactionCompleted = pdFALSE;\r
 588                                         }\r
 589                                 }\r
 590                         }\r
 591                         else if( ucState != tcpSTATUS_LISTEN )\r
 592                         {\r
 593                                 /* If we have not yet received a Tx end interrupt we would only \r
 594                                 ever expect to find the socket still listening for any \r
 595                                 sustained period. */\r
 596                                 if( ucState == ucLastState )\r
 597                                 {\r
 598                                         lSameStateCount++;\r
 599                                         if( lSameStateCount > tcpMAX_NON_LISTEN_STAUS_READS )\r
 600                                         {                                               \r
 601                                                 /* We are persistently in an unexpected state.  Assume\r
 602                                                 we cannot safely close the socket and start over. */\r
 603                                                 vTCPHardReset();\r
 604                                                 lTransactionCompleted = pdFALSE;\r
 605                                         }\r
 606                                 }\r
 607                         }\r
 608                         else\r
 609                         {\r
 610                                 /* We are in the listen state so are happy that everything\r
 611                                 is as expected. */\r
 612                                 lSameStateCount = 0;\r
 613                         }\r
 614 \r
 615                         /* Remember what state we are in this time around so we can check\r
 616                         for a persistence on an unexpected state. */\r
 617                         ucLastState = ucState;\r
 618                 }\r
 619         }\r
 620 \r
 621         /* We are going to reinitialise the WIZnet device so do not want our \r
 622         interrupts from the WIZnet to be processed. */\r
 623         VICIntEnClear |= tcpEINT0_VIC_CHANNEL_BIT;\r
 624         return lTransactionCompleted;\r
 625 }\r
 626 /*-----------------------------------------------------------*/\r
 627 \r
 628 static void prvWriteString( const char * const pucTxBuffer, long lTxLen, unsigned long *pulTxAddress )\r
 629 {\r
 630 unsigned long ulSendAddress;\r
 631 \r
 632         /* Send a string to the Tx buffer internal to the WIZnet device. */\r
 633 \r
 634         /* Calculate the address to which we are going to write in the buffer. */\r
 635         ulSendAddress = ( *pulTxAddress & tcpSINGLE_SOCKET_ADDR_MASK ) + tcpSINGLE_SOCKET_ADDR_OFFSET;\r
 636 \r
 637         /* Send the buffer to the calculated address.  Use the semaphore so we\r
 638         can wait until the entire message has been transferred. */\r
 639         i2cMessage( ( unsigned char * ) pucTxBuffer, lTxLen, tcpDEVICE_ADDRESS, ( unsigned short ) ulSendAddress, i2cWRITE, xMessageComplete, portMAX_DELAY );\r
 640 \r
 641         /* Wait until the semaphore indicates that the message has been transferred. */\r
 642         if( !xSemaphoreTake( xMessageComplete, tcpLONG_DELAY ) )\r
 643         {\r
 644                 return;\r
 645         }\r
 646 \r
 647         /* Return the new address of the end of the buffer (within the WIZnet \r
 648         device). */\r
 649         *pulTxAddress += ( unsigned long ) lTxLen;\r
 650 }\r
 651 /*-----------------------------------------------------------*/\r
 652 \r
 653 static void prvFlushBuffer( unsigned long ulTxAddress )\r
 654 {\r
 655 unsigned char ucTxBuffer[ tcpMAX_REGISTER_LEN ];\r
 656 \r
 657         /* We have written some data to the Tx buffer internal to the WIZnet\r
 658         device.  Now we update the Tx pointer inside the WIZnet then send a\r
 659         Send command - which causes     the data up to the new Tx pointer to be \r
 660         transmitted. */\r
 661 \r
 662         /* Make sure endieness is correct for transmission. */\r
 663         ulTxAddress = htonl( ulTxAddress );\r
 664 \r
 665         /* Place the new Tx pointer in the string to be transmitted. */\r
 666         ucTxBuffer[ 0 ] = ( unsigned char ) ( ulTxAddress & 0xff );\r
 667         ulTxAddress >>= 8;\r
 668         ucTxBuffer[ 1 ] = ( unsigned char ) ( ulTxAddress & 0xff );\r
 669         ulTxAddress >>= 8;\r
 670         ucTxBuffer[ 2 ] = ( unsigned char ) ( ulTxAddress & 0xff );\r
 671         ulTxAddress >>= 8;\r
 672         ucTxBuffer[ 3 ] = ( unsigned char ) ( ulTxAddress & 0xff );\r
 673         ulTxAddress >>= 8;\r
 674 \r
 675         /* And send it to the WIZnet device. */\r
 676         i2cMessage( ucTxBuffer, sizeof( ulTxAddress ), tcpDEVICE_ADDRESS, tcpTX_WRITE_POINTER_REG, i2cWRITE, xMessageComplete, portMAX_DELAY );\r
 677 \r
 678         if( !xSemaphoreTake( xMessageComplete, tcpLONG_DELAY ) )\r
 679         {\r
 680                 return;\r
 681         }\r
 682 \r
 683         vTaskDelay( tcpSHORT_DELAY );\r
 684 \r
 685         /* Transmit! */\r
 686         i2cMessage( ucDataSend, sizeof( ucDataSend ), tcpDEVICE_ADDRESS, tcpCOMMAND_REG, i2cWRITE, xMessageComplete, portMAX_DELAY );\r
 687 \r
 688         if( !xSemaphoreTake( xMessageComplete, tcpLONG_DELAY ) )\r
 689         {\r
 690                 return;\r
 691         }\r
 692 }\r
 693 /*-----------------------------------------------------------*/\r
 694 \r
 695 static void prvSendSamplePage( void )\r
 696 {\r
 697 extern long lErrorInTask;\r
 698 unsigned long ulTxAddress;\r
 699 unsigned char ucShadow;\r
 700 long lIndex;\r
 701 static unsigned long ulRefreshCount = 0x00;\r
 702 static char cPageBuffer[ tcpBUFFER_LEN ];\r
 703 \r
 704 \r
 705         /* This function just generates a sample page of HTML which gets\r
 706         sent each time a client attaches to the socket.  The page is created\r
 707         from two fixed strings (cSamplePageFirstPart and cSamplePageSecondPart)\r
 708         with a bit of dynamically generated data in the middle. */\r
 709 \r
 710         /* We need to know the address to which the html string should be sent\r
 711         in the WIZnet Tx buffer.  First read the shadow register. */\r
 712         prvReadRegister( &ucShadow, tcpTX_WRITE_SHADOW_REG, tcpSHADOW_READ_LEN );\r
 713 \r
 714         /* Now a short delay is required. */\r
 715         vTaskDelay( tcpSHORT_DELAY );\r
 716 \r
 717         /* Now we can read the real pointer value. */\r
 718         prvReadRegister( ( unsigned char * ) &ulTxAddress, tcpTX_WRITE_POINTER_REG, sizeof( ulTxAddress ) );\r
 719 \r
 720         /* Make sure endieness is correct. */\r
 721         ulTxAddress = htonl( ulTxAddress );\r
 722 \r
 723         /* Send the start of the page. */\r
 724         prvWriteString( cSamplePageFirstPart, strlen( cSamplePageFirstPart ), &ulTxAddress );\r
 725 \r
 726         /* Generate a bit of dynamic data and place it in the buffer ready to be\r
 727         transmitted. */\r
 728         strcpy( cPageBuffer, "<BR>Number of ticks since boot = 0x" );\r
 729         lIndex = strlen( cPageBuffer );\r
 730         ultoa( xTaskGetTickCount(), &( cPageBuffer[ lIndex ] ), 0 );\r
 731         strcat( cPageBuffer, "<br>Number of tasks executing = ");\r
 732         lIndex = strlen( cPageBuffer );\r
 733         ultoa( ( unsigned long ) uxTaskGetNumberOfTasks(), &( cPageBuffer[ lIndex ] ), 0 );\r
 734         strcat( cPageBuffer, "<br>IO port 0 state (used by flash tasks) = 0x" );\r
 735         lIndex = strlen( cPageBuffer );\r
 736         ultoa( ( unsigned long ) GPIO0_IOPIN, &( cPageBuffer[ lIndex ] ), 0 );\r
 737         strcat( cPageBuffer, "<br>Refresh = 0x" );\r
 738         lIndex = strlen( cPageBuffer );\r
 739         ultoa( ( unsigned long ) ulRefreshCount, &( cPageBuffer[ lIndex ] ), 0 );\r
 740         \r
 741         if( lErrorInTask )\r
 742         {\r
 743                 strcat( cPageBuffer, "<p>An error has occurred in at least one task." );\r
 744         }\r
 745         else\r
 746         {\r
 747                 strcat( cPageBuffer, "<p>All tasks executing without error." );         \r
 748         }\r
 749 \r
 750         ulRefreshCount++;\r
 751 \r
 752         /* Send the dynamically generated string. */\r
 753         prvWriteString( cPageBuffer, strlen( cPageBuffer ), &ulTxAddress );\r
 754 \r
 755         /* Finish the page. */\r
 756         prvWriteString( cSamplePageSecondPart, strlen( cSamplePageSecondPart ), &ulTxAddress );\r
 757 \r
 758         /* Tell the WIZnet to send the data we have just written to its Tx buffer. */\r
 759         prvFlushBuffer( ulTxAddress );\r
 760 }\r
 761 \r