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

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