add arduino-0018-linux (32 bit)

arduino-0018-linux/libraries/Ethernet/Client.cpp

@@ -0,0 +1,148 @@
+extern "C" {
+  #include "types.h"
+  #include "w5100.h"
+  #include "socket.h"
+  #include "string.h"
+}
+
+#include "WProgram.h"
+
+#include "Ethernet.h"
+#include "Client.h"
+#include "Server.h"
+
+uint16_t Client::_srcport = 0;
+
+Client::Client(uint8_t sock) {
+  _sock = sock;
+}
+
+Client::Client(uint8_t *ip, uint16_t port) {
+  _ip = ip;
+  _port = port;  
+  _sock = 255;
+}
+
+uint8_t Client::connect() {
+  if (_sock != 255)
+    return 0;
+  
+  for (int i = 0; i < MAX_SOCK_NUM; i++) {
+    uint8_t s = getSn_SR(i);
+    if (s == SOCK_CLOSED || s == SOCK_FIN_WAIT) {
+      _sock = i;
+      break;
+    }
+  }
+  
+  if (_sock == 255)
+    return 0;
+    
+  _srcport++;
+  if (_srcport + 1024 == 0) _srcport = 0;
+  socket(_sock, Sn_MR_TCP, _srcport + 1024, 0);
+  
+  if (!::connect(_sock, _ip, _port)) {
+    _sock = 255;
+    return 0;
+  }
+    
+  while (status() != SOCK_ESTABLISHED) {
+    delay(1);
+    if (status() == SOCK_CLOSED) {
+      _sock = 255;
+      return 0;
+    }
+  }
+  
+  return 1;
+}
+
+void Client::write(uint8_t b) {
+  if (_sock != 255)
+    send(_sock, &b, 1);
+}
+
+void Client::write(const char *str) {
+  if (_sock != 255)
+    send(_sock, (const uint8_t *)str, strlen(str));
+}
+
+void Client::write(const uint8_t *buf, size_t size) {
+  if (_sock != 255)
+    send(_sock, buf, size);
+}
+
+int Client::available() {
+  if (_sock != 255)
+    return getSn_RX_RSR(_sock);
+  return 0;
+}
+
+int Client::read() {
+  uint8_t b;
+  if (!available())
+    return -1;
+  recv(_sock, &b, 1);
+  return b;
+}
+
+void Client::flush() {
+  while (available())
+    read();
+}
+
+void Client::stop() {
+  if (_sock == 255)
+    return;
+  
+  // attempt to close the connection gracefully (send a FIN to other side)
+  disconnect(_sock);
+  unsigned long start = millis();
+  
+  // wait a second for the connection to close
+  while (status() != SOCK_CLOSED && millis() - start < 1000)
+    delay(1);
+    
+  // if it hasn't closed, close it forcefully
+  if (status() != SOCK_CLOSED)
+    close(_sock);
+  
+  EthernetClass::_server_port[_sock] = 0;
+  _sock = 255;
+}
+
+uint8_t Client::connected() {
+  if (_sock == 255) {
+    return 0;
+  } else {
+    uint8_t s = status();
+    return !(s == SOCK_LISTEN || s == SOCK_CLOSED || s == SOCK_FIN_WAIT ||
+      (s == SOCK_CLOSE_WAIT && !available()));
+  }
+}
+
+uint8_t Client::status() {
+  if (_sock == 255) {
+    return SOCK_CLOSED;
+  } else {
+    return getSn_SR(_sock);
+  }
+}
+
+// the next three functions are a hack so we can compare the client returned
+// by Server::available() to null, or use it as the condition in an
+// if-statement.  this lets us stay compatible with the Processing network
+// library.
+
+uint8_t Client::operator==(int p) {
+  return _sock == 255;
+}
+
+uint8_t Client::operator!=(int p) {
+  return _sock != 255;
+}
+
+Client::operator bool() {
+  return _sock != 255;
+}

arduino-0018-linux/libraries/Ethernet/Client.h

@@ -0,0 +1,31 @@
+#ifndef Client_h
+#define Client_h
+
+#include "Print.h"
+
+class Client : public Print {
+private:
+  static uint16_t _srcport;
+  uint8_t _sock;
+  uint8_t *_ip;
+  uint16_t _port;
+public:
+  Client(uint8_t);
+  Client(uint8_t *, uint16_t);
+  uint8_t status();
+  uint8_t connect();
+  virtual void write(uint8_t);
+  virtual void write(const char *str);
+  virtual void write(const uint8_t *buf, size_t size);
+  int available();
+  int read();
+  void flush();
+  void stop();
+  uint8_t connected();
+  uint8_t operator==(int);
+  uint8_t operator!=(int);
+  operator bool();
+  friend class Server;
+};
+
+#endif

arduino-0018-linux/libraries/Ethernet/Ethernet.cpp

@@ -0,0 +1,38 @@
+extern "C" {
+  #include "types.h"
+  #include "w5100.h"
+}
+  
+#include "Ethernet.h"
+
+// XXX: don't make assumptions about the value of MAX_SOCK_NUM.
+uint8_t EthernetClass::_state[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+uint16_t EthernetClass::_server_port[MAX_SOCK_NUM] = { 0, 0, 0, 0 };
+
+void EthernetClass::begin(uint8_t *mac, uint8_t *ip)
+{
+  uint8_t gateway[4];
+  gateway[0] = ip[0];
+  gateway[1] = ip[1];
+  gateway[2] = ip[2];
+  gateway[3] = 1;
+  begin(mac, ip, gateway);
+}
+
+void EthernetClass::begin(uint8_t *mac, uint8_t *ip, uint8_t *gateway)
+{
+  uint8_t subnet[] = { 255, 255, 255, 0 };
+  begin(mac, ip, gateway, subnet);
+}
+
+void EthernetClass::begin(uint8_t *mac, uint8_t *ip, uint8_t *gateway, uint8_t *subnet)
+{
+	iinchip_init();
+	sysinit(0x55, 0x55);
+	setSHAR(mac);
+	setSIPR(ip);
+  setGAR(gateway);
+  setSUBR(subnet);
+}
+
+EthernetClass Ethernet;

arduino-0018-linux/libraries/Ethernet/Ethernet.h

@@ -0,0 +1,22 @@
+#ifndef Ethernet_h
+#define Ethernet_h
+
+#include <inttypes.h>
+#include "Client.h"
+#include "Server.h"
+
+class EthernetClass {
+private:
+public:
+  static uint8_t _state[MAX_SOCK_NUM];
+  static uint16_t _server_port[MAX_SOCK_NUM];
+  void begin(uint8_t *, uint8_t *);
+  void begin(uint8_t *, uint8_t *, uint8_t *);
+  void begin(uint8_t *, uint8_t *, uint8_t *, uint8_t *);
+  friend class Client;
+  friend class Server;
+};
+
+extern EthernetClass Ethernet;
+
+#endif

arduino-0018-linux/libraries/Ethernet/Server.cpp

@@ -0,0 +1,91 @@
+extern "C" {
+  #include "types.h"
+  #include "w5100.h"
+  #include "socket.h"
+  #include "string.h"
+}
+
+#include "Ethernet.h"
+#include "Client.h"
+#include "Server.h"
+
+Server::Server(uint16_t port)
+{
+  _port = port;
+}
+
+void Server::begin()
+{
+  for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+    Client client(sock);
+    if (client.status() == SOCK_CLOSED) {
+      socket(sock, Sn_MR_TCP, _port, 0);
+      listen(sock);
+      EthernetClass::_server_port[sock] = _port;
+      break;
+    }
+  }  
+}
+
+void Server::accept()
+{
+  int listening = 0;
+  
+  for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+    Client client(sock);
+    
+    if (EthernetClass::_server_port[sock] == _port) {
+      if (client.status() == SOCK_LISTEN) {
+        listening = 1;
+      } else if (client.status() == SOCK_CLOSE_WAIT && !client.available()) {
+        client.stop();
+      }
+    } 
+  }
+  
+  if (!listening) {
+    begin();
+  }
+}
+
+Client Server::available()
+{
+  accept();
+  
+  for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+    Client client(sock);
+    if (EthernetClass::_server_port[sock] == _port &&
+        client.status() == SOCK_ESTABLISHED) {
+      if (client.available()) {
+        // XXX: don't always pick the lowest numbered socket.
+        return client;
+      }
+    }
+  }
+  
+  return Client(255);
+}
+
+void Server::write(uint8_t b) 
+{
+  write(&b, 1);
+}
+
+void Server::write(const char *str) 
+{
+  write((const uint8_t *)str, strlen(str));
+}
+
+void Server::write(const uint8_t *buffer, size_t size) 
+{
+  accept();
+  
+  for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
+    Client client(sock);
+    
+    if (EthernetClass::_server_port[sock] == _port &&
+        client.status() == SOCK_ESTABLISHED) {
+      client.write(buffer, size);
+    }
+  }
+}

