Merge branch 'master' into pgmspace_to_libc

Author: earlephilhower

.travis.yml

@@ -1,4 +1,3 @@
-sudo: false
 language: bash
 os: linux
 dist: trusty

bootloaders/eboot/Makefile

@@ -17,11 +17,13 @@ AR := $(XTENSA_TOOLCHAIN)xtensa-lx106-elf-ar
 LD := $(XTENSA_TOOLCHAIN)xtensa-lx106-elf-gcc
 OBJDUMP := $(XTENSA_TOOLCHAIN)xtensa-lx106-elf-objdump
 
-
+INC += -I../../tools/sdk/include
 CFLAGS += -std=gnu99
 
 CFLAGS += -O0 -g -Wpointer-arith -Wno-implicit-function-declaration -Wl,-EL -fno-inline-functions -nostdlib -mlongcalls -mno-text-section-literals
 
+CFLAGS += $(INC)
+
 LDFLAGS	+= -nostdlib -Wl,--no-check-sections -umain
 
 LD_SCRIPT := -Teboot.ld

bootloaders/eboot/eboot.elf

@@ -8,15 +8,19 @@
 #ifndef FLASH_H
 #define FLASH_H
 
+
+/* The geometry defines are placed in the sdk. The .h was factored out for reuse by eboot here.
+ * Beware: this means that eboot has an external dependency.
+ * The following .h is placed in tools/sdk/includes
+ */
+#include <spi_flash_geometry.h>
+
 int SPIEraseBlock(uint32_t block);
 int SPIEraseSector(uint32_t sector);
 int SPIRead(uint32_t addr, void *dest, size_t size);
 int SPIWrite(uint32_t addr, void *src, size_t size);
 int SPIEraseAreaEx(const uint32_t start, const uint32_t size);
 
