diff --git a/branches/follower/libw5100/LICENSE.txt b/branches/follower/libw5100/LICENSE.txt new file mode 100644 index 0000000..5193721 --- /dev/null +++ b/branches/follower/libw5100/LICENSE.txt @@ -0,0 +1,4 @@ +The original license of the WIZnet supplied vendor code is unknown. + +The modifications and additions are licensed under the LGPL version 2 or later. + diff --git a/branches/follower/libw5100/README.txt b/branches/follower/libw5100/README.txt new file mode 100644 index 0000000..9834442 --- /dev/null +++ b/branches/follower/libw5100/README.txt @@ -0,0 +1,44 @@ + +WIZnet W5100 / WIZ810MJ Hardwired TCP/IP Ethernet Chip/Module Driver for Arduino +================================================================================ + +For more information see: + + + +Based on the W5100 driver from WIZnet. + + +Installation and Building +------------------------- + +Arduino will compile the library automatically if you put the correct +files in the library directory of the Arduino application. + +If you are installing this library you should put the files +from the directory named 'src/libw5100/' in the Arduino library directory. +It will be compiled automatically within the IDE. + +For Arduino version 0010 the library directory location is: + + /hardware/libraries/ + +For Ardino version 0009 the library directory location was: + + /lib/targets/libraries/ + +If you want to compile the library manually you can use the following: + + avr-gcc -mmcu=atmega168 -Wall -Os -fsigned-char -combine -c socket.c w5100.c -o wiz810mj.o + + avr-strip --strip-debug --strip-unneeded -X -x *.o + +Open a demo '.pde' to compile. + +From the original driver README +------------------------------- + +(You're almost certainly not going to need this.) + ++ How to Change the interface mode + Change the value of the __DEF_IINCHIP_BUS__ in the types.h file. diff --git a/branches/follower/libw5100/src/demo/irc_bot/irc_bot.pde b/branches/follower/libw5100/src/demo/irc_bot/irc_bot.pde new file mode 100644 index 0000000..d73320d --- /dev/null +++ b/branches/follower/libw5100/src/demo/irc_bot/irc_bot.pde @@ -0,0 +1,144 @@ +/* + + IRC Bot demonstration + + (May not function.) + +*/ + +#include "libw5100.h" + +#include "stream_connection.h" + +void setup() { + /* + Setup function required by Arduino + */ + + // Configure the network device + SpiConfiguration SPI = SpiConfiguration(); + SPI.begin(); + W5100Device W5100 = W5100Device(PIN_RESET); + NetworkInterface Network = NetworkInterface(W5100); + + // You need to customise these to your own environment + Network.device.setIp(210,55,77,111); + Network.device.setMask(255,255,255,128); + Network.device.setGateway(210,55,77,1); + + Serial.begin(9600); + + randomSeed(analogRead(0)); + + // Rough state-machine to log on and process messages + + // TODO: Implement DNS--This IP is irc.freenode.net + NetworkConnection conn = Network.connect(209,177,146,34, 6667); + + Serial.println("Waiting to connect..."); + + while (!conn.isConnected()) { + delay(500); + } + + Serial.println("Connected..."); + + int byteRead = -1; + int dataWait = 0; + + StreamConnection stream = StreamConnection(conn); + + // Change as needed + conn.print("NICK Arduino\n"); + conn.print("USER Arduino 0 0 Arduino\n"); + + byte buf[4] = {0, 0, 0, 0}; + + int state = 0; + + while (conn.isConnected()) { + + if (stream.peekByte() >= 0) { + // New line + if (stream.peekByte() != ':') { + // Skip local responses/messages entirely. TODO: Handle PINGs? + while (stream.skipSegment("\x0A\x0D") < 0) { + // Ummm, we ran outta data--this screws things up... + // TODO: Have a time out? + delay(500); + } + } else { + if (state == 0) { // We've just connected + // Skip sending servername // TODO: Check it's the main one? + while (stream.skipSegment(" ") < 0) { + // Ummm, we ran outta data--this screws things up... + // TODO: Have a time out? + delay(500); + } + + for (int idx=0; idx < 3; idx++) { + while (stream.peekByte() < 0) { // TODO: Time out? + delay(500); + } + buf[idx] = stream.readByte(); + } + + Serial.println((const char *) buf); + + if (strcmp((const char *) buf, "376") == 0) { // End MOTD + state=1; + conn.print("JOIN #arduino\n"); + } + } else if (state == 1) { // We've joined the channel, process messages. + // Skip sending servername // TODO: Check it's the main one? + while (stream.skipSegment(" ") < 0) { + // Ummm, we ran outta data--this screws things up... + // TODO: Have a time out? + delay(500); + } + + // Look for messages addressed to us in the channel + if (stream.gobbleMatch(" ", "PRIVMSG") > 0) { + Serial.println("Matched PRIV MSG"); + if (stream.gobbleMatch(" :", "#arduino") > 0) { // We treat the ":" as a separator too--does this break? + Serial.println("Matched #arduino"); + + // Check the message is to us... + if ((stream.peekByte() == 'A') && (stream.gobbleMatch(":", "Arduino") > 0)) { + Serial.println("Matched something"); + // Give them something for their trouble... + if (random(1,3)==1) { + conn.print("PRIVMSG #arduino :Maybe."); + } else if (random(1,3)==1) { + conn.print("PRIVMSG #arduino :Probably."); + } + } + } + + } else { + // No match + } + + } else { + // Just skip this line + while ((byteRead = stream.readSegmentByte("\x0A\x0D")) >=0) { + Serial.print(byteRead, BYTE); + } + Serial.println(""); + } + + while (stream.skipSegment("\x0A\x0D") < 0) { + // Ummm, we ran outta data--this screws things up... + // TODO: Have a time out? + delay(500); + } + } + } + } +} + +void loop() { + /* + Loop function required by Arduino + */ +} diff --git a/branches/follower/libw5100/src/demo/irc_bot/stream_connection.cpp b/branches/follower/libw5100/src/demo/irc_bot/stream_connection.cpp new file mode 100644 index 0000000..c053e88 --- /dev/null +++ b/branches/follower/libw5100/src/demo/irc_bot/stream_connection.cpp @@ -0,0 +1,137 @@ +/* + + Utility class to process data in a byte-wise manner without + requiring large memory buffers on the microcontroller. + +*/ + +#include "stream_connection.h" + +StreamConnection::StreamConnection(NetworkConnection& connection) : _connection (connection) { + /* + + Initialise our one character buffer for the last character + read to indicate no character is currently buffered. + + */ + _byteSeen = -1; +} + +int StreamConnection::peekByte() { + /* + + See what the next character will be without consuming it. + + */ + if (_byteSeen < 0) { + if (_connection.available()) { + _byteSeen = _connection.read(); + } + } + + return _byteSeen; +} + + +int StreamConnection::readByte() { + /* + + Read the next character, reffering to the buffer first if available, + consuming it in the process. + + */ + int newByte = -1; + + if (_byteSeen < 0) { + if (_connection.available()) { + newByte = _connection.read(); + } + } else { + newByte = _byteSeen; + _byteSeen = -1; + } + + return newByte; +} + + +int StreamConnection::readSegmentByte(const char * separators) { + /* + + Read bytes until we encounter a separator, which we don't consume. + + */ + // Blocks + while (peekByte() < 0) { // TODO: Time out? + delay(500); + } + if (!strchr(separators, peekByte())) { + return readByte(); + } + return -1; +} + + +int StreamConnection::skipSegment(const char * separators) { + /* + + Skip a segment between separators and the closing separators. + + This enables us to skip to the end of a line for example. + + */ + + do { + if (peekByte() < 0) { + return -1; + } + // Skip everything not a separator + } while (!strchr(separators, peekByte()) && readByte()); + + do { + /* // We can't return here or we get stuck above. + if (peekByte() < 0) { + return -1; + }*/ + while (peekByte() < 0) { + delay(500); // TODO: Time out? + } + // Skip everything that *is* a separator + } while (strchr(separators, peekByte()) && readByte()); + + return 1; +} + + +int StreamConnection::gobbleMatch(const char * separators, const char * target) { + /* + + See if the next characters match the target string, + consuming characters in the process. + + */ + + int idx = 0; + int byteRead = -1; + + while ((byteRead = readSegmentByte(separators)) >=0) { + if (idx < strlen(target)) { + if (byteRead != target[idx]) { + break; + } + idx++; + } else { + break; + } + } + + if ((byteRead == -1) && (idx == strlen(target))) { // Matched + while (skipSegment(separators) < 0) { + // Ummm, we ran outta data--this screws things up... + // TODO: Have a time out? + delay(500); + } + return 1; + } + return -1; +} diff --git a/branches/follower/libw5100/src/demo/irc_bot/stream_connection.h b/branches/follower/libw5100/src/demo/irc_bot/stream_connection.h new file mode 100644 index 0000000..f501a3d --- /dev/null +++ b/branches/follower/libw5100/src/demo/irc_bot/stream_connection.h @@ -0,0 +1,29 @@ +/* + + Utility class to process data in a byte-wise manner without + requiring large memory buffers on the microcontroller. + +*/ + +#ifndef _STREAM_CONNECTION_H_ +#define _STREAM_CONNECTION_H_ + +#include "libw5100.h" + +class StreamConnection { + + public: + StreamConnection(NetworkConnection& connection); + int peekByte(); + int readByte(); + int skipSegment(const char * separators); // TODO: Return if separators found or not? + int readSegmentByte(const char * separators); + int debug; + int gobbleMatch(const char * separators, const char * target); + + private: + NetworkConnection& _connection; + int _byteSeen; +}; + +#endif diff --git a/branches/follower/libw5100/src/demo/multi_conn_echo_server/echo_server.cpp b/branches/follower/libw5100/src/demo/multi_conn_echo_server/echo_server.cpp new file mode 100644 index 0000000..31f4f8e --- /dev/null +++ b/branches/follower/libw5100/src/demo/multi_conn_echo_server/echo_server.cpp @@ -0,0 +1,69 @@ +/* + + Simple state machine-based Echo Server. + + This could be used as the base for a more sophisticated server + that filtered the returned input, or altered state on the microcontroller + in response to the incoming data. + +*/ + +#include "libw5100.h" + +#include "echo_server.h" + +#define ECHO_CONNECT_WAIT 0 +#define ECHO_CONNECTED 1 +#define ECHO_CLOSE 2 +#define ECHO_HALT 3 + +EchoServer::EchoServer(int port) : _connection (NetworkConnection(port)) { + /* + + Create a listening echo server on the requested port. + + */ + + _state = ECHO_CONNECT_WAIT; + + _connection.listen(); // TODO: We should be using Network.listen(...) here and in initialisation list. +} + +void EchoServer::next() { + /* + + Process incoming data and return it to the sender. + + */ + + // TODO: Use better state machine implementation? + + if (_state == ECHO_CONNECT_WAIT) { + + if (_connection.isConnected()) { + _state = ECHO_CONNECTED; + } else { + // Keep waiting + } + + } else if (_state == ECHO_CONNECTED) { + + if (_connection.available()) { + _connection.print(_connection.read()); + } else if (!_connection.isConnected()) { + // Data finished and client disconnected + _state == ECHO_CLOSE; + } + + } else if (_state == ECHO_CLOSE) { + + _connection.close(); + _state = ECHO_HALT; + + } else if (_state == ECHO_HALT) { + // Do nothing + } else { + // Unknown state, do nothing. + } +} + diff --git a/branches/follower/libw5100/src/demo/multi_conn_echo_server/echo_server.h b/branches/follower/libw5100/src/demo/multi_conn_echo_server/echo_server.h new file mode 100644 index 0000000..222a941 --- /dev/null +++ b/branches/follower/libw5100/src/demo/multi_conn_echo_server/echo_server.h @@ -0,0 +1,21 @@ +/* + + Simple state machine-based Echo Server. + +*/ + +#ifndef _ECHO_SERVER_H_ +#define _ECHO_SERVER_H_ + +class EchoServer { + + public: + EchoServer(int port); + void next(); // TODO: Return something useful? + + private: + NetworkConnection _connection; // TODO: Make public? + int _state; +}; + +#endif diff --git a/branches/follower/libw5100/src/demo/multi_conn_echo_server/multi_conn_echo_server.pde b/branches/follower/libw5100/src/demo/multi_conn_echo_server/multi_conn_echo_server.pde new file mode 100644 index 0000000..17c0f54 --- /dev/null +++ b/branches/follower/libw5100/src/demo/multi_conn_echo_server/multi_conn_echo_server.pde @@ -0,0 +1,45 @@ +/* + + Multi-connection Echo Server demonstration. + + This demonstration currently only runs each server once. + +*/ + +#include "libw5100.h" + +#include "echo_server.h" + +void setup() { + /* + Setup function required by Arduino + */ + + // Configure the network device + SpiConfiguration SPI = SpiConfiguration(); + SPI.begin(); + W5100Device W5100 = W5100Device(PIN_RESET); + NetworkInterface Network = NetworkInterface(W5100); + + // You need to customise these to your own environment + Network.device.setIp(210,55,77,111); + Network.device.setMask(255,255,255,128); + Network.device.setGateway(210,55,77,1); + + // This uses the 1-argument constructor of EchoServer and supplies it with 7 for each instance. + EchoServer servers[MAX_SOCK_NUM] = {7, 7, 7, 7}; // This will break if MAX_SOCK_NUM changes. + + while (1) { + for (int i=0; i network proxy demonstration. + +*/ + +#include + +void setup() { + /* + Setup function required by Arduino + */ + + // Configure the network device + SpiConfiguration SPI = SpiConfiguration(); + SPI.begin(); + W5100Device W5100 = W5100Device(PIN_RESET); + NetworkInterface Network = NetworkInterface(W5100); + + // You need to customise these to your own environment + Network.device.setIp(210,55,77,111); + Network.device.setMask(255,255,255,128); + Network.device.setGateway(210,55,77,1); + + Serial.begin(9600); // Read the output in the Arduino serial monitor + + while (1) { + NetworkConnection conn = Network.listen(7); + + Serial.println("Waiting for client..."); + + while (!conn.isConnected()) { + delay(500); + } + + Serial.println("Connected..."); + + while (conn.isConnected()) { + if (conn.available()) { + Serial.print(conn.read(), BYTE); + } + + if (Serial.available()) { + conn.print(Serial.read()); + } + } + + conn.close(); + Serial.println("Connection closed."); + + } + +} + + +void loop() { + /* + Loop function required by Arduino + */ +} diff --git a/branches/follower/libw5100/src/demo/sketch_programmer/sketch_programmer.pde b/branches/follower/libw5100/src/demo/sketch_programmer/sketch_programmer.pde new file mode 100644 index 0000000..7d8ddc1 --- /dev/null +++ b/branches/follower/libw5100/src/demo/sketch_programmer/sketch_programmer.pde @@ -0,0 +1,68 @@ +/* + + Sketch uploader / programmer demonstration + + This demonstration requires a Bare Bones Freeduino or similar + Arduino-compatible board with an FTDI-USB cable connector. + + Connect the target board to the programmer connector on + the Netduino shield. + + Compile the sketch in Arduino as normal, press reset on the target + and then run the following command (on one line, + replace file names and IP): + + /hardware/tools/avr/bin/avrdude + -C /hardware/tools/avr/etc/avrdude.conf + -pm168 -cstk500v1 -Pnet:192.168.2.105:7 + -D -v -Uflash:w:/tmp/build31431.tmp/Blink_edit.hex:i + +*/ + +#include "libw5100.h" + +void setup() { + /* + Setup function required by Arduino + */ + + // Configure the network device + SpiConfiguration SPI = SpiConfiguration(); + SPI.begin(); + W5100Device W5100 = W5100Device(PIN_RESET); + NetworkInterface Network = NetworkInterface(W5100); + + // You need to customise these to your own environment + Network.device.setIp(210,55,77,111); + Network.device.setMask(255,255,255,128); + Network.device.setGateway(210,55,77,1); + + Serial.begin(19200); + + while (1) { + NetworkConnection conn = Network.listen(7); + + while (!conn.isConnected()) { + delay(500); + } + + while (conn.isConnected()) { + if (conn.available()) { + Serial.print(conn.read(), BYTE); + } + + if (Serial.available()) { + conn.print(Serial.read()); + } + } + + conn.close(); + } +} + + +void loop() { + /* + Loop function required by Arduino + */ +} diff --git a/branches/follower/libw5100/src/libw5100/connection.cpp b/branches/follower/libw5100/src/libw5100/connection.cpp new file mode 100644 index 0000000..cf9f0ea --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/connection.cpp @@ -0,0 +1,162 @@ +/* + + NetworkConnection + + High level socket instance wrapper + +*/ + +#include "connection.h" + +int NetworkConnection::_nextSocket = 0; + + +NetworkConnection::NetworkConnection(uint16_t port) { + /* + + Create the low-level socket this instance wraps (for server connections). + + */ + _socket = _nextSocket; // TODO: Do properly (& max) + _nextSocket++; + socket(_socket, Sn_MR_TCP, port, 0); +} + + +NetworkConnection::NetworkConnection() { + /* + + Create the low-level socket this instance wraps (for client connections). + + */ + NetworkConnection(0); +} + + +int NetworkConnection::listen() { // TODO: Make private or protected? + /* + + Start listening for a connection from a client. + + */ + return !!::listen(_socket); // TODO: Use C++ namespaces for the driver functions? +} + + +int NetworkConnection::connect(uint8 * addr, uint16 port) { // TODO: Make private or protected? + /* + + Client connection to a server. + + */ + + // TODO: Accept bytes here for addr? + int result = 0; + + result = !!::connect(_socket, addr, port); // TODO: Use C++ namespaces for the driver functions? + return result; +} + + +int NetworkConnection::available() { + /* + + Functionality matches 'Serial.available()'. + + Note: If the socket is not connected then this will return 0, + but it is intended that 'isConnected()' would be checked first. + + Returns: + "The number of bytes available to read ... or 0 if none are available. + If any data has come in, [...].available() will be greater than 0." + + */ + // TODO: Do we want to check for 'isConnected' as well, or not? + // We have to, I guess, for valid behaviour with 'getSn_*'. + if (!isConnected()) { + return 0; + } + + return getSn_RX_RSR(_socket); +} + + +#define NO_READ_DATA_AVAILABLE -1 + +int NetworkConnection::read() { + /* + + Functionality matches 'Serial.read()'. + + Returns: + "an int, the first byte of incoming serial data available + (or -1 if no data is available)." + + + Note: I thought 'recv' blocked until data was available, + but it currently seems not to block after all. + However, because I'm seeking to match the 'Serial.read' + behaviour we don't actually want to block anyway, + so we'll ignore it for the moment and handle things + ourself for now. + + */ + uint8_t theByte; + + if (!available()) { + return NO_READ_DATA_AVAILABLE; + } + + recv(_socket, &theByte, 1); + return theByte; +} + + +int NetworkConnection::isConnected() { + /* + + Returns true if the connection is established. + + */ + // TODO: If we want the 'Network*' classes to be generic we + // would need to handle this differently: + return (getSn_SR(_socket) == SOCK_ESTABLISHED); +} + + +void NetworkConnection::print(uint8_t b) { + /* + + Send a character over connection. Naming matches 'Serial' API. + + */ + if (isConnected()) { + send(_socket, &b, 1); + } else { + // Just drop it if we're not connected. + } +} + + +void NetworkConnection::print(const char * text) { + /* + + Send a string over connection. Naming matches 'Serial' API. + + */ + for (unsigned int idx = 0; idx < strlen(text); idx++) { + print(text[idx]); + } +} + +void NetworkConnection::close() { + /* + + Close the connection. + + */ + // TODO: Determine if we need/want the disconnect (see pg 26 W5100) + ::close(_socket); + disconnect(_socket); +} + diff --git a/branches/follower/libw5100/src/libw5100/connection.h b/branches/follower/libw5100/src/libw5100/connection.h new file mode 100644 index 0000000..81755ac --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/connection.h @@ -0,0 +1,47 @@ +/* + + NetworkConnection + + High level socket instance wrapper + +*/ + +#ifndef _CONNECTION_H_ +#define _CONNECTION_H_ + +// Required for use in Arduino environment +#include + +// From original driver +#include "types.h" +#include "w5100.h" +#include "socket.h" + +#include + +// TODO: Make this 'NetworkServerConnection'? Or just 'ServerConnection'? +// TODO: Pull one-line methods into class definition to allow inlining? +class NetworkConnection { // Essentially a Socket wrapper + + public: + // TODO: Split into client/server connections? Subclass? + NetworkConnection(uint16_t port); // TODO: Add UDP, TCP choice? // For servers + NetworkConnection(); // For clients--is using the default constructor hide misuse? TODO: As above. + + int listen(); + int connect(uint8 * addr, uint16 port); + int isConnected(); + int available(); + int read(); + void print(uint8_t); + void print(const char * text); + void close(); + + private: + SOCKET _socket; + static const int _MAX_SOCKETS = MAX_SOCK_NUM; // TODO: Use this. + static int _nextSocket; +}; + + +#endif diff --git a/branches/follower/libw5100/src/libw5100/interface.cpp b/branches/follower/libw5100/src/libw5100/interface.cpp new file mode 100644 index 0000000..101f004 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/interface.cpp @@ -0,0 +1,99 @@ +/* + + Network Interface + + Generic wrapper around a specific network device. + + A Network Interface (representing the physical network device) returns a + connecting or listening Network Connection (representing a socket in either + client or server state). + +*/ + +#include "interface.h" + +#define HANDLE_BAD_ERROR() while (1) {}; + +NetworkInterface::NetworkInterface(W5100Device& networkDevice) : device (networkDevice) { + /* + + Initialise the physical device with default network details. + + Note: The "weirdness" in this function declaration is a "initalization list", + i.e. this bit: + + ) : device (networkDevice) { + + it is needed to give the 'device' Reference a value supplied to the method + rather than having a new 'W5100Device' instance created. + */ + + // This may not be the best place to do all this, but it'll do for now: + device.setMac(0x02,0xDE,0xAD,0xBE,0xEF,0x00); + + device.setIp(169,254,254,169); // A local-link IP -- NOTE: This is out of spec. + device.setMask(255,255,0,0); // Matches local-link IP /16 + + device.setGateway(0,0,0,0); // We can't even guess this, so just skip it. + +}; + +NetworkConnection NetworkInterface::listen(uint16_t port) { + /* + + Start to listen for a request from a client. + + + NOTE: For reasons I don't understand, this FAILS TO WORK if port >255. + The port that gets opened is ~(port mod 255) but if you limit + port to be uint8_t for example you don't get an error until + the port number is bigger than 'long'. + + TODO: Track and fix this for port numbers > 255. + + + Returns a NetworkConnection listening on the specified TCP port. + + */ + NetworkConnection connection = NetworkConnection(port); + + // TODO: How to best handle errors? + // There's two major categories I can think of currently: + // 1) A socket wasn't available to listen in the first place + // 2) The listen attempt failed for some reason + // Using 'HANDLE_BAD_ERROR()' (currently an infinite loop) is + // not ideal but should prevent the above errors slipping by unnoticed. + if (!connection.listen()) { + HANDLE_BAD_ERROR(); + } + + return connection; +} + + +NetworkConnection NetworkInterface::connect(byte b0, byte b1, byte b2, byte b3, uint16 port) { + /* + + Connect to a server. + + */ + NetworkConnection connection = NetworkConnection(4000); + + byte _scratchBuffer[4]; // TODO: Move this? + + // TODO: Better? + _scratchBuffer[0] = b0; + _scratchBuffer[1] = b1; + _scratchBuffer[2] = b2; + _scratchBuffer[3] = b3; + + if (!connection.connect(_scratchBuffer, port)) { + HANDLE_BAD_ERROR(); + } + + return connection; +} + +//#include "w5100_device.h" + +//NetworkInterface Network = NetworkInterface(W5100); diff --git a/branches/follower/libw5100/src/libw5100/interface.h b/branches/follower/libw5100/src/libw5100/interface.h new file mode 100644 index 0000000..4e00e97 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/interface.h @@ -0,0 +1,27 @@ +/* + + Network Interface + + Generic wrapper around a specific network device. + +*/ + +#ifndef _INTERFACE_H_ +#define _INTERFACE_H_ + +#include "w5100_device.h" +#include "connection.h" + +// TODO?: Do we want to have a "default" socket accessible by 'Network.read()' etc? +class NetworkInterface { + + public: + NetworkInterface(W5100Device& networkDevice); + + NetworkConnection listen(uint16_t port); + NetworkConnection connect(byte b0, byte b1, byte b2, byte b3, uint16 port); + + W5100Device& device; // TODO: Make this a generic "network device" interface +}; + +#endif diff --git a/branches/follower/libw5100/src/libw5100/libw5100.h b/branches/follower/libw5100/src/libw5100/libw5100.h new file mode 100644 index 0000000..105c6a4 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/libw5100.h @@ -0,0 +1,20 @@ +/* + + libw5100.h + +*/ + +#ifndef _LIBW5100_H_ +#define _LIBW5100_H_ + +// New object wrapper interface +#include "spi.h" +#include "w5100_device.h" +#include "connection.h" +#include "interface.h" + +// TODO: Allow this to be changed in the main program, but use default otherwise. +// WIZnet module /RESET +#define PIN_RESET 9 + +#endif diff --git a/branches/follower/libw5100/src/libw5100/socket.c b/branches/follower/libw5100/src/libw5100/socket.c new file mode 100644 index 0000000..442f86f --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/socket.c @@ -0,0 +1,484 @@ +/* +* +@file socket.c +@brief setting chip register for socket +* +*/ +#include +#include + +#include "types.h" + +#ifdef __DEF_IINCHIP_DBG__ +#include +#endif + + +#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 + 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); +} + + +/** +@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); + 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); + // wait for completion + while (IINCHIP_READ(Sn_CR(s))) + { + if (IINCHIP_READ(Sn_SR(s)) == SOCK_CLOSED) + { +#ifdef __DEF_IINCHIP_DBG__ + printf("SOCK_CLOSED.\r\n"); +#endif + ret = 0; break; + } + } + } + + 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); +} + + +/** +@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); + + // wait for completion + while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) + { + status = IINCHIP_READ(Sn_SR(s)); + if (status == SOCK_CLOSED) + { +#ifdef __DEF_IINCHIP_DBG__ + printf("SOCK_CLOSED.\r\n"); +#endif + putISR(s, getISR(s) & (Sn_IR_RECV | Sn_IR_DISCON | Sn_IR_CON)); + IINCHIP_WRITE(Sn_IR(s), (Sn_IR_SEND_OK | Sn_IR_TIMEOUT)); + return 0; + } + } + putISR(s, getISR(s) & (~Sn_IR_SEND_OK)); + IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK); + 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); + 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) + ) + { + ; +#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); + + while ( (IINCHIP_READ(Sn_IR(s)) & Sn_IR_SEND_OK) != Sn_IR_SEND_OK ) + { + status = IINCHIP_READ(Sn_SR(s)); +#ifndef __DEF_IINCHIP_INT__ + isr = IINCHIP_READ(Sn_IR(s)); +#endif + if ((isr & Sn_IR_TIMEOUT) || (getISR(s) & Sn_IR_TIMEOUT)) + { +#ifdef __DEF_IINCHIP_DBG__ + printf("send fail.\r\n"); +#endif + putISR(s, getISR(s) & (Sn_IR_RECV | Sn_IR_DISCON | Sn_IR_CON)); /* clear SEND_OK & TIMEOUT in I_STATUS[s] */ + IINCHIP_WRITE(Sn_IR(s), (Sn_IR_SEND_OK | Sn_IR_TIMEOUT)); // clear SEND_OK & TIMEOUT in Sn_IR(s) + return 0; + } + } + putISR(s, getISR(s) & (~Sn_IR_SEND_OK)); + IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK); + + } + 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); + } +#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); + + while (IINCHIP_READ(Sn_CR(s))) + { + // status = IINCHIP_READ(Sn_SR(s)); +#ifndef __DEF_IINCHIP_INT__ + isr = IINCHIP_READ(Sn_IR(s)); +#endif + if ((getISR(s) & Sn_IR_TIMEOUT) || (isr & Sn_IR_TIMEOUT)) + { +#ifdef __DEF_IINCHIP_DBG__ + printf("igmpsend fail.\r\n"); +#endif + putISR(s, getISR(s) & (Sn_IR_RECV | Sn_IR_DISCON | Sn_IR_CON)); + IINCHIP_WRITE(Sn_IR(s), (Sn_IR_SEND_OK | Sn_IR_TIMEOUT)); + return 0; + } + } + putISR(s, getISR(s) & (~Sn_IR_SEND_OK)); + IINCHIP_WRITE(Sn_IR(s), Sn_IR_SEND_OK); + } + return ret; +} diff --git a/branches/follower/libw5100/src/libw5100/socket.h b/branches/follower/libw5100/src/libw5100/socket.h new file mode 100644 index 0000000..98ba2f1 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/socket.h @@ -0,0 +1,32 @@ +/* +* +@file socket.h +@brief define function of socket API +* +*/ + +#ifndef _SOCKET_H_ +#define _SOCKET_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +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); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif +/* _SOCKET_H_ */ diff --git a/branches/follower/libw5100/src/libw5100/spi.cpp b/branches/follower/libw5100/src/libw5100/spi.cpp new file mode 100644 index 0000000..d3438f7 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/spi.cpp @@ -0,0 +1,60 @@ +/* + + SPI Configuration + + TODO: Enable multiple SPI devices to be controlled. + +*/ + +#include "spi.h" + +SpiConfiguration::SpiConfiguration() { + // begin(); +} + +void SpiConfiguration::begin(void) { + /* + + Configure pins and registers required for SPI communication. + + */ + + // Configure I/O pins + pinMode(PIN_DATA_OUT, OUTPUT); + pinMode(PIN_DATA_IN, INPUT); + pinMode(PIN_SPI_CLOCK, OUTPUT); + pinMode(PIN_SLAVE_SELECT, OUTPUT); + + digitalWrite(PIN_SLAVE_SELECT, HIGH); // Disable slave + + /* + Configure SPI Control Register (SPCR) (All values initially 0) + Bit Description + 7 SPI Interrupt Enable -- disable (SPIE --> 0) + 6 SPI Enable -- enable (SPE --> 1) + 5 Data Order -- MSB 1st (DORD --> 0) (Slave specific) + 4 Master/Slave Select -- master (MSTR --> 1) + 3 Clock Polarity -- (CPOL --> 0) (Slave specific) ("Mode") + 2 Clock Phase -- (CPHA --> 0) (Slave specific) + 1 SPI Clock Rate Select 1 -- } (SPR1 --> 0) + 0 SPI Clock Rate Select 0 -- } fOSC/4 (SPR0 --> 0) ("Fastest" but see SPI2X in SPSR) + */ + SPCR = (1< + +class SpiConfiguration { + /* + + Handles SPI configuration with an API consistent + with the style of existing Arduino 'HardwareSerial' class. + + Needs to be used before SPI functionality is accessed. + + */ + + public: + SpiConfiguration(); + void begin(void); +}; + +#endif diff --git a/branches/follower/libw5100/src/libw5100/types.h b/branches/follower/libw5100/src/libw5100/types.h new file mode 100644 index 0000000..2ebb539 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/types.h @@ -0,0 +1,194 @@ +/* +* +@file type.h +* +*/ + +#ifndef _TYPE_H_ +#define _TYPE_H_ + + +/*************************************************** + * attribute for mcu ( types, ... ) + ***************************************************/ +//#include "mcu_define.h" +#define __ARDUINO__ 1 +#define __MCU_AVR__ 1 +#define __MCU_TYPE__ __MCU_AVR__ + +// TODO: We should really specify the Chip Select pin based on +// the MCU rather than the platform. +#ifdef __ARDUINO__ +#define CS_PIN (1 << PB2) +#endif + +//---- Refer "Rom File Maker Manual Vx.x.pdf" +#include + +#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 8000000 /**< 8Mhz(for serial) */ + +/* ## __DEF_IINCHIP_xxx__ : define option for iinchip driver *****************/ +#ifndef __ARDUINO__ +#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. + Otherwise, the source files must be removed from your + project. */ +#endif + +#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 + + +/* gcc version */ +/* WinAVR-20050214-install.exe */ +#define __WINAVR_20050214__ 0 +#define __WINAVR_20060125__ 1 +#define __WINAVR_20060421__ 2 + +/* #define __COMPILER_VERSION__ __WINAVR_20060421__ // <- move makefile*/ + +#if (__COMPILER_VERSION__ == __WINAVR_20050214__) +#ifndef __STDIO_FDEVOPEN_COMPAT_12 +#define __STDIO_FDEVOPEN_COMPAT_12 +#endif +#endif + +#ifndef NULL +#define NULL ((void *) 0) +#endif + +#ifndef __ARDUINO__ +typedef enum { false, true } bool; +#endif + +#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 0x01000001 /**< System F/W Version(test) : 0.0.0.1 */ +#define HW_PM_VERSION "0.1" +#define HW_NM_VERSION "0.1" +#define HW_MB_VERSION "0.1" + + +#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_ */ diff --git a/branches/follower/libw5100/src/libw5100/w5100.c b/branches/follower/libw5100/src/libw5100/w5100.c new file mode 100644 index 0000000..aeb5a7b --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/w5100.c @@ -0,0 +1,1270 @@ +/* +@file w5100.c +*/ + +#include +#include + +#include +// #include + +#include "types.h" + +#include "w5100.h" + + + +#ifdef __DEF_IINCHIP_PPP__ + #include "md5.h" + #include "delay.h" // for wait function +#endif + +static uint8 I_STATUS[MAX_SOCK_NUM]; +static uint16 SMASK[MAX_SOCK_NUM]; /**< Variable for Tx buffer MASK in each channel */ +static uint16 RMASK[MAX_SOCK_NUM]; /**< Variable for Rx buffer MASK in each channel */ +static uint16 SSIZE[MAX_SOCK_NUM]; /**< Max Tx buffer size by each channel */ +static uint16 RSIZE[MAX_SOCK_NUM]; /**< Max Rx buffer size by each channel */ +static uint16 SBUFBASEADDRESS[MAX_SOCK_NUM]; /**< Tx buffer base address by each channel */ +static uint16 RBUFBASEADDRESS[MAX_SOCK_NUM]; /**< Rx buffer base address by each channel */ + +uint8 getISR(uint8 s) +{ + return I_STATUS[s]; +} + +void putISR(uint8 s, uint8 val) +{ + I_STATUS[s] = val; +} + +uint16 getIINCHIP_RxMAX(uint8 s) +{ + return RSIZE[s]; +} +uint16 getIINCHIP_TxMAX(uint8 s) +{ + return SSIZE[s]; +} +uint16 getIINCHIP_RxMASK(uint8 s) +{ + return RMASK[s]; +} +uint16 getIINCHIP_TxMASK(uint8 s) +{ + return SMASK[s]; +} +uint16 getIINCHIP_RxBASE(uint8 s) +{ + return RBUFBASEADDRESS[s]; +} +uint16 getIINCHIP_TxBASE(uint8 s) +{ + return SBUFBASEADDRESS[s]; +} + + /** +@brief This function writes the data into W5100 registers. +*/ +uint8 IINCHIP_WRITE(uint16 addr,uint8 data) +{ +// DIRECT MODE I/F +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) + IINCHIP_ISR_DISABLE(); + *((vuint8*)(addr)) = data; + IINCHIP_ISR_ENABLE(); +#elif(__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) /* INDIRECT MODE I/F */ + IINCHIP_ISR_DISABLE(); + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); + *((vuint8*)IDM_DR) = data; + IINCHIP_ISR_ENABLE(); +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) + //SPI MODE I/F + IINCHIP_ISR_DISABLE(); +#ifndef __ARDUINO__ + DDRB = 0x07; // MISO=input, etc.=output + // PB3(MISO), PB2(MOSI), PB1(SCK), PB0(/SS) + PORTB = 0x01; // CS=1, waiting for SPI start + SPCR = 0x50; // SPI mode 0, 4MHz + SPSR = 0x01; // SPI2X=0 + + PORTB = 0x00; // CS=0, SPI start +#else + PORTB = PORTB & ~CS_PIN; // CS=0, SPI start +#endif // ifndef __ARDUINO__ + SPDR = 0xF0; + while((SPSR&0x80)==0x00); + SPDR = (uint8)((addr & 0xFF00) >> 8); + while((SPSR&0x80)==0x00); + SPDR = (uint8)(addr & 0x00FF); + while((SPSR&0x80)==0x00); + SPDR = data; + while((SPSR&0x80)==0x00); +#ifndef __ARDUINO__ + PORTB = 0x01; // SPI end + // CS=1, waiting for SPI start +#else + PORTB = PORTB | CS_PIN; // SPI end +#endif // ifndef __ARDUINO__ + IINCHIP_ISR_ENABLE(); +#else + #error "unknown bus type" +#endif + return 1; +} + + +/** +@brief This function reads the value from W5100 registers. +*/ +uint8 IINCHIP_READ(uint16 addr) +{ + uint8 data; + +// DIRECT MODE I/F + +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) + IINCHIP_ISR_DISABLE(); + data = *((vuint8*)(addr)); + IINCHIP_ISR_ENABLE(); +#elif(__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) + IINCHIP_ISR_DISABLE(); + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); + data = *((vuint8*)IDM_DR); + IINCHIP_ISR_ENABLE(); + +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) + //SPI MODE I/F + IINCHIP_ISR_DISABLE(); +#ifndef __ARDUINO__ + DDRB = 0x07; // MISO=input, etc.=output + // PB3(MISO), PB2(MOSI), PB1(SCK), PB0(/SS) + PORTB = 0x01; // CS=1, waiting for SPI start + SPCR = 0x50; // SPI mode 0, 4MHz + SPSR = 0x01; // SPI2X=0 + + PORTB = 0x00; // CS=0, SPI start +#else + PORTB = PORTB & ~CS_PIN; // CS=0, SPI start +#endif // ifndef __ARDUINO__ + SPDR = 0x0F; + while((SPSR&0x80)==0x00); + SPDR = (uint8)((addr & 0xFF00) >> 8); + while((SPSR&0x80)==0x00); + SPDR = (uint8)(addr & 0x00FF); + while((SPSR&0x80)==0x00); + SPDR = 0x00; // write dummy data + while((SPSR&0x80)==0x00); + data = SPDR; // read data +#ifndef __ARDUINO__ + PORTB = 0x01; // SPI end + // CS=1, waiting for SPI start +#else + PORTB = PORTB | CS_PIN; // SPI end +#endif // ifndef __ARDUINO__ + IINCHIP_ISR_ENABLE(); +#else + #error "unknown bus type" +#endif + return data; +} + + +/** +@brief This function writes into W5100 memory(Buffer) +*/ +uint16 wiz_write_buf(uint16 addr,uint8* buf,uint16 len) +{ +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) + IINCHIP_ISR_DISABLE(); + memcpy((uint8 *)addr, buf, len); + IINCHIP_ISR_ENABLE(); +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) + uint16 idx = 0; + IINCHIP_ISR_DISABLE(); + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); + for (idx = 0; idx < len ; idx++) *((vuint8*)IDM_DR) = buf[idx]; + IINCHIP_ISR_ENABLE(); +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) + //SPI MODE I/F + IINCHIP_ISR_DISABLE(); + uint16 ii=0; + + for(ii=0;ii> 8); + while((SPSR&0x80)==0x00); + SPDR = (uint8)((addr+ii) & 0x00FF); + while((SPSR&0x80)==0x00); + SPDR = buf[ii]; + while((SPSR&0x80)==0x00); +#ifndef __ARDUINO__ + PORTB = 0x01; // SPI end + // CS=1, waiting for SPI start +#else + PORTB = PORTB | CS_PIN; // SPI end +#endif // ifndef __ARDUINO__ + } + IINCHIP_ISR_ENABLE(); +#else + #error "unknown bus type" +#endif + return len; +} + + +/** +@brief This function reads into W5100 memory(Buffer) +*/ +uint16 wiz_read_buf(uint16 addr, uint8* buf,uint16 len) +{ +#if (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_DIRECT_MODE__) + IINCHIP_ISR_DISABLE(); + memcpy(buf, (uint8 *)addr, len); + IINCHIP_ISR_ENABLE(); +#elif(__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_INDIRECT_MODE__) + uint16 idx = 0; + IINCHIP_ISR_DISABLE(); + *((vuint8*)IDM_AR0) = (uint8)((addr & 0xFF00) >> 8); + *((vuint8*)IDM_AR1) = (uint8)(addr & 0x00FF); + for (idx = 0; idx < len ; idx++) buf[idx] = *((vuint8*)IDM_DR); + IINCHIP_ISR_ENABLE(); +#elif (__DEF_IINCHIP_BUS__ == __DEF_IINCHIP_SPI_MODE__) + //SPI MODE I/F + IINCHIP_ISR_DISABLE(); + uint16 iii=0; + for (iii=0; iii> 8); + while((SPSR&0x80)==0x00); + SPDR = (uint8)((addr+iii) & 0x00FF); + while((SPSR&0x80)==0x00); + //for (iii=0; iii> i*2) & 0x03) // Set Tx memory size + { + case 0: + SSIZE[i] = (int16)(1024); + SMASK[i] = (uint16)(0x03FF); + break; + case 1: + SSIZE[i] = (int16)(2048); + SMASK[i] = (uint16)(0x07FF); + break; + case 2: + SSIZE[i] = (int16)(4096); + SMASK[i] = (uint16)(0x0FFF); + break; + case 3: + SSIZE[i] = (int16)(8192); + SMASK[i] = (uint16)(0x1FFF); + break; + } + } + if (rsum < 8192) + { + switch((rx_size >> i*2) & 0x03) // Set Rx memory size + { + case 0: + RSIZE[i] = (int16)(1024); + RMASK[i] = (uint16)(0x03FF); + break; + case 1: + RSIZE[i] = (int16)(2048); + RMASK[i] = (uint16)(0x07FF); + break; + case 2: + RSIZE[i] = (int16)(4096); + RMASK[i] = (uint16)(0x0FFF); + break; + case 3: + RSIZE[i] = (int16)(8192); + RMASK[i] = (uint16)(0x1FFF); + break; + } + } + ssum += SSIZE[i]; + rsum += RSIZE[i]; + + if (i != 0) // Sets base address of Tx and Rx memory for channel #1,#2,#3 + { + SBUFBASEADDRESS[i] = SBUFBASEADDRESS[i-1] + SSIZE[i-1]; + RBUFBASEADDRESS[i] = RBUFBASEADDRESS[i-1] + RSIZE[i-1]; + } +#ifdef __DEF_IINCHIP_DBG__ + printf("%d : %.4x : %.4x : %.4x : %.4x\r\n", i, (uint16)SBUFBASEADDRESS[i], (uint16)RBUFBASEADDRESS[i], SSIZE[i], RSIZE[i]); +#endif + } +} + +void setMR(uint8 val) +{ + *((volatile uint8*)(MR)) = val; +} + + +/** +@brief This function sets up gateway IP address. +*/ +void setGAR( + uint8 * addr /**< a pointer to a 4 -byte array responsible to set the Gateway IP address. */ + ) +{ + IINCHIP_WRITE((GAR0 + 0),addr[0]); + IINCHIP_WRITE((GAR0 + 1),addr[1]); + IINCHIP_WRITE((GAR0 + 2),addr[2]); + IINCHIP_WRITE((GAR0 + 3),addr[3]); +} +void getGWIP(uint8 * addr) +{ + addr[0] = IINCHIP_READ((GAR0 + 0)); + addr[1] = IINCHIP_READ((GAR0 + 1)); + addr[2] = IINCHIP_READ((GAR0 + 2)); + addr[3] = IINCHIP_READ((GAR0 + 3)); +} + + +/** +@brief It sets up SubnetMask address +*/ +void setSUBR( + uint8 * addr /**< a pointer to a 4 -byte array responsible to set the SubnetMask address */ + ) +{ + IINCHIP_WRITE((SUBR0 + 0),addr[0]); + IINCHIP_WRITE((SUBR0 + 1),addr[1]); + IINCHIP_WRITE((SUBR0 + 2),addr[2]); + IINCHIP_WRITE((SUBR0 + 3),addr[3]); +} + + +/** +@brief This function sets up MAC address. +*/ +void setSHAR( + uint8 * addr /**< a pointer to a 6 -byte array responsible to set the MAC address. */ + ) +{ + IINCHIP_WRITE((SHAR0 + 0),addr[0]); + IINCHIP_WRITE((SHAR0 + 1),addr[1]); + IINCHIP_WRITE((SHAR0 + 2),addr[2]); + IINCHIP_WRITE((SHAR0 + 3),addr[3]); + IINCHIP_WRITE((SHAR0 + 4),addr[4]); + IINCHIP_WRITE((SHAR0 + 5),addr[5]); +} + + +/** +@brief This function sets up Source IP address. +*/ +void setSIPR( + uint8 * addr /**< a pointer to a 4 -byte array responsible to set the Source IP address. */ + ) +{ + IINCHIP_WRITE((SIPR0 + 0),addr[0]); + IINCHIP_WRITE((SIPR0 + 1),addr[1]); + IINCHIP_WRITE((SIPR0 + 2),addr[2]); + IINCHIP_WRITE((SIPR0 + 3),addr[3]); +} + + +/** +@brief This function gets Interrupt register in common register. + */ +uint8 getIR( void ) +{ + return IINCHIP_READ(IR); +} + + + +/** +@brief This function sets up Retransmission time. + +If there is no response from the peer or delay in response then retransmission +will be there as per RTR (Retry Time-value Register)setting +*/ +void setRTR(uint16 timeout) +{ + IINCHIP_WRITE(RTR0,(uint8)((timeout & 0xff00) >> 8)); + IINCHIP_WRITE((RTR0 + 1),(uint8)(timeout & 0x00ff)); +} + + +/** +@brief This function set the number of Retransmission. + +If there is no response from the peer or delay in response then recorded time +as per RTR & RCR register seeting then time out will occur. +*/ +void setRCR(uint8 retry) +{ + IINCHIP_WRITE(RCR,retry); +} + + +/** +@brief This function set the interrupt mask Enable/Disable appropriate Interrupt. ('1' : interrupt enable) + +If any bit in IMR is set as '0' then there is not interrupt signal though the bit is +set in IR register. +*/ +void setIMR(uint8 mask) +{ + IINCHIP_WRITE(IMR,mask); // must be setted 0x10. +} + + +/** +@brief These below functions are used to get the Gateway, SubnetMask + and Source Hardware Address (MAC Address) and Source IP address +*/ +void getGAR(uint8 * addr) +{ + addr[0] = IINCHIP_READ(GAR0); + addr[1] = IINCHIP_READ(GAR0+1); + addr[2] = IINCHIP_READ(GAR0+2); + addr[3] = IINCHIP_READ(GAR0+3); +} +void getSUBR(uint8 * addr) +{ + addr[0] = IINCHIP_READ(SUBR0); + addr[1] = IINCHIP_READ(SUBR0+1); + addr[2] = IINCHIP_READ(SUBR0+2); + addr[3] = IINCHIP_READ(SUBR0+3); +} +void getSHAR(uint8 * addr) +{ + addr[0] = IINCHIP_READ(SHAR0); + addr[1] = IINCHIP_READ(SHAR0+1); + addr[2] = IINCHIP_READ(SHAR0+2); + addr[3] = IINCHIP_READ(SHAR0+3); + addr[4] = IINCHIP_READ(SHAR0+4); + addr[5] = IINCHIP_READ(SHAR0+5); +} +void getSIPR(uint8 * addr) +{ + addr[0] = IINCHIP_READ(SIPR0); + addr[1] = IINCHIP_READ(SIPR0+1); + addr[2] = IINCHIP_READ(SIPR0+2); + addr[3] = IINCHIP_READ(SIPR0+3); +} + + +/** +@brief These below functions are used to get the Destination Hardware Address (MAC Address), Destination IP address and Destination Port. +*/ +void getSn_DHAR(SOCKET s, uint8 * addr) +{ + addr[0] = IINCHIP_READ(Sn_DHAR0(s)); + addr[1] = IINCHIP_READ(Sn_DHAR0(s)+1); + addr[2] = IINCHIP_READ(Sn_DHAR0(s)+2); + addr[3] = IINCHIP_READ(Sn_DHAR0(s)+3); + addr[4] = IINCHIP_READ(Sn_DHAR0(s)+4); + addr[5] = IINCHIP_READ(Sn_DHAR0(s)+5); +} +void setSn_DHAR(SOCKET s, uint8 * addr) +{ + IINCHIP_WRITE((Sn_DHAR0(s) + 0),addr[0]); + IINCHIP_WRITE((Sn_DHAR0(s) + 1),addr[1]); + IINCHIP_WRITE((Sn_DHAR0(s) + 2),addr[2]); + IINCHIP_WRITE((Sn_DHAR0(s) + 3),addr[3]); + IINCHIP_WRITE((Sn_DHAR0(s) + 4),addr[4]); + IINCHIP_WRITE((Sn_DHAR0(s) + 5),addr[5]); +} +void getSn_DIPR(SOCKET s, uint8 * addr) +{ + addr[0] = IINCHIP_READ(Sn_DIPR0(s)); + addr[1] = IINCHIP_READ(Sn_DIPR0(s)+1); + addr[2] = IINCHIP_READ(Sn_DIPR0(s)+2); + addr[3] = IINCHIP_READ(Sn_DIPR0(s)+3); +} +void setSn_DIPR(SOCKET s, uint8 * addr) +{ + IINCHIP_WRITE((Sn_DIPR0(s) + 0),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]); +} +void getSn_DPORT(SOCKET s, uint8 * addr) +{ + addr[0] = IINCHIP_READ(Sn_DPORT0(s)); + addr[1] = IINCHIP_READ(Sn_DPORT0(s)+1); +} +void setSn_DPORT(SOCKET s, uint8 * addr) +{ + IINCHIP_WRITE((Sn_DPORT0(s) + 0),addr[0]); + IINCHIP_WRITE((Sn_DPORT0(s) + 1),addr[1]); +} + + +/** +@brief This sets the maximum segment size of TCP in Active Mode), while in Passive Mode this is set by peer +*/ +void setSn_MSS(SOCKET s, uint16 Sn_MSSR0) +{ + IINCHIP_WRITE(Sn_MSSR0(s),(uint8)((Sn_MSSR0 & 0xff00) >> 8)); + IINCHIP_WRITE((Sn_MSSR0(s) + 1),(uint8)(Sn_MSSR0 & 0x00ff)); +} + +void setSn_TTL(SOCKET s, uint8 ttl) +{ + IINCHIP_WRITE(Sn_TTL(s), ttl); +} + + +/** +@brief These below function is used to setup the Protocol Field of IP Header when + executing the IP Layer RAW mode. +*/ +void setSn_PROTO(SOCKET s, uint8 proto) +{ + IINCHIP_WRITE(Sn_PROTO(s),proto); +} + + +/** +@brief get socket interrupt status + +These below functions are used to read the Interrupt & Soket Status register +*/ +uint8 getSn_IR(SOCKET s) +{ + return IINCHIP_READ(Sn_IR(s)); +} + + +/** +@brief get socket status +*/ +uint8 getSn_SR(SOCKET s) +{ + return IINCHIP_READ(Sn_SR(s)); +} + + +/** +@brief get socket TX free buf size + +This gives free buffer size of transmit buffer. This is the data size that user can transmit. +User shuold check this value first and control the size of transmitting data +*/ +uint16 getSn_TX_FSR(SOCKET s) +{ + uint16 val=0,val1=0; + do + { + val1 = IINCHIP_READ(Sn_TX_FSR0(s)); + val1 = (val1 << 8) + IINCHIP_READ(Sn_TX_FSR0(s) + 1); + if (val1 != 0) + { + val = IINCHIP_READ(Sn_TX_FSR0(s)); + val = (val << 8) + IINCHIP_READ(Sn_TX_FSR0(s) + 1); + } + } while (val != val1); + return val; +} + + +/** +@brief get socket RX recv buf size + +This gives size of received data in receive buffer. +*/ +uint16 getSn_RX_RSR(SOCKET s) +{ + uint16 val=0,val1=0; + do + { + val1 = IINCHIP_READ(Sn_RX_RSR0(s)); + val1 = (val1 << 8) + IINCHIP_READ(Sn_RX_RSR0(s) + 1); + if(val1 != 0) + { + val = IINCHIP_READ(Sn_RX_RSR0(s)); + val = (val << 8) + IINCHIP_READ(Sn_RX_RSR0(s) + 1); + } + } while (val != val1); + return val; +} + + +/** +@brief This function is being called by send() and sendto() function also. + +This function read the Tx write pointer register and after copy the data in buffer update the Tx write pointer +register. User should read upper byte first and lower byte later to get proper value. +*/ +void send_data_processing(SOCKET s, uint8 *data, uint16 len) +{ + uint16 ptr; + ptr = IINCHIP_READ(Sn_TX_WR0(s)); + ptr = ((ptr & 0x00ff) << 8) + IINCHIP_READ(Sn_TX_WR0(s) + 1); + write_data(s, data, (uint8 *)(ptr), len); + ptr += len; + IINCHIP_WRITE(Sn_TX_WR0(s),(uint8)((ptr & 0xff00) >> 8)); + IINCHIP_WRITE((Sn_TX_WR0(s) + 1),(uint8)(ptr & 0x00ff)); +} + + +/** +@brief This function is being called by recv() also. + +This function read the Rx read pointer register +and after copy the data from receive buffer update the Rx write pointer register. +User should read upper byte first and lower byte later to get proper value. +*/ +void recv_data_processing(SOCKET s, uint8 *data, uint16 len) +{ + uint16 ptr; + 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 + read_data(s, (uint8 *)ptr, data, len); // read data + ptr += len; + IINCHIP_WRITE(Sn_RX_RD0(s),(uint8)((ptr & 0xff00) >> 8)); + IINCHIP_WRITE((Sn_RX_RD0(s) + 1),(uint8)(ptr & 0x00ff)); +} + + +/** +@brief for copy the data form application buffer to Transmite buffer of the chip. + +This function is being used for copy the data form application buffer to Transmite +buffer of the chip. It calculate the actual physical address where one has to write +the data in transmite buffer. Here also take care of the condition while it exceed +the Tx memory uper-bound of socket. +*/ +void write_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len) +{ + uint16 size; + uint16 dst_mask; + uint8 * dst_ptr; + + dst_mask = (uint16)dst & getIINCHIP_TxMASK(s); + dst_ptr = (uint8 *)(getIINCHIP_TxBASE(s) + dst_mask); + + if (dst_mask + len > getIINCHIP_TxMAX(s)) + { + size = getIINCHIP_TxMAX(s) - dst_mask; + wiz_write_buf((uint16)dst_ptr, (uint8*)src, size); + src += size; + size = len - size; + dst_ptr = (uint8 *)(getIINCHIP_TxBASE(s)); + wiz_write_buf((uint16)dst_ptr, (uint8*)src, size); + } + else + { + wiz_write_buf((uint16)dst_ptr, (uint8*)src, len); + } +} + + +/** +@brief This function is being used for copy the data form Receive buffer of the chip to application buffer. + +It calculate the actual physical address where one has to read +the data from Receive buffer. Here also take care of the condition while it exceed +the Rx memory uper-bound of socket. +*/ +void read_data(SOCKET s, vuint8 * src, vuint8 * dst, uint16 len) +{ + uint16 size; + uint16 src_mask; + uint8 * src_ptr; + + src_mask = (uint16)src & getIINCHIP_RxMASK(s); + src_ptr = (uint8 *)(getIINCHIP_RxBASE(s) + src_mask); + + if( (src_mask + len) > getIINCHIP_RxMAX(s) ) + { + size = getIINCHIP_RxMAX(s) - src_mask; + wiz_read_buf((uint16)src_ptr, (uint8*)dst,size); + dst += size; + size = len - size; + src_ptr = (uint8 *)(getIINCHIP_RxBASE(s)); + wiz_read_buf((uint16)src_ptr, (uint8*) dst,size); + } + else + { + wiz_read_buf((uint16)src_ptr, (uint8*) dst,len); + } +} + + +#ifdef __DEF_IINCHIP_PPP__ +#define PPP_OPTION_BUF_LEN 64 + +uint8 pppinit_in(uint8 * id, uint8 idlen, uint8 * passwd, uint8 passwdlen); + + +/** +@brief make PPPoE connection +@return 1 => success to connect, 2 => Auth fail, 3 => timeout, 4 => Auth type not support + +*/ +uint8 pppinit(uint8 * id, uint8 idlen, uint8 * passwd, uint8 passwdlen) +{ + uint8 ret; + uint8 isr; + + // PHASE0. W5100 PPPoE(ADSL) setup + // enable pppoe mode + printf("-- PHASE 0. W5100 PPPoE(ADSL) setup process --\r\n"); + printf("\r\n"); + IINCHIP_WRITE(MR,IINCHIP_READ(MR) | MR_PPPOE); + + // open socket in pppoe mode + isr = IINCHIP_READ(Sn_IR(0));// first clear isr(0), W5100 at present time + IINCHIP_WRITE(Sn_IR(0),isr); + + IINCHIP_WRITE(PTIMER,200); // 5sec timeout + IINCHIP_WRITE(PMAGIC,0x01); // magic number + IINCHIP_WRITE(Sn_MR(0),Sn_MR_PPPOE); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_OPEN); + + ret = pppinit_in(id, idlen, passwd, passwdlen); + + // close ppp connection socket + IINCHIP_WRITE(Sn_CR(0),Sn_CR_CLOSE); + return ret; +} + + +uint8 pppinit_in(uint8 * id, uint8 idlen, uint8 * passwd, uint8 passwdlen) +{ + uint8 loop_idx = 0; + uint8 isr = 0; + uint8 buf[PPP_OPTION_BUF_LEN]; + uint16 len; + uint8 str[PPP_OPTION_BUF_LEN]; + uint8 str_idx,dst_idx; + + // PHASE1. PPPoE Discovery + // start to connect pppoe connection + printf("-- PHASE 1. PPPoE Discovery process --"); + printf(" ok\r\n"); + printf("\r\n"); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCON); + wait_10ms(100); + + loop_idx = 0; + //check whether PPPoE discovery end or not + while (!(IINCHIP_READ(Sn_IR(0)) & Sn_IR_PNEXT)) + { + printf("."); + if (loop_idx++ == 10) // timeout + { + printf("timeout before LCP\r\n"); + return 3; + } + wait_10ms(100); + } + + // PHASE2. LCP process + printf("-- PHASE 2. LCP process --"); + + // send LCP Request + { + // Magic number option + // option format (type value + length value + data) + // write magic number value + buf[0] = 0x05; // type value + buf[1] = 0x06; // length value + buf[2] = 0x01; buf[3] = 0x01; buf[4] = 0x01; buf[5]= 0x01; // data + // for MRU option, 1492 0x05d4 + // buf[6] = 0x01; buf[7] = 0x04; buf[8] = 0x05; buf[9] = 0xD4; + } + send_data_processing(0, buf, 0x06); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); // send request + wait_10ms(100); + + while (!((isr = IINCHIP_READ(Sn_IR(0))) & Sn_IR_PNEXT)) + { + if (isr & Sn_IR_PRECV) // Not support option + { + len = getSn_RX_RSR(0); + if ( len > 0 ) + { + recv_data_processing(0, str, len); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_RECV); + // for debug + //printf("LCP proc\r\n"); for (i = 0; i < len; i++) printf ("%02x ", str[i]); printf("\r\n"); + // get option length + len = str[4]; len = ((len & 0x00ff) << 8) + str[5]; + len += 2; + str_idx = 6; dst_idx = 0; // ppp header is 6 byte, so starts at 6. + do + { + if ((str[str_idx] == 0x01) || (str[str_idx] == 0x02) || (str[str_idx] == 0x03) || (str[str_idx] == 0x05)) + { + // skip as length of support option. str_idx+1 is option's length. + str_idx += str[str_idx+1]; + } + else + { + // not support option , REJECT + memcpy((uint8 *)(buf+dst_idx), (uint8 *)(str+str_idx), str[str_idx+1]); + dst_idx += str[str_idx+1]; str_idx += str[str_idx+1]; + } + } while (str_idx != len); + // for debug + // printf("LCP dst proc\r\n"); for (i = 0; i < dst_idx; i++) printf ("%02x ", dst[i]); printf("\r\n"); + + // send LCP REJECT packet + send_data_processing(0, buf, dst_idx); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCJ); + } + } + printf("."); + if (loop_idx++ == 10) // timeout + { + printf("timeout after LCP\r\n"); + return 3; + } + wait_10ms(100); + } + printf(" ok\r\n"); + printf("\r\n"); + + printf("-- PHASE 3. PPPoE(ADSL) Authentication mode --\r\n"); + printf("Authentication protocol : %.2x %.2x, ", IINCHIP_READ(PATR0), IINCHIP_READ(PATR0+1)); + + loop_idx = 0; + if (IINCHIP_READ(PATR0) == 0xc0 && IINCHIP_READ(PATR0+1) == 0x23) + { + printf("PAP\r\n"); // in case of adsl normally supports PAP. + // send authentication data + // copy (idlen + id + passwdlen + passwd) + buf[loop_idx] = idlen; loop_idx++; + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(id), idlen); loop_idx += idlen; + buf[loop_idx] = passwdlen; loop_idx++; + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(passwd), passwdlen); loop_idx += passwdlen; + send_data_processing(0, buf, loop_idx); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); + wait_10ms(100); + } + else if (IINCHIP_READ(PATR0) == 0xc2 && IINCHIP_READ(PATR0+1) == 0x23) + { + uint8 chal_len; + md5_ctx context; + uint8 digest[16]; + + len = getSn_RX_RSR(0); + if ( len > 0 ) + { + recv_data_processing(0, str, len); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_RECV); +#ifdef __DEF_IINCHIP_DBG__ + printf("recv CHAP\r\n"); + { + int16 i; + + for (i = 0; i < 32; i++) + printf ("%02x ", str[i]); + } + printf("\r\n"); +#endif +// str is C2 23 xx CHAL_ID xx xx CHAP_LEN CHAP_DATA +// index 0 1 2 3 4 5 6 7 ... + + memset(buf,0x00,64); + buf[loop_idx] = str[3]; loop_idx++; // chal_id + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(passwd), passwdlen); loop_idx += passwdlen; //passwd + chal_len = str[6]; // chal_id + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(str+7), chal_len); loop_idx += chal_len; //challenge + buf[loop_idx] = 0x80; +#ifdef __DEF_IINCHIP_DBG__ + printf("CHAP proc d1\r\n"); + { + int16 i; + for (i = 0; i < 64; i++) + printf ("%02x ", buf[i]); + } + printf("\r\n"); +#endif + + md5_init(&context); + md5_update(&context, buf, loop_idx); + md5_final(digest, &context); + +#ifdef __DEF_IINCHIP_DBG__ + printf("CHAP proc d1\r\n"); + { + int16 i; + for (i = 0; i < 16; i++) + printf ("%02x", digest[i]); + } + printf("\r\n"); +#endif + loop_idx = 0; + buf[loop_idx] = 16; loop_idx++; // hash_len + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(digest), 16); loop_idx += 16; // hashed value + memcpy((uint8 *)(buf+loop_idx), (uint8 *)(id), idlen); loop_idx += idlen; // id + send_data_processing(0, buf, loop_idx); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); + wait_10ms(100); + } + } + else + { + printf("Not support\r\n"); +#ifdef __DEF_IINCHIP_DBG__ + printf("Not support PPP Auth type: %.2x%.2x\r\n",IINCHIP_READ(PATR0), IINCHIP_READ(PATR0+1)); +#endif + return 4; + } + printf("\r\n"); + + printf("-- Waiting for PPPoE server's admission --"); + loop_idx = 0; + while (!((isr = IINCHIP_READ(Sn_IR(0))) & Sn_IR_PNEXT)) + { + if (isr & Sn_IR_PFAIL) + { + printf("failed\r\nReinput id, password..\r\n"); + return 2; + } + printf("."); + if (loop_idx++ == 10) // timeout + { + printf("timeout after PAP\r\n"); + return 3; + } + wait_10ms(100); + } + printf("ok\r\n"); + printf("\r\n"); + printf("-- PHASE 4. IPCP process --"); + // IP Address + buf[0] = 0x03; buf[1] = 0x06; buf[2] = 0x00; buf[3] = 0x00; buf[4] = 0x00; buf[5] = 0x00; + send_data_processing(0, buf, 6); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); + wait_10ms(100); + + loop_idx = 0; + while (1) + { + if (IINCHIP_READ(Sn_IR(0)) & Sn_IR_PRECV) + { + len = getSn_RX_RSR(0); + if ( len > 0 ) + { + recv_data_processing(0, str, len); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_RECV); + //for debug + //printf("IPCP proc\r\n"); for (i = 0; i < len; i++) printf ("%02x ", str[i]); printf("\r\n"); + str_idx = 6; dst_idx = 0; + if (str[2] == 0x03) // in case of NAK + { + do + { + if (str[str_idx] == 0x03) // request only ip information + { + memcpy((uint8 *)(buf+dst_idx), (uint8 *)(str+str_idx), str[str_idx+1]); + dst_idx += str[str_idx+1]; str_idx += str[str_idx+1]; + } + else + { + // skip byte + str_idx += str[str_idx+1]; + } + // for debug + //printf("s: %d, d: %d, l: %d", str_idx, dst_idx, len); + } while (str_idx != len); + send_data_processing(0, buf, dst_idx); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); // send ipcp request + wait_10ms(100); + break; + } + } + } + printf("."); + if (loop_idx++ == 10) // timeout + { + printf("timeout after IPCP\r\n"); + return 3; + } + wait_10ms(100); + send_data_processing(0, buf, 6); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); //ipcp re-request + } + + loop_idx = 0; + while (!(IINCHIP_READ(Sn_IR(0)) & Sn_IR_PNEXT)) + { + printf("."); + if (loop_idx++ == 10) // timeout + { + printf("timeout after IPCP NAK\r\n"); + return 3; + } + wait_10ms(100); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PCR); // send ipcp request + } + printf("ok\r\n"); + printf("\r\n"); + return 1; + // after this function, User must save the pppoe server's mac address and pppoe session id in current connection +} + + +/** +@brief terminate PPPoE connection +*/ +uint8 pppterm(uint8 * mac, uint8 * sessionid) +{ + uint16 i; + uint8 isr; +#ifdef __DEF_IINCHIP_DBG__ + printf("pppterm()\r\n"); +#endif + /* Set PPPoE bit in MR(Common Mode Register) : enable socket0 pppoe */ + IINCHIP_WRITE(MR,IINCHIP_READ(MR) | MR_PPPOE); + + // write pppoe server's mac address and session id + // must be setted these value. + for (i = 0; i < 6; i++) IINCHIP_WRITE((Sn_DHAR0(0)+i),mac[i]); + for (i = 0; i < 2; i++) IINCHIP_WRITE((Sn_DPORT0(0)+i),sessionid[i]); + isr = IINCHIP_READ(Sn_IR(0)); + IINCHIP_WRITE(Sn_IR(0),isr); + + //open socket in pppoe mode + IINCHIP_WRITE(Sn_MR(0),Sn_MR_PPPOE); + IINCHIP_WRITE(Sn_CR(0),Sn_CR_OPEN); + wait_1us(1); + // close pppoe connection + IINCHIP_WRITE(Sn_CR(0),Sn_CR_PDISCON); + wait_10ms(100); + // close socket + IINCHIP_WRITE(Sn_CR(0),Sn_CR_CLOSE); + +#ifdef __DEF_IINCHIP_DBG__ + printf("pppterm() end ..\r\n"); +#endif + + return 1; +} +#endif diff --git a/branches/follower/libw5100/src/libw5100/w5100.h b/branches/follower/libw5100/src/libw5100/w5100.h new file mode 100644 index 0000000..e87be4c --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/w5100.h @@ -0,0 +1,312 @@ +/* +@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) + +//not support +//#define RX_CH_DMEM_SIZE (COMMON_BASE + 0x001E) +//#define TX_CH_DMEM_SIZE (COMMON_BASE + 0x001F) + +/** + @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 +*********************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +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); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif diff --git a/branches/follower/libw5100/src/libw5100/w5100_device.cpp b/branches/follower/libw5100/src/libw5100/w5100_device.cpp new file mode 100644 index 0000000..6fec945 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/w5100_device.cpp @@ -0,0 +1,140 @@ +/* + + W5100 device configuration + +*/ + +#include "w5100_device.h" + +W5100Device::W5100Device(int resetPin) { + /* + + Store configuration and initialise the W5100 device + + */ + + // TODO: We should really allow the chip-select pin to be set here? + // Or require that it's defined. (Currently in the library file 'types.h'.) + _resetPin = resetPin; + + _init(); +} + + +void W5100Device::_init(void) { + /* + + Initialise the W5100 device and driver. + + */ + + /* + Initialise the W5100 chip + + (Originally I thought it was possible for the chip + to function without a hardware reset but it + seems not to be the case.) + */ + pinMode(_resetPin, OUTPUT); + + // We rely on the time between function calls to + // be long enough for the chip to recognise the + // reset. + digitalWrite(_resetPin, HIGH); + digitalWrite(_resetPin, LOW); // reset + digitalWrite(_resetPin, HIGH); + + // Enable SPI bug fix + // (We only need to do this to enable additional optional + // devices on the SPI bus. The current version of the W5100 + // requires SPI_EN to be low when you communicate with other + // devices on the SPI bus.) +#define PIN_SPI_EN 8 // WIZnet module SPI_EN + pinMode(PIN_SPI_EN, OUTPUT); + digitalWrite(PIN_SPI_EN, HIGH); + + // Chip initialisation by driver + // Might be redundant following the above reset, + // as this performs a software reset. + iinchip_init(); + + // Initialise driver + // (This is required to configure some variables used + // internally by the driver--even if the default chip + // configuration is used.) + sysinit(0x55, 0x55); +} + + +byte * W5100Device::_packBuffer(byte b0, byte b1, byte b2, byte b3) { + /* + + Utility function to pack four bytes into a buffer + in order to pass on to the lower-level drive functions. + + */ + return _packBuffer(b0, b1, b2, b3, 0, 0); // Adds two bytes of padding +} + + +byte * W5100Device::_packBuffer(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5) { + /* + + Utility function to pack six bytes into a buffer + in order to pass on to the lower-level drive functions. + + */ + _scratchBuffer[0] = b0; + _scratchBuffer[1] = b1; + _scratchBuffer[2] = b2; + _scratchBuffer[3] = b3; + _scratchBuffer[4] = b4; + _scratchBuffer[5] = b5; + + return _scratchBuffer; +} + + +void W5100Device::setIp(byte b0, byte b1, byte b2, byte b3) { + /* + + Set device IP address. + + */ + setSIPR(_packBuffer(b0, b1, b2, b3)); +} + + +void W5100Device::setMask(byte b0, byte b1, byte b2, byte b3) { + /* + + Set device net mask. + + */ + setSUBR(_packBuffer(b0, b1, b2, b3)); +} + + +void W5100Device::setGateway(byte b0, byte b1, byte b2, byte b3) { + /* + + Set device gateway. + + (Note: this is required to access the internet from within a LAN.) + + */ + setGAR(_packBuffer(b0, b1, b2, b3)); +} + + +void W5100Device::setMac(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5) { + /* + + Set device MAC address. + + */ + setSHAR(_packBuffer(b0, b1, b2, b3, b4, b5)); +} + +// W5100Device W5100 = W5100Device(PIN_RESET); + diff --git a/branches/follower/libw5100/src/libw5100/w5100_device.h b/branches/follower/libw5100/src/libw5100/w5100_device.h new file mode 100644 index 0000000..1404fb0 --- /dev/null +++ b/branches/follower/libw5100/src/libw5100/w5100_device.h @@ -0,0 +1,39 @@ +/* + + W5100 device configuration + +*/ + +#ifndef _W5100_DEVICE_H_ +#define _W5100_DEVICE_H_ + +// From original driver +#include "types.h" +#include "w5100.h" +#include "socket.h" + +// Required for use in Arduino environment +#include + +class W5100Device { + + public: + W5100Device(int resetPin); + + void setIp(byte b0, byte b1, byte b2, byte b3); + void setMask(byte b0, byte b1, byte b2, byte b3); + void setGateway(byte b0, byte b1, byte b2, byte b3); + void setMac(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5); + + void _init(void); + + private: + byte * _packBuffer(byte b0, byte b1, byte b2, byte b3); + byte * _packBuffer(byte b0, byte b1, byte b2, byte b3, byte b4, byte b5); + + int _resetPin; + + byte _scratchBuffer[6]; // TODO: Can we make this static? +}; + +#endif