arduino-0018-linux/libraries/Ethernet/Server.h

@@ -0,0 +1,25 @@
+#ifndef Server_h
+#define Server_h
+
+extern "C" {
+  #include "utility/types.h"
+}
+
+#include "Print.h"
+
+class Client;
+
+class Server : public Print {
+private:
+  uint16_t _port;
+  void accept();
+public:
+  Server(uint16_t);
+  Client available();
+  void begin();
+  virtual void write(uint8_t);
+  virtual void write(const char *str);
+  virtual void write(const uint8_t *buf, size_t size);
+};
+
+#endif

arduino-0018-linux/libraries/Ethernet/examples/ChatServer/ChatServer.pde

@@ -0,0 +1,34 @@
+/*
+ * Chat Server
+ *
+ * A simple server that distributes any incoming messages to all
+ * connected clients.  To use telnet to 10.0.0.177 and type!
+ */
+
+#include <Ethernet.h>
+
+// network configuration.  gateway and subnet are optional.
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+byte ip[] = { 10, 0, 0, 177 };
+byte gateway[] = { 10, 0, 0, 1 };
+byte subnet[] = { 255, 255, 0, 0 };
+
+// telnet defaults to port 23
+Server server(23);
+
+void setup()
+{
+  // initialize the ethernet device
+  Ethernet.begin(mac, ip, gateway, subnet);
+  
+  // start listening for clients
+  server.begin();
+}
+
+void loop()
+{
+  Client client = server.available();
+  if (client) {
+    server.write(client.read());
+  }
+}

arduino-0018-linux/libraries/Ethernet/examples/WebClient/WebClient.pde

@@ -0,0 +1,41 @@
+#include <Ethernet.h>
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+byte ip[] = { 10, 0, 0, 177 };
+byte server[] = { 64, 233, 187, 99 }; // Google
+
+Client client(server, 80);
+
+void setup()
+{
+  Ethernet.begin(mac, ip);
+  Serial.begin(9600);
+  
+  delay(1000);
+  
+  Serial.println("connecting...");
+  
+  if (client.connect()) {
+    Serial.println("connected");
+    client.println("GET /search?q=arduino HTTP/1.0");
+    client.println();
+  } else {
+    Serial.println("connection failed");
+  }
+}
+
+void loop()
+{
+  if (client.available()) {
+    char c = client.read();
+    Serial.print(c);
+  }
+  
+  if (!client.connected()) {
+    Serial.println();
+    Serial.println("disconnecting.");
+    client.stop();
+    for(;;)
+      ;
+  }
+}

arduino-0018-linux/libraries/Ethernet/examples/WebServer/WebServer.pde

@@ -0,0 +1,61 @@
+/*
+ * Web Server
+ *
+ * A simple web server that shows the value of the analog input pins.
+ */
+
+#include <Ethernet.h>
+
+byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
+byte ip[] = { 10, 0, 0, 177 };
+
+Server server(80);
+
+void setup()
+{
+  Ethernet.begin(mac, ip);
+  server.begin();
+}
+
+void loop()
+{
+  Client client = server.available();
+  if (client) {
+    // an http request ends with a blank line
+    boolean current_line_is_blank = true;
+    while (client.connected()) {
+      if (client.available()) {
+        char c = client.read();
+        // if we've gotten to the end of the line (received a newline
+        // character) and the line is blank, the http request has ended,
+        // so we can send a reply
+        if (c == '\n' && current_line_is_blank) {
+          // send a standard http response header
+          client.println("HTTP/1.1 200 OK");
+          client.println("Content-Type: text/html");
+          client.println();
+          
+          // output the value of each analog input pin
+          for (int i = 0; i < 6; i++) {
+            client.print("analog input ");
+            client.print(i);
+            client.print(" is ");
+            client.print(analogRead(i));
+            client.println("<br />");
+          }
+          break;
+        }
+        if (c == '\n') {
+          // we're starting a new line
+          current_line_is_blank = true;
+        } else if (c != '\r') {
+          // we've gotten a character on the current line
+          current_line_is_blank = false;
+        }
+      }
+    }
+    // give the web browser time to receive the data
+    delay(1);
+    client.stop();
+  }
+}

arduino-0018-linux/libraries/Ethernet/keywords.txt

@@ -0,0 +1,30 @@
+#######################################
+# Syntax Coloring Map For Ethernet
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+Ethernet	KEYWORD1
+Client	KEYWORD1
+Server	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+status	KEYWORD2
+connect	KEYWORD2
+write	KEYWORD2
+available	KEYWORD2
+read	KEYWORD2
+flush	KEYWORD2
+stop	KEYWORD2
+connected	KEYWORD2
+begin	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

arduino-0018-linux/libraries/Ethernet/utility/socket.c

