2 ********************************************************************************
\r
4 * (c) Copyright 2005, http://www.tern.com
\r
6 * MODIFIED BY RICHARD BARRY TO ADD SEMAPHORE FOR COMMUNICATION BETWEEN THE
\r
7 * WIZnet ISR AND THE HTTP TASK.
\r
9 * - Derived based on development version provided by Wiznet.
\r
11 * Filename : socket.h
\r
13 * Created : 2002/06/20
\r
15 * 2002/09/27 : - Renaming
\r
16 * INT_STATUS --> INT_REG
\r
17 * STATUS(i) --> INT_STATUS(i)
\r
18 * C_STATUS(i) --> SOCK_STATUS(i)
\r
19 * 2003/11/06 : Ported for use with TERN controller. Note all byte access is at even addresses
\r
20 * 2005/10/8 : Modified constants for easier initialization.
\r
22 * Description : Header file of W3100A for TERN embedded controller
\r
23 ********************************************************************************
\r
26 ###############################################################################
\r
27 File Include Section
\r
28 ###############################################################################
\r
30 #include "i2chip_hw.h"
\r
36 #include <FreeRTOS.h>
\r
38 #include <portasm.h>
\r
42 ###############################################################################
\r
43 Local Variable Declaration Section
\r
44 ###############################################################################
\r
46 u_char I_STATUS[4]; // Store Interrupt Status according to channels
\r
47 u_int Local_Port; // Designate Local Port
\r
48 union un_l2cval SEQ_NUM; // Set initial sequence number
\r
50 u_long SMASK[MAX_SOCK_NUM]; // Variable to store MASK of Tx in each channel,
\r
51 // on setting dynamic memory size.
\r
52 u_long RMASK[MAX_SOCK_NUM]; // Variable to store MASK of Rx in each channel,
\r
53 // on setting dynamic memory size.
\r
54 int SSIZE[MAX_SOCK_NUM]; // Maximun Tx memory size by each channel
\r
55 int RSIZE[MAX_SOCK_NUM]; // Maximun Rx memory size by each channel
\r
57 u_int SBUFBASEADDRESS[MAX_SOCK_NUM]; // Maximun Tx memory base address by each channel
\r
58 u_int RBUFBASEADDRESS[MAX_SOCK_NUM]; // Maximun Rx memory base address by each channel
\r
61 ###############################################################################
\r
62 Function Implementation Section
\r
63 ###############################################################################
\r
67 ********************************************************************************
\r
68 * Interrupt handling function of the W3100A
\r
71 * Stores the status information that each function waits for in the global variable I_STATUS
\r
72 * for transfer. I_STATUS stores the interrupt status value for each channel.
\r
75 * Note : Internal Function
\r
76 ********************************************************************************
\r
79 portBASE_TYPE prvProcessISR( void )
\r
81 unsigned char status;
\r
82 extern xSemaphoreHandle xTCPSemaphore;
\r
83 portBASE_TYPE xSwitchRequired = pdFALSE;
\r
85 #ifdef I2CHIP_WINDOW
\r
86 u_int current_window = i2chip_get_window();
\r
89 status = READ_VALUE(INT_REG);
\r
94 xSwitchRequired = pdTRUE;
\r
95 // channel 0 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)
\r
98 I_STATUS[0] = READ_VALUE(INT_STATUS(0));
\r
100 // if (I_STATUS[0] & SESTABLISHED)
\r
101 // ISR_ESTABLISHED(0);
\r
102 // if (I_STATUS[0] & SCLOSED)
\r
105 WRITE_VALUE(INT_REG, 0x01);
\r
108 // channel 1 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)
\r
111 I_STATUS[1] = READ_VALUE(INT_STATUS(1));
\r
113 // if (I_STATUS[1] & SESTABLISHED)
\r
114 // ISR_ESTABLISHED(1);
\r
115 // if (I_STATUS[1] & SCLOSED)
\r
118 WRITE_VALUE(INT_REG, 0x02);
\r
121 // channel 2 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)
\r
124 I_STATUS[2] = READ_VALUE(INT_STATUS(2));
\r
126 // if (I_STATUS[2] & SESTABLISHED)
\r
127 // ISR_ESTABLISHED(2);
\r
128 // if (I_STATUS[2] & SCLOSED)
\r
131 WRITE_VALUE(INT_REG, 0x04);
\r
134 // channel 3 interrupt(sysinit, sockinit, established, closed, timeout, send_ok, recv_ok)
\r
137 I_STATUS[3] = READ_VALUE(INT_STATUS(3));
\r
139 // if (I_STATUS[3] & SESTABLISHED) ISR_ESTABLISHED(3);
\r
140 // if (I_STATUS[3] & SCLOSED) ISR_CLOSED(3);
\r
142 WRITE_VALUE(INT_REG, 0x08);
\r
145 // channel 0 receive interrupt
\r
149 WRITE_VALUE(INT_REG, 0x10);
\r
152 // channel 1 receive interrupt
\r
156 WRITE_VALUE(INT_REG, 0x20);
\r
159 // channel 2 receive interrupt
\r
163 WRITE_VALUE(INT_REG, 0x40);
\r
166 // channel 3 receive interrupt
\r
170 WRITE_VALUE(INT_REG, 0x80);
\r
172 status = READ_VALUE(INT_REG);
\r
175 WRITE_VALUE(INT_REG, 0xFF);
\r
177 #ifdef I2CHIP_WINDOW
\r
178 i2chip_set_window(current_window);
\r
181 if( xSwitchRequired == pdTRUE )
\r
183 xSwitchRequired = xSemaphoreGiveFromISR( xTCPSemaphore, pdFALSE );
\r
186 return xSwitchRequired;
\r
189 void far interrupt in4_isr_i2chip(void)
\r
191 if( prvProcessISR() == pdTRUE )
\r
193 portEND_SWITCHING_ISR();
\r
200 ****************************************************************************************************
\r
201 * Established connection interrupt handling function.
\r
204 * Called upon connection establishment, and may be inserted in user code if needed by
\r
208 * Note : Internal Function
\r
209 ****************************************************************************************************
\r
212 void ISR_ESTABLISHED(SOCKET s)
\r
214 // TO ADD YOUR CODE
\r
219 ****************************************************************************************************
\r
220 * Closed connection interrupt handling function
\r
223 * Called upon connection closure, and may be inserted in user code if needed by the programmer.
\r
226 * Note : Internal Function
\r
227 ****************************************************************************************************
\r
230 void ISR_CLOSED(SOCKET s)
\r
232 // TO ADD YOUR CODE
\r
237 ****************************************************************************************************
\r
238 * Received data interrupt handling function
\r
241 * Called upon receiving data, and may be inserted in user code if needed by the programmer.
\r
244 * Note : Internal Function
\r
245 ****************************************************************************************************
\r
248 void ISR_RX(SOCKET s)
\r
250 // TO ADD YOUR CODE
\r
255 ****************************************************************************************************
\r
256 * W3100A Initialization Function
\r
258 * Description: Reset of W3100A S/W and Registeration of i386 interrupt
\r
259 * Arguments : None.
\r
262 ****************************************************************************************************
\r
264 void initW3100A(void)
\r
267 // Install interrupt handler for i2Chip
\r
268 INT_INIT(in4_isr_i2chip);
\r
271 Local_Port = 1000; // This default value will be set if you didn't designate it when you
\r
272 // create a socket. If you don't designate port number and create a
\r
273 // socket continuously, the port number will be assigned with
\r
274 // incremented by one to Local_Port
\r
275 SEQ_NUM.lVal = 4294967293ul; // Sets the initial SEQ# to be used for TCP communication.
\r
276 // (It should be ramdom value)
\r
277 WRITE_VALUE(COMMAND(0), CSW_RESET); // Software RESET
\r
281 ****************************************************************************************************
\r
282 * W3100A initialization function
\r
285 * Sets the Tx, Rx memory size by each channel, source MAC, source IP, gateway, and subnet mask
\r
286 * to be used by the W3100A to the designated values.
\r
287 * May be called when reflecting modified network information or Tx, Rx memory size on the W3100A
\r
288 * Include Ping Request for ARP update (In case that a device embedding W3100A is directly
\r
289 * connected to Router)
\r
290 * Arguments : sbufsize - Tx memory size (00 - 1KByte, 01- 2KBtye, 10 - 4KByte, 11 - 8KByte)
\r
291 * bit 1-0 : Tx memory size of channel #0
\r
292 * bit 3-2 : Tx memory size of channel #1
\r
293 * bit 5-4 : Tx memory size of channel #2
\r
294 * bit 7-6 : Tx memory size of channel #3
\r
295 * rbufsize - Rx memory size (00 - 1KByte, 01- 2KBtye, 10 - 4KByte, 11 - 8KByte)
\r
296 * bit 1-0 : Rx memory size of channel #0
\r
297 * bit 3-2 : Rx memory size of channel #1
\r
298 * bit 5-4 : Rx memory size of channel #2
\r
299 * bit 7-6 : Rx memory size of channel #3
\r
301 * Note : API Function
\r
302 * Maximum memory size for Tx, Rx in W3100A is 8KBytes,
\r
303 * In the range of 8KBytes, the memory size could be allocated dynamically by
\r
305 * Be attentive to sum of memory size shouldn't exceed 8Kbytes
\r
306 * and to data transmission and receiption from non-allocated channel may cause
\r
308 * If 8KBytes memory already is assigned to centain channel, other 3 channels
\r
309 * couldn't be used, for there's no available memory.
\r
310 * If two 4KBytes memory are assigned to two each channels, other 2 channels couldn't
\r
311 * be used, for there's no available memory.
\r
312 * (Example of memory assignment)
\r
313 * sbufsize => 00000011, rbufsize => 00000011 :
\r
314 * Assign 8KBytes for Tx and Rx to channel #0, Cannot use channel #1,#2,#3
\r
315 * sbufsize => 00001010, rbufsize => 00001010 :
\r
316 * Assign 4KBytes for Tx and Rx to each channel #0,#1 respectively. Cannot use
\r
318 * sbufsize => 01010101, rbufsize => 01010101 :
\r
319 * Assign 2KBytes for Tx and Rx to each all channels respectively.
\r
320 * sbufsize => 00010110, rbufsize => 01010101 :
\r
321 * Assign 4KBytes for Tx, 2KBytes for Rx to channel #0
\r
322 * s 2KBytes for Tx, 2KBytes for Rx to channel #1
\r
323 * 2KBytes for Tx, 2KBytes for Rx to channel #2
\r
324 * 2KBytes is available exclusively for Rx in channel #3. There's no memory for Tx.
\r
325 ****************************************************************************************************
\r
327 void sysinit(u_char sbufsize, u_char rbufsize)
\r
335 // Set Tx memory size for each channel
\r
336 WRITE_VALUE(TX_DMEM_SIZE, sbufsize);
\r
338 // Set Rx memory size for each channel
\r
339 WRITE_VALUE(RX_DMEM_SIZE, rbufsize);
\r
341 // Set Base Address of Tx memory for channel #0
\r
342 SBUFBASEADDRESS[0] = 0;
\r
344 // Set Base Address of Rx memory for channel #0
\r
345 RBUFBASEADDRESS[0] = 0;
\r
347 // Set maximum memory size for Tx and Rx, mask, base address of memory by each channel
\r
348 for(i = 0 ; i < MAX_SOCK_NUM; i++)
\r
354 switch((sbufsize >> i*2) & 0x03) // Set maximum Tx memory size
\r
358 SMASK[i] = 0x000003FF;
\r
363 SMASK[i] = 0x000007FF;
\r
368 SMASK[i] = 0x00000FFF;
\r
373 SMASK[i] = 0x00001FFF;
\r
379 switch((rbufsize >> i*2) & 0x03) // Set maximum Rx memory size
\r
383 RMASK[i] = 0x000003FF;
\r
388 RMASK[i] = 0x000007FF;
\r
393 RMASK[i] = 0x00000FFF;
\r
398 RMASK[i] = 0x00001FFF;
\r
405 // Set base address of Tx and Rx memory for channel #1,#2,#3
\r
408 SBUFBASEADDRESS[i] = ssum - SSIZE[i];
\r
409 RBUFBASEADDRESS[i] = rsum - RSIZE[i];
\r
413 WRITE_VALUE(COMMAND(0), CSYS_INIT);
\r
415 while(!(I_STATUS[0] & SSYS_INIT_OK))
\r
416 I2CHIP_POLL_ISR(in4_isr_i2chip);
\r
420 u_char xdata pingbuf[8];
\r
421 setIPprotocol(0, IPPROTO_ICMP);
\r
422 socket(0, SOCK_IPL_RAW, 3000,0); // Create a socket for ARP update
\r
424 pingbuf[0] = 8; // ICMP TYPE
\r
425 pingbuf[1] = 0; // ICMP CODE
\r
426 pingbuf[2] = 0xf7; // CHECKSUM (already calculated)
\r
428 pingbuf[4] = 0; // ID
\r
430 pingbuf[6] = 0; // SEQ #
\r
432 pingbuf[8] = 0; // Data 1 Byte
\r
434 sendto(0, pingbuf, 9, GATEWAY_PTR,3000); // Ping Request
\r
436 printf("Route MAC Update Success");
\r
442 ****************************************************************************************************
\r
443 * Function to set subnet mask
\r
446 * Arguments : addr--> Pointer that has the value to be set
\r
449 ****************************************************************************************************
\r
451 void setsubmask(u_char * addr)
\r
454 u_char far* sm_ptr = SUBNET_MASK_PTR; // We can only convert to 'regular'
\r
455 // pointer if we're confident arithmetic
\r
456 // won't take us out of current window.
\r
458 for (i = 0; i < 4; i++)
\r
460 WRITE_VALUE(sm_ptr + SA_OFFSET(i), addr[i]);
\r
465 ****************************************************************************************************
\r
466 * Function to set gateway IP
\r
469 * Arguments : addr--> Pointer that has Gateway IP to be set
\r
472 ****************************************************************************************************
\r
474 void setgateway(u_char * addr)
\r
477 u_char far* gw_ptr = GATEWAY_PTR; // We can only convert to 'regular'
\r
478 // pointer if we're confident arithmetic
\r
479 // won't take us out of current window.
\r
480 for (i = 0; i < 4; i++)
\r
482 WRITE_VALUE(gw_ptr + SA_OFFSET(i), addr[i]);
\r
487 ****************************************************************************************************
\r
488 * Function to set W3100A IP
\r
491 * Arguments : addr--> Pointer that has Source IP to be set
\r
494 ****************************************************************************************************
\r
496 void setIP(u_char * addr)
\r
499 u_char far* src_ptr = SRC_IP_PTR; // We can only convert to 'regular'
\r
500 // pointer if we're confident arithmetic
\r
501 // won't take us out of current window.
\r
503 for (i = 0; i < 4; i++)
\r
505 WRITE_VALUE(src_ptr + SA_OFFSET(i), addr[i]);
\r
510 void getIP(u_char* addr)
\r
513 u_char far* src_ptr = SRC_IP_PTR; // We can only convert to 'regular'
\r
514 // pointer if we're confident arithmetic
\r
515 // won't take us out of current window.
\r
517 for (i = 0; i < 4; i++)
\r
518 addr[i] = READ_VALUE(src_ptr + SA_OFFSET(i));
\r
523 ****************************************************************************************************
\r
524 * Function to set MAC
\r
527 * Arguments : addr--> Pointer that has MAC to be set
\r
530 ****************************************************************************************************
\r
532 void setMACAddr(u_char * addr)
\r
535 u_char far* ha_ptr = SRC_HA_PTR; // We can only convert to 'regular'
\r
536 // pointer if we're confident arithmetic
\r
537 // won't take us out of current window.
\r
539 for (i = 0; i < 6; i++)
\r
541 WRITE_VALUE(ha_ptr + SA_OFFSET(i), addr[i]);
\r
546 ****************************************************************************************************
\r
547 * Function to set TCP timeout
\r
549 * Description: The function that used to adjust time to resend TCP
\r
550 * Arguments : val --> Pointer that has the value to be set
\r
551 * Upper 2 byte:Initial timeout value
\r
552 * Last 1 byte:The count to retry till timeout
\r
555 ****************************************************************************************************
\r
557 void settimeout(u_char * val)
\r
560 u_char far* tout_ptr = TIMEOUT_PTR; // We can only convert to 'regular'
\r
561 // pointer if we're confident arithmetic
\r
562 // won't take us out of current window.
\r
564 for (i = 0; i < 3; i++)
\r
566 WRITE_VALUE(tout_ptr + SA_OFFSET(i), val[i]);
\r
571 ****************************************************************************************************
\r
572 * Function to set interrupt mask.
\r
575 * Arguments : mask--> Mask value to be set ('1'-> interrupt )
\r
578 ****************************************************************************************************
\r
580 void setINTMask(u_char mask)
\r
582 WRITE_VALUE(INTMASK, mask);
\r
586 ****************************************************************************************************
\r
587 * Function to set enable in sending and receiving of broadcast data
\r
589 * Description: Enable to process of broadcating data in UDP or IP RAW mode.
\r
590 * Arguments : s --> Channel No. to be set
\r
593 ****************************************************************************************************
\r
595 void setbroadcast(SOCKET s)
\r
597 u_char val = READ_VALUE(OPT_PROTOCOL(s));
\r
598 WRITE_VALUE(OPT_PROTOCOL(s), val | SOCKOPT_BROADCAST);
\r
602 ****************************************************************************************************
\r
603 * Function to set process protocol in IP RAW mode.
\r
606 * Arguments : s--> Channel No. to be set
\r
607 * tos-->Protocol Value to be set
\r
610 ****************************************************************************************************
\r
612 void setTOS(SOCKET s, u_char tos)
\r
614 WRITE_VALUE(TOS(s), tos);
\r
618 ****************************************************************************************************
\r
619 * Upper layer protocol setup function in IP RAW Mode
\r
621 * Description : Upper layer protocol setup function in protocol field of IP header when
\r
622 * developing upper layer protocol like ICMP, IGMP, EGP etc. by using IP Protocol
\r
623 * Arguments : s - Channel number
\r
624 * ipprotocol - Upper layer protocol setting value of IP Protocol
\r
625 * (Possible to use designated IPPROTO_ in header file)
\r
627 * Note : API Function
\r
628 * This function should be called before calling socket() that is, before
\r
629 * socket initialization.
\r
630 ****************************************************************************************************
\r
632 void setIPprotocol(SOCKET s, u_char ipprotocol)
\r
634 WRITE_VALUE(IP_PROTOCOL(s), ipprotocol);
\r
638 ****************************************************************************************************
\r
639 * Initialization function to appropriate channel
\r
641 * Description : Initialize designated channel and wait until W3100 has done.
\r
642 * Arguments : s - channel number
\r
643 * protocol - designate protocol for channel
\r
644 * SOCK_STREAM(0x01) -> TCP.
\r
645 * SOCK_DGRAM(0x02) -> UDP.
\r
646 * SOCK_IPL_RAW(0x03) -> IP LAYER RAW.
\r
647 * SOCK_MACL_RAW(0x04) -> MAC LAYER RAW.
\r
648 * port - designate source port for appropriate channel
\r
649 * flag - designate option to be used in appropriate.
\r
650 * SOCKOPT_BROADCAST(0x80) -> Send/receive broadcast message in UDP
\r
651 * SOCKOPT_NDTIMEOUT(0x40) -> Use register value which designated TIMEOUT
\r
653 * SOCKOPT_NDACK(0x20) -> When not using no delayed ack
\r
654 * SOCKOPT_SWS(0x10) -> When not using silly window syndrome
\r
655 * Returns : When succeeded : Channel number, failed :-1
\r
656 * Note : API Function
\r
657 ****************************************************************************************************
\r
659 char socket(SOCKET s, u_char protocol, u_int port, u_char flag)
\r
663 //Designate socket protocol and option
\r
664 WRITE_VALUE(OPT_PROTOCOL(s), protocol | flag);
\r
666 // setup designated port number
\r
669 k = (u_char)((port & 0xff00) >> 8);
\r
670 WRITE_VALUE(SRC_PORT_PTR(s), k);
\r
671 k = (u_char)(port & 0x00ff);
\r
672 WRITE_VALUE(SRC_PORT_PTR(s) + SA_OFFSET(1), k);
\r
676 // Designate random port number which is managed by local when you didn't designate source port
\r
679 WRITE_VALUE(SRC_PORT_PTR(s), (u_char)((Local_Port & 0xff00) >> 8));
\r
680 WRITE_VALUE(SRC_PORT_PTR(s) + SA_OFFSET(1), (u_char)(Local_Port & 0x00ff));
\r
685 WRITE_VALUE(COMMAND(s), CSOCK_INIT);
\r
687 // Waiting Interrupt to CSOCK_INIT
\r
688 while (I_STATUS[s] == 0)
\r
689 I2CHIP_POLL_ISR(in4_isr_i2chip);
\r
691 if (!(I_STATUS[s] & SSOCK_INIT_OK))
\r
694 initseqnum(s); // Use initial seq# with random number
\r
700 ****************************************************************************************************
\r
701 * Connection establishing function to designated peer.
\r
703 * Description : This function establish a connection to the peer by designated channel,
\r
704 * and wait until the connection is established successfully. (TCP client mode)
\r
705 * Arguments : s - channel number
\r
706 * addr - destination IP Address
\r
707 * port - destination Port Number
\r
708 * Returns : when succeeded : 1, failed : -1
\r
709 * Note : API Function
\r
710 ****************************************************************************************************
\r
712 char connect(SOCKET s, u_char far * addr, u_int port)
\r
716 { //designate destination port
\r
717 WRITE_VALUE(DST_PORT_PTR(s), (u_char)((port & 0xff00) >> 8));
\r
718 WRITE_VALUE(DST_PORT_PTR(s) + SA_OFFSET(1), (u_char)(port & 0x00ff));
\r
723 WRITE_VALUE(DST_IP_PTR(s), addr[0]); //designate destination IP address
\r
724 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(1), addr[1]);
\r
725 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(2), addr[2]);
\r
726 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(3), addr[3]);
\r
730 WRITE_VALUE(COMMAND(s), CCONNECT); // CONNECT
\r
731 I2CHIP_POLL_ISR(in4_isr_i2chip);
\r
733 // Wait until connection is established successfully
\r
734 while (I_STATUS[s] == 0)
\r
736 // When failed, appropriate channel will be closed and return an error
\r
737 if (select(s, SEL_CONTROL) == SOCK_CLOSED)
\r
741 if (!(I_STATUS[s] & SESTABLISHED))
\r
748 ****************************************************************************************************
\r
749 * Connection establishing function to designated peer. (Non-blocking Mode)
\r
751 * Description : This function establish a connection to the peer by designated channel.
\r
753 * Arguments : s - channel number
\r
754 * addr - destination IP Address
\r
755 * port - destination Port Number
\r
756 * Returns : when succeeded : 1, failed : -1
\r
757 * Note : API Function
\r
758 ****************************************************************************************************
\r
760 char NBconnect(SOCKET s, u_char far * addr, u_int port)
\r
764 { //designate destination port
\r
765 WRITE_VALUE(DST_PORT_PTR(s), (u_char) ((port & 0xff00) >> 8) );
\r
766 WRITE_VALUE(DST_PORT_PTR(s) + SA_OFFSET(1), (u_char)(port & 0x00ff));
\r
771 WRITE_VALUE(DST_IP_PTR(s), addr[0]); //designate destination IP address
\r
772 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(1), addr[1]);
\r
773 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(2), addr[2]);
\r
774 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(3), addr[3]);
\r
778 WRITE_VALUE(COMMAND(s), CCONNECT); // CONNECT
\r
783 ****************************************************************************************************
\r
784 * Waits for connection request from a peer (Blocking Mode)
\r
786 * Description : Wait for connection request from a peer through designated channel (TCP Server mode)
\r
787 * Arguments : s - channel number
\r
788 * addr - IP Address of the peer when a connection is established
\r
789 * port - Port number of the peer when a connection is established
\r
790 * Returns : When succeeded : 1, failed : -1
\r
791 * Note : API Function
\r
792 ****************************************************************************************************
\r
795 char listen(SOCKET s, u_char far * addr, u_int far * port)
\r
802 COMMAND(s) = CLISTEN;
\r
804 // Wait until connection is established
\r
805 while (I_STATUS[s] == 0)
\r
807 // When failed to connect, the designated channel will be closed and return an error.
\r
808 if (select(s, SEL_CONTROL) == SOCK_CLOSED)
\r
812 // Receive IP address and port number of the peer connected
\r
813 if (I_STATUS[s] & SESTABLISHED)
\r
815 i = *DST_PORT_PTR(s);
\r
816 *port = (u_int)((i & 0xff00) >> 8);
\r
817 i = *(DST_PORT_PTR(s) + 2);
\r
818 i = (u_int)(i & 0x00ff);
\r
821 addr[0] = *DST_IP_PTR(s);
\r
822 addr[1] = *(DST_IP_PTR(s) + 2);
\r
823 addr[2] = *(DST_IP_PTR(s) + 4);
\r
824 addr[3] = *(DST_IP_PTR(s) + 6);
\r
834 ****************************************************************************************************
\r
835 * Waits for connection request from a peer (Non-blocking Mode)
\r
837 * Description : Wait for connection request from a peer through designated channel (TCP Server mode)
\r
838 * Arguments : s - channel number
\r
840 * Note : API Function
\r
841 ****************************************************************************************************
\r
843 char NBlisten(SOCKET s)
\r
848 WRITE_VALUE(COMMAND(s), CLISTEN);
\r
854 ****************************************************************************************************
\r
855 * Create random value for initial Seq# when establishing TCP connection
\r
857 * Description : In this function, you can add some source codes to create random number for
\r
858 * initial Seq#. In real, TCP initial SEQ# should be random value.
\r
859 * (Currently, we're using static value in EVB/DK.)
\r
860 * Arguments : s - channel number
\r
862 * Note : API Function
\r
863 ****************************************************************************************************
\r
865 void initseqnum(SOCKET s)
\r
867 // Designate initial seq#
\r
868 // If you have random number generation function, assign random number instead of SEQ_NUM.lVal++.
\r
872 //SEQ_NUM.lVal = rand();
\r
874 WRITE_VALUE(TX_WR_PTR(s), SEQ_NUM.cVal[0]);
\r
875 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(1), SEQ_NUM.cVal[1]);
\r
876 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(2), SEQ_NUM.cVal[2]);
\r
877 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(3), SEQ_NUM.cVal[3]);
\r
880 WRITE_VALUE(TX_RD_PTR(s), SEQ_NUM.cVal[0]);
\r
881 WRITE_VALUE(TX_RD_PTR(s) + SA_OFFSET(1), SEQ_NUM.cVal[1]);
\r
882 WRITE_VALUE(TX_RD_PTR(s) + SA_OFFSET(2), SEQ_NUM.cVal[2]);
\r
883 WRITE_VALUE(TX_RD_PTR(s) + SA_OFFSET(3), SEQ_NUM.cVal[3]);
\r
886 WRITE_VALUE(TX_ACK_PTR(s), SEQ_NUM.cVal[0]);
\r
887 WRITE_VALUE(TX_ACK_PTR(s) + SA_OFFSET(1), SEQ_NUM.cVal[1]);
\r
888 WRITE_VALUE(TX_ACK_PTR(s) + SA_OFFSET(2), SEQ_NUM.cVal[2]);
\r
889 WRITE_VALUE(TX_ACK_PTR(s) + SA_OFFSET(3), SEQ_NUM.cVal[3]);
\r
894 ****************************************************************************************************
\r
895 * Function for sending TCP data.
\r
897 * Description : Function for sending TCP data and Composed of the send() and send_in() functions.
\r
898 * The send() function is an application I/F function.
\r
899 * It continues to call the send_in() function to complete the sending of the data up to the
\r
900 * size of the data to be sent when the application is called.
\r
901 * The send_in() function receives the return value (the size of the data sent), calculates
\r
902 * the size of the data to be sent, and calls the send_in() function again if there is any
\r
903 * data left to be sent.
\r
904 * Arguments : s - channel number
\r
905 * buf - Pointer pointing data to send
\r
906 * len - data size to send
\r
907 * Returns : Succeed: sent data size, Failed: -1;
\r
908 * Note : API Function
\r
909 ****************************************************************************************************
\r
911 int send(SOCKET s, u_char far * buf, u_int len)
\r
914 u_char huge* huge_buf = (u_char huge*)buf;
\r
915 u_char far* local_buf = (u_char far*)huge_buf;
\r
924 size = send_in(s, local_buf + ptr, len);
\r
929 } while ( len > 0);
\r
935 ****************************************************************************************************
\r
936 * Internal function for sending TCP data.
\r
938 * Description : Called by the send() function for TCP transmission.
\r
939 * It first calculates the free transmit buffer size
\r
940 * and compares it with the size of the data to be transmitted to determine the transmission size.
\r
941 * After calculating the data size, it copies data from TX_WR_PTR.
\r
942 * It waits if there is a previous send command in process.
\r
943 * When the send command is cleared, it updates the TX_WR_PTR up to the size to be transmitted
\r
944 and performs the send command.
\r
945 * Arguments : s - channel number
\r
946 * buf - Pointer pointing data to send
\r
947 * len - data size to send
\r
948 * Returns : Succeeded: sent data size, Failed: -1
\r
949 * Note : Internal Function
\r
950 ****************************************************************************************************
\r
952 int send_in(SOCKET s, u_char far * buf, u_int len)
\r
956 union un_l2cval wr_ptr, ack_ptr;
\r
957 unsigned int offset;
\r
960 disable(); // CT: Shadow register access should not conflict with ISR.
\r
961 k = READ_VALUE(SHADOW_TXWR_PTR(s));
\r
962 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
964 wr_ptr.cVal[3] = READ_VALUE(TX_WR_PTR(s));
\r
965 wr_ptr.cVal[2] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(1));
\r
966 wr_ptr.cVal[1] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(2));
\r
967 wr_ptr.cVal[0] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(3));
\r
969 k = READ_VALUE(SHADOW_TXACK_PTR(s));
\r
970 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
972 ack_ptr.cVal[3] = READ_VALUE(TX_ACK_PTR(s));
\r
973 ack_ptr.cVal[2] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(1));
\r
974 ack_ptr.cVal[1] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(2));
\r
975 ack_ptr.cVal[0] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(3));
\r
978 // Suppress compiler errors that k is not used
\r
981 // Calculate send free buffer size
\r
982 if (wr_ptr.lVal >= ack_ptr.lVal)
\r
983 size = (u_int)(SSIZE[s] - (wr_ptr.lVal - ack_ptr.lVal));
\r
985 size = (u_int)(SSIZE[s] - (0 - ack_ptr.lVal + wr_ptr.lVal));
\r
987 // Recalulate after some delay because of error in pointer calculation
\r
988 if (size > SSIZE[s])
\r
990 if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED)
\r
996 // Wait when previous sending has not finished yet and there's no free buffer
\r
999 if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED)
\r
1005 else if (size < len)
\r
1010 // Calculate pointer to data copy
\r
1011 offset = (UINT)(wr_ptr.lVal & SMASK[s]);
\r
1014 write_data(s, buf, offset, len);
\r
1016 while (READ_VALUE(COMMAND(s)) & CSEND)
\r
1018 // Confirm previous send command
\r
1019 if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED)
\r
1023 // update tx_wr_ptr
\r
1024 wr_ptr.lVal = wr_ptr.lVal + len;
\r
1025 WRITE_VALUE(TX_WR_PTR(s), wr_ptr.cVal[3]);
\r
1026 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(1), wr_ptr.cVal[2]);
\r
1027 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(2), wr_ptr.cVal[1]);
\r
1028 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(3), wr_ptr.cVal[0]);
\r
1033 WRITE_VALUE(COMMAND(s), CSEND);
\r
1039 ****************************************************************************************************
\r
1040 * TCP data receiving function.
\r
1042 * Description : This function is to clear out any received TCP data.
\r
1043 * Arguments : s - channel number
\r
1045 * Note : API Fcuntion
\r
1046 ****************************************************************************************************
\r
1048 void recv_clear(SOCKET s)
\r
1052 union un_l2cval wr_ptr, rd_ptr;
\r
1055 k = READ_VALUE(SHADOW_RXWR_PTR(s));
\r
1056 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1058 wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));
\r
1059 wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));
\r
1060 wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));
\r
1061 wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));
\r
1063 k = READ_VALUE(SHADOW_RXRD_PTR(s));
\r
1064 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1066 rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));
\r
1067 rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));
\r
1068 rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));
\r
1069 rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));
\r
1072 // Suppress compiler errors that k is not used
\r
1075 // calculate received data size
\r
1076 if (wr_ptr.lVal >= rd_ptr.lVal)
\r
1077 size = (u_int)(wr_ptr.lVal - rd_ptr.lVal);
\r
1079 size = (u_int)(0 - rd_ptr.lVal + wr_ptr.lVal);
\r
1081 // Update rx_rd_ptr
\r
1082 rd_ptr.lVal += size;
\r
1083 WRITE_VALUE(RX_RD_PTR(s), rd_ptr.cVal[3]);
\r
1084 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(1), rd_ptr.cVal[2]);
\r
1085 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(2), rd_ptr.cVal[1]);
\r
1086 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(3), rd_ptr.cVal[0]);
\r
1089 WRITE_VALUE(COMMAND(s), CRECV);
\r
1093 ****************************************************************************************************
\r
1094 * TCP data receiving function.
\r
1096 * Description : This function is for receiving TCP data.
\r
1097 * The recv() function is an application I/F function. It will read up to len chars if there are
\r
1098 enough characters in the buffer, otherwise will onl read the number of characters availiable
\r
1099 * Arguments : s - channel number
\r
1100 * buf - Pointer where the data to be received is copied
\r
1101 * len - Size of the data to be received
\r
1102 * Returns : Succeeded: received data size, Failed: -1
\r
1103 * Note : API Fcuntion
\r
1104 ****************************************************************************************************
\r
1106 int recv(SOCKET s, u_char far * buf, u_int len)
\r
1110 union un_l2cval wr_ptr, rd_ptr;
\r
1111 unsigned int offset;
\r
1113 // If out length is 0, then we do not need to do anything
\r
1118 k = READ_VALUE(SHADOW_RXWR_PTR(s));
\r
1119 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1121 wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));
\r
1122 wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));
\r
1123 wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));
\r
1124 wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));
\r
1126 k = READ_VALUE(SHADOW_RXRD_PTR(s));
\r
1127 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1129 rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));
\r
1130 rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));
\r
1131 rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));
\r
1132 rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));
\r
1135 // Suppress compiler errors that k is not used
\r
1138 // calculate IIM7010A received data size
\r
1139 if (wr_ptr.lVal == rd_ptr.lVal)
\r
1141 else if (wr_ptr.lVal >= rd_ptr.lVal)
\r
1142 size = (u_int)(wr_ptr.lVal - rd_ptr.lVal);
\r
1144 size = (u_int)(0 - rd_ptr.lVal + wr_ptr.lVal);
\r
1146 // Make sure we do not try to read more characters than what is availiable in the IIM7010 buffer
\r
1150 // Calculate pointer to be copied received data
\r
1151 offset = ((UINT)(rd_ptr.lVal & RMASK[s]));
\r
1153 // Copy received data
\r
1154 size = read_data(s, offset, buf, len);
\r
1156 // Update rx_rd_ptr
\r
1157 rd_ptr.lVal += size;
\r
1158 WRITE_VALUE(RX_RD_PTR(s), rd_ptr.cVal[3]);
\r
1159 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(1), rd_ptr.cVal[2]);
\r
1160 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(2), rd_ptr.cVal[1]);
\r
1161 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(3), rd_ptr.cVal[0]);
\r
1164 WRITE_VALUE(COMMAND(s), CRECV);
\r
1170 ****************************************************************************************************
\r
1171 * UDP data sending function.
\r
1173 * Description : Composed of the sendto()and sendto_in() functions.
\r
1174 * The send() function is an application I/F function.
\r
1175 * It continues to call the send_in() function to complete the sending of the data up to the
\r
1176 * size of the data to be sent
\r
1177 * when the application is called.Unlike TCP transmission, it designates the destination address
\r
1179 * Arguments : s - channel port
\r
1180 * buf - Pointer pointing data to send
\r
1181 * len - data size to send
\r
1182 * addr - destination IP address to send data
\r
1183 * port - destination port number to send data
\r
1184 * Returns : Sent data size
\r
1185 * Note : API Function
\r
1186 ****************************************************************************************************
\r
1188 u_int sendto(SOCKET s, u_char far * buf, u_int len, u_char * addr, u_int port)
\r
1193 // Wait until previous send commnad has completed.
\r
1194 while(READ_VALUE(COMMAND(s)) & CSEND)
\r
1196 if(select(s, SEL_CONTROL) == SOCK_CLOSED)
\r
1197 return -1; // Error.
\r
1200 // Designate destination port number.
\r
1203 WRITE_VALUE(DST_PORT_PTR(s), (u_char)((port & 0xff00) >> 8));
\r
1204 WRITE_VALUE(DST_PORT_PTR(s) + SA_OFFSET(1), (u_char)(port & 0x00ff));
\r
1207 // Designate destination IP address
\r
1208 WRITE_VALUE(DST_IP_PTR(s), addr[0]);
\r
1209 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(1), addr[1]);
\r
1210 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(2), addr[2]);
\r
1211 WRITE_VALUE(DST_IP_PTR(s) + SA_OFFSET(3), addr[3]);
\r
1220 size = sendto_in(s, buf + ptr, len);
\r
1223 } while ( len > 0);
\r
1229 ****************************************************************************************************
\r
1230 * UDP data sending function.
\r
1232 * Description : An internal function that is the same as the send_in() function of the TCP.
\r
1233 * Arguments : s - Channel number
\r
1234 * buf - Pointer indicating the data to send
\r
1235 * len - data size to send
\r
1236 * Returns : Sent data size
\r
1237 * Note : Internal Function
\r
1238 ****************************************************************************************************
\r
1240 u_int sendto_in(SOCKET s, u_char far * buf, u_int len)
\r
1244 union un_l2cval wr_ptr, rd_ptr;
\r
1245 unsigned int offset;
\r
1249 k = READ_VALUE(SHADOW_TXWR_PTR(s));
\r
1250 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1252 wr_ptr.cVal[3] = READ_VALUE(TX_WR_PTR(s));
\r
1253 wr_ptr.cVal[2] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(1));
\r
1254 wr_ptr.cVal[1] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(2));
\r
1255 wr_ptr.cVal[0] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(3));
\r
1257 k = READ_VALUE(SHADOW_TXRD_PTR(s));
\r
1258 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1260 rd_ptr.cVal[3] = READ_VALUE(TX_RD_PTR(s));
\r
1261 rd_ptr.cVal[2] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(1));
\r
1262 rd_ptr.cVal[1] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(2));
\r
1263 rd_ptr.cVal[0] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(3));
\r
1266 // Suppress compiler errors that k is not used
\r
1269 // Calculate free buffer size to send
\r
1270 if (wr_ptr.lVal >= rd_ptr.lVal)
\r
1271 size = (u_int)(SSIZE[s] - (wr_ptr.lVal - rd_ptr.lVal));
\r
1273 size = (u_int)(SSIZE[s] - (0 - rd_ptr.lVal + wr_ptr.lVal));
\r
1275 // Recalulate after some delay because of error in pointer caluation
\r
1276 if (size > SSIZE[s])
\r
1282 // Wait when previous sending has not finished yet and there's no free buffer
\r
1289 else if (size < len)
\r
1294 // Calculate pointer to copy data pointer
\r
1295 offset =(UINT)(wr_ptr.lVal & SMASK[s]);
\r
1298 write_data(s, buf, offset, len);
\r
1300 // Confirm previous send command
\r
1301 while (READ_VALUE(COMMAND(s)) & CSEND)
\r
1303 if(select(s, SEL_CONTROL)==SOCK_CLOSED)
\r
1304 return -1; // Error
\r
1307 // update tx_wr_ptr
\r
1308 wr_ptr.lVal = wr_ptr.lVal + len;
\r
1309 WRITE_VALUE(TX_WR_PTR(s), wr_ptr.cVal[3]);
\r
1310 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(1), wr_ptr.cVal[2]);
\r
1311 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(2), wr_ptr.cVal[1]);
\r
1312 WRITE_VALUE(TX_WR_PTR(s) + SA_OFFSET(3), wr_ptr.cVal[0]);
\r
1317 WRITE_VALUE(COMMAND(s), CSEND);
\r
1323 ****************************************************************************************************
\r
1324 * UDP data receiving function.
\r
1326 * Description : Function for receiving UDP and IP layer RAW mode data, and handling the data header.
\r
1327 * Arguments : s - channel number
\r
1328 * buf - Pointer where the data to be received is copied
\r
1329 * len - Size of the data to be received
\r
1330 * addr - Peer IP address for receiving
\r
1331 * port - Peer port number for receiving
\r
1332 * Returns : Received data size
\r
1333 * Note : API Function
\r
1334 ****************************************************************************************************
\r
1336 u_int recvfrom(SOCKET s, u_char far *buf, u_int len, u_char *addr, u_int *port)
\r
1338 struct _UDPHeader // When receiving UDP data, header added by W3100A
\r
1353 union un_l2cval wr_ptr, rd_ptr;
\r
1356 unsigned int offset;
\r
1358 if(select(s,SEL_CONTROL)==SOCK_CLOSED)
\r
1362 k = READ_VALUE(SHADOW_RXWR_PTR(s));
\r
1363 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1365 wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));
\r
1366 wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));
\r
1367 wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));
\r
1368 wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));
\r
1370 k = READ_VALUE(SHADOW_RXRD_PTR(s));
\r
1371 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1373 rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));
\r
1374 rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));
\r
1375 rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));
\r
1376 rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));
\r
1379 // Suppress compiler errors that k is not used
\r
1382 // Calculate received data size
\r
1385 else if (wr_ptr.lVal >= rd_ptr.lVal)
\r
1386 size = wr_ptr.lVal - rd_ptr.lVal;
\r
1388 size = 0 - rd_ptr.lVal + wr_ptr.lVal;
\r
1393 // Calulate received data pointer
\r
1394 offset = ((UINT)(rd_ptr.lVal & RMASK[s]));
\r
1397 if (( READ_VALUE(OPT_PROTOCOL(s)) & 0x07) == SOCK_DGRAM)
\r
1399 // Copy W3100A UDP header
\r
1400 read_data(s, offset, UDPHeader.u.stream, 8);
\r
1402 // Read UDP Packet size
\r
1403 size = UDPHeader.u.stream[0];
\r
1404 size = (size << 8) + UDPHeader.u.stream[1];
\r
1406 // Read IP address of the peer
\r
1407 addr[0] = UDPHeader.u.header.addr[0];
\r
1408 addr[1] = UDPHeader.u.header.addr[1];
\r
1409 addr[2] = UDPHeader.u.header.addr[2];
\r
1410 addr[3] = UDPHeader.u.header.addr[3];
\r
1412 // Read Port number of the peer
\r
1413 *port = UDPHeader.u.stream[6];
\r
1414 *port = (*port << 8) + UDPHeader.u.stream[7];
\r
1416 // Increase read pointer by 8, because already read as UDP header size
\r
1419 // Calculate UDP data copy pointer
\r
1420 offset = ((UINT)(rd_ptr.lVal & RMASK[s]));
\r
1422 // Calculate data size of current UDP Packet from UDP header
\r
1425 // Copy one UDP data packet to user-specific buffer
\r
1426 ret = read_data(s, offset, buf, (u_int)size);
\r
1428 // Increase read pointer by UDP packet data size
\r
1429 rd_ptr.lVal += ret;
\r
1431 else if ((READ_VALUE(OPT_PROTOCOL(s)) & 0x07) == SOCK_IPL_RAW) // When IP layer RAW mode data
\r
1433 // Copy W3100A IP Raw header
\r
1434 read_data(s, offset, UDPHeader.u.stream, 6);
\r
1436 // Read IP layer RAW Packet size
\r
1437 size = UDPHeader.u.stream[0];
\r
1438 size = (size << 8) + UDPHeader.u.stream[1];
\r
1440 // Read IP address of the peer
\r
1441 addr[0] = UDPHeader.u.header.addr[0];
\r
1442 addr[1] = UDPHeader.u.header.addr[1];
\r
1443 addr[2] = UDPHeader.u.header.addr[2];
\r
1444 addr[3] = UDPHeader.u.header.addr[3];
\r
1446 // Increase read pointer by 6, because already read as IP RAW header size
\r
1449 // Calculate IP layer raw mode data pointer
\r
1450 offset = ((UINT)(rd_ptr.lVal & RMASK[s]));
\r
1452 // Copy one IP Raw data packet to user-specific buffer
\r
1453 ret = read_data(s, offset, buf, (u_int)size);
\r
1454 rd_ptr.lVal = rd_ptr.lVal + (ret - 4);
\r
1457 // Update rx_rd_ptr
\r
1458 WRITE_VALUE(RX_RD_PTR(s), rd_ptr.cVal[3]);
\r
1459 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(1), rd_ptr.cVal[2]);
\r
1460 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(2), rd_ptr.cVal[1]);
\r
1461 WRITE_VALUE(RX_RD_PTR(s) + SA_OFFSET(3), rd_ptr.cVal[0]);
\r
1464 WRITE_VALUE(COMMAND(s), CRECV);
\r
1466 // Real received size return
\r
1471 ****************************************************************************************************
\r
1472 * Channel closing function.
\r
1474 * Description : Function for closing the connection of the designated channel.
\r
1475 * Arguments : s - channel number
\r
1477 * Note : API Function
\r
1478 ****************************************************************************************************
\r
1480 void close(SOCKET s)
\r
1486 if (select(s, SEL_CONTROL) == SOCK_CLOSED)
\r
1487 return; // Already closed
\r
1489 // When closing, if there's data which have not processed, Insert some source codes to handle this
\r
1490 // Or before application call close(), handle those data first and call close() later.
\r
1492 len = select(s, SEL_SEND);
\r
1493 if (len == SSIZE[s])
\r
1496 WRITE_VALUE(COMMAND(s), CCLOSE);
\r
1497 // TODO: The 'SCLOSED' status value is only set briefly as part of the close,
\r
1498 // and will otherwise quickly return to normal. That means your code might
\r
1499 // become 'stuck' at this point even if the packet has closed normally.
\r
1500 // Rather than a while() call, it might be preferred to time out on this
\r
1501 // close check and return to the application after some time.
\r
1502 while(!(I_STATUS[s] & SCLOSED))
\r
1503 I2CHIP_POLL_ISR(in4_isr_i2chip);
\r
1507 u_char tx_empty(SOCKET s)
\r
1509 return (select(s, SEL_SEND) == SSIZE[s]);
\r
1513 ****************************************************************************************************
\r
1514 * Channel closing function.
\r
1516 * Description : Function for closing the connection of the designated channel.
\r
1517 * Arguments : s - channel number
\r
1519 * Note : API Function
\r
1520 ****************************************************************************************************
\r
1522 char reset_sock(SOCKET s)
\r
1529 WRITE_VALUE(RESETSOCK, c);
\r
1534 ****************************************************************************************************
\r
1535 * Function handling the channel socket information.
\r
1537 * Description : Return socket information of designated channel
\r
1538 * Arguments : s - channel number
\r
1539 * func - SEL_CONTROL(0x00) -> return socket status
\r
1540 * SEL_SEND(0x01) -> return free transmit buffer size
\r
1541 * SEL_RECV(0x02) -> return received data size
\r
1542 * Returns : socket status or free transmit buffer size or received data size
\r
1543 * Note : API Function
\r
1544 ****************************************************************************************************
\r
1546 u_int select(SOCKET s, u_char func)
\r
1549 union un_l2cval rd_ptr, wr_ptr, ack_ptr;
\r
1554 // socket status information
\r
1555 case SEL_CONTROL :
\r
1556 val = READ_VALUE(SOCK_STATUS(s));
\r
1559 // Calculate send free buffer size
\r
1562 k = READ_VALUE(SHADOW_TXWR_PTR(s));
\r
1563 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1565 wr_ptr.cVal[3] = READ_VALUE(TX_WR_PTR(s));
\r
1566 wr_ptr.cVal[2] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(1));
\r
1567 wr_ptr.cVal[1] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(2));
\r
1568 wr_ptr.cVal[0] = READ_VALUE(TX_WR_PTR(s) + SA_OFFSET(3));
\r
1570 if (( READ_VALUE(OPT_PROTOCOL(s)) & 0x07) == SOCK_STREAM) // TCP
\r
1572 k = READ_VALUE(SHADOW_TXACK_PTR(s));
\r
1573 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1575 ack_ptr.cVal[3] = READ_VALUE(TX_ACK_PTR(s));
\r
1576 ack_ptr.cVal[2] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(1));
\r
1577 ack_ptr.cVal[1] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(2));
\r
1578 ack_ptr.cVal[0] = READ_VALUE(TX_ACK_PTR(s) + SA_OFFSET(3));
\r
1581 if (wr_ptr.lVal >= ack_ptr.lVal)
\r
1582 val = (u_int)(SSIZE[s] - (wr_ptr.lVal - ack_ptr.lVal));
\r
1584 val = (u_int)(SSIZE[s] - (0 - ack_ptr.lVal + wr_ptr.lVal));
\r
1586 else // UDP, IP RAW ... (except TCP)
\r
1588 k = READ_VALUE(SHADOW_TXRD_PTR(s));
\r
1589 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1591 rd_ptr.cVal[3] = READ_VALUE(TX_RD_PTR(s));
\r
1592 rd_ptr.cVal[2] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(1));
\r
1593 rd_ptr.cVal[1] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(2));
\r
1594 rd_ptr.cVal[0] = READ_VALUE(TX_RD_PTR(s) + SA_OFFSET(3));
\r
1597 if (wr_ptr.lVal >= rd_ptr.lVal)
\r
1598 val = (u_int)(SSIZE[s] - (wr_ptr.lVal - rd_ptr.lVal));
\r
1600 val = (u_int)(SSIZE[s] - (0 - rd_ptr.lVal + wr_ptr.lVal));
\r
1604 // Calculate received data size
\r
1607 k = READ_VALUE(SHADOW_RXWR_PTR(s));
\r
1608 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1610 wr_ptr.cVal[3] = READ_VALUE(RX_WR_PTR(s));
\r
1611 wr_ptr.cVal[2] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(1));
\r
1612 wr_ptr.cVal[1] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(2));
\r
1613 wr_ptr.cVal[0] = READ_VALUE(RX_WR_PTR(s) + SA_OFFSET(3));
\r
1615 k = READ_VALUE(SHADOW_RXRD_PTR(s));
\r
1616 WINDOW_RESTORE_BASE; // Needed whenever we touch a shadow ptr; different window.
\r
1618 rd_ptr.cVal[3] = READ_VALUE(RX_RD_PTR(s));
\r
1619 rd_ptr.cVal[2] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(1));
\r
1620 rd_ptr.cVal[1] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(2));
\r
1621 rd_ptr.cVal[0] = READ_VALUE(RX_RD_PTR(s) + SA_OFFSET(3));
\r
1624 if (wr_ptr.lVal == rd_ptr.lVal)
\r
1626 else if (wr_ptr.lVal > rd_ptr.lVal)
\r
1627 val = (u_int)(wr_ptr.lVal - rd_ptr.lVal);
\r
1629 val = (u_int)(0 - rd_ptr.lVal + wr_ptr.lVal);
\r
1636 // Suppress compiler errors that k is not used
\r
1642 // unsigned char dma_read_i2chip (unsigned int i2_segm, unsigned int i2_offs,
\r
1643 // unsigned int cnt, unsigned int des_segm, unsigned int des_offs);
\r
1644 // Using DMA0 to read data from i2chip buffer into destination SRAM.
\r
1646 // unsigned int cnt = number of sectors, 512-byte per sector
\r
1647 // unsigned int des_segm = segment of destination SRAM data memory
\r
1648 // unsigned int des_offs = offset of destination SRAM data memory
\r
1649 // unsigned int i2_segm = segment of i2chip buffer mapped in memory
\r
1650 // unsigned int i2_offs = offset of i2chip buffer mapped in memory
\r
1651 // return DMA counter value
\r
1653 unsigned int dma_read_i2chip(u_char far* i2_src, u_char far* des, u_int cnt)
\r
1655 u_int des_segm, des_offs;
\r
1656 u_int i2_segm, i2_offs;
\r
1659 temp = ((long)FP_SEG(des) << 4) + ((long)FP_OFF(des));
\r
1660 des_segm = (u_int)(temp >> 16);
\r
1661 des_offs = (u_int)(temp & 0xffff);
\r
1663 temp = ((long)FP_SEG(i2_src) << 4) + ((long)FP_OFF(i2_src));
\r
1664 i2_segm = (u_int)(temp >> 16);
\r
1665 i2_offs = (u_int)(temp & 0xffff);
\r
1667 outport(0xffc6, des_segm); /* D0DSTH destination SRAM segment */
\r
1668 outport(0xffc4, des_offs); /* D0DSTL destination SRAM offset */
\r
1669 outport(0xffc2, i2_segm); /* D0SRCH=SP0RD */
\r
1670 outport(0xffc0, i2_offs); /* D0SRCL=SP0RD */
\r
1671 outport(0xffc8, cnt); // D0TC counter
\r
1672 outport(0xfff8,0x0504); // PLLCON, 0203=10M,050f=40M, 051f=80MHz
\r
1673 // DMA0 mem-mem, 16-bit, unsync, Start moving data line below
\r
1674 outport(0xffca, 0xb60e); /* D0CON 1011 0110 0000 1111 */
\r
1675 // outport(0xffca, 0xb42e); // 1011 0100 0010 1110
\r
1676 while( inport(0xffc8) ); /* D0TC counter=0, DMA complete */
\r
1677 outport(0xfff8,0x051f); // PLLCON, 0203=10M,050f=40M, 051f=80MHz
\r
1678 return( inport(0xffc8) ); // counter
\r
1682 // unsigned int dma_write_i2chip (unsigned int src_segm, unsigned int src_offs,
\r
1683 // unsigned int cnt, unsigned int i2_segm, unsigned int i2_offs);
\r
1684 // Using DMA0 to write data from memory into i2chip.
\r
1686 // unsigned int cnt = number of 16-bit DMA transfers
\r
1687 // unsigned int src_segm = segment of the source SRAM data memory
\r
1688 // unsigned int src_offs = offset of the source SRAM data memory
\r
1689 // unsigned int i2_segm = segment of i2chip buffer mapped in memory
\r
1690 // unsigned int i2_offs = offset of i2chip buffer mapped in memory
\r
1691 // return DMA counter value
\r
1693 unsigned int dma_write_i2chip(u_char far* src, u_char far* i2_dest, u_int cnt)
\r
1695 u_int src_segm, src_offs;
\r
1696 u_int i2_segm, i2_offs;
\r
1699 temp = (FP_SEG(src) << 4) + (FP_OFF(src));
\r
1700 src_segm = (u_int)(temp >> 4);
\r
1701 src_offs = (u_int)(temp & 0xffff);
\r
1703 temp = (FP_SEG(i2_dest) << 4) + (FP_OFF(i2_dest));
\r
1704 i2_segm = (u_int)(temp >> 4);
\r
1705 i2_offs = (u_int)(temp & 0xffff);
\r
1707 outport(0xffc8, cnt); // D0TC counter
\r
1708 outport(0xffc6, i2_segm); // D0DSTH=i2chip buffer segment
\r
1709 outport(0xffc4, i2_offs); // D0DSTL=i2chip buffer offset
\r
1710 outport(0xffc2, src_segm); /* D0SRCH=SP0RD */
\r
1711 outport(0xffc0, src_offs); /* D0SRCL=SP0RD */
\r
1712 // outport(0xfff8,0x050f); // PLLCON, 0203=10M,050f=40M, 051f=80MHz
\r
1713 // DMA0 mem-mem, 16-bit, unsync, Start moving data line below
\r
1714 outport(0xffca, 0xb60f); /* D0CON 1011 0110 0000 1111 */
\r
1715 while( inport(0xffc8) ); /* D0TC counter=0, DMA complete */
\r
1716 // outport(0xfff8,0x051f); // PLLCON, 0203=10M,050f=40M, 051f=80MHz
\r
1718 return( inport(0xffc8) ); // counter
\r
1722 ****************************************************************************************************
\r
1723 * Copies the receive buffer data of the W3100A to the system buffer.
\r
1725 * Description : Copies the receive buffer data of the W3100A to the system buffer.
\r
1726 * It is called from the recv()or recvfrom() function.
\r
1727 * Arguments : s - channel number
\r
1728 * src - receive buffer pointer of W3100A
\r
1729 * dst - system buffer pointer
\r
1730 * len - data size to copy
\r
1731 * Returns : copied data size
\r
1732 * Note : Internal Function
\r
1733 ****************************************************************************************************
\r
1735 u_int read_data(SOCKET s, u_int offset, u_char far * dst, u_int len)
\r
1737 u_int i, size, size1;
\r
1738 u_char far* src = (u_char far*)(MK_FP_WINDOW(RECV_DATA_BUF,
\r
1739 RBUFBASEADDRESS[s] + offset));
\r
1740 // src = (u_char far*)(MK_FP_WINDOW(RECV_DATA_BUF,
\r
1745 WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.
\r
1749 if ((offset + len) > RSIZE[s])
\r
1751 size = (u_int)(RSIZE[s] - offset);
\r
1753 if (size > TERN_RDMA_THRES)
\r
1755 dma_read_i2chip(src, dst, size);
\r
1759 for (i = 0; i < size; i++)
\r
1761 *dst++ = READ_VALUE(src);
\r
1762 WINDOW_PTR_INC(src);
\r
1767 size1 = len - size;
\r
1768 src = (u_char far *)(MK_FP_WINDOW(RECV_DATA_BUF, (RBUFBASEADDRESS[s])));
\r
1770 if (size1 > TERN_RDMA_THRES)
\r
1772 dma_read_i2chip(src, dst, size);
\r
1776 for (i = 0; i < size1; i++)
\r
1778 *dst++ = READ_VALUE(src);
\r
1779 WINDOW_PTR_INC(src);
\r
1785 if (len > TERN_RDMA_THRES)
\r
1787 dma_read_i2chip(src, dst, size);
\r
1791 for (i = 0; i < len; i++)
\r
1793 *dst++ = READ_VALUE(src);
\r
1794 WINDOW_PTR_INC(src);
\r
1798 WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.
\r
1804 ****************************************************************************************************
\r
1805 * Copies the system buffer data to the transmit buffer of the W3100A.
\r
1807 * Description : Copies the system buffer data to the transmit buffer of the W3100A.
\r
1808 * It is called from the send_in()or sendto_in() function.
\r
1809 * Arguments : s - channel number
\r
1810 * src - system buffer pointer
\r
1811 * dst - send buffer pointer of W3100A
\r
1812 * len - data size to copy
\r
1813 * Returns : copied data size
\r
1814 * Note : Internal Function
\r
1815 ****************************************************************************************************
\r
1817 u_int write_data(SOCKET s, u_char far * src, u_int offset, u_int len)
\r
1819 u_int i, size, size1;
\r
1820 u_char far* dst = (u_char far*)MK_FP_WINDOW(SEND_DATA_BUF,
\r
1821 SBUFBASEADDRESS[s] + offset);
\r
1825 WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.
\r
1829 if ((offset + len) > SSIZE[s])
\r
1831 size = (u_int)(SSIZE[s] - offset);
\r
1833 for (i = 0; i < size; i++)
\r
1835 WRITE_VALUE(dst, *src++);
\r
1836 WINDOW_PTR_INC(dst);
\r
1839 size1 = len - size;
\r
1840 dst = (u_char far *)(MK_FP_WINDOW(SEND_DATA_BUF, (SBUFBASEADDRESS[s])));
\r
1842 for (i = 0; i < size1; i++)
\r
1844 WRITE_VALUE(dst, *src++);
\r
1845 WINDOW_PTR_INC(dst);
\r
1850 for (i = 0; i < len; i++)
\r
1852 WRITE_VALUE(dst, *src++);
\r
1853 WINDOW_PTR_INC(dst);
\r
1856 WINDOW_RESTORE_BASE; // Needed whenever we do a call to MK_FP_WINDOW.
\r