-#define FLASH_SECTOR_SIZE 0x1000
-#define FLASH_BLOCK_SIZE 0x10000
-#define APP_START_OFFSET 0x1000
 
 typedef struct {
     unsigned char       magic;
@@ -25,7 +29,7 @@ typedef struct {
     /* SPI Flash Interface (0 = QIO, 1 = QOUT, 2 = DIO, 0x3 = DOUT) */
     unsigned char       flash_mode;
 
-    /* High four bits: 0 = 512K, 1 = 256K, 2 = 1M, 3 = 2M, 4 = 4M, 
+    /* High four bits: 0 = 512K, 1 = 256K, 2 = 1M, 3 = 2M, 4 = 4M, 8 = 8M, 9 = 16M
        Low four bits:  0 = 40MHz, 1= 26MHz, 2 = 20MHz, 0xf = 80MHz */
     unsigned char		flash_size_freq;
 

bootloaders/eboot/flash.h

@@ -132,9 +132,43 @@ uint64_t EspClass::deepSleepMax()
 
 }
 
+/* 
+Layout of RTC Memory is as follows:
+Ref: Espressif doc 2C-ESP8266_Non_OS_SDK_API_Reference, section 3.3.23 (system_rtc_mem_write)
+
+|<------system data (256 bytes)------->|<-----------------user data (512 bytes)--------------->|
+
+SDK function signature:   
+bool	system_rtc_mem_read	(
+				uint32	des_addr,	
+				void	*	src_addr,	
+				uint32	save_size
+)   
+
+The system data section can't be used by the user, so:
+des_addr must be >=64 (i.e.: 256/4) and <192 (i.e.: 768/4)
+src_addr is a pointer to data
+save_size is the number of bytes to write
+
+For the method interface:
+offset is the user block number (block size is 4 bytes) must be >= 0 and <128
+data is a pointer to data, 4-byte aligned
+size is number of bytes in the block pointed to by data
+
+Same for write
+
+Note: If the Updater class is in play, e.g.: the application uses OTA, the eboot
+command will be stored into the first 128 bytes of user data, then it will be
+retrieved by eboot on boot. That means that user data present there will be lost.
+Ref: 
+- discussion in PR #5330.
+- https://github.com/esp8266/esp8266-wiki/wiki/Memory-Map#memmory-mapped-io-registers
+- Arduino/bootloaders/eboot/eboot_command.h RTC_MEM definition
+*/
+
 bool EspClass::rtcUserMemoryRead(uint32_t offset, uint32_t *data, size_t size)
 {
-    if (size + offset > 512) {
+    if (offset * 4 + size > 512 || size == 0) {
         return false;
     } else {
         return system_rtc_mem_read(64 + offset, data, size);
@@ -143,13 +177,15 @@ bool EspClass::rtcUserMemoryRead(uint32_t offset, uint32_t *data, size_t size)
 
 bool EspClass::rtcUserMemoryWrite(uint32_t offset, uint32_t *data, size_t size)
 {
-    if (size + offset > 512) {
+    if (offset * 4 + size > 512 || size == 0) {
         return false;
     } else {
         return system_rtc_mem_write(64 + offset, data, size);
     }
 }
 
+
+
 extern "C" void __real_system_restart_local();
 void EspClass::reset(void)
 {
@@ -165,6 +201,7 @@ void EspClass::restart(void)
 uint16_t EspClass::getVcc(void)
 {
     InterruptLock lock;
+    (void)lock;
     return system_get_vdd33();
 }
 

cores/esp8266/Esp.cpp

@@ -62,6 +62,7 @@ class DirImpl {
 
 class FSImpl {
 public:
+    virtual ~FSImpl () { }
     virtual bool begin() = 0;
     virtual void end() = 0;
     virtual bool format() = 0;

cores/esp8266/FSImpl.h

@@ -34,10 +34,10 @@ class MD5Builder {
     void add(const uint8_t * data, const uint16_t len);
     void add(const char * data){ add((const uint8_t*)data, strlen(data)); }
     void add(char * data){ add((const char*)data); }
-    void add(const String data){ add(data.c_str()); }
+    void add(const String& data){ add(data.c_str()); }
     void addHexString(const char * data);
     void addHexString(char * data){ addHexString((const char*)data); }
-    void addHexString(const String data){ addHexString(data.c_str()); }
+    void addHexString(const String& data){ addHexString(data.c_str()); }
     bool addStream(Stream & stream, const size_t maxLen);
     void calculate(void);
     void getBytes(uint8_t * output);

cores/esp8266/MD5Builder.h

@@ -0,0 +1,126 @@
+#ifndef __POLLEDTIMING_H__
+#define __POLLEDTIMING_H__
+
+
+/*
+ PolledTimeout.h - Encapsulation of a polled Timeout
+ 
+ Copyright (c) 2018 Daniel Salazar. All rights reserved.
+ This file is part of the esp8266 core for Arduino environment.
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+
+
+namespace esp8266
+{
+
+
+namespace polledTimeout
+{
+
+namespace YieldPolicy
+{
+
+struct DoNothing
+{
+  static void execute() {}
+};
+
+struct YieldOrSkip
+{
+  static void execute() {delay(0);}
+};
+
+} //YieldPolicy
+
+
+template <bool PeriodicT, typename YieldPolicyT = YieldPolicy::DoNothing>  
+class timeoutTemplate
+{
+public:
+  using timeType = decltype(millis());
+  
+  timeoutTemplate(timeType timeout) 
+    : _timeout(timeout), _start(millis())  
+  {} 
+
+  bool expired()
+  {
+    YieldPolicyT::execute(); //in case of DoNothing: gets optimized away
+    if(PeriodicT)           //in case of false: gets optimized away
+      return expiredRetrigger();
+    return expiredOneShot();
+  }
+  
+  operator bool()
+  {
+    return expired(); 
+  }
+  
+  void reset(timeType newTimeout)
+  {
+    _timeout = newTimeout;
+    reset();
+  }
+
+  void reset()
+  {
+    _start = millis(); 
+  }
+  
+protected:
+  bool checkExpired(timeType t) const
+  {
+    return (t - _start) >=  _timeout;
+  }
+  
+  bool expiredRetrigger()
+  {
+    timeType current = millis();
+    if(checkExpired(current))
+    {
+      unsigned long n = (current - _start) / _timeout; //how many _timeouts periods have elapsed, will usually be 1 (current - _start >= _timeout)
+      _start += n  * _timeout;
+      return true;
+    }
+    return false;
+  }
+  
+  bool expiredOneShot() const
+  {
+    return checkExpired(millis());
+  }
+  
+  timeType _timeout;
+  timeType _start;
+};
+
+using oneShot = polledTimeout::timeoutTemplate<false>;
+using periodic = polledTimeout::timeoutTemplate<true>;
+
+} //polledTimeout
+
+
+/* A 1-shot timeout that auto-yields when in CONT can be built as follows:
+ * using oneShotYield = esp8266::polledTimeout::timeoutTemplate<false, esp8266::polledTimeout::YieldPolicy::YieldOrSkip>;
+ *
+ * Other policies can be implemented by the user, e.g.: simple yield that panics in SYS, and the polledTimeout types built as needed as shown above, without modifying this file.
+ */
+
+}//esp8266
+
+#endif

cores/esp8266/PolledTimeout.h

@@ -1,8 +1,8 @@
 #include "Updater.h"
 #include "Arduino.h"
 #include "eboot_command.h"
-#include "interrupts.h"
-#include "esp8266_peri.h"
+#include <interrupts.h>
+#include <esp8266_peri.h>
 
 //#define DEBUG_UPDATER Serial
 
@@ -84,21 +84,21 @@ bool UpdaterClass::begin(size_t size, int command, int ledPin, uint8_t ledOn) {
 
   wifi_set_sleep_type(NONE_SLEEP_T);
 
-  uint32_t updateStartAddress = 0;
+  uintptr_t updateStartAddress = 0;
   if (command == U_FLASH) {
     //size of current sketch rounded to a sector
-    uint32_t currentSketchSize = (ESP.getSketchSize() + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
+    size_t currentSketchSize = (ESP.getSketchSize() + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
     //address of the end of the space available for sketch and update
-    uint32_t updateEndAddress = (uint32_t)&_SPIFFS_start - 0x40200000;
+    uintptr_t updateEndAddress = (uintptr_t)&_SPIFFS_start - 0x40200000;
     //size of the update rounded to a sector
-    uint32_t roundedSize = (size + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
+    size_t roundedSize = (size + FLASH_SECTOR_SIZE - 1) & (~(FLASH_SECTOR_SIZE - 1));
     //address where we will start writing the update
     updateStartAddress = (updateEndAddress > roundedSize)? (updateEndAddress - roundedSize) : 0;
 
 #ifdef DEBUG_UPDATER
-        DEBUG_UPDATER.printf("[begin] roundedSize:       0x%08X (%d)\n", roundedSize, roundedSize);
-        DEBUG_UPDATER.printf("[begin] updateEndAddress:  0x%08X (%d)\n", updateEndAddress, updateEndAddress);
-        DEBUG_UPDATER.printf("[begin] currentSketchSize: 0x%08X (%d)\n", currentSketchSize, currentSketchSize);
+        DEBUG_UPDATER.printf("[begin] roundedSize:       0x%08zX (%zd)\n", roundedSize, roundedSize);
+        DEBUG_UPDATER.printf("[begin] updateEndAddress:  0x%08zX (%zd)\n", updateEndAddress, updateEndAddress);
+        DEBUG_UPDATER.printf("[begin] currentSketchSize: 0x%08zX (%zd)\n", currentSketchSize, currentSketchSize);
 #endif
 
     //make sure that the size of both sketches is less than the total space (updateEndAddress)
@@ -108,7 +108,7 @@ bool UpdaterClass::begin(size_t size, int command, int ledPin, uint8_t ledOn) {
     }
   }
   else if (command == U_SPIFFS) {
-     updateStartAddress = (uint32_t)&_SPIFFS_start - 0x40200000;
+     updateStartAddress = (uintptr_t)&_SPIFFS_start - 0x40200000;
   }
   else {
     // unknown command
@@ -133,7 +133,7 @@ bool UpdaterClass::begin(size_t size, int command, int ledPin, uint8_t ledOn) {
 #ifdef DEBUG_UPDATER
   DEBUG_UPDATER.printf("[begin] _startAddress:     0x%08X (%d)\n", _startAddress, _startAddress);
   DEBUG_UPDATER.printf("[begin] _currentAddress:   0x%08X (%d)\n", _currentAddress, _currentAddress);
-  DEBUG_UPDATER.printf("[begin] _size:             0x%08X (%d)\n", _size, _size);
+  DEBUG_UPDATER.printf("[begin] _size:             0x%08zX (%zd)\n", _size, _size);
 #endif
 
   _md5.begin();
@@ -159,7 +159,7 @@ bool UpdaterClass::end(bool evenIfRemaining){
 
   if(hasError() || (!isFinished() && !evenIfRemaining)){
 #ifdef DEBUG_UPDATER
-    DEBUG_UPDATER.printf("premature end: res:%u, pos:%u/%u\n", getError(), progress(), _size);
+    DEBUG_UPDATER.printf("premature end: res:%u, pos:%zu/%zu\n", getError(), progress(), _size);
 #endif
 
     _reset();
@@ -199,10 +199,10 @@ bool UpdaterClass::end(bool evenIfRemaining){
     eboot_command_write(&ebcmd);
 
 #ifdef DEBUG_UPDATER
-    DEBUG_UPDATER.printf("Staged: address:0x%08X, size:0x%08X\n", _startAddress, _size);
+    DEBUG_UPDATER.printf("Staged: address:0x%08X, size:0x%08zX\n", _startAddress, _size);
   }
   else if (_command == U_SPIFFS) {
-    DEBUG_UPDATER.printf("SPIFFS: address:0x%08X, size:0x%08X\n", _startAddress, _size);
+    DEBUG_UPDATER.printf("SPIFFS: address:0x%08X, size:0x%08zX\n", _startAddress, _size);
 #endif
   }