@@ -0,0 +1,558 @@
+/*
+*
+@file		socket.c
+@brief	setting chip register for socket
+		last update : 2008. Jan
+*
+*/
+
+#include "types.h"
+#include "w5100.h"
+#include "socket.h"
+
+static uint16 local_port;
+
+
+/**
+@brief	This Socket function initialize the channel in perticular mode, and set the port and wait for W5100 done it.
+@return 	1 for sucess else 0.
+*/  
+uint8 socket(
+	SOCKET s, 		/**< for socket number */
+	uint8 protocol, 	/**< for socket protocol */
+	uint16 port, 		/**< the source port for the socket */
+	uint8 flag		/**< the option for the socket */
+	)
+{
+	uint8 ret;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("socket()\r\n");
+#endif
+	if ((protocol == Sn_MR_TCP) || (protocol == Sn_MR_UDP) || (protocol == Sn_MR_IPRAW) || (protocol == Sn_MR_MACRAW) || (protocol == Sn_MR_PPPOE))
+	{
+		close(s);
+		IINCHIP_WRITE(Sn_MR(s),protocol | flag);
+		if (port != 0) {
+			IINCHIP_WRITE(Sn_PORT0(s),(uint8)((port & 0xff00) >> 8));
+			IINCHIP_WRITE((Sn_PORT0(s) + 1),(uint8)(port & 0x00ff));
+		} else {
+			local_port++; // if don't set the source port, set local_port number.
+			IINCHIP_WRITE(Sn_PORT0(s),(uint8)((local_port & 0xff00) >> 8));
+			IINCHIP_WRITE((Sn_PORT0(s) + 1),(uint8)(local_port & 0x00ff));
+		}
+		IINCHIP_WRITE(Sn_CR(s),Sn_CR_OPEN); // run sockinit Sn_CR
+
+		/* +20071122[chungs]:wait to process the command... */
+		while( IINCHIP_READ(Sn_CR(s)) ) 
+			;
+		/* ------- */
+		ret = 1;
+	}
+	else
+	{
+		ret = 0;
+	}
+#ifdef __DEF_IINCHIP_DBG__
+	printf("Sn_SR = %.2x , Protocol = %.2x\r\n", IINCHIP_READ(Sn_SR(s)), IINCHIP_READ(Sn_MR(s)));
+#endif
+	return ret;
+}
+
+
+/**
+@brief	This function close the socket and parameter is "s" which represent the socket number
+*/ 
+void close(SOCKET s)
+{
+#ifdef __DEF_IINCHIP_DBG__
+	printf("close()\r\n");
+#endif
+	
+	IINCHIP_WRITE(Sn_CR(s),Sn_CR_CLOSE);
+
+	/* +20071122[chungs]:wait to process the command... */
+	while( IINCHIP_READ(Sn_CR(s)) ) 
+		;
+	/* ------- */
+
+	/* +2008.01 [hwkim]: clear interrupt */	
+	#ifdef __DEF_IINCHIP_INT__
+      /* m2008.01 [bj] : all clear */
+	       putISR(s, 0x00);
+	#else
+      /* m2008.01 [bj] : all clear */
+		IINCHIP_WRITE(Sn_IR(s), 0xFF);
+	#endif
+}
+
+
+/**
+@brief	This function established  the connection for the channel in passive (server) mode. This function waits for the request from the peer.
+@return	1 for success else 0.
+*/ 
+uint8 listen(
+	SOCKET s	/**< the socket number */
+	)
+{
+	uint8 ret;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("listen()\r\n");
+#endif
+	if (IINCHIP_READ(Sn_SR(s)) == SOCK_INIT)
+	{
+		IINCHIP_WRITE(Sn_CR(s),Sn_CR_LISTEN);
+		/* +20071122[chungs]:wait to process the command... */
+		while( IINCHIP_READ(Sn_CR(s)) ) 
+			;
+		/* ------- */
+		ret = 1;
+	}
+	else
+	{
+		ret = 0;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("Fail[invalid ip,port]\r\n");
+#endif
+	}
+	return ret;
+}
+
+
+/**
+@brief	This function established  the connection for the channel in Active (client) mode. 
+		This function waits for the untill the connection is established.
+		
+@return	1 for success else 0.
+*/ 
+uint8 connect(SOCKET s, uint8 * addr, uint16 port)
+{
+	uint8 ret;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("connect()\r\n");
+#endif
+	if 
+		(
+			((addr[0] == 0xFF) && (addr[1] == 0xFF) && (addr[2] == 0xFF) && (addr[3] == 0xFF)) ||
+		 	((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
+		 	(port == 0x00) 
+		) 
+ 	{
+ 		ret = 0;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("Fail[invalid ip,port]\r\n");
+#endif
+	}
+	else
+	{
+		ret = 1;
+		// set destination IP
+		IINCHIP_WRITE(Sn_DIPR0(s),addr[0]);
+		IINCHIP_WRITE((Sn_DIPR0(s) + 1),addr[1]);
+		IINCHIP_WRITE((Sn_DIPR0(s) + 2),addr[2]);
+		IINCHIP_WRITE((Sn_DIPR0(s) + 3),addr[3]);
+		IINCHIP_WRITE(Sn_DPORT0(s),(uint8)((port & 0xff00) >> 8));
+		IINCHIP_WRITE((Sn_DPORT0(s) + 1),(uint8)(port & 0x00ff));
+		IINCHIP_WRITE(Sn_CR(s),Sn_CR_CONNECT);
+      /* m2008.01 [bj] :  wait for completion */
+		while ( IINCHIP_READ(Sn_CR(s)) ) ;
+
+	}
+
+	return ret;
+}
+
+
+
+/**
+@brief	This function used for disconnect the socket and parameter is "s" which represent the socket number
+@return	1 for success else 0.
+*/ 
+void disconnect(SOCKET s)
+{
+#ifdef __DEF_IINCHIP_DBG__
+	printf("disconnect()\r\n");
+#endif
+	IINCHIP_WRITE(Sn_CR(s),Sn_CR_DISCON);
+
+	/* +20071122[chungs]:wait to process the command... */
+	while( IINCHIP_READ(Sn_CR(s)) ) 
+		;
+	/* ------- */
+}
+
+
+/**
+@brief	This function used to send the data in TCP mode
+@return	1 for success else 0.
+*/ 
+uint16 send(
+	SOCKET s, 		/**< the socket index */
+	const uint8 * buf, 	/**< a pointer to data */
+	uint16 len		/**< the data size to be send */
+	)
+{
+	uint8 status=0;
+	uint16 ret=0;
+	uint16 freesize=0;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("send()\r\n");
+#endif
+
+   if (len > getIINCHIP_TxMAX(s)) ret = getIINCHIP_TxMAX(s); // check size not to exceed MAX size.
+   else ret = len;
+
+   // if freebuf is available, start.
+	do 
+	{
+		freesize = getSn_TX_FSR(s);
+		status = IINCHIP_READ(Sn_SR(s));
+		if ((status != SOCK_ESTABLISHED) && (status != SOCK_CLOSE_WAIT))
+		{
+			ret = 0; 
+			break;
+		}
+#ifdef __DEF_IINCHIP_DBG__
+		printf("socket %d freesize(%d) empty or error\r\n", s, freesize);
+#endif
+	} while (freesize < ret);
+
+      // copy data
+	send_data_processing(s, (uint8 *)buf, ret);
+	IINCHIP_WRITE(Sn_CR(s),Sn_CR_SEND);
+
+	/* +20071122[chungs]:wait to process the command... */
+	while( IINCHIP_READ(Sn_CR(s)) ) 
+		;
+	/* ------- */
+
+/* +2008.01 bj */	
+#ifdef __DEF_IINCHIP_INT__
+	while ( (getISR(s) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) 
+#else
+	while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) 
+#endif
+	{
+		/* m2008.01 [bj] : reduce code */
+		if ( IINCHIP_READ(Sn_SR(s)) == SOCK_CLOSED )
+		{
+#ifdef __DEF_IINCHIP_DBG__
+			printf("SOCK_CLOSED.\r\n");
+#endif
+			close(s);
+			return 0;
+		}
+  	}
+/* +2008.01 bj */	
+#ifdef __DEF_IINCHIP_INT__
+  	putISR(s, getISR(s) & (~Sn_IR_SEND_OK));
+#else
+	IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK);
+#endif
+  	return ret;
+}
+
+
+/**
+@brief	This function is an application I/F function which is used to receive the data in TCP mode.
+		It continues to wait for data as much as the application wants to receive.
+		
+@return	received data size for success else -1.
+*/ 
+uint16 recv(
+	SOCKET s, 	/**< socket index */
+	uint8 * buf, 	/**< a pointer to copy the data to be received */
+	uint16 len	/**< the data size to be read */
+	)
+{
+	uint16 ret=0;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("recv()\r\n");
+#endif
+
+
+	if ( len > 0 )
+	{
+		recv_data_processing(s, buf, len);
+		IINCHIP_WRITE(Sn_CR(s),Sn_CR_RECV);
+
+		/* +20071122[chungs]:wait to process the command... */
+		while( IINCHIP_READ(Sn_CR(s)) ) 
+			;
+		/* ------- */
+		ret = len;
+	}
+	return ret;
+}
+
+
+/**
+@brief	This function is an application I/F function which is used to send the data for other then TCP mode. 
+		Unlike TCP transmission, The peer's destination address and the port is needed.
+		
+@return	This function return send data size for success else -1.
+*/ 
+uint16 sendto(
+	SOCKET s, 		/**< socket index */
+	const uint8 * buf, 	/**< a pointer to the data */
+	uint16 len, 		/**< the data size to send */
+	uint8 * addr, 		/**< the peer's Destination IP address */
+	uint16 port		/**< the peer's destination port number */
+	)
+{
+//	uint8 status=0;
+//	uint8 isr=0;
+	uint16 ret=0;
+	
+#ifdef __DEF_IINCHIP_DBG__
+	printf("sendto()\r\n");
+#endif
+   if (len > getIINCHIP_TxMAX(s)) ret = getIINCHIP_TxMAX(s); // check size not to exceed MAX size.
+   else ret = len;
+
+	if
+		(
+		 	((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) && (addr[3] == 0x00)) ||
+		 	((port == 0x00)) ||(ret == 0)
+		) 
+ 	{
+ 	   /* +2008.01 [bj] : added return value */
+ 	   ret = 0;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("%d Fail[%.2x.%.2x.%.2x.%.2x, %.d, %d]\r\n",s, addr[0], addr[1], addr[2], addr[3] , port, len);
+	printf("Fail[invalid ip,port]\r\n");
+#endif
+	}
+	else
+	{
+		IINCHIP_WRITE(Sn_DIPR0(s),addr[0]);
+		IINCHIP_WRITE((Sn_DIPR0(s) + 1),addr[1]);
+		IINCHIP_WRITE((Sn_DIPR0(s) + 2),addr[2]);
+		IINCHIP_WRITE((Sn_DIPR0(s) + 3),addr[3]);
+		IINCHIP_WRITE(Sn_DPORT0(s),(uint8)((port & 0xff00) >> 8));
+		IINCHIP_WRITE((Sn_DPORT0(s) + 1),(uint8)(port & 0x00ff));
+
+  		// copy data
+  		send_data_processing(s, (uint8 *)buf, ret);
+		IINCHIP_WRITE(Sn_CR(s),Sn_CR_SEND);
+
+		/* +20071122[chungs]:wait to process the command... */
+		while( IINCHIP_READ(Sn_CR(s)) ) 
+			;
+		/* ------- */
+		
+/* +2008.01 bj */	
+#ifdef __DEF_IINCHIP_INT__
+   	while ( (getISR(s) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) 
+#else
+	   while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) 
+#endif
+		{
+#ifdef __DEF_IINCHIP_INT__
+      	if (getISR(s) & Sn_IR_TIMEOUT)
+#else
+	      if (IINCHIP_READ(Sn_IR(s)) & Sn_IR_TIMEOUT)
+#endif
+			{
+#ifdef __DEF_IINCHIP_DBG__
+				printf("send fail.\r\n");
+#endif
+/* +2008.01 [bj]: clear interrupt */
+#ifdef __DEF_IINCHIP_INT__
+         	putISR(s, getISR(s) & ~(Sn_IR_SEND_OK | Sn_IR_TIMEOUT));  /* clear SEND_OK & TIMEOUT */
+#else
+         	IINCHIP_WRITE(Sn_IR(s), (Sn_IR_SEND_OK | Sn_IR_TIMEOUT)); /* clear SEND_OK & TIMEOUT */
+#endif
+			return 0;
+			}
+		}
+
+/* +2008.01 bj */	
+#ifdef __DEF_IINCHIP_INT__
+     	putISR(s, getISR(s) & (~Sn_IR_SEND_OK));
+#else
+	   IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK);
+#endif
+
+	}
+	return ret;
+}
+
+
+/**
+@brief	This function is an application I/F function which is used to receive the data in other then
+	TCP mode. This function is used to receive UDP, IP_RAW and MAC_RAW mode, and handle the header as well. 
+	
+@return	This function return received data size for success else -1.
+*/ 
+uint16 recvfrom(
+	SOCKET s, 	/**< the socket number */
+	uint8 * buf, 	/**< a pointer to copy the data to be received */
+	uint16 len, 	/**< the data size to read */
+	uint8 * addr, 	/**< a pointer to store the peer's IP address */
+	uint16 *port	/**< a pointer to store the peer's port number. */
+	)
+{
+	uint8 head[8];
+	uint16 data_len=0;
+	uint16 ptr=0;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("recvfrom()\r\n");
+#endif
+
+	if ( len > 0 )
+	{
+   	ptr = IINCHIP_READ(Sn_RX_RD0(s));
+   	ptr = ((ptr & 0x00ff) << 8) + IINCHIP_READ(Sn_RX_RD0(s) + 1);
+#ifdef __DEF_IINCHIP_DBG__
+   	printf("ISR_RX: rd_ptr : %.4x\r\n", ptr);
+#endif
+   	switch (IINCHIP_READ(Sn_MR(s)) & 0x07)
+   	{
+   	case Sn_MR_UDP :
+   			read_data(s, (uint8 *)ptr, head, 0x08);
+   			ptr += 8;
+   			// read peer's IP address, port number.
+    			addr[0] = head[0];
+   			addr[1] = head[1];
+   			addr[2] = head[2];
+   			addr[3] = head[3];
+   			*port = head[4];
+   			*port = (*port << 8) + head[5];
+   			data_len = head[6];
+   			data_len = (data_len << 8) + head[7];
+   			
+#ifdef __DEF_IINCHIP_DBG__
+   			printf("UDP msg arrived\r\n");
+   			printf("source Port : %d\r\n", *port);
+   			printf("source IP : %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]);
+#endif
+
+			read_data(s, (uint8 *)ptr, buf, data_len); // data copy.
+			ptr += data_len;
+
+			IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8));
+			IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff));
+   			break;
+   
+   	case Sn_MR_IPRAW :
+   			read_data(s, (uint8 *)ptr, head, 0x06);
+   			ptr += 6;
+   
+   			addr[0] = head[0];
+   			addr[1] = head[1];
+   			addr[2] = head[2];
+   			addr[3] = head[3];
+   			data_len = head[4];
+   			data_len = (data_len << 8) + head[5];
+   	
+#ifdef __DEF_IINCHIP_DBG__
+   			printf("IP RAW msg arrived\r\n");
+   			printf("source IP : %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]);
+#endif
+			read_data(s, (uint8 *)ptr, buf, data_len); // data copy.
+			ptr += data_len;
+
+			IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8));
+			IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff));
+   			break;
+   	case Sn_MR_MACRAW :
+   			read_data(s,(uint8*)ptr,head,2);
+   			ptr+=2;
+   			data_len = head[0];
+   			data_len = (data_len<<8) + head[1] - 2;
+
+   			read_data(s,(uint8*) ptr,buf,data_len);
+   			ptr += data_len;
+   			IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8));
+   			IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff));
+   			
+#ifdef __DEF_IINCHIP_DGB__
+			printf("MAC RAW msg arrived\r\n");
+			printf("dest mac=%.2X.%.2X.%.2X.%.2X.%.2X.%.2X\r\n",buf[0],buf[1],buf[2],buf[3],buf[4],buf[5]);
+			printf("src  mac=%.2X.%.2X.%.2X.%.2X.%.2X.%.2X\r\n",buf[6],buf[7],buf[8],buf[9],buf[10],buf[11]);
+			printf("type    =%.2X%.2X\r\n",buf[12],buf[13]); 
+#endif			
+			break;
+
+   	default :
+   			break;
+   	}
+		IINCHIP_WRITE(Sn_CR(s),Sn_CR_RECV);
+
+		/* +20071122[chungs]:wait to process the command... */
+		while( IINCHIP_READ(Sn_CR(s)) ) 
+			;
+		/* ------- */
+	}
+#ifdef __DEF_IINCHIP_DBG__
+	printf("recvfrom() end ..\r\n");
+#endif
+ 	return data_len;
+}
+
+
+uint16 igmpsend(SOCKET s, const uint8 * buf, uint16 len)
+{
+	uint8 status=0;
+//	uint8 isr=0;
+	uint16 ret=0;
+	
+#ifdef __DEF_IINCHIP_DBG__
+	printf("igmpsend()\r\n");
+#endif
+   if (len > getIINCHIP_TxMAX(s)) ret = getIINCHIP_TxMAX(s); // check size not to exceed MAX size.
+   else ret = len;
+
+	if	(ret == 0) 
+ 	{
+ 	   ;
+#ifdef __DEF_IINCHIP_DBG__
+	printf("%d Fail[%d]\r\n",len);
+#endif
+	}
+	else
+	{
+		// copy data
+		send_data_processing(s, (uint8 *)buf, ret);
+		IINCHIP_WRITE(Sn_CR(s),Sn_CR_SEND);
+/* +2008.01 bj */	
+		while( IINCHIP_READ(Sn_CR(s)) ) 
+			;
+/* ------- */
+		
+/* +2008.01 bj */	
+#ifdef __DEF_IINCHIP_INT__
+   	while ( (getISR(s) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) 
+#else
+	   while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) 
+#endif
+		{
+			status = IINCHIP_READ(Sn_SR(s));
+#ifdef __DEF_IINCHIP_INT__
+      	if (getISR(s) & Sn_IR_TIMEOUT)
+#else
+	      if (IINCHIP_READ(Sn_IR(s)) & Sn_IR_TIMEOUT)
+#endif
+			{
+#ifdef __DEF_IINCHIP_DBG__
+				printf("igmpsend fail.\r\n");
+#endif
+			   /* in case of igmp, if send fails, then socket closed */
+			   /* if you want change, remove this code. */
+			   close(s);
+			   /* ----- */
+			   
+				return 0;
+			}
+		}
+
+/* +2008.01 bj */	
+#ifdef __DEF_IINCHIP_INT__
+     	putISR(s, getISR(s) & (~Sn_IR_SEND_OK));
+#else
+	   IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK);
+#endif
+   }
+	return ret;
+}
+

