diff options
Diffstat (limited to 'src')
20 files changed, 2686 insertions, 924 deletions
diff --git a/src/Duet/Network.cpp b/src/Duet/Network.cpp index f3ecfcf3..ad2fdb8b 100644 --- a/src/Duet/Network.cpp +++ b/src/Duet/Network.cpp @@ -72,7 +72,7 @@ static struct mdns_service mdns_services[] = { }, { .name = "\x05_http\x04_tcp\x05local", - .port = DEFAULT_HTTP_PORT, + .port = DefaultHttpPort, }, { .name = "\x04_ftp\x04_tcp\x05local", @@ -102,7 +102,7 @@ static uint16_t sendingWindowSize, sentDataOutstanding; static uint8_t sendingRetries; static err_t writeResult, outputResult; -static uint16_t httpPort = DEFAULT_HTTP_PORT; +static uint16_t httpPort = DefaultHttpPort; /*-----------------------------------------------------------------------------------*/ diff --git a/src/Duet/Network.h b/src/Duet/Network.h index cc099864..d3d9904b 100644 --- a/src/Duet/Network.h +++ b/src/Duet/Network.h @@ -33,12 +33,12 @@ const size_t NETWORK_TRANSACTION_COUNT = 24; // Number of NetworkTransacti const uint32_t TCP_WRITE_TIMEOUT = 4000; // Miliseconds to wait for data we have written to be acknowledged const uint32_t TCP_MAX_SEND_RETRIES = 8; // How many times can we attempt to write data -const uint8_t MAC_ADDRESS[6] = { 0xBE, 0xEF, 0xDE, 0xAD, 0xFE, 0xED }; // Need some sort of default... -const uint8_t IP_ADDRESS[4] = { 192, 168, 1, 10 }; -const uint8_t NET_MASK[4] = { 255, 255, 255, 0 }; -const uint8_t GATE_WAY[4] = { 192, 168, 1, 1 }; +const uint8_t DefaultMacAddress[6] = { 0xBE, 0xEF, 0xDE, 0xAD, 0xFE, 0xED }; // Need some sort of default... +const uint8_t DefaultIpAddress[4] = { 192, 168, 1, 10 }; +const uint8_t DefaultNetMask[4] = { 255, 255, 255, 0 }; +const uint8_t DefaultGateway[4] = { 192, 168, 1, 1 }; -const uint16_t DEFAULT_HTTP_PORT = 80; +const uint16_t DefaultHttpPort = 80; const uint16_t FTP_PORT = 21; const uint16_t TELNET_PORT = 23; diff --git a/src/DuetNG/DuetEthernet/Network.cpp b/src/DuetNG/DuetEthernet/Network.cpp index 27deb978..e2c17ddf 100644 --- a/src/DuetNG/DuetEthernet/Network.cpp +++ b/src/DuetNG/DuetEthernet/Network.cpp @@ -8,8 +8,9 @@ #include "RepRapFirmware.h" #include "compiler.h" #include "Pins.h" -#include "Ethernet3/Ethernet3.h" - +#include "IPAddress.h" +#include "wizchip_conf.h" +#include "Wiznet/Internet/DHCP/dhcp.h" void Network::SetIPAddress(const uint8_t p_ipAddress[], const uint8_t p_netmask[], const uint8_t p_gateway[]) { @@ -18,11 +19,12 @@ void Network::SetIPAddress(const uint8_t p_ipAddress[], const uint8_t p_netmask[ memcpy(gateway, p_gateway, sizeof(gateway)); } -Network::Network(Platform* p) : platform(p), responseCode(0), responseBody(nullptr), responseText(nullptr), responseFile(nullptr), - httpPort(DEFAULT_HTTP_PORT), - state(disabled), activated(false) +Network::Network(Platform* p) + : platform(p), lastTickMillis(0), + freeTransactions(nullptr), readyTransactions(nullptr), writingTransactions(nullptr), + httpPort(DefaultHttpPort), state(NetworkState::disabled), activated(false) { - SetIPAddress(IP_ADDRESS, NET_MASK, GATE_WAY); + SetIPAddress(DefaultIpAddress, DefaultNetMask, DefaultGateway); strcpy(hostname, HOSTNAME); } @@ -30,7 +32,9 @@ void Network::Init() { // Ensure that the chip is in the reset state pinMode(EspResetPin, OUTPUT_LOW); - state = disabled; + state = NetworkState::disabled; + longWait = platform->Time(); + lastTickMillis = millis(); } // This is called at the end of config.g processing. @@ -38,7 +42,7 @@ void Network::Init() void Network::Activate() { activated = true; - if (state == enabled) + if (state == NetworkState::enabled) { Start(); } @@ -51,106 +55,176 @@ void Network::Exit() void Network::Spin() { -#if 1 -#if 0 - if (state == starting) + switch(state) { - const int rc = Ethernet.begin(platform->MACAddress(), 12000, 5000); // for now we always use DHCP - if (rc == 1) + case NetworkState::enabled: + case NetworkState::disabled: + // Nothing to do + break; + + case NetworkState::establishingLink: + if (wizphy_getphylink() == PHY_LINK_ON) { - state = running; + + usingDhcp = (ipAddress[0] == 0 && ipAddress[1] == 0 && ipAddress[2] == 0 && ipAddress[3] == 0); + if (usingDhcp) + { + debugPrintf("Link established, getting IP address\n"); + // IP address is all zeros, so use DHCP + DHCP_init(DhcpSocketNumber, hostname); + lastTickMillis = millis(); + state = NetworkState::obtainingIP; + } + else + { + debugPrintf("Link established, network running\n"); + state = NetworkState::active; + } } - } - else if (state == running) -#else - if (state == starting || state == running) -#endif - { - // Check DHCP - const int rc = Ethernet.maintain(); - if (state == starting && (rc == DHCP_CHECK_RENEW_OK || rc == DHCP_CHECK_REBIND_OK)) + break; + + case NetworkState::obtainingIP: + if (wizphy_getphylink() == PHY_LINK_ON) + { + const uint32_t now = millis(); + if (now - lastTickMillis >= 1000) + { + lastTickMillis += 1000; + DHCP_time_handler(); + } + const DhcpRunResult ret = DHCP_run(); + if (ret == DhcpRunResult::DHCP_IP_ASSIGN) + { + debugPrintf("IP address obtained, network running\n"); + getSIPR(ipAddress); + // Send mDNS announcement so that some routers can perform hostname mapping + // if this board is connected via a non-IGMP capable WiFi bridge (like the TP-Link WR701N) + //mdns_announce(); + state = NetworkState::active; + } + } + else { - state = running; + DHCP_stop(); + state = NetworkState::establishingLink; } + break; + + case NetworkState::active: + if (wizphy_getphylink() == PHY_LINK_ON) + { + if (usingDhcp) + { + const uint32_t now = millis(); + if (now - lastTickMillis >= 1000) + { + lastTickMillis += 1000; + DHCP_time_handler(); + } + const DhcpRunResult ret = DHCP_run(); + if (ret == DhcpRunResult::DHCP_IP_CHANGED) + { + getSIPR(ipAddress); + } + } + + // See if we can read any packets +// ethernet_task(); + + // See if we can send anything + NetworkTransaction *transaction = writingTransactions; + if (transaction != nullptr /*&& sendingConnection == nullptr*/ ) + { + if (transaction->GetNext() != nullptr) + { + // Data is supposed to be sent and the last packet has been acknowledged. + // Rotate the transactions so every client is served even while multiple files are sent + NetworkTransaction *next = transaction->GetNext(); + writingTransactions = next; + AppendTransaction(&writingTransactions, transaction); + transaction = next; + } + + if (transaction->Send()) + { + // This transaction can be released, do this here + writingTransactions = transaction->GetNext(); + PrependTransaction(&freeTransactions, transaction); + + // If there is more data to write on this connection, do it sometime soon + NetworkTransaction *nextWrite = transaction->GetNextWrite(); + if (nextWrite != nullptr) + { + PrependTransaction(&writingTransactions, nextWrite); + } + } + } + } + else + { + DHCP_stop(); + state = NetworkState::establishingLink; + } + break; } -#endif + platform->ClassReport(longWait); } void Network::Diagnostics(MessageType mtype) { - + platform->Message(mtype, "=== Network ===\n"); + platform->MessageF(mtype, "State: %d\n", (int)state); } void Network::Start() { + SetIPAddress(platform->GetIPAddress(), platform->NetMask(), platform->GateWay()); pinMode(EspResetPin, OUTPUT_LOW); delayMicroseconds(550); // W550 reset pulse must be at least 500us long Platform::WriteDigital(EspResetPin, HIGH); // raise /Reset pin delay(55); // W5500 needs 50ms to start up - state = starting; -#if 0 - w5500.init(); - w5500.setMACAddress(platform->MACAddress()); -#endif - const int rc = Ethernet.begin(platform->MACAddress(), 12000, 5000); // for now we always use DHCP - if (rc == 1) - { - state = running; - } - else - { -#if 1 - { - uint8_t tmp = w5500.readPHYCFGR(); - uint8_t version = w5500.readVERSIONR(); - uint8_t macBuf[6]; - w5500.readSHAR(macBuf); - platform->MessageF(GENERIC_MESSAGE, "Phy %02x ver %02x Mac %02x:%02x:%02x:%02x:%02x:%02x\n", - tmp, version, macBuf[0], macBuf[1], macBuf[2], macBuf[3], macBuf[4], macBuf[5]); - } -#endif - platform->Message(GENERIC_MESSAGE, "Failed to start Ethernet interface\n"); - Stop(); - } + + static const uint8_t bufSizes[8] = { 2, 2, 2, 2, 2, 2, 2, 2 }; + wizchip_init(bufSizes, bufSizes); + + setSHAR(platform->MACAddress()); + setSIPR(ipAddress); + setGAR(gateway); + setSUBR(netmask); + + state = NetworkState::establishingLink; } void Network::Stop() { - if (state != disabled) + if (state != NetworkState::disabled) { - Ethernet.stop(); +//TODO Ethernet.stop(); + if (usingDhcp) + { + DHCP_stop(); + } digitalWrite(EspResetPin, LOW); // put the ESP back into reset - state = disabled; + state = NetworkState::disabled; } } void Network::Enable() { - if (state == disabled) + if (state == NetworkState::disabled) { - state = enabled; + state = NetworkState::enabled; if (activated) { Start(); } } -#if 1 - else if (state == starting) - { - uint8_t tmp = w5500.readPHYCFGR(); - uint8_t version = w5500.readVERSIONR(); - uint8_t macBuf[6]; - w5500.readSHAR(macBuf); - platform->MessageF(GENERIC_MESSAGE, "Phy %02x ver %02x Mac %02x:%02x:%02x:%02x:%02x:%02x\n", - tmp, version, macBuf[0], macBuf[1], macBuf[2], macBuf[3], macBuf[4], macBuf[5]); - } -#endif } void Network::Disable() { - if (activated && state != disabled) + if (activated && state != NetworkState::disabled) { Stop(); platform->Message(GENERIC_MESSAGE, "WiFi server stopped\n"); @@ -159,21 +233,12 @@ void Network::Disable() bool Network::IsEnabled() const { - return state != disabled; + return state != NetworkState::disabled; } const uint8_t *Network::GetIPAddress() const { - if (state == running) - { - static IPAddress ip; - ip = Ethernet.localIP(); - return ip.GetRawAddress(); - } - else - { - return ipAddress; - } + return ipAddress; } void Network::SetHttpPort(uint16_t port) @@ -277,6 +342,22 @@ NetworkTransaction *Network::GetTransaction(const ConnectionState *cs) #endif } +void Network::AppendTransaction(NetworkTransaction* * list, NetworkTransaction *r) +{ + r->next = nullptr; + while (*list != nullptr) + { + list = &((*list)->next); + } + *list = r; +} + +void Network::PrependTransaction(NetworkTransaction* * list, NetworkTransaction *r) +{ + r->next = *list; + *list = r; +} + void Network::OpenDataPort(uint16_t port) { //TODO @@ -384,586 +465,4 @@ bool Network::AcquireTelnetTransaction() #endif } -//*************************************************************************************************** - -// ConnectionState class - -#if 0 -void ConnectionState::Init(tcp_pcb *p) -{ - pcb = p; - localPort = p->local_port; - remoteIPAddress = p->remote_ip.addr; - remotePort = p->remote_port; - next = nullptr; - sendingTransaction = nullptr; - persistConnection = true; - isTerminated = false; -} -#endif - -void ConnectionState::Terminate() -{ - //TODO -#if 0 - if (pcb != nullptr) - { - tcp_abort(pcb); - } -#endif -} - -//*************************************************************************************************** -// NetworkTransaction class - -NetworkTransaction::NetworkTransaction(NetworkTransaction *n) : next(n), status(released) -{ - sendStack = new OutputStack(); -} - -void NetworkTransaction::Set(pbuf *p, ConnectionState *c, TransactionStatus s) -{ - cs = c; -// pb = readingPb = p; - status = s; -// inputPointer = 0; - sendBuffer = nullptr; - fileBeingSent = nullptr; - closeRequested = false; - nextWrite = nullptr; - dataAcknowledged = false; -} - -bool NetworkTransaction::HasMoreDataToRead() const -{ - //TODO - return false; -} - -// Read one char from the NetworkTransaction -bool NetworkTransaction::Read(char& b) -{ -#if 1 - return false; -#else - if (readingPb == nullptr) - { - b = 0; - return false; - } - - b = ((const char*)readingPb->payload)[inputPointer++]; - if (inputPointer == readingPb->len) - { - readingPb = readingPb->next; - inputPointer = 0; - } - return true; -#endif -} - -// Read data from the NetworkTransaction and return true on success -bool NetworkTransaction::ReadBuffer(const char *&buffer, size_t &len) -{ -#if 1 - return false; -#else - if (readingPb == nullptr) - { - return false; - } - - if (inputPointer >= readingPb->len) - { - readingPb = readingPb->next; - inputPointer = 0; - if (readingPb == nullptr) - { - return false; - } - } - - buffer = (const char*)readingPb->payload + inputPointer; - len = readingPb->len - inputPointer; - readingPb = readingPb->next; - inputPointer = 0; - return true; -#endif -} - -void NetworkTransaction::Write(char b) -{ - if (CanWrite()) - { - if (sendBuffer == nullptr && !OutputBuffer::Allocate(sendBuffer)) - { - // Should never get here - return; - } - sendBuffer->cat(b); - } -} - -void NetworkTransaction::Write(const char* s) -{ - if (CanWrite()) - { - if (sendBuffer == nullptr && !OutputBuffer::Allocate(sendBuffer)) - { - // Should never get here - return; - } - sendBuffer->cat(s); - } -} - -void NetworkTransaction::Write(StringRef ref) -{ - Write(ref.Pointer(), ref.strlen()); -} - -void NetworkTransaction::Write(const char* s, size_t len) -{ - if (CanWrite()) - { - if (sendBuffer == nullptr && !OutputBuffer::Allocate(sendBuffer)) - { - // Should never get here - return; - } - sendBuffer->cat(s, len); - } -} - -void NetworkTransaction::Write(OutputBuffer *buffer) -{ - if (CanWrite()) - { - // Note we use an individual stack here, because we don't want to link different - // OutputBuffers for different destinations together... - sendStack->Push(buffer); - } - else - { - // Don't keep buffers we can't send... - OutputBuffer::ReleaseAll(buffer); - } -} - -void NetworkTransaction::Write(OutputStack *stack) -{ - if (stack != nullptr) - { - if (CanWrite()) - { - sendStack->Append(stack); - } - else - { - stack->ReleaseAll(); - } - } -} - -void NetworkTransaction::Printf(const char* fmt, ...) -{ - if (CanWrite() && (sendBuffer != nullptr || OutputBuffer::Allocate(sendBuffer))) - { - va_list p; - va_start(p, fmt); - sendBuffer->vprintf(fmt, p); - va_end(p); - } -} - -void NetworkTransaction::SetFileToWrite(FileStore *file) -{ - if (CanWrite()) - { - fileBeingSent = file; - } - else if (file != nullptr) - { - file->Close(); - } -} - -// Send exactly one TCP window of data and return true when this transaction can be released -bool NetworkTransaction::Send() -{ -#if 1 - return true; -#else - // Free up this transaction if the connection is supposed to be closed - if (closeRequested) - { - reprap.GetNetwork()->ConnectionClosed(cs, true); // This will release the transaction too - return false; - } - - // Fill up the TCP window with some data chunks from our OutputBuffer instances - size_t bytesBeingSent = 0, bytesLeftToSend = TCP_WND; - while (sendBuffer != nullptr && bytesLeftToSend > 0) - { - size_t copyLength = min<size_t>(bytesLeftToSend, sendBuffer->BytesLeft()); - memcpy(sendingWindow + bytesBeingSent, sendBuffer->Read(copyLength), copyLength); - bytesBeingSent += copyLength; - bytesLeftToSend -= copyLength; - - if (sendBuffer->BytesLeft() == 0) - { - sendBuffer = OutputBuffer::Release(sendBuffer); - if (sendBuffer == nullptr) - { - sendBuffer = sendStack->Pop(); - } - } - } - - // We also intend to send a file, so check if we can fill up the TCP window - if (sendBuffer == nullptr && bytesLeftToSend != 0 && fileBeingSent != nullptr) - { - // For HSMCI efficiency, read from the file in multiples of 4 bytes except at the end. - // This ensures that the second and subsequent chunks can be DMA'd directly into sendingWindow. - size_t bytesToRead = bytesLeftToSend & (~3); - if (bytesToRead != 0) - { - int bytesRead = fileBeingSent->Read(sendingWindow + bytesBeingSent, bytesToRead); - if (bytesRead > 0) - { - bytesBeingSent += bytesRead; - } - - if (bytesRead != (int)bytesToRead) - { - fileBeingSent->Close(); - fileBeingSent = nullptr; - } - } - } - - if (bytesBeingSent == 0) - { - // If we have no data to send, this connection can be closed next time - if (!cs->persistConnection && nextWrite == nullptr) - { - Close(); - return false; - } - - // We want to send data from another transaction as well, so only free up this one - cs->sendingTransaction = nextWrite; - return true; - } - - // The TCP window has been filled up as much as possible, so send it now. There is no need to check - // the available space in the SNDBUF queue, because we really write only one TCP window at once. - writeResult = tcp_write(cs->pcb, sendingWindow, bytesBeingSent, 0); - if (ERR_IS_FATAL(writeResult)) - { - reprap.GetPlatform()->MessageF(HOST_MESSAGE, "Network: Failed to write data in Send (code %d)\n", writeResult); - tcp_abort(cs->pcb); - return false; - } - - outputResult = tcp_output(cs->pcb); - if (ERR_IS_FATAL(outputResult)) - { - reprap.GetPlatform()->MessageF(HOST_MESSAGE, "Network: Failed to output data in Send (code %d)\n", outputResult); - tcp_abort(cs->pcb); - return false; - } - - if (outputResult != ERR_OK && reprap.Debug(moduleNetwork)) - { - reprap.GetPlatform()->MessageF(HOST_MESSAGE, "Network: tcp_output resulted in error code %d\n", outputResult); - } - - // Set LwIP callbacks for ACK and retransmission handling - tcp_poll(cs->pcb, conn_poll, TCP_WRITE_TIMEOUT / TCP_SLOW_INTERVAL / TCP_MAX_SEND_RETRIES); - tcp_sent(cs->pcb, conn_sent); - - // Set all values for the send process - sendingConnection = cs; - sendingRetries = 0; - sendingWindowSize = sentDataOutstanding = bytesBeingSent; - return false; -#endif -} - -// This is called by the Webserver to send output data to a client. If keepConnectionAlive is set to false, -// the current connection will be terminated once everything has been sent. -void NetworkTransaction::Commit(bool keepConnectionAlive) -{ -#if 0 - // If the connection has been terminated (e.g. RST received while writing upload data), discard this transaction - if (!IsConnected() || status == released) - { - Discard(); - return; - } - - // Free buffer holding the incoming data and prepare some values for the sending process - FreePbuf(); - cs->persistConnection = keepConnectionAlive; - if (sendBuffer == nullptr) - { - sendBuffer = sendStack->Pop(); - } - status = sending; - - // Unlink the item(s) from the list of ready transactions - if (keepConnectionAlive) - { - // Our connection is still of interest, remove only this transaction from the list - NetworkTransaction *previous = nullptr; - for(NetworkTransaction *item = reprap.GetNetwork()->readyTransactions; item != nullptr; item = item->next) - { - if (item == this) - { - if (previous == nullptr) - { - reprap.GetNetwork()->readyTransactions = next; - } - else - { - previous->next = next; - } - break; - } - previous = item; - } - } - else - { - // We will close this connection soon, stop receiving data from this PCB - tcp_recv(cs->pcb, nullptr); - - // Also remove all ready transactions pointing to our ConnectionState - NetworkTransaction *previous = nullptr, *item = reprap.GetNetwork()->readyTransactions; - while (item != nullptr) - { - if (item->cs == cs) - { - if (item == this) - { - // Only unlink this item - if (previous == nullptr) - { - reprap.GetNetwork()->readyTransactions = next; - } - else - { - previous->next = next; - } - item = next; - } - else - { - // Remove all others - item->Discard(); - item = (previous == nullptr) ? reprap.GetNetwork()->readyTransactions : previous->next; - } - } - else - { - previous = item; - item = item->next; - } - } - } - - // Enqueue this transaction, so it's sent in the right order - NetworkTransaction *mySendingTransaction = cs->sendingTransaction; - if (mySendingTransaction == nullptr) - { - cs->sendingTransaction = this; - reprap.GetNetwork()->AppendTransaction(&reprap.GetNetwork()->writingTransactions, this); - } - else - { - while (mySendingTransaction->nextWrite != nullptr) - { - mySendingTransaction = mySendingTransaction->nextWrite; - } - mySendingTransaction->nextWrite = this; - } -#endif -} - -// Call this to perform some networking tasks while processing deferred requests, -// and to move this transaction and all transactions that are associated with its -// connection to the end of readyTransactions. There are three ways to do this: -// -// 1) DeferOnly: Do not modify any of the processed data and don't send an ACK. -// This will ensure that zero-window packets are sent back to the client -// 2) ResetData: Reset the read pointers and acknowledge that the data has been processed -// 3) DiscardData: Free the processed data, acknowledge it and append this transaction as -// an empty item again without payload (i.e. without pbufs) -// -void NetworkTransaction::Defer(DeferralMode mode) -{ -#if 0 - if (mode == DeferralMode::ResetData) - { - // Reset the reading pointers and send an ACK - inputPointer = 0; - readingPb = pb; - if (IsConnected() && pb != nullptr && !dataAcknowledged) - { - tcp_recved(cs->pcb, pb->tot_len); - dataAcknowledged = true; - } - } - else if (mode == DeferralMode::DiscardData) - { - // Discard the incoming data, because we don't need to process it any more - FreePbuf(); - } - - status = deferred; - - // Unlink this transaction from the list of ready transactions and append it again - Network *network = reprap.GetNetwork(); - NetworkTransaction *item, *previous = nullptr; - for(item = network->readyTransactions; item != nullptr; item = item->next) - { - if (item == this) - { - if (previous == nullptr) - { - network->readyTransactions = next; - } - else - { - previous->next = next; - } - break; - } - previous = item; - } - network->AppendTransaction(&network->readyTransactions, this); - - // Append all other transactions that are associated to this connection, so that the - // Webserver gets a chance to deal with all connected clients even while multiple - // deferred requests are present in the list. - item = network->readyTransactions; - previous = nullptr; - while (item != this) - { - if (item->cs == cs) - { - NetworkTransaction *nextItem = item->next; - if (previous == nullptr) - { - network->readyTransactions = item->next; - network->AppendTransaction(&network->readyTransactions, item); - } - else - { - previous->next = item->next; - network->AppendTransaction(&network->readyTransactions, item); - } - item = nextItem; - } - else - { - previous = item; - item = item->next; - } - } -#endif -} - - -// This method should be called if we don't want to send data to the client and if we -// don't want to interfere with the connection state. May also be called from ISR! -void NetworkTransaction::Discard() -{ -#if 0 - // Can we do anything? - if (status == released) - { - // No - don't free up released items multiple times - return; - } - - // Free up some resources - FreePbuf(); - - if (fileBeingSent != nullptr) - { - fileBeingSent->Close(); - fileBeingSent = nullptr; - } - - OutputBuffer::ReleaseAll(sendBuffer); - sendStack->ReleaseAll(); - - // Unlink this transactions from the list of ready transactions and free it. It is then appended to the list of - // free transactions because we don't want to risk reusing it when the ethernet ISR processes incoming data - NetworkTransaction *previous = nullptr; - for(NetworkTransaction *item = reprap.GetNetwork()->readyTransactions; item != nullptr; item = item->next) - { - if (item == this) - { - if (previous == nullptr) - { - reprap.GetNetwork()->readyTransactions = next; - } - else - { - previous->next = next; - } - break; - } - previous = item; - } - reprap.GetNetwork()->AppendTransaction(&reprap.GetNetwork()->freeTransactions, this); - bool callDisconnectHandler = (cs != nullptr && status == disconnected); - status = released; - - // Call disconnect event if this transaction indicates a graceful disconnect and if the connection - // still persists (may not be the case if a RST packet was received before) - if (callDisconnectHandler) - { - if (reprap.Debug(moduleNetwork)) - { - reprap.GetPlatform()->Message(HOST_MESSAGE, "Network: Discard() is handling a graceful disconnect\n"); - } - reprap.GetNetwork()->ConnectionClosed(cs, false); - } -#endif -} - -uint32_t NetworkTransaction::GetRemoteIP() const -{ - return (cs != nullptr) ? cs->GetRemoteIP() : 0; -} - -uint16_t NetworkTransaction::GetRemotePort() const -{ - return (cs != nullptr) ? cs->GetRemotePort() : 0; -} - -uint16_t NetworkTransaction::GetLocalPort() const -{ - return (cs != nullptr) ? cs->GetLocalPort() : 0; -} - -void NetworkTransaction::Close() -{ -#if 0 - tcp_pcb *pcb = cs->pcb; - tcp_recv(pcb, nullptr); - closeRequested = true; -#endif -} - -bool ConnectionState::IsConnected() const -{ - //TODO - return false; -} - // End diff --git a/src/DuetNG/DuetEthernet/Network.h b/src/DuetNG/DuetEthernet/Network.h index a2e1b4d7..36501dcc 100644 --- a/src/DuetNG/DuetEthernet/Network.h +++ b/src/DuetNG/DuetEthernet/Network.h @@ -15,131 +15,26 @@ Separated out from Platform.h by dc42 and extended by zpl #include <cstdlib> #include "MessageType.h" +#include "NetworkTransaction.h" -const uint8_t MAC_ADDRESS[6] = { 0xBE, 0xEF, 0xDE, 0xAD, 0xFE, 0xED }; // Need some sort of default... -const uint8_t IP_ADDRESS[4] = { 192, 168, 1, 10 }; // Need some sort of default... -const uint8_t NET_MASK[4] = { 255, 255, 255, 0 }; -const uint8_t GATE_WAY[4] = { 192, 168, 1, 1 }; +const uint8_t DefaultMacAddress[6] = { 0xBE, 0xEF, 0xDE, 0xAD, 0xFE, 0xED }; // Need some sort of default... +const uint8_t DefaultIpAddress[4] = { 0, 0, 0, 0 }; // Need some sort of default... +const uint8_t DefaultNetMask[4] = { 255, 255, 255, 0 }; +const uint8_t DefaultGateway[4] = { 0, 0, 0, 0 }; -const uint16_t DEFAULT_HTTP_PORT = 80; +const uint16_t DefaultHttpPort = 80; const uint16_t FTP_PORT = 21; const uint16_t TELNET_PORT = 23; -class Platform; - -struct tcp_pcb; -struct pbuf; - -class NetworkTransaction; - -// ConnectionState structure that we use to track TCP connections. It is usually combined with NetworkTransactions. -struct ConnectionState -{ -// tcp_pcb *volatile pcb; // Connection PCB - uint16_t localPort, remotePort; // Copy of the local and remote ports, because the PCB may be unavailable - uint32_t remoteIPAddress; // Same for the remote IP address - NetworkTransaction * volatile sendingTransaction; // NetworkTransaction that is currently sending via this connection - ConnectionState * volatile next; // Next ConnectionState in this list - bool persistConnection; // Do we expect this connection to stay alive? - volatile bool isTerminated; // Will be true if the connection has gone down unexpectedly (TCP RST) - -// void Init(tcp_pcb *p); - uint16_t GetLocalPort() const { return localPort; } - uint32_t GetRemoteIP() const { return remoteIPAddress; } - uint16_t GetRemotePort() const { return remotePort; } - bool IsConnected() const; // { return pcb != nullptr; } - bool IsTerminated() const { return isTerminated; } - void Terminate(); -}; +// We have 8 sockets available on the W5500. We reserve one for DHCP, leaving 7 for TCP/IP transactions i.e. HTTP, FTP and Telnet. +const size_t NumTcpSockets = 7; +const uint8_t DhcpSocketNumber = 7; -// Assign a status to each NetworkTransaction -enum TransactionStatus -{ - released, - connected, - receiving, - sending, - disconnected, - deferred, - acquired -}; - -// How is a deferred request supposed to be handled? -enum class DeferralMode -{ - DeferOnly, // don't change anything, because we want to read more of it next time - ResetData, // keep the data and reset all reading pointers allowing us to process it again - DiscardData // discard all incoming data and re-enqueue the empty transaction -}; - -// Start with a class to hold input and output from the network that needs to be responded to. -// This includes changes in the connection state, e.g. connects and disconnects. -class NetworkTransaction -{ - public: - friend class Network; - - NetworkTransaction(NetworkTransaction* n); - void Set(pbuf *p, ConnectionState* c, TransactionStatus s); - TransactionStatus GetStatus() const { return status; } - bool IsConnected() const; - - bool HasMoreDataToRead() const; // { return readingPb != nullptr; } - bool Read(char& b); - bool ReadBuffer(const char *&buffer, size_t &len); - void Write(char b); - void Write(const char* s); - void Write(StringRef ref); - void Write(const char* s, size_t len); - void Write(OutputBuffer *buffer); - void Write(OutputStack *stack); - void Printf(const char *fmt, ...); - void SetFileToWrite(FileStore *file); - - ConnectionState *GetConnection() const { return cs; } - uint16_t GetLocalPort() const; - uint32_t GetRemoteIP() const; - uint16_t GetRemotePort() const; - - void Commit(bool keepConnectionAlive); - void Defer(DeferralMode mode); - void Discard(); - - private: - bool CanWrite() const; - bool Send(); - void Close(); - - ConnectionState* cs; - NetworkTransaction* volatile next; // next NetworkTransaction in the list we are in - NetworkTransaction* volatile nextWrite; // next NetworkTransaction queued to write to assigned connection -// pbuf *pb, *readingPb; // received packet queue and a pointer to the pbuf being read from -// size_t inputPointer; // amount of data already taken from the first packet buffer - - OutputBuffer *sendBuffer; - OutputStack *sendStack; - FileStore * volatile fileBeingSent; - - volatile TransactionStatus status; - volatile bool closeRequested, dataAcknowledged; -}; +class Platform; // The main network class that drives the network. class Network { - enum NetworkState - { - disabled, // WiFi not active - enabled, // WiFi enabled but not started yet - starting, // starting up (waiting for initialisation) - running -// idle, // nothing happening -// receivePending, // we have asserted TransferReady and await completion of a receive-only transaction -// sendReceivePending, // we have asserted TransferReady and await completion of a transmit/receive -// transferDone, // transfer completed but receive DMA fifo may not have been flushed yet -// processing, // a transaction has been completed but we haven't released the input buffer yet -// sending // a transaction has been completed and we are sending the response - }; public: const uint8_t *GetIPAddress() const; void SetIPAddress(const uint8_t p_ipAddress[], const uint8_t p_netmask[], const uint8_t p_gateway[]); @@ -183,19 +78,26 @@ public: bool AcquireTelnetTransaction(); private: - void SetupSpi(); + enum class NetworkState + { + disabled, // WiFi not active + enabled, // WiFi enabled but not started yet + establishingLink, // starting up (waiting for initialisation) + obtainingIP, + active + }; Platform *platform; + float longWait; + uint32_t lastTickMillis; -// uint32_t responseIp; - uint32_t responseCode; -// uint32_t responseFragment; - OutputBuffer *responseBody; - const char* responseText; - FileStore *responseFile; -// uint32_t responseFileBytes; + void AppendTransaction(NetworkTransaction* * list, NetworkTransaction *r); + void PrependTransaction(NetworkTransaction* * list, NetworkTransaction *r); + bool AcquireTransaction(ConnectionState *cs); - float longWait; + NetworkTransaction * freeTransactions; + NetworkTransaction * readyTransactions; + NetworkTransaction * writingTransactions; uint16_t httpPort; uint8_t ipAddress[4]; @@ -205,16 +107,7 @@ private: NetworkState state; bool activated; + bool usingDhcp; }; -inline bool NetworkTransaction::IsConnected() const -{ - return (cs != nullptr && cs->IsConnected()); -} - -inline bool NetworkTransaction::CanWrite() const -{ - return (IsConnected() && status != released); -} - #endif diff --git a/src/DuetNG/DuetEthernet/NetworkTransacrion.cpp b/src/DuetNG/DuetEthernet/NetworkTransacrion.cpp new file mode 100644 index 00000000..e954723d --- /dev/null +++ b/src/DuetNG/DuetEthernet/NetworkTransacrion.cpp @@ -0,0 +1,595 @@ +/* + * NetworkTransacrion.cpp + * + * Created on: 23 Dec 2016 + * Author: David + */ + +#include "NetworkTransaction.h" +#include <cstdarg> + +//*************************************************************************************************** + +// ConnectionState class + +#if 0 +void ConnectionState::Init(tcp_pcb *p) +{ + pcb = p; + localPort = p->local_port; + remoteIPAddress = p->remote_ip.addr; + remotePort = p->remote_port; + next = nullptr; + sendingTransaction = nullptr; + persistConnection = true; + isTerminated = false; +} +#endif + +void ConnectionState::Terminate() +{ + //TODO +#if 0 + if (pcb != nullptr) + { + tcp_abort(pcb); + } +#endif +} + +bool ConnectionState::IsConnected() const +{ + //TODO + return false; +} + +//*************************************************************************************************** +// NetworkTransaction class + +NetworkTransaction::NetworkTransaction(NetworkTransaction *n) : next(n), status(released) +{ + sendStack = new OutputStack(); +} + +#if 0 +void NetworkTransaction::Set(pbuf *p, ConnectionState *c, TransactionStatus s) +{ + cs = c; +// pb = readingPb = p; + status = s; +// inputPointer = 0; + sendBuffer = nullptr; + fileBeingSent = nullptr; + closeRequested = false; + nextWrite = nullptr; + dataAcknowledged = false; +} +#endif + +bool NetworkTransaction::HasMoreDataToRead() const +{ + //TODO + return false; +} + +// Read one char from the NetworkTransaction +bool NetworkTransaction::Read(char& b) +{ +#if 1 + return false; +#else + if (readingPb == nullptr) + { + b = 0; + return false; + } + + b = ((const char*)readingPb->payload)[inputPointer++]; + if (inputPointer == readingPb->len) + { + readingPb = readingPb->next; + inputPointer = 0; + } + return true; +#endif +} + +// Read data from the NetworkTransaction and return true on success +bool NetworkTransaction::ReadBuffer(const char *&buffer, size_t &len) +{ +#if 1 + return false; +#else + if (readingPb == nullptr) + { + return false; + } + + if (inputPointer >= readingPb->len) + { + readingPb = readingPb->next; + inputPointer = 0; + if (readingPb == nullptr) + { + return false; + } + } + + buffer = (const char*)readingPb->payload + inputPointer; + len = readingPb->len - inputPointer; + readingPb = readingPb->next; + inputPointer = 0; + return true; +#endif +} + +void NetworkTransaction::Write(char b) +{ + if (CanWrite()) + { + if (sendBuffer == nullptr && !OutputBuffer::Allocate(sendBuffer)) + { + // Should never get here + return; + } + sendBuffer->cat(b); + } +} + +void NetworkTransaction::Write(const char* s) +{ + if (CanWrite()) + { + if (sendBuffer == nullptr && !OutputBuffer::Allocate(sendBuffer)) + { + // Should never get here + return; + } + sendBuffer->cat(s); + } +} + +void NetworkTransaction::Write(StringRef ref) +{ + Write(ref.Pointer(), ref.strlen()); +} + +void NetworkTransaction::Write(const char* s, size_t len) +{ + if (CanWrite()) + { + if (sendBuffer == nullptr && !OutputBuffer::Allocate(sendBuffer)) + { + // Should never get here + return; + } + sendBuffer->cat(s, len); + } +} + +void NetworkTransaction::Write(OutputBuffer *buffer) +{ + if (CanWrite()) + { + // Note we use an individual stack here, because we don't want to link different + // OutputBuffers for different destinations together... + sendStack->Push(buffer); + } + else + { + // Don't keep buffers we can't send... + OutputBuffer::ReleaseAll(buffer); + } +} + +void NetworkTransaction::Write(OutputStack *stack) +{ + if (stack != nullptr) + { + if (CanWrite()) + { + sendStack->Append(stack); + } + else + { + stack->ReleaseAll(); + } + } +} + +void NetworkTransaction::Printf(const char* fmt, ...) +{ + if (CanWrite() && (sendBuffer != nullptr || OutputBuffer::Allocate(sendBuffer))) + { + va_list p; + va_start(p, fmt); + sendBuffer->vprintf(fmt, p); + va_end(p); + } +} + +void NetworkTransaction::SetFileToWrite(FileStore *file) +{ + if (CanWrite()) + { + fileBeingSent = file; + } + else if (file != nullptr) + { + file->Close(); + } +} + +// Send exactly one TCP window of data and return true when this transaction can be released +bool NetworkTransaction::Send() +{ +#if 1 + return true; +#else + // Free up this transaction if the connection is supposed to be closed + if (closeRequested) + { + reprap.GetNetwork()->ConnectionClosed(cs, true); // This will release the transaction too + return false; + } + + // Fill up the TCP window with some data chunks from our OutputBuffer instances + size_t bytesBeingSent = 0, bytesLeftToSend = TCP_WND; + while (sendBuffer != nullptr && bytesLeftToSend > 0) + { + size_t copyLength = min<size_t>(bytesLeftToSend, sendBuffer->BytesLeft()); + memcpy(sendingWindow + bytesBeingSent, sendBuffer->Read(copyLength), copyLength); + bytesBeingSent += copyLength; + bytesLeftToSend -= copyLength; + + if (sendBuffer->BytesLeft() == 0) + { + sendBuffer = OutputBuffer::Release(sendBuffer); + if (sendBuffer == nullptr) + { + sendBuffer = sendStack->Pop(); + } + } + } + + // We also intend to send a file, so check if we can fill up the TCP window + if (sendBuffer == nullptr && bytesLeftToSend != 0 && fileBeingSent != nullptr) + { + // For HSMCI efficiency, read from the file in multiples of 4 bytes except at the end. + // This ensures that the second and subsequent chunks can be DMA'd directly into sendingWindow. + size_t bytesToRead = bytesLeftToSend & (~3); + if (bytesToRead != 0) + { + int bytesRead = fileBeingSent->Read(sendingWindow + bytesBeingSent, bytesToRead); + if (bytesRead > 0) + { + bytesBeingSent += bytesRead; + } + + if (bytesRead != (int)bytesToRead) + { + fileBeingSent->Close(); + fileBeingSent = nullptr; + } + } + } + + if (bytesBeingSent == 0) + { + // If we have no data to send, this connection can be closed next time + if (!cs->persistConnection && nextWrite == nullptr) + { + Close(); + return false; + } + + // We want to send data from another transaction as well, so only free up this one + cs->sendingTransaction = nextWrite; + return true; + } + + // The TCP window has been filled up as much as possible, so send it now. There is no need to check + // the available space in the SNDBUF queue, because we really write only one TCP window at once. + writeResult = tcp_write(cs->pcb, sendingWindow, bytesBeingSent, 0); + if (ERR_IS_FATAL(writeResult)) + { + reprap.GetPlatform()->MessageF(HOST_MESSAGE, "Network: Failed to write data in Send (code %d)\n", writeResult); + tcp_abort(cs->pcb); + return false; + } + + outputResult = tcp_output(cs->pcb); + if (ERR_IS_FATAL(outputResult)) + { + reprap.GetPlatform()->MessageF(HOST_MESSAGE, "Network: Failed to output data in Send (code %d)\n", outputResult); + tcp_abort(cs->pcb); + return false; + } + + if (outputResult != ERR_OK && reprap.Debug(moduleNetwork)) + { + reprap.GetPlatform()->MessageF(HOST_MESSAGE, "Network: tcp_output resulted in error code %d\n", outputResult); + } + + // Set LwIP callbacks for ACK and retransmission handling + tcp_poll(cs->pcb, conn_poll, TCP_WRITE_TIMEOUT / TCP_SLOW_INTERVAL / TCP_MAX_SEND_RETRIES); + tcp_sent(cs->pcb, conn_sent); + + // Set all values for the send process + sendingConnection = cs; + sendingRetries = 0; + sendingWindowSize = sentDataOutstanding = bytesBeingSent; + return false; +#endif +} + +// This is called by the Webserver to send output data to a client. If keepConnectionAlive is set to false, +// the current connection will be terminated once everything has been sent. +void NetworkTransaction::Commit(bool keepConnectionAlive) +{ +#if 0 + // If the connection has been terminated (e.g. RST received while writing upload data), discard this transaction + if (!IsConnected() || status == released) + { + Discard(); + return; + } + + // Free buffer holding the incoming data and prepare some values for the sending process + FreePbuf(); + cs->persistConnection = keepConnectionAlive; + if (sendBuffer == nullptr) + { + sendBuffer = sendStack->Pop(); + } + status = sending; + + // Unlink the item(s) from the list of ready transactions + if (keepConnectionAlive) + { + // Our connection is still of interest, remove only this transaction from the list + NetworkTransaction *previous = nullptr; + for(NetworkTransaction *item = reprap.GetNetwork()->readyTransactions; item != nullptr; item = item->next) + { + if (item == this) + { + if (previous == nullptr) + { + reprap.GetNetwork()->readyTransactions = next; + } + else + { + previous->next = next; + } + break; + } + previous = item; + } + } + else + { + // We will close this connection soon, stop receiving data from this PCB + tcp_recv(cs->pcb, nullptr); + + // Also remove all ready transactions pointing to our ConnectionState + NetworkTransaction *previous = nullptr, *item = reprap.GetNetwork()->readyTransactions; + while (item != nullptr) + { + if (item->cs == cs) + { + if (item == this) + { + // Only unlink this item + if (previous == nullptr) + { + reprap.GetNetwork()->readyTransactions = next; + } + else + { + previous->next = next; + } + item = next; + } + else + { + // Remove all others + item->Discard(); + item = (previous == nullptr) ? reprap.GetNetwork()->readyTransactions : previous->next; + } + } + else + { + previous = item; + item = item->next; + } + } + } + + // Enqueue this transaction, so it's sent in the right order + NetworkTransaction *mySendingTransaction = cs->sendingTransaction; + if (mySendingTransaction == nullptr) + { + cs->sendingTransaction = this; + reprap.GetNetwork()->AppendTransaction(&reprap.GetNetwork()->writingTransactions, this); + } + else + { + while (mySendingTransaction->nextWrite != nullptr) + { + mySendingTransaction = mySendingTransaction->nextWrite; + } + mySendingTransaction->nextWrite = this; + } +#endif +} + +// Call this to perform some networking tasks while processing deferred requests, +// and to move this transaction and all transactions that are associated with its +// connection to the end of readyTransactions. There are three ways to do this: +// +// 1) DeferOnly: Do not modify any of the processed data and don't send an ACK. +// This will ensure that zero-window packets are sent back to the client +// 2) ResetData: Reset the read pointers and acknowledge that the data has been processed +// 3) DiscardData: Free the processed data, acknowledge it and append this transaction as +// an empty item again without payload (i.e. without pbufs) +// +void NetworkTransaction::Defer(DeferralMode mode) +{ +#if 0 + if (mode == DeferralMode::ResetData) + { + // Reset the reading pointers and send an ACK + inputPointer = 0; + readingPb = pb; + if (IsConnected() && pb != nullptr && !dataAcknowledged) + { + tcp_recved(cs->pcb, pb->tot_len); + dataAcknowledged = true; + } + } + else if (mode == DeferralMode::DiscardData) + { + // Discard the incoming data, because we don't need to process it any more + FreePbuf(); + } + + status = deferred; + + // Unlink this transaction from the list of ready transactions and append it again + Network *network = reprap.GetNetwork(); + NetworkTransaction *item, *previous = nullptr; + for(item = network->readyTransactions; item != nullptr; item = item->next) + { + if (item == this) + { + if (previous == nullptr) + { + network->readyTransactions = next; + } + else + { + previous->next = next; + } + break; + } + previous = item; + } + network->AppendTransaction(&network->readyTransactions, this); + + // Append all other transactions that are associated to this connection, so that the + // Webserver gets a chance to deal with all connected clients even while multiple + // deferred requests are present in the list. + item = network->readyTransactions; + previous = nullptr; + while (item != this) + { + if (item->cs == cs) + { + NetworkTransaction *nextItem = item->next; + if (previous == nullptr) + { + network->readyTransactions = item->next; + network->AppendTransaction(&network->readyTransactions, item); + } + else + { + previous->next = item->next; + network->AppendTransaction(&network->readyTransactions, item); + } + item = nextItem; + } + else + { + previous = item; + item = item->next; + } + } +#endif +} + + +// This method should be called if we don't want to send data to the client and if we +// don't want to interfere with the connection state. May also be called from ISR! +void NetworkTransaction::Discard() +{ +#if 0 + // Can we do anything? + if (status == released) + { + // No - don't free up released items multiple times + return; + } + + // Free up some resources + FreePbuf(); + + if (fileBeingSent != nullptr) + { + fileBeingSent->Close(); + fileBeingSent = nullptr; + } + + OutputBuffer::ReleaseAll(sendBuffer); + sendStack->ReleaseAll(); + + // Unlink this transactions from the list of ready transactions and free it. It is then appended to the list of + // free transactions because we don't want to risk reusing it when the ethernet ISR processes incoming data + NetworkTransaction *previous = nullptr; + for(NetworkTransaction *item = reprap.GetNetwork()->readyTransactions; item != nullptr; item = item->next) + { + if (item == this) + { + if (previous == nullptr) + { + reprap.GetNetwork()->readyTransactions = next; + } + else + { + previous->next = next; + } + break; + } + previous = item; + } + reprap.GetNetwork()->AppendTransaction(&reprap.GetNetwork()->freeTransactions, this); + bool callDisconnectHandler = (cs != nullptr && status == disconnected); + status = released; + + // Call disconnect event if this transaction indicates a graceful disconnect and if the connection + // still persists (may not be the case if a RST packet was received before) + if (callDisconnectHandler) + { + if (reprap.Debug(moduleNetwork)) + { + reprap.GetPlatform()->Message(HOST_MESSAGE, "Network: Discard() is handling a graceful disconnect\n"); + } + reprap.GetNetwork()->ConnectionClosed(cs, false); + } +#endif +} + +uint32_t NetworkTransaction::GetRemoteIP() const +{ + return (cs != nullptr) ? cs->GetRemoteIP() : 0; +} + +uint16_t NetworkTransaction::GetRemotePort() const +{ + return (cs != nullptr) ? cs->GetRemotePort() : 0; +} + +uint16_t NetworkTransaction::GetLocalPort() const +{ + return (cs != nullptr) ? cs->GetLocalPort() : 0; +} + +void NetworkTransaction::Close() +{ +#if 0 + tcp_pcb *pcb = cs->pcb; + tcp_recv(pcb, nullptr); + closeRequested = true; +#endif +} + +// End diff --git a/src/DuetNG/DuetEthernet/NetworkTransaction.h b/src/DuetNG/DuetEthernet/NetworkTransaction.h new file mode 100644 index 00000000..91a9eedb --- /dev/null +++ b/src/DuetNG/DuetEthernet/NetworkTransaction.h @@ -0,0 +1,160 @@ +/* + * NetworkTransaction.h + * + * Created on: 23 Dec 2016 + * Author: David + */ + +#ifndef SRC_DUETNG_DUETETHERNET_NETWORKTRANSACTION_H_ +#define SRC_DUETNG_DUETETHERNET_NETWORKTRANSACTION_H_ + +#include <cstdint> +#include <cstddef> +#include "Libraries/General/StringRef.h" +#include "OutputMemory.h" +#include "Storage/FileStore.h" + +typedef uint8_t SocketNumber; + +const SocketNumber NoSocket = 255; + +// Network buffer class. These buffers are 2K long so that they can accept as much data as the W5500 can provide in one go. +class NetworkBuffer +{ +public: + friend class NetworkTransaction; + + NetworkBuffer(); + + // Release this buffer and return the next one in the chain + NetworkBuffer *Release(); + + // Read 1 character, returning true of successful, false if no data left + bool Read(char& b); + + // Read some data + bool ReadBuffer(const char *&buffer, size_t &len); + + // Return the amount of data available, not including continuation buffers + size_t Remaining() const; + + // Return the amount of data available, including continuation buffers + size_t TotalRemaining() const; + +private: + NetworkBuffer *next; + size_t dataLength; + size_t readPointer; + uint8_t data[2048]; +}; + +class NetworkTransaction; + +// ConnectionState structure that we use to track TCP connections. It is usually combined with NetworkTransactions. +class ConnectionState +{ +public: + void Init(SocketNumber s); + uint16_t GetLocalPort() const { return localPort; } + uint32_t GetRemoteIP() const { return remoteIPAddress; } + uint16_t GetRemotePort() const { return remotePort; } + bool IsConnected() const; // { return pcb != nullptr; } + bool IsTerminated() const { return isTerminated; } + void Terminate(); + +private: + uint16_t localPort, remotePort; // Copy of the local and remote ports, because the PCB may be unavailable + uint32_t remoteIPAddress; // Same for the remote IP address + NetworkTransaction * volatile sendingTransaction; // NetworkTransaction that is currently sending via this connection + ConnectionState * volatile next; // Next ConnectionState in this list + bool persistConnection; // Do we expect this connection to stay alive? + bool isTerminated; // Will be true if the connection has gone down unexpectedly (TCP RST) + SocketNumber socketNum; // The W5500 socket number we are using +}; + +// Assign a status to each NetworkTransaction +enum TransactionStatus +{ + released, + connected, + receiving, + sending, + disconnected, + deferred, + acquired +}; + +// How is a deferred request supposed to be handled? +enum class DeferralMode +{ + DeferOnly, // don't change anything, because we want to read more of it next time + ResetData, // keep the data and reset all reading pointers allowing us to process it again + DiscardData // discard all incoming data and re-enqueue the empty transaction +}; + +// Start with a class to hold input and output from the network that needs to be responded to. +// This includes changes in the connection state, e.g. connects and disconnects. +class NetworkTransaction +{ +public: + friend class Network; + + NetworkTransaction(NetworkTransaction* n); +// void Set(pbuf *p, ConnectionState* c, TransactionStatus s); + TransactionStatus GetStatus() const { return status; } + bool IsConnected() const; + + bool HasMoreDataToRead() const; // { return readingPb != nullptr; } + bool Read(char& b); + bool ReadBuffer(const char *&buffer, size_t &len); + void Write(char b); + void Write(const char* s); + void Write(StringRef ref); + void Write(const char* s, size_t len); + void Write(OutputBuffer *buffer); + void Write(OutputStack *stack); + void Printf(const char *fmt, ...); + void SetFileToWrite(FileStore *file); + + ConnectionState *GetConnection() const { return cs; } + uint16_t GetLocalPort() const; + uint32_t GetRemoteIP() const; + uint16_t GetRemotePort() const; + + bool Send(); + void Commit(bool keepConnectionAlive); + void Defer(DeferralMode mode); + void Discard(); + + NetworkTransaction *GetNext() const { return next; } + NetworkTransaction *GetNextWrite() const { return nextWrite; } + +private: + bool CanWrite() const; + void Close(); + + ConnectionState* cs; + NetworkTransaction* next; // next NetworkTransaction in the list we are in + NetworkTransaction* nextWrite; // next NetworkTransaction queued to write to assigned connection + NetworkBuffer *pb, *readingPb; // received packet queue and a pointer to the pbuf being read from +// size_t inputPointer; // amount of data already taken from the first packet buffer + + OutputBuffer *sendBuffer; + OutputStack *sendStack; + FileStore * volatile fileBeingSent; + + volatile TransactionStatus status; + volatile bool closeRequested, dataAcknowledged; +}; + +inline bool NetworkTransaction::IsConnected() const +{ + return (cs != nullptr && cs->IsConnected()); +} + +inline bool NetworkTransaction::CanWrite() const +{ + return (IsConnected() && status != released); +} + +#endif /* SRC_DUETNG_DUETETHERNET_NETWORKTRANSACTION_H_ */ diff --git a/src/DuetNG/DuetEthernet/Webserver.cpp b/src/DuetNG/DuetEthernet/Webserver.cpp index 293b77e0..af1bdcbe 100644 --- a/src/DuetNG/DuetEthernet/Webserver.cpp +++ b/src/DuetNG/DuetEthernet/Webserver.cpp @@ -121,36 +121,26 @@ void Webserver::Init() // Deal with input/output from/to the client (if any) void Webserver::Spin() { - if (webserverActive) + // Check if we are enabled and we can actually send something back to the client + if (webserverActive && OutputBuffer::GetBytesLeft(nullptr) != 0) { - // Check if we can actually send something back to the client - if (OutputBuffer::GetBytesLeft(nullptr) == 0) - { - platform->ClassReport(longWait); - return; - } - // We must ensure that we have exclusive access to LWIP if (!network->Lock()) { - platform->ClassReport(longWait); - return; - } - - // Allow each ProtocolInterpreter to do something - httpInterpreter->Spin(); - ftpInterpreter->Spin(); - telnetInterpreter->Spin(); + // Allow each ProtocolInterpreter to do something + httpInterpreter->Spin(); + ftpInterpreter->Spin(); + telnetInterpreter->Spin(); - // See if we have new data to process - currentTransaction = network->GetTransaction(readingConnection); - if (currentTransaction != nullptr) - { - // Take care of different protocol types here - ProtocolInterpreter *interpreter; - uint16_t localPort = currentTransaction->GetLocalPort(); - switch (localPort) + // See if we have new data to process + currentTransaction = network->GetTransaction(readingConnection); + if (currentTransaction != nullptr) { + // Take care of different protocol types here + ProtocolInterpreter *interpreter; + const uint16_t localPort = currentTransaction->GetLocalPort(); + switch (localPort) + { case FTP_PORT: /* FTP */ interpreter = ftpInterpreter; break; @@ -169,82 +159,82 @@ void Webserver::Spin() interpreter = ftpInterpreter; } break; - } + } - // See if we have to print some debug info - if (reprap.Debug(moduleWebserver)) - { - const char *type; - switch (currentTransaction->GetStatus()) + // See if we have to print some debug info + if (reprap.Debug(moduleWebserver)) { - case released: type = "released"; break; - case connected: type = "connected"; break; - case receiving: type = "receiving"; break; - case sending: type = "sending"; break; - case disconnected: type = "disconnected"; break; - case deferred: type = "deferred"; break; - case acquired: type = "acquired"; break; - default: type = "unknown"; break; + const char *type; + switch (currentTransaction->GetStatus()) + { + case released: type = "released"; break; + case connected: type = "connected"; break; + case receiving: type = "receiving"; break; + case sending: type = "sending"; break; + case disconnected: type = "disconnected"; break; + case deferred: type = "deferred"; break; + case acquired: type = "acquired"; break; + default: type = "unknown"; break; + } + platform->MessageF(HOST_MESSAGE, "Incoming transaction: Type %s at local port %d (remote port %d)\n", + type, localPort, currentTransaction->GetRemotePort()); } - platform->MessageF(HOST_MESSAGE, "Incoming transaction: Type %s at local port %d (remote port %d)\n", - type, localPort, currentTransaction->GetRemotePort()); - } - // For protocols other than HTTP it is important to send a HELO message - TransactionStatus status = currentTransaction->GetStatus(); - if (status == connected) - { - interpreter->ConnectionEstablished(); - } - // Graceful disconnects are handled here, because prior NetworkTransactions might still contain valid - // data. That's why it's a bad idea to close these connections immediately in the Network class. - else if (status == disconnected) - { - // This will call the disconnect events and effectively close the connection - currentTransaction->Discard(); - } - // Check for fast uploads via this connection - else if (interpreter->DoingFastUpload()) - { - interpreter->DoFastUpload(); - } - // Process other messages (if we can) - else if (interpreter->CanParseData()) - { - readingConnection = currentTransaction->GetConnection(); - for(size_t i = 0; i < TCP_MSS / 3; i++) + // For protocols other than HTTP it is important to send a HELO message + TransactionStatus status = currentTransaction->GetStatus(); + if (status == connected) + { + interpreter->ConnectionEstablished(); + } + // Graceful disconnects are handled here, because prior NetworkTransactions might still contain valid + // data. That's why it's a bad idea to close these connections immediately in the Network class. + else if (status == disconnected) + { + // This will call the disconnect events and effectively close the connection + currentTransaction->Discard(); + } + // Check for fast uploads via this connection + else if (interpreter->DoingFastUpload()) + { + interpreter->DoFastUpload(); + } + // Process other messages (if we can) + else if (interpreter->CanParseData()) { - char c; - if (currentTransaction->Read(c)) + readingConnection = currentTransaction->GetConnection(); + for (size_t i = 0; i < TCP_MSS / 3; i++) { - // Each ProtocolInterpreter must take care of the current NetworkTransaction by - // calling either Commit(), Discard() or Defer() - if (interpreter->CharFromClient(c)) + char c; + if (currentTransaction->Read(c)) { + // Each ProtocolInterpreter must take care of the current NetworkTransaction by calling either Commit(), Discard() or Defer() + if (interpreter->CharFromClient(c)) + { + readingConnection = nullptr; + break; + } + } + else + { + // We ran out of data before finding a complete request. This happens when the incoming + // message length exceeds the TCP MSS. Notify the current ProtocolInterpreter about this, + // which will remove the current transaction too + interpreter->NoMoreDataAvailable(); readingConnection = nullptr; break; } } - else - { - // We ran out of data before finding a complete request. This happens when the incoming - // message length exceeds the TCP MSS. Notify the current ProtocolInterpreter about this, - // which will remove the current transaction too - interpreter->NoMoreDataAvailable(); - readingConnection = nullptr; - break; - } } } + else if (readingConnection != nullptr) + { + // We failed to find a transaction for a reading connection. + // This should never happen, but if it does, terminate this connection instantly + platform->Message(HOST_MESSAGE, "Error: Transaction for reading connection not found\n"); + readingConnection->Terminate(); + } + network->Unlock(); // unlock LWIP again } - else if (readingConnection != nullptr) - { - // We failed to find a transaction for a reading connection. - // This should never happen, but if it does, terminate this connection instantly - platform->Message(HOST_MESSAGE, "Error: Transaction for reading connection not found\n"); - readingConnection->Terminate(); - } - network->Unlock(); // unlock LWIP again } platform->ClassReport(longWait); } diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.cpp b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.cpp index 7447386b..3fab829e 100644 --- a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.cpp +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.cpp @@ -53,6 +53,7 @@ //***************************************************************************** #include "w5500.h" +#include "WizSpi.h" #define _W5500_SPI_VDM_OP_ 0x00 #define _W5500_SPI_FDM_OP_LEN1_ 0x01 @@ -63,35 +64,35 @@ uint8_t WIZCHIP_READ(uint32_t AddrSel) { - SpiAssertSS(); - SpiSendAddress(AddrSel | (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_)); - const uint8_t ret = SpiReadByte(); - SpiReleaseSS(); + WizSpi::AssertSS(); + WizSpi::SendAddress(AddrSel | (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_)); + const uint8_t ret = WizSpi::ExchangeByte(0xFF, true); + WizSpi::ReleaseSS(); return ret; } void WIZCHIP_WRITE(uint32_t AddrSel, uint8_t wb ) { - SpiAssertSS(); - SpiSendAddress(AddrSel | (_W5500_SPI_WRITE_ | _W5500_SPI_VDM_OP_)); - SpiSendByte(wb); - SpiReleaseSS(); + WizSpi::AssertSS(); + WizSpi::SendAddress(AddrSel | (_W5500_SPI_WRITE_ | _W5500_SPI_VDM_OP_)); + WizSpi::ExchangeByte(wb, true); + WizSpi::ReleaseSS(); } void WIZCHIP_READ_BUF (uint32_t AddrSel, uint8_t* pBuf, uint16_t len) { - SpiAssertSS(); - SpiSendAddress(AddrSel | (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_)); - SpiReadBurst(pBuf, len); - SpiReleaseSS(); + WizSpi::AssertSS(); + WizSpi::SendAddress(AddrSel | (_W5500_SPI_READ_ | _W5500_SPI_VDM_OP_)); + WizSpi::ReadBurst(pBuf, len); + WizSpi::ReleaseSS(); } void WIZCHIP_WRITE_BUF(uint32_t AddrSel, const uint8_t* pBuf, uint16_t len) { - SpiAssertSS(); - SpiSendAddress(AddrSel | (_W5500_SPI_WRITE_ | _W5500_SPI_VDM_OP_)); - SpiSendBurst(pBuf, len); - SpiReleaseSS(); + WizSpi::AssertSS(); + WizSpi::SendAddress(AddrSel | (_W5500_SPI_WRITE_ | _W5500_SPI_VDM_OP_)); + WizSpi::SendBurst(pBuf, len); + WizSpi::ReleaseSS(); } @@ -128,7 +129,7 @@ uint16_t getSn_RX_RSR(uint8_t sn) return val; } -void wiz_send_data(uint8_t sn, uint8_t *wizdata, uint16_t len) +void wiz_send_data(uint8_t sn, const uint8_t *wizdata, uint16_t len) { if (len != 0) { diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.h b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.h index 048c47eb..495772ac 100644 --- a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.h +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/W5500/w5500.h @@ -2266,7 +2266,7 @@ static inline uint16_t getSn_TxMAX(uint8_t sn) * @param len Data length * @sa wiz_recv_data() */ -void wiz_send_data(uint8_t sn, uint8_t *wizdata, uint16_t len); +void wiz_send_data(uint8_t sn, const uint8_t *wizdata, uint16_t len); /** * @ingroup Basic_IO_function diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/WizSpi.cpp b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/WizSpi.cpp new file mode 100644 index 00000000..c32a14a5 --- /dev/null +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/WizSpi.cpp @@ -0,0 +1,431 @@ +/* + * WizSpi.cpp + * + * Created on: 16 Dec 2016 + * Author: David + */ + +#include "WizSpi.h" +#include "variant.h" +#include "Pins.h" + +// Define exactly one of the following as 1, the other as zero +// The PDC seems to be too slow to work reliably without getting transmit underruns, so we use the DMAC now. +#define USE_PDC 0 // use peripheral DMA controller +#define USE_DMAC 0 // use general DMA controller + +#if USE_PDC +#include "pdc.h" +#endif + +#if USE_DMAC +#include "dmac.h" +#endif + +#include "matrix.h" + +// Functions called by the W5500 module to transfer data to/from the W5500 via SPI +const uint32_t SpiClockFrequency = 10000000; // use 10MHz for now, increase it later +const unsigned int SpiPeripheralChannelId = 0; // we use NPCS0 as the slave select signal + +#if USE_PDC +static Pdc *spi_pdc; +static inline void spi_rx_dma_enable() +{ + pdc_enable_transfer(spi_pdc, PERIPH_PTCR_RXTEN); +} + +static inline void spi_tx_dma_enable() +{ + pdc_enable_transfer(spi_pdc, PERIPH_PTCR_TXTEN); +} + +static inline void spi_rx_dma_disable() +{ + pdc_disable_transfer(spi_pdc, PERIPH_PTCR_RXTDIS); +} + +static inline void spi_tx_dma_disable() +{ + pdc_disable_transfer(spi_pdc, PERIPH_PTCR_TXTDIS); +} + +static bool spi_dma_check_rx_complete() +{ + return true; +} + +static void spi_tx_dma_setup(const TransactionBuffer *buf, uint32_t maxTransmitLength) +{ + pdc_packet_t pdc_spi_packet; + pdc_spi_packet.ul_addr = reinterpret_cast<uint32_t>(buf); + pdc_spi_packet.ul_size = buf->PacketLength() * 4; // need length in bytes + pdc_tx_init(spi_pdc, &pdc_spi_packet, NULL); +} + +static void spi_rx_dma_setup(const TransactionBuffer *buf) +{ + pdc_packet_t pdc_spi_packet; + pdc_spi_packet.ul_addr = reinterpret_cast<uint32_t>(buf); + pdc_spi_packet.ul_size = TransactionBuffer::MaxReceiveBytes; + pdc_rx_init(spi_pdc, &pdc_spi_packet, NULL); +} + +#endif + +#if USE_DMAC + +// Our choice of DMA channels to use +const uint32_t CONF_SPI_DMAC_TX_CH = 1; +const uint32_t CONF_SPI_DMAC_RX_CH = 2; + +// Hardware IDs of the SPI transmit and receive DMA interfaces. See atsam datasheet. +const uint32_t DMA_HW_ID_SPI_TX = 1; +const uint32_t DMA_HW_ID_SPI_RX = 2; + +static inline void spi_rx_dma_enable() +{ + dmac_channel_enable(DMAC, CONF_SPI_DMAC_RX_CH); +} + +static inline void spi_tx_dma_enable() +{ + dmac_channel_enable(DMAC, CONF_SPI_DMAC_TX_CH); +} + +static inline void spi_rx_dma_disable() +{ + dmac_channel_disable(DMAC, CONF_SPI_DMAC_RX_CH); +} + +static inline void spi_tx_dma_disable() +{ + dmac_channel_disable(DMAC, CONF_SPI_DMAC_TX_CH); +} + +static bool spi_dma_check_rx_complete() +{ + uint32_t status = DMAC->DMAC_CHSR; + if ( ((status & (DMAC_CHSR_ENA0 << CONF_SPI_DMAC_RX_CH)) == 0) // controller is not enabled, perhaps because it finished a full buffer transfer + || ((status & (DMAC_CHSR_EMPT0 << CONF_SPI_DMAC_RX_CH)) != 0) // controller is enabled, probably suspended, and the FIFO is empty + ) + { + // Disable the channel. + // We also need to set the resume bit, otherwise it remains suspended when we re-enable it. + DMAC->DMAC_CHDR = (DMAC_CHDR_DIS0 << CONF_SPI_DMAC_RX_CH) | (DMAC_CHDR_RES0 << CONF_SPI_DMAC_RX_CH); + return true; + } + return false; +} + +static void spi_tx_dma_setup(const TransactionBuffer *buf, uint32_t maxTransmitLength) +{ + DMAC->DMAC_EBCISR; // clear any pending interrupts + + dmac_channel_set_source_addr(DMAC, CONF_SPI_DMAC_TX_CH, reinterpret_cast<uint32_t>(buf)); + dmac_channel_set_destination_addr(DMAC, CONF_SPI_DMAC_TX_CH, reinterpret_cast<uint32_t>(& SPI->SPI_TDR)); + dmac_channel_set_descriptor_addr(DMAC, CONF_SPI_DMAC_TX_CH, 0); + dmac_channel_set_ctrlA(DMAC, CONF_SPI_DMAC_TX_CH, maxTransmitLength | DMAC_CTRLA_SRC_WIDTH_WORD | DMAC_CTRLA_DST_WIDTH_BYTE); + dmac_channel_set_ctrlB(DMAC, CONF_SPI_DMAC_TX_CH, + DMAC_CTRLB_SRC_DSCR | DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_MEM2PER_DMA_FC | DMAC_CTRLB_SRC_INCR_INCREMENTING | DMAC_CTRLB_DST_INCR_FIXED); +} + +static void spi_rx_dma_setup(const TransactionBuffer *buf) +{ + DMAC->DMAC_EBCISR; // clear any pending interrupts + + dmac_channel_set_source_addr(DMAC, CONF_SPI_DMAC_RX_CH, reinterpret_cast<uint32_t>(& SPI->SPI_RDR)); + dmac_channel_set_destination_addr(DMAC, CONF_SPI_DMAC_RX_CH, reinterpret_cast<uint32_t>(buf)); + dmac_channel_set_descriptor_addr(DMAC, CONF_SPI_DMAC_RX_CH, 0); +// dmac_channel_set_ctrlA(DMAC, CONF_SPI_DMAC_RX_CH, TransactionBuffer::MaxTransferBytes | DMAC_CTRLA_SRC_WIDTH_BYTE | DMAC_CTRLA_DST_WIDTH_WORD); + dmac_channel_set_ctrlB(DMAC, CONF_SPI_DMAC_RX_CH, + DMAC_CTRLB_SRC_DSCR | DMAC_CTRLB_DST_DSCR | DMAC_CTRLB_FC_PER2MEM_DMA_FC | DMAC_CTRLB_SRC_INCR_FIXED | DMAC_CTRLB_DST_INCR_INCREMENTING); +} + +#endif + +#if USE_PDC || USE_DMAC + +static void spi_dma_disable() +{ + spi_tx_dma_disable(); + spi_rx_dma_disable(); +} + +#if 0 +/** + * \brief Set SPI slave transfer. + */ +static void spi_slave_dma_setup(bool dataToSend, bool allowReceive) +{ +#if USE_PDC + pdc_disable_transfer(spi_pdc, PERIPH_PTCR_TXTDIS | PERIPH_PTCR_RXTDIS); + + TransactionBuffer *outBufPointer = (dataToSend) ? &outBuffer : reinterpret_cast<TransactionBuffer*>(&dummyOutBuffer); + spi_tx_dma_setup(outBufPointer); + if (allowReceive) + { + outBufPointer->SetDataTaken(); + spi_rx_dma_setup(&inBuffer); + pdc_enable_transfer(spi_pdc, PERIPH_PTCR_TXTEN | PERIPH_PTCR_RXTEN); + } + else + { + outBufPointer->ClearDataTaken(); + pdc_enable_transfer(spi_pdc, PERIPH_PTCR_TXTEN); + } +#endif + +#if USE_DMAC + spi_dma_disable(); + + TransactionBuffer *outBufPointer = (dataToSend) ? &outBuffer : reinterpret_cast<TransactionBuffer*>(&dummyOutBuffer); + if (allowReceive) + { + spi_rx_dma_setup(&inBuffer); + spi_rx_dma_enable(); +// outBufPointer->SetDataTaken(); + } + else + { +// outBufPointer->ClearDataTaken(); + } + +// spi_tx_dma_setup(outBufPointer, (dataToSend) ? TransactionBuffer::MaxTransferBytes : 4 * TransactionBuffer::headerDwords); + spi_tx_dma_enable(); +#endif +} +#endif + +#endif + +namespace WizSpi +{ + // Initialise the SPI interface + void Init() + { + #if USE_PDC + spi_pdc = spi_get_pdc_base(SPI); + // The PDCs are masters 2 and 3 and the SRAM is slave 0. Give the PDCs the highest priority. + matrix_set_master_burst_type(0, MATRIX_ULBT_8_BEAT_BURST); + matrix_set_slave_default_master_type(0, MATRIX_DEFMSTR_LAST_DEFAULT_MASTER); + matrix_set_slave_priority(0, (3 << MATRIX_PRAS0_M2PR_Pos) | (3 << MATRIX_PRAS0_M3PR_Pos)); + matrix_set_slave_slot_cycle(0, 8); + #endif + + #if USE_DMAC + pmc_enable_periph_clk(ID_DMAC); + dmac_init(DMAC); + dmac_set_priority_mode(DMAC, DMAC_PRIORITY_ROUND_ROBIN); + dmac_enable(DMAC); + // The DMAC is master 4 and the SRAM is slave 0. Give the DMAC the highest priority. + matrix_set_slave_default_master_type(0, MATRIX_DEFMSTR_LAST_DEFAULT_MASTER); + matrix_set_slave_priority(0, (3 << MATRIX_PRAS0_M4PR_Pos)); + // Set the slave slot cycle limit. + // If we leave it at the default value of 511 clock cycles, we get transmit underruns due to the HSMCI using the bus for too long. + // A value of 8 seems to work. I haven't tried other values yet. + matrix_set_slave_slot_cycle(0, 8); + #endif + + // Set up the SPI pins + ConfigurePin(g_APinDescription[APIN_SPI_SCK]); + ConfigurePin(g_APinDescription[APIN_SPI_MOSI]); + ConfigurePin(g_APinDescription[APIN_SPI_MISO]); +#if 1 + pinMode(APIN_SPI_SS0, OUTPUT_HIGH); // use manual SS control for now +#else + ConfigurePin(g_APinDescription[APIN_SPI_SS0]); +#endif + + pmc_enable_periph_clk(ID_SPI); + +#if USE_PDC || USE_DMAC + spi_dma_disable(); +#endif + + spi_reset(SPI); // this clears the transmit and receive registers and puts the SPI into slave mode + SPI->SPI_MR = SPI_MR_MSTR // master mode + | SPI_MR_MODFDIS // disable fault detection + | SPI_MR_PCS(SpiPeripheralChannelId); // fixed peripheral select + + // Set SPI mode, clock frequency, CS active after transfer, delay between transfers + const uint16_t baud_div = (uint16_t)spi_calc_baudrate_div(SpiClockFrequency, SystemCoreClock); + const uint32_t csr = SPI_CSR_SCBR(baud_div) // Baud rate + | SPI_CSR_BITS_8_BIT // Transfer bit width + | SPI_CSR_DLYBCT(0) // Transfer delay + | SPI_CSR_CSAAT // Keep CS low after transfer in case we are slow in writing the next byte + | SPI_CSR_NCPHA; // Data is captured on the leading edge of the clock (SPI mode 0) + SPI->SPI_CSR[SpiPeripheralChannelId] = csr; + spi_enable(SPI); + +#if USE_DMAC + // Configure DMA RX channel + dmac_channel_set_configuration(DMAC, CONF_SPI_DMAC_RX_CH, + DMAC_CFG_SRC_PER(DMA_HW_ID_SPI_RX) | DMAC_CFG_SRC_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ASAP_CFG); + + // Configure DMA TX channel + dmac_channel_set_configuration(DMAC, CONF_SPI_DMAC_TX_CH, + DMAC_CFG_DST_PER(DMA_HW_ID_SPI_TX) | DMAC_CFG_DST_H2SEL | DMAC_CFG_SOD | DMAC_CFG_FIFOCFG_ASAP_CFG); +#endif + } + + void Stop() + { + NVIC_DisableIRQ(SPI_IRQn); + spi_disable(SPI); +#if USE_PDC || USE_DMA + spi_dma_check_rx_complete(); + spi_dma_disable(); +#endif + } + + // Wait for transmitter ready returning true if timed out + static inline bool waitForTxReady() + { + uint32_t timeout = SPI_TIMEOUT; + while (!spi_is_tx_ready(SPI)) + { + if (--timeout == 0) + { + return true; + } + } + return false; + } + + // Wait for transmitter empty returning true if timed out + static inline bool waitForTxEmpty() + { + uint32_t timeout = SPI_TIMEOUT; + while (!spi_is_tx_empty(SPI)) + { + if (!timeout--) + { + return true; + } + } + return false; + } + + // Wait for receive data available returning true if timed out + static inline bool waitForRxReady() + { + uint32_t timeout = SPI_TIMEOUT; + while (!spi_is_rx_ready(SPI)) + { + if (--timeout == 0) + { + return true; + } + } + return false; + } + + // Set the SS pin low to address the W5500 + void AssertSS() + { + spi_set_peripheral_chip_select_value(SPI, spi_get_pcs(SpiPeripheralChannelId)); + digitalWrite(SamCsPin, LOW); + } + + // Set the SS pin high again + void ReleaseSS() + { + waitForTxEmpty(); + digitalWrite(SamCsPin, HIGH); + } + + void SendAddress(uint32_t addr) + { + (void)ExchangeByte((uint8_t)(addr >> 16), false); + (void)ExchangeByte((uint8_t)(addr >> 8), false); + (void)ExchangeByte((uint8_t)addr, false); + } + + uint8_t ExchangeByte(uint8_t b, bool isLast) + { + if (waitForTxReady()) + { + return 0; + } + + // Write to transmit register + uint32_t dOut = b; + if (isLast) + { + dOut |= SPI_TDR_LASTXFER; + } + SPI->SPI_TDR = dOut; + + // Wait for receive register + if (waitForRxReady()) + { + return 0; + } + + // Get data from receive register + return (uint8_t)SPI->SPI_RDR; + } + + spi_status_t ReadBurst(uint8_t* rx_data, size_t len) + { + for (size_t i = 0; i < len; ++i) + { + uint32_t dOut = 0x000000FF; + if (waitForTxReady()) + { + return SPI_ERROR_TIMEOUT; + } + + // Write to transmit register + if (i + 1 == len) + { + dOut |= SPI_TDR_LASTXFER; + } + SPI->SPI_TDR = dOut; + + // Wait for receive register + if (waitForRxReady()) + { + return SPI_ERROR_TIMEOUT; + } + + // Get data from receive register + *rx_data++ = (uint8_t)SPI->SPI_RDR; + } + + return SPI_OK; + } + + spi_status_t SendBurst(const uint8_t* tx_data, size_t len) + { + for (uint32_t i = 0; i < len; ++i) + { + uint32_t dOut = (uint32_t)*tx_data++; + if (waitForTxReady()) + { + return SPI_ERROR_TIMEOUT; + } + + // Write to transmit register + if (i + 1 == len) + { + dOut |= SPI_TDR_LASTXFER; + } + SPI->SPI_TDR = dOut; + // Wait for receive register + if (waitForRxReady()) + { + return SPI_ERROR_TIMEOUT; + } + + // Get data from receive register + (void)SPI->SPI_RDR; + } + + return SPI_OK; + } + +} // end namespace + +// End diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/WizSpi.h b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/WizSpi.h new file mode 100644 index 00000000..2829e168 --- /dev/null +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/WizSpi.h @@ -0,0 +1,25 @@ +/* + * Spi.h + * + * Created on: 16 Dec 2016 + * Author: David + */ + +#ifndef SRC_DUETNG_DUETETHERNET_ETHERNET3_UTILITY_WIZSPI_H_ +#define SRC_DUETNG_DUETETHERNET_ETHERNET3_UTILITY_WIZSPI_H_ + +#include "spi.h" + +namespace WizSpi +{ + void Init(); + void Stop(); + void AssertSS(); + void ReleaseSS(); + void SendAddress(uint32_t addr); + uint8_t ExchangeByte(uint8_t b, bool isLast); + spi_status_t ReadBurst(uint8_t* rx_data, size_t len); + spi_status_t SendBurst(const uint8_t* tx_data, size_t len); +} + +#endif /* SRC_DUETNG_DUETETHERNET_ETHERNET3_UTILITY_WIZSPI_H_ */ diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.cpp b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.cpp index 5aeca9b8..a647d08a 100644 --- a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.cpp +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.cpp @@ -55,6 +55,18 @@ //***************************************************************************** #include "socket.h" +#define _SOCKET_DEBUG_ + +#ifdef _SOCKET_DEBUG_ +extern "C" void debugPrintf(const char *fmt, ...); +extern "C" void delay(uint32_t); +# define DEBUG_PRINTF(...) debugPrintf(__VA_ARGS__) +#else +# define DEBUG_PRINTF(_fmt, ...) +#endif + + + #define SOCK_ANY_PORT_NUM 0xC000 static uint16_t sock_any_port = SOCK_ANY_PORT_NUM; @@ -82,7 +94,7 @@ uint8_t sock_pack_info[_WIZCHIP_SOCK_NUM_] = {0,}; static void ExecCommand(uint8_t sn, uint8_t cmd) { - setSn_CR(sn, Sn_CR_OPEN); + setSn_CR(sn, cmd); while(getSn_CR(sn) != 0) { } } @@ -309,6 +321,7 @@ int32_t send(uint8_t sn, uint8_t * buf, uint16_t len) { break; } + DEBUG_PRINTF("Socket %u need %u free %u\n", sn, len, freesize); } wiz_send_data(sn, buf, len); @@ -373,7 +386,7 @@ int32_t recv(uint8_t sn, uint8_t * buf, uint16_t len) return (int32_t)len; } -int32_t sendto(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t port) +int32_t sendto(uint8_t sn, const uint8_t * buf, uint16_t len, const uint8_t * addr, uint16_t port) { switch(getSn_MR(sn) & 0x0F) { @@ -426,10 +439,10 @@ int32_t sendto(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t { break; } + DEBUG_PRINTF("Socket %u need %u free %u\n", sn, len, freesize); }; wiz_send_data(sn, buf, len); - ExecCommand(sn, Sn_CR_SEND); while(1) @@ -445,6 +458,10 @@ int32_t sendto(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t setSn_IR(sn, Sn_IR_TIMEOUT); return SOCKERR_TIMEOUT; } + DEBUG_PRINTF("Socket %u waiting for send to complete, IR=%02x\n", sn, tmp); +#ifdef _SOCKET_DEBUG_ + delay(10); // to avoid too many messages +#endif } return (int32_t)len; } diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.h b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.h index d7da7a8f..24bb7f7c 100644 --- a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.h +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/socket.h @@ -294,7 +294,7 @@ int32_t recv(uint8_t sn, uint8_t * buf, uint16_t len); * @ref SOCKERR_TIMEOUT - Timeout occurred \n * @ref SOCK_BUSY - Socket is busy. */ -int32_t sendto(uint8_t sn, uint8_t * buf, uint16_t len, uint8_t * addr, uint16_t port); +int32_t sendto(uint8_t sn, const uint8_t * buf, uint16_t len, const uint8_t * addr, uint16_t port); /** * @ingroup WIZnet_socket_APIs diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.cpp b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.cpp index 85d19e26..6e3a8c2c 100644 --- a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.cpp +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.cpp @@ -53,6 +53,7 @@ #include <cstddef> #include <cstring> #include "wizchip_conf.h" +#include "WizSpi.h" /** * @\ref WIZCHIP instance data @@ -181,8 +182,9 @@ void wizchip_sw_reset(void) setSIPR(sip); } -int8_t wizchip_init(uint8_t* txsize, uint8_t* rxsize) +int8_t wizchip_init(const uint8_t* txsize, const uint8_t* rxsize) { + WizSpi::Init(); wizchip_sw_reset(); if (txsize != nullptr) { diff --git a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.h b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.h index edb0f590..ceeec9a6 100644 --- a/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.h +++ b/src/DuetNG/DuetEthernet/Wiznet/Ethernet/wizchip_conf.h @@ -305,7 +305,7 @@ int8_t ctlnetwork(ctlnetwork_type cntype, void* arg); * @ingroup extra_functions * @brief Reset WIZCHIP by softly. */ -void wizchip_sw_reset(void); +void wizchip_sw_reset(void); /** * @ingroup extra_functions @@ -315,7 +315,7 @@ void wizchip_sw_reset(void); * @return 0 : succcess \n * -1 : fail. Invalid buffer size */ -int8_t wizchip_init(uint8_t* txsize, uint8_t* rxsize); +int8_t wizchip_init(const uint8_t* txsize, const uint8_t* rxsize); /** * @ingroup extra_functions diff --git a/src/DuetNG/DuetEthernet/Wiznet/Internet/DHCP/dhcp.cpp b/src/DuetNG/DuetEthernet/Wiznet/Internet/DHCP/dhcp.cpp new file mode 100644 index 00000000..079f72bf --- /dev/null +++ b/src/DuetNG/DuetEthernet/Wiznet/Internet/DHCP/dhcp.cpp @@ -0,0 +1,1004 @@ +//***************************************************************************** +// +//! \file dhcp.c +//! \brief DHCP APIs implement file. +//! \details Processig DHCP protocol as DISCOVER, OFFER, REQUEST, ACK, NACK and DECLINE. +//! \version 1.1.0 +//! \date 2013/11/18 +//! \par Revision history +//! <2013/11/18> 1st Release +//! <2012/12/20> V1.1.0 +//! 1. Optimize code +//! 2. Add reg_dhcp_cbfunc() +//! 3. Add DHCP_stop() +//! 4. Integrate check_DHCP_state() & DHCP_run() to DHCP_run() +//! 5. Don't care system endian +//! 6. Add comments +//! <2012/12/26> V1.1.1 +//! 1. Modify variable declaration: dhcp_tick_1s is declared volatile for code optimization +//! \author Eric Jung & MidnightCow +//! \copyright +//! +//! Copyright (c) 2013, WIZnet Co., LTD. +//! All rights reserved. +//! +//! Redistribution and use in source and binary forms, with or without +//! modification, are permitted provided that the following conditions +//! are met: +//! +//! * Redistributions of source code must retain the above copyright +//! notice, this list of conditions and the following disclaimer. +//! * Redistributions in binary form must reproduce the above copyright +//! notice, this list of conditions and the following disclaimer in the +//! documentation and/or other materials provided with the distribution. +//! * Neither the name of the <ORGANIZATION> nor the names of its +//! contributors may be used to endorse or promote products derived +//! from this software without specific prior written permission. +//! +//! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +//! AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +//! IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +//! ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +//! LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +//! CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +//! SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +//! INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +//! CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +//! ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +//! THE POSSIBILITY OF SUCH DAMAGE. +// +//***************************************************************************** + +#include "socket.h" +#include "dhcp.h" +#include <cstring> + +/* If you want to display debug & processing message, Define _DHCP_DEBUG_ in dhcp.h */ + +#define _DHCP_DEBUG_ + +#ifdef _DHCP_DEBUG_ +extern "C" void debugPrintf(const char *fmt, ...); +# define DEBUG_PRINTF(...) debugPrintf(__VA_ARGS__) +#else +# define DEBUG_PRINTF(_fmt, ...) +#endif + +/* DHCP state machine. */ +#define STATE_DHCP_INIT 0 ///< Initialize +#define STATE_DHCP_DISCOVER 1 ///< send DISCOVER and wait OFFER +#define STATE_DHCP_REQUEST 2 ///< send REQEUST and wait ACK or NACK +#define STATE_DHCP_LEASED 3 ///< ReceiveD ACK and IP leased +#define STATE_DHCP_REREQUEST 4 ///< send REQUEST for maintaining leased IP +#define STATE_DHCP_RELEASE 5 ///< No use +#define STATE_DHCP_STOP 6 ///< Stop processing DHCP + +#define DHCP_FLAGSBROADCAST 0x8000 ///< The broadcast value of flags in @ref RIP_MSG +#define DHCP_FLAGSUNICAST 0x0000 ///< The unicast value of flags in @ref RIP_MSG + +/* DHCP message OP code */ +#define DHCP_BOOTREQUEST 1 ///< Request Message used in op of @ref RIP_MSG +#define DHCP_BOOTREPLY 2 ///< Reply Message used i op of @ref RIP_MSG + +/* DHCP message type */ +#define DHCP_DISCOVER 1 ///< DISCOVER message in OPT of @ref RIP_MSG +#define DHCP_OFFER 2 ///< OFFER message in OPT of @ref RIP_MSG +#define DHCP_REQUEST 3 ///< REQUEST message in OPT of @ref RIP_MSG +#define DHCP_DECLINE 4 ///< DECLINE message in OPT of @ref RIP_MSG +#define DHCP_ACK 5 ///< ACK message in OPT of @ref RIP_MSG +#define DHCP_NAK 6 ///< NACK message in OPT of @ref RIP_MSG +#define DHCP_RELEASE 7 ///< RELEASE message in OPT of @ref RIP_MSG. No use +#define DHCP_INFORM 8 ///< INFORM message in OPT of @ref RIP_MSG. No use + +#define DHCP_HTYPE10MB 1 ///< Used in type of @ref RIP_MSG +#define DHCP_HTYPE100MB 2 ///< Used in type of @ref RIP_MSG + +#define DHCP_HLENETHERNET 6 ///< Used in hlen of @ref RIP_MSG +#define DHCP_HOPS 0 ///< Used in hops of @ref RIP_MSG +#define DHCP_SECS 0 ///< Used in secs of @ref RIP_MSG + +#define INFINITE_LEASETIME 0xffffffff ///< Infinite lease time + +#define OPT_SIZE 312 /// Max OPT size of @ref RIP_MSG +#define RIP_MSG_SIZE (236+OPT_SIZE) /// Max size of @ref RIP_MSG + +/* + * @brief DHCP option and value (cf. RFC1533) + */ +enum +{ + padOption = 0, + subnetMask = 1, + timerOffset = 2, + routersOnSubnet = 3, + timeServer = 4, + nameServer = 5, + dns = 6, + logServer = 7, + cookieServer = 8, + lprServer = 9, + impressServer = 10, + resourceLocationServer = 11, + hostName = 12, + bootFileSize = 13, + meritDumpFile = 14, + domainName = 15, + swapServer = 16, + rootPath = 17, + extentionsPath = 18, + IPforwarding = 19, + nonLocalSourceRouting = 20, + policyFilter = 21, + maxDgramReasmSize = 22, + defaultIPTTL = 23, + pathMTUagingTimeout = 24, + pathMTUplateauTable = 25, + ifMTU = 26, + allSubnetsLocal = 27, + broadcastAddr = 28, + performMaskDiscovery = 29, + maskSupplier = 30, + performRouterDiscovery = 31, + routerSolicitationAddr = 32, + staticRoute = 33, + trailerEncapsulation = 34, + arpCacheTimeout = 35, + ethernetEncapsulation = 36, + tcpDefaultTTL = 37, + tcpKeepaliveInterval = 38, + tcpKeepaliveGarbage = 39, + nisDomainName = 40, + nisServers = 41, + ntpServers = 42, + vendorSpecificInfo = 43, + netBIOSnameServer = 44, + netBIOSdgramDistServer = 45, + netBIOSnodeType = 46, + netBIOSscope = 47, + xFontServer = 48, + xDisplayManager = 49, + dhcpRequestedIPaddr = 50, + dhcpIPaddrLeaseTime = 51, + dhcpOptionOverload = 52, + dhcpMessageType = 53, + dhcpServerIdentifier = 54, + dhcpParamRequest = 55, + dhcpMsg = 56, + dhcpMaxMsgSize = 57, + dhcpT1value = 58, + dhcpT2value = 59, + dhcpClassIdentifier = 60, + dhcpClientIdentifier = 61, + endOption = 255 +}; + +/* + * @brief DHCP message format + */ +typedef struct { + uint8_t op; ///< @ref DHCP_BOOTREQUEST or @ref DHCP_BOOTREPLY + uint8_t htype; ///< @ref DHCP_HTYPE10MB or @ref DHCP_HTYPE100MB + uint8_t hlen; ///< @ref DHCP_HLENETHERNET + uint8_t hops; ///< @ref DHCP_HOPS + uint32_t xid; ///< @ref DHCP_XID This increase one every DHCP transaction. + uint16_t secs; ///< @ref DHCP_SECS + uint16_t flags; ///< @ref DHCP_FLAGSBROADCAST or @ref DHCP_FLAGSUNICAST + uint8_t ciaddr[4]; ///< @ref Request IP to DHCP sever + uint8_t yiaddr[4]; ///< @ref Offered IP from DHCP server + uint8_t siaddr[4]; ///< No use + uint8_t giaddr[4]; ///< No use + uint8_t chaddr[16]; ///< DHCP client 6bytes MAC address. Others is filled to zero + uint8_t sname[64]; ///< No use + uint8_t file[128]; ///< No use + uint8_t OPT[OPT_SIZE]; ///< Option +} RIP_MSG; + + + +uint8_t DHCP_SOCKET; // Socket number for DHCP + +uint8_t DHCP_SIP[4]; // DHCP Server IP address + +// Network information from DHCP Server +uint8_t OLD_allocated_ip[4] = {0, }; // Previous IP address +uint8_t DHCP_allocated_ip[4] = {0, }; // IP address from DHCP +uint8_t DHCP_allocated_gw[4] = {0, }; // Gateway address from DHCP +uint8_t DHCP_allocated_sn[4] = {0, }; // Subnet mask from DHCP +uint8_t DHCP_allocated_dns[4] = {0, }; // DNS address from DHCP + + +int8_t dhcp_state = STATE_DHCP_INIT; // DHCP state +int8_t dhcp_retry_count = 0; + +uint32_t dhcp_lease_time = INFINITE_LEASETIME; +volatile uint32_t dhcp_tick_1s = 0; // unit 1 second +uint32_t dhcp_tick_next = DHCP_WAIT_TIME ; + +uint32_t DHCP_XID; // Any number + +static RIP_MSG dhcpMessageBuffer; +RIP_MSG* const pDHCPMSG = &dhcpMessageBuffer; // Buffer pointer for DHCP processing + +char HOST_NAME[16] = DCHP_HOST_NAME; +uint8_t DHCP_CHADDR[6]; // DHCP Client MAC address. + +/* The default callback function */ +void default_ip_assign(void); +void default_ip_update(void); +void default_ip_conflict(void); + +/* Callback handler */ +void (*dhcp_ip_assign)(void) = default_ip_assign; /* handler to be called when the IP address from DHCP server is first assigned */ +void (*dhcp_ip_update)(void) = default_ip_update; /* handler to be called when the IP address from DHCP server is updated */ +void (*dhcp_ip_conflict)(void) = default_ip_conflict; /* handler to be called when the IP address from DHCP server is conflict */ + +void reg_dhcp_cbfunc(void(*ip_assign)(void), void(*ip_update)(void), void(*ip_conflict)(void)); + + +/* send DISCOVER message to DHCP server */ +void send_DHCP_DISCOVER(void); + +/* send REQEUST message to DHCP server */ +void send_DHCP_REQUEST(void); + +/* send DECLINE message to DHCP server */ +void send_DHCP_DECLINE(void); + +/* IP conflict check by sending ARP-request to leased IP and wait ARP-response. */ +bool check_DHCP_leasedIP(void); + +/* check the timeout in DHCP process */ +DhcpRunResult check_DHCP_timeout(void); + +/* Initialize to timeout process. */ +void reset_DHCP_timeout(void); + +/* Parse message as OFFER and ACK and NACK from DHCP server.*/ +int8_t parseDHCPMSG(void); + +/* The default handler of ip assign first */ +void default_ip_assign(void) +{ + setSIPR(DHCP_allocated_ip); + setSUBR(DHCP_allocated_sn); + setGAR (DHCP_allocated_gw); +} + +/* The default handler of ip chaged */ +void default_ip_update(void) +{ + /* WIZchip Software Reset */ + setMR(MR_RST); + getMR(); // for delay + default_ip_assign(); + setSHAR(DHCP_CHADDR); +} + +/* The default handler of ip chaged */ +void default_ip_conflict(void) +{ + // WIZchip Software Reset + setMR(MR_RST); + getMR(); // for delay + setSHAR(DHCP_CHADDR); +} + +/* register the call back func. */ +void reg_dhcp_cbfunc(void(*ip_assign)(void), void(*ip_update)(void), void(*ip_conflict)(void)) +{ + dhcp_ip_assign = default_ip_assign; + dhcp_ip_update = default_ip_update; + dhcp_ip_conflict = default_ip_conflict; + if(ip_assign) { dhcp_ip_assign = ip_assign; } + if(ip_update) { dhcp_ip_update = ip_update; } + if(ip_conflict) { dhcp_ip_conflict = ip_conflict; } +} + +/* make the common DHCP message */ +void makeDHCPMSG(void) +{ + uint8_t bk_mac[6]; + getSHAR(bk_mac); + pDHCPMSG->op = DHCP_BOOTREQUEST; + pDHCPMSG->htype = DHCP_HTYPE10MB; + pDHCPMSG->hlen = DHCP_HLENETHERNET; + pDHCPMSG->hops = DHCP_HOPS; + uint8_t* ptmp = (uint8_t*)(&pDHCPMSG->xid); + *(ptmp+0) = (uint8_t)((DHCP_XID & 0xFF000000) >> 24); + *(ptmp+1) = (uint8_t)((DHCP_XID & 0x00FF0000) >> 16); + *(ptmp+2) = (uint8_t)((DHCP_XID & 0x0000FF00) >> 8); + *(ptmp+3) = (uint8_t)((DHCP_XID & 0x000000FF) >> 0); + pDHCPMSG->secs = DHCP_SECS; + ptmp = (uint8_t*)(&pDHCPMSG->flags); + *(ptmp+0) = (uint8_t)((DHCP_FLAGSBROADCAST & 0xFF00) >> 8); + *(ptmp+1) = (uint8_t)((DHCP_FLAGSBROADCAST & 0x00FF) >> 0); + + pDHCPMSG->ciaddr[0] = 0; + pDHCPMSG->ciaddr[1] = 0; + pDHCPMSG->ciaddr[2] = 0; + pDHCPMSG->ciaddr[3] = 0; + + pDHCPMSG->yiaddr[0] = 0; + pDHCPMSG->yiaddr[1] = 0; + pDHCPMSG->yiaddr[2] = 0; + pDHCPMSG->yiaddr[3] = 0; + + pDHCPMSG->siaddr[0] = 0; + pDHCPMSG->siaddr[1] = 0; + pDHCPMSG->siaddr[2] = 0; + pDHCPMSG->siaddr[3] = 0; + + pDHCPMSG->giaddr[0] = 0; + pDHCPMSG->giaddr[1] = 0; + pDHCPMSG->giaddr[2] = 0; + pDHCPMSG->giaddr[3] = 0; + + pDHCPMSG->chaddr[0] = DHCP_CHADDR[0]; + pDHCPMSG->chaddr[1] = DHCP_CHADDR[1]; + pDHCPMSG->chaddr[2] = DHCP_CHADDR[2]; + pDHCPMSG->chaddr[3] = DHCP_CHADDR[3]; + pDHCPMSG->chaddr[4] = DHCP_CHADDR[4]; + pDHCPMSG->chaddr[5] = DHCP_CHADDR[5]; + + for (size_t i = 6; i < 16; i++) + { + pDHCPMSG->chaddr[i] = 0; + } + for (size_t i = 0; i < 64; i++) + { + pDHCPMSG->sname[i] = 0; + } + for (size_t i = 0; i < 128; i++) + { + pDHCPMSG->file[i] = 0; + } + + // MAGIC_COOKIE + pDHCPMSG->OPT[0] = (uint8_t)((MAGIC_COOKIE & 0xFF000000) >> 24); + pDHCPMSG->OPT[1] = (uint8_t)((MAGIC_COOKIE & 0x00FF0000) >> 16); + pDHCPMSG->OPT[2] = (uint8_t)((MAGIC_COOKIE & 0x0000FF00) >> 8); + pDHCPMSG->OPT[3] = (uint8_t) (MAGIC_COOKIE & 0x000000FF) >> 0; +} + +/* SEND DHCP DISCOVER */ +void send_DHCP_DISCOVER(void) +{ + makeDHCPMSG(); + + size_t k = 4; // because MAGIC_COOKIE already made by makeDHCPMSG() + + // Option Request Param + pDHCPMSG->OPT[k++] = dhcpMessageType; + pDHCPMSG->OPT[k++] = 0x01; + pDHCPMSG->OPT[k++] = DHCP_DISCOVER; + + // Client identifier + pDHCPMSG->OPT[k++] = dhcpClientIdentifier; + pDHCPMSG->OPT[k++] = 0x07; + pDHCPMSG->OPT[k++] = 0x01; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[0]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[1]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[2]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[3]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[4]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[5]; + + // host name + pDHCPMSG->OPT[k++] = hostName; + pDHCPMSG->OPT[k++] = 0; // fill zero length of hostname + size_t i; + for (i = 0 ; HOST_NAME[i] != 0; i++) + { + pDHCPMSG->OPT[k++] = HOST_NAME[i]; + } + pDHCPMSG->OPT[k - (i+1)] = i; // length of hostname + pDHCPMSG->OPT[k++] = dhcpParamRequest; + pDHCPMSG->OPT[k++] = 0x06; // length of request + pDHCPMSG->OPT[k++] = subnetMask; + pDHCPMSG->OPT[k++] = routersOnSubnet; + pDHCPMSG->OPT[k++] = dns; + pDHCPMSG->OPT[k++] = domainName; + pDHCPMSG->OPT[k++] = dhcpT1value; + pDHCPMSG->OPT[k++] = dhcpT2value; + pDHCPMSG->OPT[k++] = endOption; + + for (i = k; i < OPT_SIZE; i++) + { + pDHCPMSG->OPT[i] = 0; + } + + // send broadcasting packet + uint8_t ip[4]; + ip[0] = 255; + ip[1] = 255; + ip[2] = 255; + ip[3] = 255; + + DEBUG_PRINTF("> Send DHCP_DISCOVER\n"); + + sendto(DHCP_SOCKET, (uint8_t *)pDHCPMSG, RIP_MSG_SIZE, ip, DHCP_SERVER_PORT); + DEBUG_PRINTF("Sent\n"); +} + +/* SEND DHCP REQUEST */ +void send_DHCP_REQUEST(void) +{ + + makeDHCPMSG(); + + uint8_t ip[4]; + if (dhcp_state == STATE_DHCP_LEASED || dhcp_state == STATE_DHCP_REREQUEST) + { + *((uint8_t*)(&pDHCPMSG->flags)) = ((DHCP_FLAGSUNICAST & 0xFF00)>> 8); + *((uint8_t*)(&pDHCPMSG->flags)+1) = (DHCP_FLAGSUNICAST & 0x00FF); + pDHCPMSG->ciaddr[0] = DHCP_allocated_ip[0]; + pDHCPMSG->ciaddr[1] = DHCP_allocated_ip[1]; + pDHCPMSG->ciaddr[2] = DHCP_allocated_ip[2]; + pDHCPMSG->ciaddr[3] = DHCP_allocated_ip[3]; + ip[0] = DHCP_SIP[0]; + ip[1] = DHCP_SIP[1]; + ip[2] = DHCP_SIP[2]; + ip[3] = DHCP_SIP[3]; + } + else + { + ip[0] = 255; + ip[1] = 255; + ip[2] = 255; + ip[3] = 255; + } + + size_t k = 4; // because MAGIC_COOKIE already made by makeDHCPMSG() + + // Option Request Param. + pDHCPMSG->OPT[k++] = dhcpMessageType; + pDHCPMSG->OPT[k++] = 0x01; + pDHCPMSG->OPT[k++] = DHCP_REQUEST; + + pDHCPMSG->OPT[k++] = dhcpClientIdentifier; + pDHCPMSG->OPT[k++] = 0x07; + pDHCPMSG->OPT[k++] = 0x01; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[0]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[1]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[2]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[3]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[4]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[5]; + + if (ip[3] == 255) // if(dchp_state == STATE_DHCP_LEASED || dchp_state == DHCP_REREQUEST_STATE) + { + pDHCPMSG->OPT[k++] = dhcpRequestedIPaddr; + pDHCPMSG->OPT[k++] = 0x04; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[0]; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[1]; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[2]; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[3]; + + pDHCPMSG->OPT[k++] = dhcpServerIdentifier; + pDHCPMSG->OPT[k++] = 0x04; + pDHCPMSG->OPT[k++] = DHCP_SIP[0]; + pDHCPMSG->OPT[k++] = DHCP_SIP[1]; + pDHCPMSG->OPT[k++] = DHCP_SIP[2]; + pDHCPMSG->OPT[k++] = DHCP_SIP[3]; + } + + // host name + pDHCPMSG->OPT[k++] = hostName; + pDHCPMSG->OPT[k++] = 0; // length of hostname + size_t i; + for (i = 0 ; HOST_NAME[i] != 0; i++) + { + pDHCPMSG->OPT[k++] = HOST_NAME[i]; + } + pDHCPMSG->OPT[k - (i+1)] = i; // length of hostname + pDHCPMSG->OPT[k++] = dhcpParamRequest; + pDHCPMSG->OPT[k++] = 0x08; + pDHCPMSG->OPT[k++] = subnetMask; + pDHCPMSG->OPT[k++] = routersOnSubnet; + pDHCPMSG->OPT[k++] = dns; + pDHCPMSG->OPT[k++] = domainName; + pDHCPMSG->OPT[k++] = dhcpT1value; + pDHCPMSG->OPT[k++] = dhcpT2value; + pDHCPMSG->OPT[k++] = performRouterDiscovery; + pDHCPMSG->OPT[k++] = staticRoute; + pDHCPMSG->OPT[k++] = endOption; + + for (size_t i = k; i < OPT_SIZE; i++) + { + pDHCPMSG->OPT[i] = 0; + } + + DEBUG_PRINTF("> Send DHCP_REQUEST\n"); + + sendto(DHCP_SOCKET, (uint8_t *)pDHCPMSG, RIP_MSG_SIZE, ip, DHCP_SERVER_PORT); +} + +/* SEND DHCP DHCPDECLINE */ +void send_DHCP_DECLINE(void) +{ + makeDHCPMSG(); + + size_t k = 4; // beacaue MAGIC_COOKIE already made by makeDHCPMSG() + + *((uint8_t*)(&pDHCPMSG->flags)) = ((DHCP_FLAGSUNICAST & 0xFF00)>> 8); + *((uint8_t*)(&pDHCPMSG->flags)+1) = (DHCP_FLAGSUNICAST & 0x00FF); + + // Option Request Param. + pDHCPMSG->OPT[k++] = dhcpMessageType; + pDHCPMSG->OPT[k++] = 0x01; + pDHCPMSG->OPT[k++] = DHCP_DECLINE; + + pDHCPMSG->OPT[k++] = dhcpClientIdentifier; + pDHCPMSG->OPT[k++] = 0x07; + pDHCPMSG->OPT[k++] = 0x01; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[0]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[1]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[2]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[3]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[4]; + pDHCPMSG->OPT[k++] = DHCP_CHADDR[5]; + + pDHCPMSG->OPT[k++] = dhcpRequestedIPaddr; + pDHCPMSG->OPT[k++] = 0x04; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[0]; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[1]; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[2]; + pDHCPMSG->OPT[k++] = DHCP_allocated_ip[3]; + + pDHCPMSG->OPT[k++] = dhcpServerIdentifier; + pDHCPMSG->OPT[k++] = 0x04; + pDHCPMSG->OPT[k++] = DHCP_SIP[0]; + pDHCPMSG->OPT[k++] = DHCP_SIP[1]; + pDHCPMSG->OPT[k++] = DHCP_SIP[2]; + pDHCPMSG->OPT[k++] = DHCP_SIP[3]; + + pDHCPMSG->OPT[k++] = endOption; + + for (size_t i = k; i < OPT_SIZE; i++) + { + pDHCPMSG->OPT[i] = 0; + } + + //send broadcasting packet + uint8_t ip[4]; + ip[0] = 0xFF; + ip[1] = 0xFF; + ip[2] = 0xFF; + ip[3] = 0xFF; + + DEBUG_PRINTF("\n> Send DHCP_DECLINE\n"); + + sendto(DHCP_SOCKET, (uint8_t *)pDHCPMSG, RIP_MSG_SIZE, ip, DHCP_SERVER_PORT); +} + +/* PARSE REPLY pDHCPMSG */ +int8_t parseDHCPMSG(void) +{ + uint8_t type = 0; + uint16_t len; + if ((len = getSn_RX_RSR(DHCP_SOCKET)) > 0) + { + if (len > sizeof(RIP_MSG)) + { + len = sizeof(RIP_MSG); + } + + uint8_t svr_addr[6]; + uint16_t svr_port; + len = recvfrom(DHCP_SOCKET, (uint8_t *)pDHCPMSG, len, svr_addr, &svr_port); + + DEBUG_PRINTF("DHCP message : %d.%d.%d.%d(%d) %d received. \n", svr_addr[0], svr_addr[1], svr_addr[2], svr_addr[3],svr_port, len); + + if (svr_port == DHCP_SERVER_PORT) + { + // compare mac address + if ( (pDHCPMSG->chaddr[0] == DHCP_CHADDR[0]) && (pDHCPMSG->chaddr[1] == DHCP_CHADDR[1]) + && (pDHCPMSG->chaddr[2] == DHCP_CHADDR[2]) && (pDHCPMSG->chaddr[3] == DHCP_CHADDR[3]) + && (pDHCPMSG->chaddr[4] == DHCP_CHADDR[4]) && (pDHCPMSG->chaddr[5] == DHCP_CHADDR[5]) + ) + { + const uint8_t *p = (uint8_t *)(&pDHCPMSG->op); + p = p + 240; // 240 = sizeof(RIP_MSG) + MAGIC_COOKIE size in RIP_MSG.opt - sizeof(RIP_MSG.opt) + const uint8_t * const e = p + (len - 240); + + while (p < e) + { + switch (*p ) + { + case endOption : + p = e; // for break while(p < e) + break; + case padOption : + p++; + break; + case dhcpMessageType : + p++; + p++; + type = *p++; + break; + case subnetMask : + p++; + p++; + DHCP_allocated_sn[0] = *p++; + DHCP_allocated_sn[1] = *p++; + DHCP_allocated_sn[2] = *p++; + DHCP_allocated_sn[3] = *p++; + break; + case routersOnSubnet : + { + p++; + const uint8_t opt_len = *p++; + DHCP_allocated_gw[0] = *p++; + DHCP_allocated_gw[1] = *p++; + DHCP_allocated_gw[2] = *p++; + DHCP_allocated_gw[3] = *p++; + p = p + (opt_len - 4); + } + break; + case dns : + { + p++; + const uint8_t opt_len = *p++; + DHCP_allocated_dns[0] = *p++; + DHCP_allocated_dns[1] = *p++; + DHCP_allocated_dns[2] = *p++; + DHCP_allocated_dns[3] = *p++; + p = p + (opt_len - 4); + } + break; + case dhcpIPaddrLeaseTime : + { + p++; + p++; + dhcp_lease_time = *p++; + dhcp_lease_time = (dhcp_lease_time << 8) + *p++; + dhcp_lease_time = (dhcp_lease_time << 8) + *p++; + dhcp_lease_time = (dhcp_lease_time << 8) + *p++; +#if 0 //#ifdef _DHCP_DEBUG_ + dhcp_lease_time = 10; +#endif + } + break; + case dhcpServerIdentifier : + { + p++; + p++; + DHCP_SIP[0] = *p++; + DHCP_SIP[1] = *p++; + DHCP_SIP[2] = *p++; + DHCP_SIP[3] = *p++; + } + break; + + default : + { + p++; + const uint8_t opt_len = *p++; + p += opt_len; + } + break; + } // switch + } // while + } // if + } // if + } // if + return type; +} + +DhcpRunResult DHCP_run(void) +{ + if (dhcp_state == STATE_DHCP_STOP) + { + return DhcpRunResult::DHCP_STOPPED; + } + + if (getSn_SR(DHCP_SOCKET) != SOCK_UDP) + { + socket(DHCP_SOCKET, Sn_MR_UDP, DHCP_CLIENT_PORT, 0x00); + } + + DhcpRunResult ret = DhcpRunResult::DHCP_RUNNING; + const uint8_t type = parseDHCPMSG(); + + switch (dhcp_state) + { + case STATE_DHCP_INIT: + DHCP_allocated_ip[0] = 0; + DHCP_allocated_ip[1] = 0; + DHCP_allocated_ip[2] = 0; + DHCP_allocated_ip[3] = 0; + send_DHCP_DISCOVER(); + dhcp_state = STATE_DHCP_DISCOVER; + break; + + case STATE_DHCP_DISCOVER: + if (type == DHCP_OFFER) + { + DEBUG_PRINTF("> Receive DHCP_OFFER\n"); + DHCP_allocated_ip[0] = pDHCPMSG->yiaddr[0]; + DHCP_allocated_ip[1] = pDHCPMSG->yiaddr[1]; + DHCP_allocated_ip[2] = pDHCPMSG->yiaddr[2]; + DHCP_allocated_ip[3] = pDHCPMSG->yiaddr[3]; + + send_DHCP_REQUEST(); + dhcp_state = STATE_DHCP_REQUEST; + } + else + { + ret = check_DHCP_timeout(); + } + break; + + case STATE_DHCP_REQUEST : + if (type == DHCP_ACK) + { + DEBUG_PRINTF("> Receive DHCP_ACK\n"); + if (check_DHCP_leasedIP()) + { + // Network info assignment from DHCP + dhcp_ip_assign(); + reset_DHCP_timeout(); + dhcp_state = STATE_DHCP_LEASED; + ret = DhcpRunResult::DHCP_IP_ASSIGN; + } + else + { + // IP address conflict occurred + reset_DHCP_timeout(); + dhcp_ip_conflict(); + dhcp_state = STATE_DHCP_INIT; + } + } + else if (type == DHCP_NAK) + { + DEBUG_PRINTF("> Receive DHCP_NACK\n"); + reset_DHCP_timeout(); + dhcp_state = STATE_DHCP_DISCOVER; + } + else + { + ret = check_DHCP_timeout(); + } + break; + + case STATE_DHCP_LEASED : + ret = DhcpRunResult::DHCP_IP_LEASED; + if ((dhcp_lease_time != INFINITE_LEASETIME) && ((dhcp_lease_time/2) < dhcp_tick_1s)) + { + DEBUG_PRINTF("> Maintains the IP address \n"); + OLD_allocated_ip[0] = DHCP_allocated_ip[0]; + OLD_allocated_ip[1] = DHCP_allocated_ip[1]; + OLD_allocated_ip[2] = DHCP_allocated_ip[2]; + OLD_allocated_ip[3] = DHCP_allocated_ip[3]; + + DHCP_XID++; + + send_DHCP_REQUEST(); + reset_DHCP_timeout(); + dhcp_state = STATE_DHCP_REREQUEST; + } + break; + + case STATE_DHCP_REREQUEST : + ret = DhcpRunResult::DHCP_IP_LEASED; + if (type == DHCP_ACK) + { + dhcp_retry_count = 0; + if (OLD_allocated_ip[0] != DHCP_allocated_ip[0] || + OLD_allocated_ip[1] != DHCP_allocated_ip[1] || + OLD_allocated_ip[2] != DHCP_allocated_ip[2] || + OLD_allocated_ip[3] != DHCP_allocated_ip[3]) + { + ret = DhcpRunResult::DHCP_IP_CHANGED; + dhcp_ip_update(); + DEBUG_PRINTF(">IP changed.\n"); + } + else + { + DEBUG_PRINTF(">IP is continued.\n"); + } + reset_DHCP_timeout(); + dhcp_state = STATE_DHCP_LEASED; + } + else if (type == DHCP_NAK) + { + DEBUG_PRINTF("> Receive DHCP_NACK, Failed to maintain ip\n"); + reset_DHCP_timeout(); + dhcp_state = STATE_DHCP_DISCOVER; + } + else + { + ret = check_DHCP_timeout(); + } + break; + + default : + break; + } + + return ret; +} + +void DHCP_stop(void) +{ + close(DHCP_SOCKET); + dhcp_state = STATE_DHCP_STOP; +} + +DhcpRunResult check_DHCP_timeout(void) +{ + DhcpRunResult ret = DhcpRunResult::DHCP_RUNNING; + + if (dhcp_retry_count < MAX_DHCP_RETRY) + { + if (dhcp_tick_next < dhcp_tick_1s) + { + switch ( dhcp_state ) + { + case STATE_DHCP_DISCOVER : + DEBUG_PRINTF("<<timeout>> state : STATE_DHCP_DISCOVER\n"); + send_DHCP_DISCOVER(); + break; + + case STATE_DHCP_REQUEST : + DEBUG_PRINTF("<<timeout>> state : STATE_DHCP_REQUEST\n"); + + send_DHCP_REQUEST(); + break; + + case STATE_DHCP_REREQUEST : + DEBUG_PRINTF("<<timeout>> state : STATE_DHCP_REREQUEST\n"); + + send_DHCP_REQUEST(); + break; + + default : + break; + } + + dhcp_tick_1s = 0; + dhcp_tick_next = dhcp_tick_1s + DHCP_WAIT_TIME; + dhcp_retry_count++; + } + } + else + { // exceeded retry count + switch(dhcp_state) + { + case STATE_DHCP_DISCOVER: + dhcp_state = STATE_DHCP_INIT; + ret = DhcpRunResult::DHCP_FAILED; + break; + case STATE_DHCP_REQUEST: + case STATE_DHCP_REREQUEST: + send_DHCP_DISCOVER(); + dhcp_state = STATE_DHCP_DISCOVER; + break; + default : + break; + } + reset_DHCP_timeout(); + } + return ret; +} + +bool check_DHCP_leasedIP(void) +{ + uint8_t tmp; + int32_t ret; + + //WIZchip RCR value changed for ARP Timeout count control + tmp = getRCR(); + setRCR(0x03); + + // IP conflict detection : ARP request - ARP reply + // Broadcasting ARP Request for check the IP conflict using UDP sendto() function + // TODO the following takes 620ms to time out - hanging for this long isn't very nice + ret = sendto(DHCP_SOCKET, (const uint8_t *)"CHECK_IP_CONFLICT", 17, DHCP_allocated_ip, 5000); + + // RCR value restore + setRCR(tmp); + + if (ret == SOCKERR_TIMEOUT) + { + // UDP send Timeout occurred : allocated IP address is unique, DHCP Success + DEBUG_PRINTF("\n> Check leased IP - OK\n"); + return true; + } + else + { + // Received ARP reply or etc : IP address conflict occur, DHCP Failed + send_DHCP_DECLINE(); + + ret = dhcp_tick_1s; + //TODO can't tolerate a 1 to 2 second wait here + while((dhcp_tick_1s - ret) < 2) { } // wait for 1s over; wait to complete to send DECLINE message; + + return false; + } +} + +void DHCP_init(uint8_t s, const char *hname) +{ + strncpy(HOST_NAME, hname, sizeof(HOST_NAME)); + HOST_NAME[sizeof(HOST_NAME) - 1] = 0; + + uint8_t zeroip[4] = {0,0,0,0}; + getSHAR(DHCP_CHADDR); + DEBUG_PRINTF("MAC address: %02x:%02x:%02x:%02x:%02x:%02x\n", DHCP_CHADDR[0], DHCP_CHADDR[1], DHCP_CHADDR[2], DHCP_CHADDR[3], DHCP_CHADDR[4], DHCP_CHADDR[5]); + + if ((DHCP_CHADDR[0] | DHCP_CHADDR[1] | DHCP_CHADDR[2] | DHCP_CHADDR[3] | DHCP_CHADDR[4] | DHCP_CHADDR[5]) == 0x00) + { + // assing temporary mac address, you should be set SHAR before call this function. + DHCP_CHADDR[0] = 0x00; + DHCP_CHADDR[1] = 0x08; + DHCP_CHADDR[2] = 0xdc; + DHCP_CHADDR[3] = 0x00; + DHCP_CHADDR[4] = 0x00; + DHCP_CHADDR[5] = 0x00; + setSHAR(DHCP_CHADDR); + } + + DHCP_SOCKET = s; // SOCK_DHCP + DHCP_XID = 0x12345678; + + // WIZchip Netinfo Clear + setSIPR(zeroip); + setSIPR(zeroip); + setGAR(zeroip); + + reset_DHCP_timeout(); + dhcp_state = STATE_DHCP_INIT; +} + +/* Rset the DHCP timeout count and retry count. */ +void reset_DHCP_timeout(void) +{ + dhcp_tick_1s = 0; + dhcp_tick_next = DHCP_WAIT_TIME; + dhcp_retry_count = 0; +} + +void DHCP_time_handler(void) +{ + dhcp_tick_1s++; +} + +void getIPfromDHCP(uint8_t* ip) +{ + ip[0] = DHCP_allocated_ip[0]; + ip[1] = DHCP_allocated_ip[1]; + ip[2] = DHCP_allocated_ip[2]; + ip[3] = DHCP_allocated_ip[3]; +} + +void getGWfromDHCP(uint8_t* ip) +{ + ip[0] =DHCP_allocated_gw[0]; + ip[1] =DHCP_allocated_gw[1]; + ip[2] =DHCP_allocated_gw[2]; + ip[3] =DHCP_allocated_gw[3]; +} + +void getSNfromDHCP(uint8_t* ip) +{ + ip[0] = DHCP_allocated_sn[0]; + ip[1] = DHCP_allocated_sn[1]; + ip[2] = DHCP_allocated_sn[2]; + ip[3] = DHCP_allocated_sn[3]; +} + +void getDNSfromDHCP(uint8_t* ip) +{ + ip[0] = DHCP_allocated_dns[0]; + ip[1] = DHCP_allocated_dns[1]; + ip[2] = DHCP_allocated_dns[2]; + ip[3] = DHCP_allocated_dns[3]; +} + +uint32_t getDHCPLeasetime(void) +{ + return dhcp_lease_time; +} + +// End diff --git a/src/DuetNG/DuetEthernet/Wiznet/Internet/DHCP/dhcp.h b/src/DuetNG/DuetEthernet/Wiznet/Internet/DHCP/dhcp.h new file mode 100644 index 00000000..4f238b6e --- /dev/null +++ b/src/DuetNG/DuetEthernet/Wiznet/Internet/DHCP/dhcp.h @@ -0,0 +1,144 @@ +//***************************************************************************** +// +//! \file dhcp.h +//! \brief DHCP APIs Header file. +//! \details Processig DHCP protocol as DISCOVER, OFFER, REQUEST, ACK, NACK and DECLINE. +//! \version 1.1.0 +//! \date 2013/11/18 +//! \par Revision history +//! <2013/11/18> 1st Release +//! <2012/12/20> V1.1.0 +//! 1. Move unreferenced DEFINE to dhcp.c +//! <2012/12/26> V1.1.1 +//! \author Eric Jung & MidnightCow +//! \copyright +//! +//! Copyright (c) 2013, WIZnet Co., LTD. +//! All rights reserved. +//! +//! Redistribution and use in source and binary forms, with or without +//! modification, are permitted provided that the following conditions +//! are met: +//! +//! * Redistributions of source code must retain the above copyright +//! notice, this list of conditions and the following disclaimer. +//! * Redistributions in binary form must reproduce the above copyright +//! notice, this list of conditions and the following disclaimer in the +//! documentation and/or other materials provided with the distribution. +//! * Neither the name of the <ORGANIZATION> nor the names of its +//! contributors may be used to endorse or promote products derived +//! from this software without specific prior written permission. +//! +//! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +//! AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +//! IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +//! ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +//! LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +//! CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +//! SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +//! INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +//! CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +//! ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +//! THE POSSIBILITY OF SUCH DAMAGE. +// +//***************************************************************************** +#ifndef _DHCP_H_ +#define _DHCP_H_ + +/* Retry to processing DHCP */ +#define MAX_DHCP_RETRY 2 ///< Maxium retry count +#define DHCP_WAIT_TIME 10 ///< Wait Time 10s + + +/* UDP port numbers for DHCP */ +#define DHCP_SERVER_PORT 67 ///< DHCP server port number +#define DHCP_CLIENT_PORT 68 ///< DHCP client port number + + +#define MAGIC_COOKIE 0x63825363 ///< Any number. You can be modified it any number + +#define DCHP_HOST_NAME "DuetEthernet" + +/* + * @brief return value of @ref DHCP_run() + */ +enum class DhcpRunResult : uint8_t +{ + DHCP_FAILED = 0, ///< Processing Fail + DHCP_RUNNING, ///< Processing DHCP protocol + DHCP_IP_ASSIGN, ///< First Occupy IP from DHPC server (if cbfunc == null, act as default default_ip_assign) + DHCP_IP_CHANGED, ///< Change IP address by new ip from DHCP (if cbfunc == null, act as default default_ip_update) + DHCP_IP_LEASED, ///< Stand by + DHCP_STOPPED ///< Stop processing DHCP protocol +}; + +/* + * @brief DHCP client initialization (outside of the main loop) + * @param s - socket number + * @param hname - null-terminated host name string + */ +void DHCP_init(uint8_t s, const char *hname); + +/* + * @brief DHCP 1s Tick Timer handler + * @note SHOULD BE register to your system 1s Tick timer handler + */ +void DHCP_time_handler(void); + +/* + * @brief Register call back function + * @param ip_assign - callback func when IP is assigned from DHCP server first + * @param ip_update - callback func when IP is changed + * @prarm ip_conflict - callback func when the assigned IP is conflict with others. + */ +void reg_dhcp_cbfunc(void(*ip_assign)(void), void(*ip_update)(void), void(*ip_conflict)(void)); + +/* + * @brief DHCP client in the main loop + * @return The value is as the follow \n + * @ref DHCP_FAILED \n + * @ref DHCP_RUNNING \n + * @ref DHCP_IP_ASSIGN \n + * @ref DHCP_IP_CHANGED \n + * @ref DHCP_IP_LEASED \n + * @ref DHCP_STOPPED \n + * + * @note This function is always called by you main task. + */ +DhcpRunResult DHCP_run(void); + +/* + * @brief Stop DHCP processing + * @note If you want to restart. call DHCP_init() and DHCP_run() + */ +void DHCP_stop(void); + +/* Get Network information assigned from DHCP server */ +/* + * @brief Get IP address + * @param ip - IP address to be returned + */ +void getIPfromDHCP(uint8_t* ip); +/* + * @brief Get Gateway address + * @param ip - Gateway address to be returned + */ +void getGWfromDHCP(uint8_t* ip); +/* + * @brief Get Subnet mask value + * @param ip - Subnet mask to be returned + */ +void getSNfromDHCP(uint8_t* ip); +/* + * @brief Get DNS address + * @param ip - DNS address to be returned + */ +void getDNSfromDHCP(uint8_t* ip); + +/* + * @brief Get the leased time by DHCP sever + * @return unit 1s + */ +uint32_t getDHCPLeasetime(void); + +#endif /* _DHCP_H_ */ diff --git a/src/DuetNG/DuetWiFi/Network.cpp b/src/DuetNG/DuetWiFi/Network.cpp index 3b9c6226..31aa3459 100644 --- a/src/DuetNG/DuetWiFi/Network.cpp +++ b/src/DuetNG/DuetWiFi/Network.cpp @@ -743,7 +743,7 @@ const uint8_t *Network::GetIPAddress() const uint16_t Network::GetHttpPort() const { - return DEFAULT_HTTP_PORT; + return DefaultHttpPort; } void Network::SetHttpPort(uint16_t port) diff --git a/src/DuetNG/DuetWiFi/Network.h b/src/DuetNG/DuetWiFi/Network.h index a4bf3759..2d403412 100644 --- a/src/DuetNG/DuetWiFi/Network.h +++ b/src/DuetNG/DuetWiFi/Network.h @@ -21,10 +21,10 @@ const uint32_t rcNumber = 0x0000FFFF; const uint32_t rcJson = 0x00010000; const uint32_t rcKeepOpen = 0x00020000; -static const uint8_t IP_ADDRESS[4] = { 192, 168, 1, 10 }; // Need some sort of default... -static const uint8_t NET_MASK[4] = { 255, 255, 255, 0 }; -static const uint8_t GATE_WAY[4] = { 192, 168, 1, 1 }; -static const uint16_t DEFAULT_HTTP_PORT = 80; +static const uint8_t DefaultIpAddress[4] = { 192, 168, 1, 10 }; // Need some sort of default... +static const uint8_t DefaultNetMask[4] = { 255, 255, 255, 0 }; +static const uint8_t DefaultGateway[4] = { 192, 168, 1, 1 }; +static const uint16_t DefaultHttpPort = 80; class TransactionBuffer; class WifiFirmwareUploader; diff --git a/src/Platform.cpp b/src/Platform.cpp index 972f7877..b118ba5d 100644 --- a/src/Platform.cpp +++ b/src/Platform.cpp @@ -208,15 +208,15 @@ void Platform::Init() SERIAL_AUX2_DEVICE.begin(baudRates[2]); #endif - compatibility = marlin; // default to Marlin because the common host programs expect the "OK" response to commands - ARRAY_INIT(ipAddress, IP_ADDRESS); - ARRAY_INIT(netMask, NET_MASK); - ARRAY_INIT(gateWay, GATE_WAY); + compatibility = marlin; // default to Marlin because the common host programs expect the "OK" response to commands + ARRAY_INIT(ipAddress, DefaultIpAddress); + ARRAY_INIT(netMask, DefaultNetMask); + ARRAY_INIT(gateWay, DefaultGateway); #if defined(DUET_NG) && defined(DUET_WIFI) memset(macAddress, 0xFF, sizeof(macAddress)); #else - ARRAY_INIT(macAddress, MAC_ADDRESS); + ARRAY_INIT(macAddress, DefaultMacAddress); #endif zProbeType = 0; // Default is to use no Z probe switch @@ -435,7 +435,7 @@ void Platform::Init() } #endif - // MCU temperature and power monitoring + // MCU temperature monitoring - doesn't work in RADDS due to pin assignmentgs and SAM3X chip bug #ifndef __RADDS__ temperatureAdcChannel = GetTemperatureAdcChannel(); AnalogInEnableChannel(temperatureAdcChannel, true); @@ -446,6 +446,7 @@ void Platform::Init() mcuTemperatureAdjust = 0.0; #ifdef DUET_NG + // Power monitoring vInMonitorAdcChannel = PinToAdcChannel(PowerMonitorVinDetectPin); pinMode(PowerMonitorVinDetectPin, AIN); AnalogInEnableChannel(vInMonitorAdcChannel, true); |