+++ /dev/null
-/*\r
-********************************************************************************\r
-* TERN, Inc.\r
-* (c) Copyright 2005, http://www.tern.com\r
-*\r
-* MODIFIED BY RICHARD BARRY TO ADD SEMAPHORE FOR COMMUNICATION BETWEEN THE \r
-* WIZnet ISR AND THE HTTP TASK.\r
-*\r
-* - Derived based on development version provided by Wiznet.\r
-*\r
-* Filename : socket.h\r
-* Programmer(s):\r
-* Created : 2002/06/20\r
-* Modified :\r
-* 2002/09/27 : - Renaming\r
-* INT_STATUS --> INT_REG\r
-* STATUS(i) --> INT_STATUS(i)\r
-* C_STATUS(i) --> SOCK_STATUS(i)\r
-* 2003/11/06 : Ported for use with TERN controller. Note all byte access is at even addresses\r
-* 2005/10/8 : Modified constants for easier initialization.\r
-*\r
-* Description : Header file of W3100A for TERN embedded controller\r
-********************************************************************************\r
-*/\r
-/*\r
-###############################################################################\r
-File Include Section\r
-###############################################################################\r
-*/\r
-#include "i2chip_hw.h" \r
-#include "socket.h"\r
-#include "types.h"\r
-#include <string.h>\r
-#include <stdio.h>\r
-\r
-#include <FreeRTOS.h>\r
-#include <semphr.h>\r
-#include <portasm.h>\r
-\r
-\r
-/*\r
-###############################################################################\r
-Local Variable Declaration Section\r
-###############################################################################\r
-*/\r
-u_char I_STATUS[4]; // Store Interrupt Status according to channels\r
-u_int Local_Port; // Designate Local Port\r
-union un_l2cval SEQ_NUM; // Set initial sequence number\r
-\r
-u_long SMASK[MAX_SOCK_NUM]; // Variable to store MASK of Tx in each channel,\r
- // on setting dynamic memory size.\r
-u_long RMASK[MAX_SOCK_NUM]; // Variable to store MASK of Rx in each channel,\r
- // on setting dynamic memory size.\r
-int SSIZE[MAX_SOCK_NUM]; // Maximun Tx memory size by each channel\r
-int RSIZE[MAX_SOCK_NUM]; // Maximun Rx memory size by each channel\r
-\r
-u_int SBUFBASEADDRESS[MAX_SOCK_NUM]; // Maximun Tx memory base address by each channel\r
-u_int RBUFBASEADDRESS[MAX_SOCK_NUM]; // Maximun Rx memory base address by each channel\r
-\r
-/*\r
-###############################################################################\r
-Function Implementation Section\r
-###############################################################################\r
-*/\r
-\r
-/*\r
-********************************************************************************\r
-* Interrupt handling function of the W3100A\r
-*\r
-* Description :\r
-* Stores the status information that each function waits for in the global variable I_STATUS\r
-* for transfer. I_STATUS stores the interrupt status value for each channel.\r
-* Arguments : None\r
-* Returns : None\r
-* Note : Internal Function\r
-********************************************************************************\r
-*/\r
-\r
-portBASE_TYPE prvProcessISR( void )\r
-{\r
-unsigned char status;\r
-extern xSemaphoreHandle xTCPSemaphore;\r
-portBASE_TYPE xSwitchRequired = pdFALSE;\r
-\r
-#ifdef I2CHIP_WINDOW\r
-u_int current_window = i2chip_get_window();\r
-#endif\r
-\r
-status = READ_VALUE(INT_REG);\r
-\r
-\r
-if (status)\r
- {\r
- xSwitchRequired = pdTRUE;\r
- // channel 0 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)\r
- if (status & 0x01)\r
- {\r
- I_STATUS[0] = READ_VALUE(INT_STATUS(0));\r
-\r
-// if (I_STATUS[0] & SESTABLISHED)\r
-// ISR_ESTABLISHED(0);\r
-// if (I_STATUS[0] & SCLOSED)\r
-// ISR_CLOSED(0);\r
-\r
- WRITE_VALUE(INT_REG, 0x01);\r
- }\r
-\r
- // channel 1 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)\r
- if (status & 0x02)\r
- {\r
- I_STATUS[1] = READ_VALUE(INT_STATUS(1));\r
-\r
-// if (I_STATUS[1] & SESTABLISHED)\r
-// ISR_ESTABLISHED(1);\r
-// if (I_STATUS[1] & SCLOSED)\r
-// ISR_CLOSED(1);\r
-\r
- WRITE_VALUE(INT_REG, 0x02);\r
- }\r
-\r
- // channel 2 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)\r
- if (status & 0x04)\r
- {\r
- I_STATUS[2] = READ_VALUE(INT_STATUS(2));\r
-\r
-// if (I_STATUS[2] & SESTABLISHED)\r
-// ISR_ESTABLISHED(2);\r
-// if (I_STATUS[2] & SCLOSED)\r
-// ISR_CLOSED(2);\r
-\r
- WRITE_VALUE(INT_REG, 0x04);\r
- }\r
-\r
- // channel 3 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)\r
- if (status & 0x08)\r
- {\r
- I_STATUS[3] = READ_VALUE(INT_STATUS(3));\r
-\r
-// if (I_STATUS[3] & SESTABLISHED) ISR_ESTABLISHED(3);\r
-// if (I_STATUS[3] & SCLOSED) ISR_CLOSED(3);\r
-\r
- WRITE_VALUE(INT_REG, 0x08);\r
- }\r
-\r
- // channel 0 receive interrupt\r
- if (status & 0x10)\r
- {\r
-// ISR_RX(0);\r
- WRITE_VALUE(INT_REG, 0x10);\r
- }\r
-\r
- // channel 1 receive interrupt\r
- if (status & 0x20)\r
- {\r
-// ISR_RX(1);\r
- WRITE_VALUE(INT_REG, 0x20);\r
- }\r
-\r
- // channel 2 receive interrupt\r
- if (status & 0x40)\r
- {\r
-// ISR_RX(2);\r
- WRITE_VALUE(INT_REG, 0x40);\r
- }\r
-\r
- // channel 3 receive interrupt\r
- if (status & 0x80)\r
- {\r
-// ISR_RX(3);\r
- WRITE_VALUE(INT_REG, 0x80);\r
- }\r
- status = READ_VALUE(INT_REG);\r
- }\r
-\r
-WRITE_VALUE(INT_REG, 0xFF);\r
-\r
-#ifdef I2CHIP_WINDOW\r
-i2chip_set_window(current_window);\r
-#endif\r
-\r
- if( xSwitchRequired == pdTRUE )\r
- {\r
- xSwitchRequired = xSemaphoreGiveFromISR( xTCPSemaphore, pdFALSE );\r
- }\r
-\r
- return xSwitchRequired;\r
-}\r
-\r
-void far interrupt in4_isr_i2chip(void)\r
-{\r
- if( prvProcessISR() == pdTRUE )\r
- {\r
- portEND_SWITCHING_ISR();\r
- }\r
-\r
- INT_EOI;\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Established connection interrupt handling function.\r
-*\r
-* Description :\r
-* Called upon connection establishment, and may be inserted in user code if needed by\r
-* the programmer.\r
-* Arguments : None\r
-* Returns : None\r
-* Note : Internal Function\r
-****************************************************************************************************\r
-*/\r
-/*\r
-void ISR_ESTABLISHED(SOCKET s)\r
-{\r
-// TO ADD YOUR CODE\r
-}\r
-*/\r
-\r
-/*\r
-****************************************************************************************************\r
-* Closed connection interrupt handling function\r
-*\r
-* Description :\r
-* Called upon connection closure, and may be inserted in user code if needed by the programmer.\r
-* Arguments : None\r
-* Returns : None\r
-* Note : Internal Function\r
-****************************************************************************************************\r
-*/\r
-/*\r
-void ISR_CLOSED(SOCKET s)\r
-{\r
-// TO ADD YOUR CODE\r
-}\r
-*/\r
-\r
-/*\r
-****************************************************************************************************\r
-* Received data interrupt handling function\r
-*\r
-* Description :\r
-* Called upon receiving data, and may be inserted in user code if needed by the programmer.\r
-* Arguments : None\r
-* Returns : None\r
-* Note : Internal Function\r
-****************************************************************************************************\r
-*/\r
-/*\r
-void ISR_RX(SOCKET s)\r
-{\r
-// TO ADD YOUR CODE\r
-}\r
-*/\r
-\r
-/*\r
-****************************************************************************************************\r
-* W3100A Initialization Function\r
-*\r
-* Description: Reset of W3100A S/W and Registeration of i386 interrupt\r
-* Arguments : None.\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void initW3100A(void)\r
-{\r
-\r
-// Install interrupt handler for i2Chip\r
-INT_INIT(in4_isr_i2chip);\r
-\r
-\r
-Local_Port = 1000; // This default value will be set if you didn't designate it when you\r
- // create a socket. If you don't designate port number and create a\r
- // socket continuously, the port number will be assigned with\r
- // incremented by one to Local_Port\r
-SEQ_NUM.lVal = 4294967293ul; // Sets the initial SEQ# to be used for TCP communication.\r
- // (It should be ramdom value)\r
-WRITE_VALUE(COMMAND(0), CSW_RESET); // Software RESET\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* W3100A initialization function\r
-*\r
-* Description :\r
-* Sets the Tx, Rx memory size by each channel, source MAC, source IP, gateway, and subnet mask\r
-* to be used by the W3100A to the designated values.\r
-* May be called when reflecting modified network information or Tx, Rx memory size on the W3100A\r
-* Include Ping Request for ARP update (In case that a device embedding W3100A is directly\r
-* connected to Router)\r
-* Arguments : sbufsize - Tx memory size (00 - 1KByte, 01- 2KBtye, 10 - 4KByte, 11 - 8KByte)\r
-* bit 1-0 : Tx memory size of channel #0\r
-* bit 3-2 : Tx memory size of channel #1\r
-* bit 5-4 : Tx memory size of channel #2\r
-* bit 7-6 : Tx memory size of channel #3\r
-* rbufsize - Rx memory size (00 - 1KByte, 01- 2KBtye, 10 - 4KByte, 11 - 8KByte)\r
-* bit 1-0 : Rx memory size of channel #0\r
-* bit 3-2 : Rx memory size of channel #1\r
-* bit 5-4 : Rx memory size of channel #2\r
-* bit 7-6 : Rx memory size of channel #3\r
-* Returns : None\r
-* Note : API Function\r
-* Maximum memory size for Tx, Rx in W3100A is 8KBytes,\r
-* In the range of 8KBytes, the memory size could be allocated dynamically by\r
-* each channel\r
-* Be attentive to sum of memory size shouldn't exceed 8Kbytes\r
-* and to data transmission and receiption from non-allocated channel may cause\r
-* some problems.\r
-* If 8KBytes memory already is assigned to centain channel, other 3 channels\r
-* couldn't be used, for there's no available memory.\r
-* If two 4KBytes memory are assigned to two each channels, other 2 channels couldn't\r
-* be used, for there's no available memory.\r
-* (Example of memory assignment)\r
-* sbufsize => 00000011, rbufsize => 00000011 :\r
-* Assign 8KBytes for Tx and Rx to channel #0, Cannot use channel #1,#2,#3\r
-* sbufsize => 00001010, rbufsize => 00001010 :\r
-* Assign 4KBytes for Tx and Rx to each channel #0,#1 respectively. Cannot use\r
-* channel #2,#3\r
-* sbufsize => 01010101, rbufsize => 01010101 :\r
-* Assign 2KBytes for Tx and Rx to each all channels respectively.\r
-* sbufsize => 00010110, rbufsize => 01010101 :\r
-* Assign 4KBytes for Tx, 2KBytes for Rx to channel #0\r
-* s 2KBytes for Tx, 2KBytes for Rx to channel #1\r
-* 2KBytes for Tx, 2KBytes for Rx to channel #2\r
-* 2KBytes is available exclusively for Rx in channel #3. There's no memory for Tx.\r
-****************************************************************************************************\r
-*/\r
-void sysinit(u_char sbufsize, u_char rbufsize)\r
-{\r
-char i;\r
-int ssum,rsum;\r
-\r
-ssum = 0;\r
-rsum = 0;\r
-\r
-// Set Tx memory size for each channel\r
-WRITE_VALUE(TX_DMEM_SIZE, sbufsize);\r
-\r
-// Set Rx memory size for each channel\r
-WRITE_VALUE(RX_DMEM_SIZE, rbufsize);\r
-\r
-// Set Base Address of Tx memory for channel #0\r
-SBUFBASEADDRESS[0] = 0;\r
-\r
-// Set Base Address of Rx memory for channel #0\r
-RBUFBASEADDRESS[0] = 0;\r
-\r
-// Set maximum memory size for Tx and Rx, mask, base address of memory by each channel\r
-for(i = 0 ; i < MAX_SOCK_NUM; i++)\r
- {\r
- SSIZE[i] = 0;\r
- RSIZE[i] = 0;\r
- if(ssum < 8192)\r
- {\r
- switch((sbufsize >> i*2) & 0x03) // Set maximum Tx memory size\r
- {\r
- case 0:\r
- SSIZE[i] = 1024;\r
- SMASK[i] = 0x000003FF;\r
- break;\r
-\r
- case 1:\r
- SSIZE[i] = 2048;\r
- SMASK[i] = 0x000007FF;\r
- break;\r
-\r
- case 2:\r
- SSIZE[i] = 4096;\r
- SMASK[i] = 0x00000FFF;\r
- break;\r
-\r
- case 3:\r
- SSIZE[i] = 8192;\r
- SMASK[i] = 0x00001FFF;\r
- break;\r
- }\r
- }\r
- if(rsum < 8192)\r
- {\r
- switch((rbufsize >> i*2) & 0x03) // Set maximum Rx memory size\r
- {\r
- case 0:\r
- RSIZE[i] = 1024;\r
- RMASK[i] = 0x000003FF;\r
- break;\r
-\r
- case 1:\r
- RSIZE[i] = 2048;\r
- RMASK[i] = 0x000007FF;\r
- break;\r
-\r
- case 2:\r
- RSIZE[i] = 4096;\r
- RMASK[i] = 0x00000FFF;\r
- break;\r
-\r
- case 3:\r
- RSIZE[i] = 8192;\r
- RMASK[i] = 0x00001FFF;\r
- break;\r
- }\r
- }\r
- ssum += SSIZE[i];\r
- rsum += RSIZE[i];\r
-\r
- // Set base address of Tx and Rx memory for channel #1,#2,#3\r
- if(i != 0)\r
- {\r
- SBUFBASEADDRESS[i] = ssum - SSIZE[i];\r
- RBUFBASEADDRESS[i] = rsum - RSIZE[i];\r
- }\r
- }\r
-\r
- WRITE_VALUE(COMMAND(0), CSYS_INIT);\r
-\r
-while(!(I_STATUS[0] & SSYS_INIT_OK))\r
- I2CHIP_POLL_ISR(in4_isr_i2chip);\r
-\r
-#ifdef __PING__\r
- {\r
- u_char xdata pingbuf[8];\r
- setIPprotocol(0, IPPROTO_ICMP);\r
- socket(0, SOCK_IPL_RAW, 3000,0); // Create a socket for ARP update\r
-\r
- pingbuf[0] = 8; // ICMP TYPE\r
- pingbuf[1] = 0; // ICMP CODE\r
- pingbuf[2] = 0xf7; // CHECKSUM (already calculated)\r
- pingbuf[3] = 0xfd;\r
- pingbuf[4] = 0; // ID\r
- pingbuf[5] = 1;\r
- pingbuf[6] = 0; // SEQ #\r
- pingbuf[7] = 1;\r
- pingbuf[8] = 0; // Data 1 Byte\r
-\r
- sendto(0, pingbuf, 9, GATEWAY_PTR,3000); // Ping Request\r
- close(0);\r
- printf("Route MAC Update Success");\r
- }\r
-#endif\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set subnet mask\r
-*\r
-* Description:\r
-* Arguments : addr--> Pointer that has the value to be set\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void setsubmask(u_char * addr)\r
-{\r
-u_char i;\r
-u_char far* sm_ptr = SUBNET_MASK_PTR; // We can only convert to 'regular'\r
- // pointer if we're confident arithmetic\r
- // won't take us out of current window.\r
-\r
-for (i = 0; i < 4; i++)\r
- {\r
- WRITE_VALUE(sm_ptr + SA_OFFSET(i), addr[i]);\r
- }\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set gateway IP\r
-*\r
-* Description:\r
-* Arguments : addr--> Pointer that has Gateway IP to be set\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void setgateway(u_char * addr)\r
-{\r
-u_char i;\r
-u_char far* gw_ptr = GATEWAY_PTR; // We can only convert to 'regular'\r
- // pointer if we're confident arithmetic\r
- // won't take us out of current window.\r
-for (i = 0; i < 4; i++)\r
- {\r
- WRITE_VALUE(gw_ptr + SA_OFFSET(i), addr[i]);\r
- }\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set W3100A IP\r
-*\r
-* Description:\r
-* Arguments : addr--> Pointer that has Source IP to be set\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void setIP(u_char * addr)\r
-{\r
-u_char i;\r
-u_char far* src_ptr = SRC_IP_PTR; // We can only convert to 'regular'\r
- // pointer if we're confident arithmetic\r
- // won't take us out of current window.\r
-\r
-for (i = 0; i < 4; i++)\r
- {\r
- WRITE_VALUE(src_ptr + SA_OFFSET(i), addr[i]);\r
- }\r
-}\r
-\r
-// DEBUG\r
-void getIP(u_char* addr)\r
-{\r
-u_char i;\r
-u_char far* src_ptr = SRC_IP_PTR; // We can only convert to 'regular'\r
- // pointer if we're confident arithmetic\r
- // won't take us out of current window.\r
-\r
-for (i = 0; i < 4; i++)\r
- addr[i] = READ_VALUE(src_ptr + SA_OFFSET(i));\r
-}\r
-\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set MAC\r
-*\r
-* Description:\r
-* Arguments : addr--> Pointer that has MAC to be set\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void setMACAddr(u_char * addr)\r
-{\r
-u_char i;\r
-u_char far* ha_ptr = SRC_HA_PTR; // We can only convert to 'regular'\r
- // pointer if we're confident arithmetic\r
- // won't take us out of current window.\r
-\r
-for (i = 0; i < 6; i++)\r
- {\r
- WRITE_VALUE(ha_ptr + SA_OFFSET(i), addr[i]);\r
- }\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set TCP timeout\r
-*\r
-* Description: The function that used to adjust time to resend TCP\r
-* Arguments : val --> Pointer that has the value to be set\r
-* Upper 2 byte:Initial timeout value\r
-* Last 1 byte:The count to retry till timeout\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void settimeout(u_char * val)\r
-{\r
-u_char i;\r
-u_char far* tout_ptr = TIMEOUT_PTR; // We can only convert to 'regular'\r
- // pointer if we're confident arithmetic\r
- // won't take us out of current window.\r
-\r
-for (i = 0; i < 3; i++)\r
- {\r
- WRITE_VALUE(tout_ptr + SA_OFFSET(i), val[i]);\r
- }\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set interrupt mask.\r
-*\r
-* Description:\r
-* Arguments : mask--> Mask value to be set ('1'-> interrupt )\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void setINTMask(u_char mask)\r
-{\r
-WRITE_VALUE(INTMASK, mask);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set enable in sending and receiving of broadcast data\r
-*\r
-* Description: Enable to process of broadcating data in UDP or IP RAW mode.\r
-* Arguments : s --> Channel No. to be set\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void setbroadcast(SOCKET s)\r
-{\r
-u_char val = READ_VALUE(OPT_PROTOCOL(s));\r
-WRITE_VALUE(OPT_PROTOCOL(s), val | SOCKOPT_BROADCAST);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function to set process protocol in IP RAW mode.\r
-*\r
-* Description:\r
-* Arguments : s--> Channel No. to be set\r
-* tos-->Protocol Value to be set\r
-* Returns : None.\r
-* Note :\r
-****************************************************************************************************\r
-*/\r
-void setTOS(SOCKET s, u_char tos)\r
-{\r
-WRITE_VALUE(TOS(s), tos);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Upper layer protocol setup function in IP RAW Mode\r
-*\r
-* Description : Upper layer protocol setup function in protocol field of IP header when\r
-* developing upper layer protocol like ICMP, IGMP, EGP etc. by using IP Protocol\r
-* Arguments : s - Channel number\r
-* ipprotocol - Upper layer protocol setting value of IP Protocol\r
-* (Possible to use designated IPPROTO_ in header file)\r
-* Returns : None\r
-* Note : API Function\r
-* This function should be called before calling socket() that is, before\r
-* socket initialization.\r
-****************************************************************************************************\r
-*/\r
-void setIPprotocol(SOCKET s, u_char ipprotocol)\r
-{\r
-WRITE_VALUE(IP_PROTOCOL(s), ipprotocol);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Initialization function to appropriate channel\r
-*\r
-* Description : Initialize designated channel and wait until W3100 has done.\r
-* Arguments : s - channel number\r
-* protocol - designate protocol for channel\r
-* SOCK_STREAM(0x01) -> TCP.\r
-* SOCK_DGRAM(0x02) -> UDP.\r
-* SOCK_IPL_RAW(0x03) -> IP LAYER RAW.\r
-* SOCK_MACL_RAW(0x04) -> MAC LAYER RAW.\r
-* port - designate source port for appropriate channel\r
-* flag - designate option to be used in appropriate.\r
-* SOCKOPT_BROADCAST(0x80) -> Send/receive broadcast message in UDP\r
-* SOCKOPT_NDTIMEOUT(0x40) -> Use register value which designated TIMEOUT\r
-* value\r
-* SOCKOPT_NDACK(0x20) -> When not using no delayed ack\r
-* SOCKOPT_SWS(0x10) -> When not using silly window syndrome\r
-* Returns : When succeeded : Channel number, failed :-1\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-char socket(SOCKET s, u_char protocol, u_int port, u_char flag)\r
-{\r
-u_char k;\r
-\r
-//Designate socket protocol and option\r
-WRITE_VALUE(OPT_PROTOCOL(s), protocol | flag);\r
-\r
-// setup designated port number\r
-if (port != 0)\r
- {\r
- k = (u_char)((port & 0xff00) >> 8);\r
- WRITE_VALUE(SRC_PORT_PTR(s), k);\r
- k = (u_char)(port & 0x00ff);\r
- WRITE_VALUE(SRC_PORT_PTR(s) + SA_OFFSET(1), k);\r
- }\r
-else\r
- {\r
- // Designate random port number which is managed by local when you didn't designate source port\r
- Local_Port++;\r
-\r
- WRITE_VALUE(SRC_PORT_PTR(s), (u_char)((Local_Port & 0xff00) >> 8));\r
- WRITE_VALUE(SRC_PORT_PTR(s) + SA_OFFSET(1), (u_char)(Local_Port & 0x00ff));\r
- }\r
-\r
-// SOCK_INIT\r
-I_STATUS[s] = 0;\r
-WRITE_VALUE(COMMAND(s), CSOCK_INIT);\r
-\r
-// Waiting Interrupt to CSOCK_INIT\r
-while (I_STATUS[s] == 0)\r
- I2CHIP_POLL_ISR(in4_isr_i2chip);\r
-\r
-if (!(I_STATUS[s] & SSOCK_INIT_OK))\r
- return(-1);\r
-\r
-initseqnum(s); // Use initial seq# with random number\r
-\r
-return(s);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Connection establishing function to designated peer.\r
-*\r
-* Description : This function establish a connection to the peer by designated channel,\r
-* and wait until the connection is established successfully. (TCP client mode)\r
-* Arguments : s - channel number\r
-* addr - destination IP Address\r
-* port - destination Port Number\r
-* Returns : when succeeded : 1, failed : -1\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-char connect(SOCKET s, u_char far * addr, u_int port)\r
-{\r
-\r
-if (port != 0)\r
- { //designate destination port\r
- WRITE_VALUE(DST_PORT_PTR(s), (u_char)((port & 0xff00) >> 8));\r
- WRITE_VALUE(DST_PORT_PTR(s) + SA_OFFSET(1), (u_char)(port & 0x00ff));\r
- }\r
-else\r
- return(-1);\r
-\r
- WRITE_VALUE(DST_IP_PTR(s), addr[0]); //designate destination IP address\r
- WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(1), addr[1]);\r
- WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(2), addr[2]);\r
- WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(3), addr[3]);\r
-\r
-I_STATUS[s] = 0;\r
-\r
- WRITE_VALUE(COMMAND(s), CCONNECT); // CONNECT\r
- I2CHIP_POLL_ISR(in4_isr_i2chip);\r
-\r
-// Wait until connection is established successfully\r
-while (I_STATUS[s] == 0)\r
- {\r
- // When failed, appropriate channel will be closed and return an error\r
- if (select(s, SEL_CONTROL) == SOCK_CLOSED)\r
- return -1;\r
- }\r
-\r
-if (!(I_STATUS[s] & SESTABLISHED))\r
- return(-1);\r
-\r
-return(1);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Connection establishing function to designated peer. (Non-blocking Mode)\r
-*\r
-* Description : This function establish a connection to the peer by designated channel.\r
-*\r
-* Arguments : s - channel number\r
-* addr - destination IP Address\r
-* port - destination Port Number\r
-* Returns : when succeeded : 1, failed : -1\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-char NBconnect(SOCKET s, u_char far * addr, u_int port)\r
-{\r
-\r
-if (port != 0)\r
- { //designate destination port\r
- WRITE_VALUE(DST_PORT_PTR(s), (u_char) ((port & 0xff00) >> 8) );\r
- WRITE_VALUE(DST_PORT_PTR(s) + SA_OFFSET(1), (u_char)(port & 0x00ff));\r
- }\r
-else\r
- return(-1);\r
-\r
- WRITE_VALUE(DST_IP_PTR(s), addr[0]); //designate destination IP address\r
- WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(1), addr[1]);\r
- WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(2), addr[2]);\r
- WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(3), addr[3]);\r
-\r
-I_STATUS[s] = 0;\r
-\r
-WRITE_VALUE(COMMAND(s), CCONNECT); // CONNECT\r
-return(1);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Waits for connection request from a peer (Blocking Mode)\r
-*\r
-* Description : Wait for connection request from a peer through designated channel (TCP Server mode)\r
-* Arguments : s - channel number\r
-* addr - IP Address of the peer when a connection is established\r
-* port - Port number of the peer when a connection is established\r
-* Returns : When succeeded : 1, failed : -1\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-/*\r
-char listen(SOCKET s, u_char far * addr, u_int far * port)\r
-{\r
-u_int i;\r
-\r
-I_STATUS[s] = 0;\r
-\r
-// LISTEN\r
-COMMAND(s) = CLISTEN;\r
-\r
-// Wait until connection is established\r
-while (I_STATUS[s] == 0)\r
- {\r
- // When failed to connect, the designated channel will be closed and return an error.\r
- if (select(s, SEL_CONTROL) == SOCK_CLOSED)\r
- return -1;\r
- }\r
-\r
-// Receive IP address and port number of the peer connected\r
-if (I_STATUS[s] & SESTABLISHED)\r
- {\r
- i = *DST_PORT_PTR(s);\r
- *port = (u_int)((i & 0xff00) >> 8);\r
- i = *(DST_PORT_PTR(s) + 2);\r
- i = (u_int)(i & 0x00ff);\r
- *port += (i << 8);\r
-\r
- addr[0] = *DST_IP_PTR(s);\r
- addr[1] = *(DST_IP_PTR(s) + 2);\r
- addr[2] = *(DST_IP_PTR(s) + 4);\r
- addr[3] = *(DST_IP_PTR(s) + 6);\r
- }\r
-else\r
- return(-1);\r
-\r
-return(1);\r
-}\r
-*/\r
-\r
-/*\r
-****************************************************************************************************\r
-* Waits for connection request from a peer (Non-blocking Mode)\r
-*\r
-* Description : Wait for connection request from a peer through designated channel (TCP Server mode)\r
-* Arguments : s - channel number\r
-* Returns : None\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-char NBlisten(SOCKET s)\r
-{\r
-I_STATUS[s] = 0;\r
-\r
-// LISTEN\r
-WRITE_VALUE(COMMAND(s), CLISTEN);\r
-\r
-return(1);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Create random value for initial Seq# when establishing TCP connection\r
-*\r
-* Description : In this function, you can add some source codes to create random number for\r
-* initial Seq#. In real, TCP initial SEQ# should be random value.\r
-* (Currently, we're using static value in EVB/DK.)\r
-* Arguments : s - channel number\r
-* Returns : None\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-void initseqnum(SOCKET s)\r
-{\r
-// Designate initial seq#\r
-// If you have random number generation function, assign random number instead of SEQ_NUM.lVal++.\r
-SEQ_NUM.lVal++;\r
-\r
-//randomize();\r
-//SEQ_NUM.lVal = rand();\r
-\r
-WRITE_VALUE(TX_WR_PTR(s), SEQ_NUM.cVal[0]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(1), SEQ_NUM.cVal[1]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(2), SEQ_NUM.cVal[2]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(3), SEQ_NUM.cVal[3]);\r
-delay0(2);\r
-\r
-WRITE_VALUE(TX_RD_PTR(s), SEQ_NUM.cVal[0]);\r
-WRITE_VALUE(TX_RD_PTR(s) + SA_OFFSET(1), SEQ_NUM.cVal[1]);\r
-WRITE_VALUE(TX_RD_PTR(s) + SA_OFFSET(2), SEQ_NUM.cVal[2]);\r
-WRITE_VALUE(TX_RD_PTR(s) + SA_OFFSET(3), SEQ_NUM.cVal[3]);\r
-delay0(2);\r
-\r
-WRITE_VALUE(TX_ACK_PTR(s), SEQ_NUM.cVal[0]);\r
-WRITE_VALUE(TX_ACK_PTR(s) + SA_OFFSET(1), SEQ_NUM.cVal[1]);\r
-WRITE_VALUE(TX_ACK_PTR(s) + SA_OFFSET(2), SEQ_NUM.cVal[2]);\r
-WRITE_VALUE(TX_ACK_PTR(s) + SA_OFFSET(3), SEQ_NUM.cVal[3]);\r
-delay0(2);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function for sending TCP data.\r
-*\r
-* Description : Function for sending TCP data and Composed of the send() and send_in() functions.\r
-* The send() function is an application I/F function.\r
-* It continues to call the send_in() function to complete the sending of the data up to the\r
-* size of the data to be sent when the application is called.\r
-* The send_in() function receives the return value (the size of the data sent), calculates\r
-* the size of the data to be sent, and calls the send_in() function again if there is any\r
-* data left to be sent.\r
-* Arguments : s - channel number\r
-* buf - Pointer pointing data to send\r
-* len - data size to send\r
-* Returns : Succeed: sent data size, Failed: -1;\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-int send(SOCKET s, u_char far * buf, u_int len)\r
-{\r
-int ptr, size;\r
-u_char huge* huge_buf = (u_char huge*)buf;\r
-u_char far* local_buf = (u_char far*)huge_buf; \r
-\r
-if (len <= 0)\r
- return (0);\r
-else\r
- {\r
- ptr = 0;\r
- do\r
- {\r
- size = send_in(s, local_buf + ptr, len);\r
- if (size == -1)\r
- return -1;\r
- len = len - size;\r
- ptr += size;\r
- } while ( len > 0);\r
- }\r
-return ptr;\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Internal function for sending TCP data.\r
-*\r
-* Description : Called by the send() function for TCP transmission.\r
-* It first calculates the free transmit buffer size\r
-* and compares it with the size of the data to be transmitted to determine the transmission size.\r
-* After calculating the data size, it copies data from TX_WR_PTR.\r
-* It waits if there is a previous send command in process.\r
-* When the send command is cleared, it updates the TX_WR_PTR up to the size to be transmitted\r
- and performs the send command.\r
-* Arguments : s - channel number\r
-* buf - Pointer pointing data to send\r
-* len - data size to send\r
-* Returns : Succeeded: sent data size, Failed: -1\r
-* Note : Internal Function\r
-****************************************************************************************************\r
-*/\r
-int send_in(SOCKET s, u_char far * buf, u_int len)\r
-{\r
-u_char k;\r
-u_int size;\r
-union un_l2cval wr_ptr, ack_ptr;\r
-unsigned int offset;\r
-\r
-S_START:\r
-disable(); // CT: Shadow register access should not conflict with ISR.\r
-k = READ_VALUE(SHADOW_TXWR_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-wr_ptr.cVal[3] = READ_VALUE(TX_WR_PTR(s));\r
-wr_ptr.cVal[2] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(1));\r
-wr_ptr.cVal[1] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(2));\r
-wr_ptr.cVal[0] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(3));\r
-\r
-k = READ_VALUE(SHADOW_TXACK_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-ack_ptr.cVal[3] = READ_VALUE(TX_ACK_PTR(s));\r
-ack_ptr.cVal[2] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(1));\r
-ack_ptr.cVal[1] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(2));\r
-ack_ptr.cVal[0] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(3));\r
-enable();\r
-\r
-// Suppress compiler errors that k is not used\r
-k = k;\r
-\r
-// Calculate send free buffer size\r
-if (wr_ptr.lVal >= ack_ptr.lVal)\r
- size = (u_int)(SSIZE[s] - (wr_ptr.lVal - ack_ptr.lVal));\r
-else\r
- size = (u_int)(SSIZE[s] - (0 - ack_ptr.lVal + wr_ptr.lVal));\r
-\r
-// Recalulate after some delay because of error in pointer calculation\r
-if (size > SSIZE[s])\r
- {\r
- if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED)\r
- return -1;\r
- delay_ms(1);\r
- goto S_START;\r
- }\r
-\r
-// Wait when previous sending has not finished yet and there's no free buffer\r
-if (size == 0)\r
- {\r
- if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED)\r
- return -1;\r
-\r
- delay_ms(1);\r
- goto S_START;\r
- }\r
-else if (size < len)\r
- {\r
- len = size;\r
- }\r
-\r
-// Calculate pointer to data copy\r
-offset = (UINT)(wr_ptr.lVal & SMASK[s]);\r
-\r
-// copy data\r
-write_data(s, buf, offset, len);\r
-\r
-while (READ_VALUE(COMMAND(s)) & CSEND)\r
- {\r
- // Confirm previous send command\r
- if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED)\r
- return -1;\r
- }\r
-\r
-// update tx_wr_ptr\r
-wr_ptr.lVal = wr_ptr.lVal + len;\r
-WRITE_VALUE(TX_WR_PTR(s), wr_ptr.cVal[3]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(1), wr_ptr.cVal[2]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(2), wr_ptr.cVal[1]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(3), wr_ptr.cVal[0]);\r
-\r
-delay0(1);\r
-\r
-// SEND\r
-WRITE_VALUE(COMMAND(s), CSEND);\r
-\r
-return(len);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* TCP data receiving function.\r
-*\r
-* Description : This function is to clear out any received TCP data.\r
-* Arguments : s - channel number\r
-* Returns : None\r
-* Note : API Fcuntion\r
-****************************************************************************************************\r
-*/\r
-void recv_clear(SOCKET s)\r
-{\r
-u_char k;\r
-u_int size;\r
-union un_l2cval wr_ptr, rd_ptr;\r
-\r
-disable();\r
-k = READ_VALUE(SHADOW_RXWR_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));\r
-wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));\r
-wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));\r
-wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));\r
-\r
-k = READ_VALUE(SHADOW_RXRD_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));\r
-rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));\r
-rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));\r
-rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));\r
-enable();\r
-\r
-// Suppress compiler errors that k is not used\r
-k = k;\r
-\r
-// calculate received data size\r
-if (wr_ptr.lVal >= rd_ptr.lVal)\r
- size = (u_int)(wr_ptr.lVal - rd_ptr.lVal);\r
-else\r
- size = (u_int)(0 - rd_ptr.lVal + wr_ptr.lVal);\r
-\r
-// Update rx_rd_ptr\r
-rd_ptr.lVal += size;\r
-WRITE_VALUE(RX_RD_PTR(s), rd_ptr.cVal[3]);\r
-WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(1), rd_ptr.cVal[2]);\r
-WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(2), rd_ptr.cVal[1]);\r
-WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(3), rd_ptr.cVal[0]);\r
-\r
-// RECV\r
- WRITE_VALUE(COMMAND(s), CRECV);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* TCP data receiving function.\r
-*\r
-* Description : This function is for receiving TCP data.\r
-* The recv() function is an application I/F function. It will read up to len chars if there are\r
- enough characters in the buffer, otherwise will onl read the number of characters availiable\r
-* Arguments : s - channel number\r
-* buf - Pointer where the data to be received is copied\r
-* len - Size of the data to be received\r
-* Returns : Succeeded: received data size, Failed: -1\r
-* Note : API Fcuntion\r
-****************************************************************************************************\r
-*/\r
-int recv(SOCKET s, u_char far * buf, u_int len)\r
-{\r
-u_char k;\r
-u_int size;\r
-union un_l2cval wr_ptr, rd_ptr;\r
-unsigned int offset;\r
-\r
-// If out length is 0, then we do not need to do anything\r
-if (len <= 0)\r
- return (0);\r
-\r
-disable();\r
-k = READ_VALUE(SHADOW_RXWR_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));\r
-wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));\r
-wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));\r
-wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));\r
-\r
-k = READ_VALUE(SHADOW_RXRD_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));\r
-rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));\r
-rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));\r
-rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));\r
-enable();\r
-\r
-// Suppress compiler errors that k is not used\r
-k = k;\r
-\r
-// calculate IIM7010A received data size\r
-if (wr_ptr.lVal == rd_ptr.lVal)\r
- return(0);\r
-else if (wr_ptr.lVal >= rd_ptr.lVal)\r
- size = (u_int)(wr_ptr.lVal - rd_ptr.lVal);\r
-else\r
- size = (u_int)(0 - rd_ptr.lVal + wr_ptr.lVal);\r
-\r
-// Make sure we do not try to read more characters than what is availiable in the IIM7010 buffer\r
-if (size < len)\r
- len = size;\r
-\r
-// Calculate pointer to be copied received data\r
-offset = ((UINT)(rd_ptr.lVal & RMASK[s]));\r
-\r
-// Copy received data\r
-size = read_data(s, offset, buf, len);\r
-\r
-// Update rx_rd_ptr\r
-rd_ptr.lVal += size;\r
-WRITE_VALUE(RX_RD_PTR(s), rd_ptr.cVal[3]);\r
-WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(1), rd_ptr.cVal[2]);\r
-WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(2), rd_ptr.cVal[1]);\r
-WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(3), rd_ptr.cVal[0]);\r
-\r
-// RECV\r
- WRITE_VALUE(COMMAND(s), CRECV);\r
-return(size);\r
-}\r
-\r
-\r
-/*\r
-****************************************************************************************************\r
-* UDP data sending function.\r
-*\r
-* Description : Composed of the sendto()and sendto_in() functions.\r
-* The send() function is an application I/F function.\r
-* It continues to call the send_in() function to complete the sending of the data up to the\r
-* size of the data to be sent\r
-* when the application is called.Unlike TCP transmission, it designates the destination address\r
-* and the port.\r
-* Arguments : s - channel port\r
-* buf - Pointer pointing data to send\r
-* len - data size to send\r
-* addr - destination IP address to send data\r
-* port - destination port number to send data\r
-* Returns : Sent data size\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-u_int sendto(SOCKET s, u_char far * buf, u_int len, u_char * addr, u_int port)\r
-{\r
-//char val;\r
-u_int ptr, size;\r
-\r
-// Wait until previous send commnad has completed.\r
-while(READ_VALUE(COMMAND(s)) & CSEND)\r
- {\r
- if(select(s, SEL_CONTROL) == SOCK_CLOSED)\r
- return -1; // Error.\r
- }\r
-\r
-// Designate destination port number.\r
-if (port != 0)\r
- {\r
- WRITE_VALUE(DST_PORT_PTR(s), (u_char)((port & 0xff00) >> 8));\r
- WRITE_VALUE(DST_PORT_PTR(s) + SA_OFFSET(1), (u_char)(port & 0x00ff));\r
- }\r
-\r
-// Designate destination IP address\r
-WRITE_VALUE(DST_IP_PTR(s), addr[0]);\r
-WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(1), addr[1]);\r
-WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(2), addr[2]);\r
-WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(3), addr[3]);\r
-\r
-if (len <= 0)\r
- return (0);\r
-else\r
- {\r
- ptr = 0;\r
- do\r
- {\r
- size = sendto_in(s, buf + ptr, len);\r
- len = len - size;\r
- ptr += size;\r
- } while ( len > 0);\r
- }\r
-return ptr;\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* UDP data sending function.\r
-*\r
-* Description : An internal function that is the same as the send_in() function of the TCP.\r
-* Arguments : s - Channel number\r
-* buf - Pointer indicating the data to send\r
-* len - data size to send\r
-* Returns : Sent data size\r
-* Note : Internal Function\r
-****************************************************************************************************\r
-*/\r
-u_int sendto_in(SOCKET s, u_char far * buf, u_int len)\r
-{\r
-u_char k;\r
-u_int size;\r
-union un_l2cval wr_ptr, rd_ptr;\r
-unsigned int offset;\r
-\r
-S2_START:\r
-disable();\r
-k = READ_VALUE(SHADOW_TXWR_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-wr_ptr.cVal[3] = READ_VALUE(TX_WR_PTR(s));\r
-wr_ptr.cVal[2] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(1));\r
-wr_ptr.cVal[1] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(2));\r
-wr_ptr.cVal[0] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(3));\r
-\r
-k = READ_VALUE(SHADOW_TXRD_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-rd_ptr.cVal[3] = READ_VALUE(TX_RD_PTR(s));\r
-rd_ptr.cVal[2] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(1));\r
-rd_ptr.cVal[1] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(2));\r
-rd_ptr.cVal[0] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(3));\r
-enable();\r
-\r
-// Suppress compiler errors that k is not used\r
-k = k;\r
-\r
-// Calculate free buffer size to send\r
-if (wr_ptr.lVal >= rd_ptr.lVal)\r
- size = (u_int)(SSIZE[s] - (wr_ptr.lVal - rd_ptr.lVal));\r
-else\r
- size = (u_int)(SSIZE[s] - (0 - rd_ptr.lVal + wr_ptr.lVal));\r
-\r
-// Recalulate after some delay because of error in pointer caluation\r
-if (size > SSIZE[s])\r
- {\r
- delay_ms(1);\r
- goto S2_START;\r
- }\r
-\r
-// Wait when previous sending has not finished yet and there's no free buffer\r
-if (size == 0)\r
- {\r
- delay_ms(1);\r
- goto S2_START;\r
-\r
- }\r
-else if (size < len)\r
- {\r
- len = size;\r
- }\r
-\r
-// Calculate pointer to copy data pointer\r
-offset =(UINT)(wr_ptr.lVal & SMASK[s]);\r
-\r
-// copy data\r
-write_data(s, buf, offset, len);\r
-\r
-// Confirm previous send command\r
-while (READ_VALUE(COMMAND(s)) & CSEND)\r
- {\r
- if(select(s, SEL_CONTROL)==SOCK_CLOSED)\r
- return -1; // Error\r
- }\r
-\r
-// update tx_wr_ptr\r
-wr_ptr.lVal = wr_ptr.lVal + len;\r
-WRITE_VALUE(TX_WR_PTR(s), wr_ptr.cVal[3]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(1), wr_ptr.cVal[2]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(2), wr_ptr.cVal[1]);\r
-WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(3), wr_ptr.cVal[0]);\r
-\r
-delay0(1);\r
-\r
-// SEND\r
-WRITE_VALUE(COMMAND(s), CSEND);\r
-\r
-return(len);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* UDP data receiving function.\r
-*\r
-* Description : Function for receiving UDP and IP layer RAW mode data, and handling the data header.\r
-* Arguments : s - channel number\r
-* buf - Pointer where the data to be received is copied\r
-* len - Size of the data to be received\r
-* addr - Peer IP address for receiving\r
-* port - Peer port number for receiving\r
-* Returns : Received data size\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-u_int recvfrom(SOCKET s, u_char far *buf, u_int len, u_char *addr, u_int *port)\r
-{\r
-struct _UDPHeader // When receiving UDP data, header added by W3100A\r
- {\r
- union\r
- {\r
- struct\r
- {\r
- u_int size;\r
- u_char addr[4];\r
- u_int port;\r
- } header;\r
- u_char stream[8];\r
- } u;\r
- } UDPHeader;\r
-\r
-u_int ret;\r
-union un_l2cval wr_ptr, rd_ptr;\r
-u_long size;\r
-u_char k;\r
-unsigned int offset;\r
-\r
-if(select(s,SEL_CONTROL)==SOCK_CLOSED)\r
- return -1;\r
-\r
-disable();\r
-k = READ_VALUE(SHADOW_RXWR_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));\r
-wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));\r
-wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));\r
-wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));\r
-\r
-k = READ_VALUE(SHADOW_RXRD_PTR(s));\r
-WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
-delay0(2);\r
-rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));\r
-rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));\r
-rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));\r
-rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));\r
-enable();\r
-\r
-// Suppress compiler errors that k is not used\r
-k = k;\r
-\r
-// Calculate received data size\r
-if (len <= 0)\r
- return (0);\r
-else if (wr_ptr.lVal >= rd_ptr.lVal)\r
- size = wr_ptr.lVal - rd_ptr.lVal;\r
-else\r
- size = 0 - rd_ptr.lVal + wr_ptr.lVal;\r
-\r
-if (size == 0)\r
- return 0;\r
-\r
- // Calulate received data pointer\r
-offset = ((UINT)(rd_ptr.lVal & RMASK[s]));\r
-\r
-// When UDP data\r
-if (( READ_VALUE(OPT_PROTOCOL(s)) & 0x07) == SOCK_DGRAM)\r
- {\r
- // Copy W3100A UDP header\r
- read_data(s, offset, UDPHeader.u.stream, 8);\r
-\r
- // Read UDP Packet size\r
- size = UDPHeader.u.stream[0];\r
- size = (size << 8) + UDPHeader.u.stream[1];\r
-\r
- // Read IP address of the peer\r
- addr[0] = UDPHeader.u.header.addr[0];\r
- addr[1] = UDPHeader.u.header.addr[1];\r
- addr[2] = UDPHeader.u.header.addr[2];\r
- addr[3] = UDPHeader.u.header.addr[3];\r
-\r
- // Read Port number of the peer\r
- *port = UDPHeader.u.stream[6];\r
- *port = (*port << 8) + UDPHeader.u.stream[7];\r
-\r
- // Increase read pointer by 8, because already read as UDP header size\r
- rd_ptr.lVal += 8;\r
-\r
- // Calculate UDP data copy pointer\r
- offset = ((UINT)(rd_ptr.lVal & RMASK[s]));\r
-\r
- // Calculate data size of current UDP Packet from UDP header\r
- size = size - 8;\r
-\r
- // Copy one UDP data packet to user-specific buffer\r
- ret = read_data(s, offset, buf, (u_int)size);\r
-\r
- // Increase read pointer by UDP packet data size\r
- rd_ptr.lVal += ret;\r
- }\r
-else if ((READ_VALUE(OPT_PROTOCOL(s)) & 0x07) == SOCK_IPL_RAW) // When IP layer RAW mode data\r
- {\r
- // Copy W3100A IP Raw header\r
- read_data(s, offset, UDPHeader.u.stream, 6);\r
-\r
- // Read IP layer RAW Packet size\r
- size = UDPHeader.u.stream[0];\r
- size = (size << 8) + UDPHeader.u.stream[1];\r
-\r
- // Read IP address of the peer\r
- addr[0] = UDPHeader.u.header.addr[0];\r
- addr[1] = UDPHeader.u.header.addr[1];\r
- addr[2] = UDPHeader.u.header.addr[2];\r
- addr[3] = UDPHeader.u.header.addr[3];\r
-\r
- // Increase read pointer by 6, because already read as IP RAW header size\r
- rd_ptr.lVal += 6;\r
-\r
- // Calculate IP layer raw mode data pointer\r
- offset = ((UINT)(rd_ptr.lVal & RMASK[s]));\r
-\r
- // Copy one IP Raw data packet to user-specific buffer\r
- ret = read_data(s, offset, buf, (u_int)size);\r
- rd_ptr.lVal = rd_ptr.lVal + (ret - 4);\r
- }\r
-\r
- // Update rx_rd_ptr\r
- WRITE_VALUE(RX_RD_PTR(s), rd_ptr.cVal[3]);\r
- WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(1), rd_ptr.cVal[2]);\r
- WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(2), rd_ptr.cVal[1]);\r
- WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(3), rd_ptr.cVal[0]);\r
-\r
- // RECV\r
- WRITE_VALUE(COMMAND(s), CRECV);\r
-\r
-// Real received size return\r
-return(ret);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Channel closing function.\r
-*\r
-* Description : Function for closing the connection of the designated channel.\r
-* Arguments : s - channel number\r
-* Returns : None\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-void close(SOCKET s)\r
-{\r
-u_int len;\r
-\r
-I_STATUS[s] = 0;\r
-\r
-if (select(s, SEL_CONTROL) == SOCK_CLOSED)\r
- return; // Already closed\r
-\r
-// When closing, if there's data which have not processed, Insert some source codes to handle this\r
-// Or before application call close(), handle those data first and call close() later.\r
-\r
-len = select(s, SEL_SEND);\r
-if (len == SSIZE[s])\r
- {\r
- // CLOSE\r
- WRITE_VALUE(COMMAND(s), CCLOSE);\r
- // TODO: The 'SCLOSED' status value is only set briefly as part of the close,\r
- // and will otherwise quickly return to normal. That means your code might\r
- // become 'stuck' at this point even if the packet has closed normally.\r
- // Rather than a while() call, it might be preferred to time out on this\r
- // close check and return to the application after some time.\r
- while(!(I_STATUS[s] & SCLOSED))\r
- I2CHIP_POLL_ISR(in4_isr_i2chip);\r
- }\r
-}\r
-\r
-u_char tx_empty(SOCKET s)\r
-{\r
- return (select(s, SEL_SEND) == SSIZE[s]);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Channel closing function.\r
-*\r
-* Description : Function for closing the connection of the designated channel.\r
-* Arguments : s - channel number\r
-* Returns : None\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-char reset_sock(SOCKET s)\r
-{\r
-u_char c;\r
-\r
-c = 1 << s;\r
-\r
-// RESET\r
-WRITE_VALUE(RESETSOCK, c);\r
-return (1);\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Function handling the channel socket information.\r
-*\r
-* Description : Return socket information of designated channel\r
-* Arguments : s - channel number\r
-* func - SEL_CONTROL(0x00) -> return socket status\r
-* SEL_SEND(0x01) -> return free transmit buffer size\r
-* SEL_RECV(0x02) -> return received data size\r
-* Returns : socket status or free transmit buffer size or received data size\r
-* Note : API Function\r
-****************************************************************************************************\r
-*/\r
-u_int select(SOCKET s, u_char func)\r
-{\r
-u_int val;\r
-union un_l2cval rd_ptr, wr_ptr, ack_ptr;\r
-u_char k;\r
-\r
-switch (func)\r
- {\r
- // socket status information\r
- case SEL_CONTROL :\r
- val = READ_VALUE(SOCK_STATUS(s));\r
- break;\r
-\r
- // Calculate send free buffer size\r
- case SEL_SEND :\r
- disable();\r
- k = READ_VALUE(SHADOW_TXWR_PTR(s));\r
- WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
- delay0(2);\r
- wr_ptr.cVal[3] = READ_VALUE(TX_WR_PTR(s));\r
- wr_ptr.cVal[2] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(1));\r
- wr_ptr.cVal[1] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(2));\r
- wr_ptr.cVal[0] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(3));\r
-\r
- if (( READ_VALUE(OPT_PROTOCOL(s)) & 0x07) == SOCK_STREAM) // TCP\r
- {\r
- k = READ_VALUE(SHADOW_TXACK_PTR(s));\r
- WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
- delay0(2);\r
- ack_ptr.cVal[3] = READ_VALUE(TX_ACK_PTR(s));\r
- ack_ptr.cVal[2] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(1));\r
- ack_ptr.cVal[1] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(2));\r
- ack_ptr.cVal[0] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(3));\r
- enable();\r
-\r
- if (wr_ptr.lVal >= ack_ptr.lVal)\r
- val = (u_int)(SSIZE[s] - (wr_ptr.lVal - ack_ptr.lVal));\r
- else\r
- val = (u_int)(SSIZE[s] - (0 - ack_ptr.lVal + wr_ptr.lVal));\r
- }\r
- else // UDP, IP RAW ... (except TCP)\r
- {\r
- k = READ_VALUE(SHADOW_TXRD_PTR(s));\r
- WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
- delay0(2);\r
- rd_ptr.cVal[3] = READ_VALUE(TX_RD_PTR(s));\r
- rd_ptr.cVal[2] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(1));\r
- rd_ptr.cVal[1] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(2));\r
- rd_ptr.cVal[0] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(3));\r
- enable();\r
-\r
- if (wr_ptr.lVal >= rd_ptr.lVal)\r
- val = (u_int)(SSIZE[s] - (wr_ptr.lVal - rd_ptr.lVal));\r
- else\r
- val = (u_int)(SSIZE[s] - (0 - rd_ptr.lVal + wr_ptr.lVal));\r
- }\r
- break;\r
-\r
- // Calculate received data size\r
- case SEL_RECV :\r
- disable();\r
- k = READ_VALUE(SHADOW_RXWR_PTR(s));\r
- WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
- delay0(2);\r
- wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));\r
- wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));\r
- wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));\r
- wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));\r
-\r
- k = READ_VALUE(SHADOW_RXRD_PTR(s));\r
- WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.\r
- delay0(2);\r
- rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));\r
- rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));\r
- rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));\r
- rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));\r
- enable();\r
-\r
- if (wr_ptr.lVal == rd_ptr.lVal)\r
- val = 0;\r
- else if (wr_ptr.lVal > rd_ptr.lVal)\r
- val = (u_int)(wr_ptr.lVal - rd_ptr.lVal);\r
- else\r
- val = (u_int)(0 - rd_ptr.lVal + wr_ptr.lVal);\r
- break;\r
-\r
- default :\r
- val = -1;\r
- break;\r
- }\r
-// Suppress compiler errors that k is not used\r
-k = k;\r
-return(val);\r
-}\r
-\r
-//\r
-// unsigned char dma_read_i2chip (unsigned int i2_segm, unsigned int i2_offs,\r
-// unsigned int cnt, unsigned int des_segm, unsigned int des_offs);\r
-// Using DMA0 to read data from i2chip buffer into destination SRAM.\r
-// where:\r
-// unsigned int cnt = number of sectors, 512-byte per sector\r
-// unsigned int des_segm = segment of destination SRAM data memory\r
-// unsigned int des_offs = offset of destination SRAM data memory\r
-// unsigned int i2_segm = segment of i2chip buffer mapped in memory\r
-// unsigned int i2_offs = offset of i2chip buffer mapped in memory\r
-// return DMA counter value\r
-//\r
-unsigned int dma_read_i2chip(u_char far* i2_src, u_char far* des, u_int cnt)\r
-{\r
- u_int des_segm, des_offs;\r
- u_int i2_segm, i2_offs;\r
- u_long temp;\r
-\r
- temp = ((long)FP_SEG(des) << 4) + ((long)FP_OFF(des));\r
- des_segm = (u_int)(temp >> 16);\r
- des_offs = (u_int)(temp & 0xffff);\r
-\r
- temp = ((long)FP_SEG(i2_src) << 4) + ((long)FP_OFF(i2_src));\r
- i2_segm = (u_int)(temp >> 16);\r
- i2_offs = (u_int)(temp & 0xffff);\r
-\r
- outport(0xffc6, des_segm); /* D0DSTH destination SRAM segment */\r
- outport(0xffc4, des_offs); /* D0DSTL destination SRAM offset */\r
- outport(0xffc2, i2_segm); /* D0SRCH=SP0RD */\r
- outport(0xffc0, i2_offs); /* D0SRCL=SP0RD */\r
- outport(0xffc8, cnt); // D0TC counter\r
- outport(0xfff8,0x0504); // PLLCON, 0203=10M,050f=40M, 051f=80MHz\r
-// DMA0 mem-mem, 16-bit, unsync, Start moving data line below\r
- outport(0xffca, 0xb60e); /* D0CON 1011 0110 0000 1111 */\r
-// outport(0xffca, 0xb42e); // 1011 0100 0010 1110\r
- while( inport(0xffc8) ); /* D0TC counter=0, DMA complete */\r
- outport(0xfff8,0x051f); // PLLCON, 0203=10M,050f=40M, 051f=80MHz\r
-return( inport(0xffc8) ); // counter\r
-}\r
-\r
-//\r
-// unsigned int dma_write_i2chip (unsigned int src_segm, unsigned int src_offs,\r
-// unsigned int cnt, unsigned int i2_segm, unsigned int i2_offs);\r
-// Using DMA0 to write data from memory into i2chip.\r
-// where:\r
-// unsigned int cnt = number of 16-bit DMA transfers\r
-// unsigned int src_segm = segment of the source SRAM data memory\r
-// unsigned int src_offs = offset of the source SRAM data memory\r
-// unsigned int i2_segm = segment of i2chip buffer mapped in memory\r
-// unsigned int i2_offs = offset of i2chip buffer mapped in memory\r
-// return DMA counter value\r
-//\r
-unsigned int dma_write_i2chip(u_char far* src, u_char far* i2_dest, u_int cnt)\r
-{\r
- u_int src_segm, src_offs;\r
- u_int i2_segm, i2_offs;\r
- u_long temp;\r
-\r
- temp = (FP_SEG(src) << 4) + (FP_OFF(src));\r
- src_segm = (u_int)(temp >> 4);\r
- src_offs = (u_int)(temp & 0xffff);\r
-\r
- temp = (FP_SEG(i2_dest) << 4) + (FP_OFF(i2_dest));\r
- i2_segm = (u_int)(temp >> 4);\r
- i2_offs = (u_int)(temp & 0xffff);\r
-\r
- outport(0xffc8, cnt); // D0TC counter\r
- outport(0xffc6, i2_segm); // D0DSTH=i2chip buffer segment\r
- outport(0xffc4, i2_offs); // D0DSTL=i2chip buffer offset\r
- outport(0xffc2, src_segm); /* D0SRCH=SP0RD */\r
- outport(0xffc0, src_offs); /* D0SRCL=SP0RD */\r
-// outport(0xfff8,0x050f); // PLLCON, 0203=10M,050f=40M, 051f=80MHz\r
-// DMA0 mem-mem, 16-bit, unsync, Start moving data line below\r
- outport(0xffca, 0xb60f); /* D0CON 1011 0110 0000 1111 */\r
- while( inport(0xffc8) ); /* D0TC counter=0, DMA complete */\r
-// outport(0xfff8,0x051f); // PLLCON, 0203=10M,050f=40M, 051f=80MHz\r
-\r
-return( inport(0xffc8) ); // counter\r
-}\r
-\r
-/*\r
-****************************************************************************************************\r
-* Copies the receive buffer data of the W3100A to the system buffer.\r
-*\r
-* Description : Copies the receive buffer data of the W3100A to the system buffer.\r
-* It is called from the recv()or recvfrom() function.\r
-* Arguments : s - channel number\r
-* src - receive buffer pointer of W3100A\r
-* dst - system buffer pointer\r
-* len - data size to copy\r
-* Returns : copied data size\r
-* Note : Internal Function\r
-****************************************************************************************************\r
-*/\r
-u_int read_data(SOCKET s, u_int offset, u_char far * dst, u_int len)\r
-{\r
- u_int i, size, size1;\r
- u_char far* src = (u_char far*)(MK_FP_WINDOW(RECV_DATA_BUF,\r
- RBUFBASEADDRESS[s] + offset));\r
-// src = (u_char far*)(MK_FP_WINDOW(RECV_DATA_BUF,\r
-// 0));\r
-\r
- if (len == 0)\r
- {\r
- WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.\r
- return 0;\r
- }\r
-\r
- if ((offset + len) > RSIZE[s])\r
- {\r
- size = (u_int)(RSIZE[s] - offset);\r
-\r
- if (size > TERN_RDMA_THRES)\r
- {\r
- dma_read_i2chip(src, dst, size);\r
- }\r
- else\r
- {\r
- for (i = 0; i < size; i++)\r
- {\r
- *dst++ = READ_VALUE(src);\r
- WINDOW_PTR_INC(src);\r
-\r
- }\r
- }\r
-\r
- size1 = len - size;\r
- src = (u_char far *)(MK_FP_WINDOW(RECV_DATA_BUF, (RBUFBASEADDRESS[s])));\r
-\r
- if (size1 > TERN_RDMA_THRES)\r
- {\r
- dma_read_i2chip(src, dst, size);\r
- }\r
- else\r
- {\r
- for (i = 0; i < size1; i++)\r
- {\r
- *dst++ = READ_VALUE(src);\r
- WINDOW_PTR_INC(src);\r
- }\r
- }\r
- }\r
- else\r
- {\r
- if (len > TERN_RDMA_THRES)\r
- {\r
- dma_read_i2chip(src, dst, size);\r
- }\r
- else\r
- {\r
- for (i = 0; i < len; i++)\r
- {\r
- *dst++ = READ_VALUE(src);\r
- WINDOW_PTR_INC(src);\r
- }\r
- }\r
- }\r
- WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.\r
- return len;\r
-}\r
-\r
-\r
-/*\r
-****************************************************************************************************\r
-* Copies the system buffer data to the transmit buffer of the W3100A.\r
-*\r
-* Description : Copies the system buffer data to the transmit buffer of the W3100A.\r
-* It is called from the send_in()or sendto_in() function.\r
-* Arguments : s - channel number\r
-* src - system buffer pointer\r
-* dst - send buffer pointer of W3100A\r
-* len - data size to copy\r
-* Returns : copied data size\r
-* Note : Internal Function\r
-****************************************************************************************************\r
-*/\r
-u_int write_data(SOCKET s, u_char far * src, u_int offset, u_int len)\r
-{\r
- u_int i, size, size1;\r
- u_char far* dst = (u_char far*)MK_FP_WINDOW(SEND_DATA_BUF,\r
- SBUFBASEADDRESS[s] + offset);\r
-\r
- if (len == 0)\r
- {\r
- WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.\r
- return 0;\r
- }\r
-\r
- if ((offset + len) > SSIZE[s])\r
- {\r
- size = (u_int)(SSIZE[s] - offset);\r
-\r
- for (i = 0; i < size; i++)\r
- {\r
- WRITE_VALUE(dst, *src++);\r
- WINDOW_PTR_INC(dst);\r
- }\r
-\r
- size1 = len - size;\r
- dst = (u_char far *)(MK_FP_WINDOW(SEND_DATA_BUF, (SBUFBASEADDRESS[s])));\r
-\r
- for (i = 0; i < size1; i++)\r
- {\r
- WRITE_VALUE(dst, *src++);\r
- WINDOW_PTR_INC(dst);\r
- }\r
- }\r
- else\r
- {\r
- for (i = 0; i < len; i++)\r
- {\r
- WRITE_VALUE(dst, *src++);\r
- WINDOW_PTR_INC(dst);\r
- }\r
- }\r
- WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.\r
- return len;\r
-}\r
-\r
-\r
-\r
projects / freertos / commitdiff