arduino-0018-linux/libraries/Ethernet/utility/socket.h

@@ -0,0 +1,23 @@
+/*
+*
+@file		socket.h
+@brief	define function of socket API 
+*
+*/
+
+#ifndef	_SOCKET_H_
+#define	_SOCKET_H_
+
+extern uint8 socket(SOCKET s, uint8 protocol, uint16 port, uint8 flag); // Opens a socket(TCP or UDP or IP_RAW mode)
+extern void close(SOCKET s); // Close socket
+extern uint8 connect(SOCKET s, uint8 * addr, uint16 port); // Establish TCP connection (Active connection)
+extern void disconnect(SOCKET s); // disconnect the connection
+extern uint8 listen(SOCKET s);	// Establish TCP connection (Passive connection)
+extern uint16 send(SOCKET s, const uint8 * buf, uint16 len); // Send data (TCP)
+extern uint16 recv(SOCKET s, uint8 * buf, uint16 len);	// Receive data (TCP)
+extern uint16 sendto(SOCKET s, const uint8 * buf, uint16 len, uint8 * addr, uint16 port); // Send data (UDP/IP RAW)
+extern uint16 recvfrom(SOCKET s, uint8 * buf, uint16 len, uint8 * addr, uint16  *port); // Receive data (UDP/IP RAW)
+
+extern uint16 igmpsend(SOCKET s, const uint8 * buf, uint16 len);
+#endif
+/* _SOCKET_H_ */

arduino-0018-linux/libraries/Ethernet/utility/spi.h

@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+//AVR Mega168 SPI HAL
+#define BIT0							0x01
+#define BIT1							0x02
+#define BIT2							0x04
+#define BIT3							0x08
+#define BIT4							0x10
+#define BIT5							0x20
+#define BIT6							0x40
+#define BIT7							0x80
+
+#define SPI0_SS_BIT						BIT2
+#define SPI0_SS_DDR						DDRB
+#define SPI0_SS_PORT					PORTB
+
+#define SPI0_SCLK_BIT					BIT5
+#define SPI0_SCLK_DDR					DDRB
+#define SPI0_SCLK_PORT					PORTB
+
+#define	SPI0_MOSI_BIT					BIT3
+#define SPI0_MOSI_DDR					DDRB
+#define SPI0_MOSI_PORT					PORTB
+
+#define	SPI0_MISO_BIT					BIT4
+#define SPI0_MISO_DDR					DDRB
+#define SPI0_MISO_PORT					PORTB
+
+
+#define SPI0_WaitForReceive()				
+#define SPI0_RxData()	 				(SPDR)
+
+#define SPI0_TxData(Data)				(SPDR = Data)
+#define SPI0_WaitForSend()				while( (SPSR & 0x80)==0x00 )
+
+#define SPI0_SendByte(Data)				SPI0_TxData(Data);SPI0_WaitForSend()
+#define SPI0_RecvBute()					SPI0_RxData()
+
+// PB4(MISO), PB3(MOSI), PB5(SCK), PB2(/SS)         // CS=1, waiting for SPI start // SPI mode 0, 4MHz
+#define SPI0_Init()						DDRB  |= SPI0_SS_BIT|SPI0_SCLK_BIT|SPI0_MOSI_BIT;\
+										PORTB |= SPI0_SS_BIT; PORTB &= ~(SPI0_SCLK_BIT|SPI0_MOSI_BIT);\
+										SPCR  = 0x50  
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+//IInChip SPI HAL
+#define IINCHIP_SpiInit					SPI0_Init
+#define IINCHIP_SpiSendData				SPI0_SendByte	
+#define IINCHIP_SpiRecvData				SPI0_RxData
+
+
+#define IINCHIP_CS_BIT					BIT2
+#define IINCHIP_CS_DDR					DDRB
+#define IINCHIP_CS_PORT					PORTB
+
+#define IINCHIP_CSInit()					(IINCHIP_CS_DDR |= IINCHIP_CS_BIT)
+#define IINCHIP_CSon()					(IINCHIP_CS_PORT |= IINCHIP_CS_BIT)
+#define IINCHIP_CSoff()					(IINCHIP_CS_PORT &= ~IINCHIP_CS_BIT)
+//-----------------------------------------------------------------------------

arduino-0018-linux/libraries/Ethernet/utility/types.h

@@ -0,0 +1,165 @@
+/*
+*
+@file		type.h
+*
+*/
+
+#ifndef _TYPE_H_
+#define _TYPE_H_
+
+
+/***************************************************
+ * attribute for mcu ( types, ... ) 
+ ***************************************************/
+//#include "mcu_define.h"
+#define __MCU_AVR__	1
+#define __MCU_TYPE__	__MCU_AVR__
+
+//---- Refer "Rom File Maker Manual Vx.x.pdf"
+#include <avr/pgmspace.h>
+
+#define	_ENDIAN_LITTLE_	0	/**<  This must be defined if system is little-endian alignment */
+#define	_ENDIAN_BIG_		1
+#define 	SYSTEM_ENDIAN		_ENDIAN_LITTLE_
+
+#define	MAX_SOCK_NUM		4	/**< Maxmium number of socket  */
+#define	CLK_CPU			F_CPU		/**< 8Mhz(for serial) */
+
+/* ## __DEF_IINCHIP_xxx__ : define option for iinchip driver *****************/
+//#define __DEF_IINCHIP_DBG__ /* involve debug code in driver (socket.c) */
+//#define __DEF_IINCHIP_INT__ /**< involve interrupt service routine (socket.c) */
+//#define __DEF_IINCHIP_PPP__ /* involve pppoe routine (socket.c) */
+                            /* If it is defined, the source files(md5.h,md5.c) must be included in your project.
+                               Otherwize, the source files must be removed in your project. */
+
+#define __DEF_IINCHIP_DIRECT_MODE__ 1
+#define __DEF_IINCHIP_INDIRECT_MODE__ 2
+#define __DEF_IINCHIP_SPI_MODE__ 3
+
+//#define __DEF_IINCHIP_BUS__ __DEF_IINCHIP_DIRECT_MODE__
+//#define __DEF_IINCHIP_BUS__ __DEF_IINCHIP_INDIRECT_MODE__
+#define __DEF_IINCHIP_BUS__ __DEF_IINCHIP_SPI_MODE__ /*Enable SPI_mode*/
+
+
+/**
+@brief	 __DEF_IINCHIP_MAP_xxx__ : define memory map for iinchip 
+*/
+#define __DEF_IINCHIP_MAP_BASE__ 0x8000
+#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__)
+ #define COMMON_BASE __DEF_IINCHIP_MAP_BASE__
+#else
+ #define COMMON_BASE 0x0000
+#endif
+#define __DEF_IINCHIP_MAP_TXBUF__ (COMMON_BASE + 0x4000) /* Internal Tx buffer address of the iinchip */
+#define __DEF_IINCHIP_MAP_RXBUF__ (COMMON_BASE + 0x6000) /* Internal Rx buffer address of the iinchip */
+
+
+#if (__MCU_TYPE__ == __MCU_AVR__)
+   #ifdef __DEF_IINCHIP_INT__
+      // iinchip use external interrupt 4
+      #define IINCHIP_ISR_DISABLE()	(EIMSK &= ~(0x10))
+      #define IINCHIP_ISR_ENABLE()	(EIMSK |= 0x10)
+      #define IINCHIP_ISR_GET(X)		(X = EIMSK)
+      #define IINCHIP_ISR_SET(X)		(EIMSK = X)
+   #else
+      #define IINCHIP_ISR_DISABLE()
+      #define IINCHIP_ISR_ENABLE()	
+      #define IINCHIP_ISR_GET(X)
+      #define IINCHIP_ISR_SET(X)
+   #endif
+#else
+#error "unknown MCU type"
+#endif
+
+#ifndef NULL
+#define NULL		((void *) 0)
+#endif
+
+//typedef enum { false, true } bool;
+
+#ifndef _SIZE_T
+#define _SIZE_T
+typedef unsigned int size_t;
+#endif
+
+/**
+ * The 8-bit signed data type.
+ */
+typedef char int8;
+/**
+ * The volatile 8-bit signed data type.
+ */
+typedef volatile char vint8;
+/**
+ * The 8-bit unsigned data type.
+ */
+typedef unsigned char uint8;
+/**
+ * The volatile 8-bit unsigned data type.
+ */
+typedef volatile unsigned char vuint8;
+
+/**
+ * The 16-bit signed data type.
+ */
+typedef int int16;
+/**
+ * The volatile 16-bit signed data type.
+ */
+typedef volatile int vint16;
+/**
+ * The 16-bit unsigned data type.
+ */
+typedef unsigned int uint16;
+/**
+ * The volatile 16-bit unsigned data type.
+ */
+typedef volatile unsigned int vuint16;
+/**
+ * The 32-bit signed data type.
+ */
+typedef long int32;
+/**
+ * The volatile 32-bit signed data type.
+ */
+typedef volatile long vint32;
+/**
+ * The 32-bit unsigned data type.
+ */
+typedef unsigned long uint32;
+/**
+ * The volatile 32-bit unsigned data type.
+ */
+typedef volatile unsigned long vuint32;
+
+/* bsd */
+typedef uint8			u_char;		/**< 8-bit value */
+typedef uint8 			SOCKET;
+typedef uint16			u_short;	/**< 16-bit value */
+typedef uint16			u_int;		/**< 16-bit value */
+typedef uint32			u_long;		/**< 32-bit value */
+
+typedef union _un_l2cval {
+	u_long	lVal;
+	u_char	cVal[4];
+}un_l2cval;
+
+typedef union _un_i2cval {
+	u_int	iVal;
+	u_char	cVal[2];
+}un_i2cval;
+
+
+/** global define */
+#define FW_VERSION		0x01010000	/* System F/W Version : 1.1.0.0	*/
+#define HW_VERSION	       0x01000000
+
+
+#define TX_RX_MAX_BUF_SIZE	2048
+#define TX_BUF	0x1100
+#define RX_BUF	(TX_BUF+TX_RX_MAX_BUF_SIZE)
+
+#define UART_DEVICE_CNT		1	/**< UART device number */
+/* #define SUPPORT_UART_ONE */
+
+#endif		/* _TYPE_H_ */

arduino-0018-linux/libraries/Ethernet/utility/w5100.h

@@ -0,0 +1,299 @@
+/*
+@file		w5100.h
+*/
+
+#ifndef	_W5100_H_
+#define	_W5100_H_
+
+
+#define MR __DEF_IINCHIP_MAP_BASE__
+#define IDM_OR ((__DEF_IINCHIP_MAP_BASE__ + 0x00))
+#define IDM_AR0 ((__DEF_IINCHIP_MAP_BASE__ + 0x01))
+#define IDM_AR1 ((__DEF_IINCHIP_MAP_BASE__ + 0x02))
+#define IDM_DR ((__DEF_IINCHIP_MAP_BASE__ + 0x03))
+
+
+/**
+ @brief Gateway IP Register address
+ */
+#define GAR0				(COMMON_BASE + 0x0001)
+/**
+ @brief Subnet mask Register address
+ */
+#define SUBR0			(COMMON_BASE + 0x0005)
+/**
+ @brief Source MAC Register address
+ */
+#define SHAR0				(COMMON_BASE + 0x0009)
+/**
+ @brief Source IP Register address
+ */
+#define SIPR0				(COMMON_BASE + 0x000F)
+/**
+ @brief Interrupt Register
+ */
+#define IR					(COMMON_BASE + 0x0015)
+/**
+ @brief Interrupt mask register
+ */
+#define IMR					(COMMON_BASE + 0x0016)
+/**
+ @brief Timeout register address( 1 is 100us )
+ */
+#define RTR0				(COMMON_BASE + 0x0017)
+/**
+ @brief Retry count reigster
+ */
+#define RCR						(COMMON_BASE + 0x0019)
+/**
+ @brief Receive memory size reigster
+ */
+#define RMSR			(COMMON_BASE + 0x001A)
+/**
+ @brief Transmit memory size reigster
+ */
+#define TMSR			(COMMON_BASE + 0x001B)
+/**
+ @brief Authentication type register address in PPPoE mode
+ */
+#define PATR0					(COMMON_BASE + 0x001C)
+//#define PPPALGO (COMMON_BASE + 0x001D)
+#define PTIMER (COMMON_BASE + 0x0028)
+#define PMAGIC (COMMON_BASE + 0x0029)
+
+/**
+ @brief Unreachable IP register address in UDP mode
+ */
+#define UIPR0				(COMMON_BASE + 0x002A)
+/**
+ @brief Unreachable Port register address in UDP mode
+ */
+#define UPORT0			(COMMON_BASE + 0x002E)
+
+/**
+ @brief socket register
+*/
+#define CH_BASE (COMMON_BASE + 0x0400)
+/**
+ @brief	size of each channel register map
+ */
+#define CH_SIZE		0x0100
+/**
+ @brief socket Mode register
+ */
+#define Sn_MR(ch)		(CH_BASE + ch * CH_SIZE + 0x0000)
+/**
+ @brief channel Sn_CR register
+ */
+#define Sn_CR(ch)				(CH_BASE + ch * CH_SIZE + 0x0001)
+/**
+ @brief channel interrupt register
+ */
+#define Sn_IR(ch)			(CH_BASE + ch * CH_SIZE + 0x0002)
+/**
+ @brief channel status register
+ */
+#define Sn_SR(ch)			(CH_BASE + ch * CH_SIZE + 0x0003)
+/**
+ @brief source port register
+ */
+#define Sn_PORT0(ch)		(CH_BASE + ch * CH_SIZE + 0x0004)
+/**
+ @brief Peer MAC register address
+ */
+#define Sn_DHAR0(ch)			(CH_BASE + ch * CH_SIZE + 0x0006)
+/**
+ @brief Peer IP register address
+ */
+#define Sn_DIPR0(ch)			(CH_BASE + ch * CH_SIZE + 0x000C)
+/**
+ @brief Peer port register address
+ */
+#define Sn_DPORT0(ch)		(CH_BASE + ch * CH_SIZE + 0x0010)
+/**
+ @brief Maximum Segment Size(Sn_MSSR0) register address
+ */
+#define Sn_MSSR0(ch)					(CH_BASE + ch * CH_SIZE + 0x0012)
+/**
+ @brief Protocol of IP Header field register in IP raw mode
+ */
+#define Sn_PROTO(ch)			(CH_BASE + ch * CH_SIZE + 0x0014)
+
+/** 
+ @brief IP Type of Service(TOS) Register 
+ */
+#define Sn_TOS(ch)						(CH_BASE + ch * CH_SIZE + 0x0015)
+/**
+ @brief IP Time to live(TTL) Register 
+ */
+#define Sn_TTL(ch)						(CH_BASE + ch * CH_SIZE + 0x0016)
+
+/**
+ @brief Transmit free memory size register
+ */
+#define Sn_TX_FSR0(ch)	(CH_BASE + ch * CH_SIZE + 0x0020)
+/**
+ @brief Transmit memory read pointer register address
+ */
+#define Sn_TX_RD0(ch)			(CH_BASE + ch * CH_SIZE + 0x0022)
+/**
+ @brief Transmit memory write pointer register address
+ */
+#define Sn_TX_WR0(ch)			(CH_BASE + ch * CH_SIZE + 0x0024)
+/**
+ @brief Received data size register
+ */
+#define Sn_RX_RSR0(ch)	(CH_BASE + ch * CH_SIZE + 0x0026)
+/**
+ @brief Read point of Receive memory
+ */
+#define Sn_RX_RD0(ch)			(CH_BASE + ch * CH_SIZE + 0x0028)
+/**
+ @brief Write point of Receive memory
+ */
+#define Sn_RX_WR0(ch)			(CH_BASE + ch * CH_SIZE + 0x002A)
+
+
+
+/* MODE register values */
+#define MR_RST			0x80 /**< reset */
+#define MR_PB			0x10 /**< ping block */
+#define MR_PPPOE		0x08 /**< enable pppoe */
+#define MR_LB  		0x04 /**< little or big endian selector in indirect mode */
+#define MR_AI			0x02 /**< auto-increment in indirect mode */
+#define MR_IND			0x01 /**< enable indirect mode */
+
+/* IR register values */
+#define IR_CONFLICT	0x80 /**< check ip confict */
+#define IR_UNREACH	0x40 /**< get the destination unreachable message in UDP sending */
+#define IR_PPPoE		0x20 /**< get the PPPoE close message */
+#define IR_SOCK(ch)	(0x01 << ch) /**< check socket interrupt */
+
+/* Sn_MR values */
+#define Sn_MR_CLOSE		0x00		/**< unused socket */
+#define Sn_MR_TCP		0x01		/**< TCP */
+#define Sn_MR_UDP		0x02		/**< UDP */
+#define Sn_MR_IPRAW	0x03		/**< IP LAYER RAW SOCK */
+#define Sn_MR_MACRAW	0x04		/**< MAC LAYER RAW SOCK */
+#define Sn_MR_PPPOE		0x05		/**< PPPoE */
+#define Sn_MR_ND		0x20		/**< No Delayed Ack(TCP) flag */
+#define Sn_MR_MULTI		0x80		/**< support multicating */
+
+
+/* Sn_CR values */
+#define Sn_CR_OPEN		0x01		/**< initialize or open socket */
+#define Sn_CR_LISTEN		0x02		/**< wait connection request in tcp mode(Server mode) */
+#define Sn_CR_CONNECT	0x04		/**< send connection request in tcp mode(Client mode) */
+#define Sn_CR_DISCON		0x08		/**< send closing reqeuset in tcp mode */
+#define Sn_CR_CLOSE		0x10		/**< close socket */
+#define Sn_CR_SEND		0x20		/**< updata txbuf pointer, send data */
+#define Sn_CR_SEND_MAC	0x21		/**< send data with MAC address, so without ARP process */
+#define Sn_CR_SEND_KEEP	0x22		/**<  send keep alive message */
+#define Sn_CR_RECV		0x40		/**< update rxbuf pointer, recv data */
+
+#ifdef __DEF_IINCHIP_PPP__
+	#define Sn_CR_PCON				0x23		 
+	#define Sn_CR_PDISCON			0x24		 
+	#define Sn_CR_PCR					0x25		 
+	#define Sn_CR_PCN					0x26		
+	#define Sn_CR_PCJ					0x27		
+#endif
+
+/* Sn_IR values */
+#ifdef __DEF_IINCHIP_PPP__
+	#define Sn_IR_PRECV			0x80		
+	#define Sn_IR_PFAIL			0x40		
+	#define Sn_IR_PNEXT			0x20		
+#endif
+#define Sn_IR_SEND_OK			0x10		/**< complete sending */
+#define Sn_IR_TIMEOUT			0x08		/**< assert timeout */
+#define Sn_IR_RECV				0x04		/**< receiving data */
+#define Sn_IR_DISCON				0x02		/**< closed socket */
+#define Sn_IR_CON					0x01		/**< established connection */
+
+/* Sn_SR values */
+#define SOCK_CLOSED				0x00		/**< closed */
+#define SOCK_INIT 				0x13		/**< init state */
+#define SOCK_LISTEN				0x14		/**< listen state */
+#define SOCK_SYNSENT	   		0x15		/**< connection state */
+#define SOCK_SYNRECV		   	0x16		/**< connection state */
+#define SOCK_ESTABLISHED		0x17		/**< success to connect */
+#define SOCK_FIN_WAIT			0x18		/**< closing state */
+#define SOCK_CLOSING		   	0x1A		/**< closing state */
+#define SOCK_TIME_WAIT			0x1B		/**< closing state */
+#define SOCK_CLOSE_WAIT			0x1C		/**< closing state */
+#define SOCK_LAST_ACK			0x1D		/**< closing state */
+#define SOCK_UDP				   0x22		/**< udp socket */
+#define SOCK_IPRAW			   0x32		/**< ip raw mode socket */
+#define SOCK_MACRAW			   0x42		/**< mac raw mode socket */
+#define SOCK_PPPOE				0x5F		/**< pppoe socket */
+
+/* IP PROTOCOL */
+#define IPPROTO_IP              0           /**< Dummy for IP */
+#define IPPROTO_ICMP            1           /**< Control message protocol */
+#define IPPROTO_IGMP            2           /**< Internet group management protocol */
+#define IPPROTO_GGP             3           /**< Gateway^2 (deprecated) */
+#define IPPROTO_TCP             6           /**< TCP */
+#define IPPROTO_PUP             12          /**< PUP */
+#define IPPROTO_UDP             17          /**< UDP */
+#define IPPROTO_IDP             22          /**< XNS idp */
+#define IPPROTO_ND              77          /**< UNOFFICIAL net disk protocol */
+#define IPPROTO_RAW             255         /**< Raw IP packet */
+
+
+/*********************************************************
+* iinchip access function
+*********************************************************/
+extern uint8 IINCHIP_READ(uint16 addr);
+extern uint8 IINCHIP_WRITE(uint16 addr,uint8 data);
+extern uint16 wiz_read_buf(uint16 addr, uint8* buf,uint16 len);
+extern uint16 wiz_write_buf(uint16 addr,uint8* buf,uint16 len);
+
+extern void iinchip_init(void); // reset iinchip
+extern void sysinit(uint8 tx_size, uint8 rx_size); // setting tx/rx buf size
+extern uint8 getISR(uint8 s);
+extern void putISR(uint8 s, uint8 val);
+extern uint16 getIINCHIP_RxMAX(uint8 s);
+extern uint16 getIINCHIP_TxMAX(uint8 s);
+extern uint16 getIINCHIP_RxMASK(uint8 s);
+extern uint16 getIINCHIP_TxMASK(uint8 s);
+extern uint16 getIINCHIP_RxBASE(uint8 s);
+extern uint16 getIINCHIP_TxBASE(uint8 s);
+extern void setGAR(uint8 * addr); // set gateway address
+extern void setSUBR(uint8 * addr); // set subnet mask address
+extern void setSHAR(uint8 * addr); // set local MAC address
+extern void setSIPR(uint8 * addr); // set local IP address
+extern void setRTR(uint16 timeout); // set retry duration for data transmission, connection, closing ...
+extern void setRCR(uint8 retry); // set retry count (above the value, assert timeout interrupt)
+extern void setIMR(uint8 mask); // set interrupt mask. 
+extern void getGAR(uint8 * addr);
+extern void getSUBR(uint8 * addr);
+extern void getSHAR(uint8 * addr);
+extern void getSIPR(uint8 * addr);
+extern uint8 getIR( void );
+extern void setSn_MSS(SOCKET s, uint16 Sn_MSSR0); // set maximum segment size
+extern void setSn_PROTO(SOCKET s, uint8 proto); // set IP Protocol value using IP-Raw mode
+extern uint8 getSn_IR(SOCKET s); // get socket interrupt status
+extern uint8 getSn_SR(SOCKET s); // get socket status
+extern uint16 getSn_TX_FSR(SOCKET s); // get socket TX free buf size
+extern uint16 getSn_RX_RSR(SOCKET s); // get socket RX recv buf size
+extern void setSn_DHAR(SOCKET s, uint8 * addr);
+extern void setSn_DIPR(SOCKET s, uint8 * addr);
+extern void setSn_DPORT(SOCKET s, uint8 * addr);
+extern void getSn_DHAR(SOCKET s, uint8 * addr);
+extern void getSn_DIPR(SOCKET s, uint8 * addr);
+extern void getSn_DPORT(SOCKET s, uint8 * addr);
+extern void setSn_TTL(SOCKET s, uint8 ttl);
+extern void setMR(uint8 val);
+
+#ifdef __DEF_IINCHIP_PPP__
+extern uint8 pppinit(uint8 *id, uint8 idlen, uint8 *passwd, uint8 passwdlen);
+extern uint8 pppterm(uint8 *mac,uint8 *sessionid);
+#endif
+
+extern void send_data_processing(SOCKET s, uint8 *data, uint16 len);
+extern void recv_data_processing(SOCKET s, uint8 *data, uint16 len);
+extern void read_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len);
+extern void write_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len);
+
+#endif