Merge branch 'master' into open-startup

core/component.mk

@@ -1,6 +1,6 @@
 INC_DIRS += $(core_ROOT)include
 
 # args for passing into compile rule generation
-core_ROOT = $(ROOT)core/
 core_SRC_DIR = $(core_ROOT)
+
 $(eval $(call component_compile_rules,core))

core/cplusplus_operators.cpp

@@ -0,0 +1,25 @@
+/* Part of esp-open-rtos
+ * BSD Licensed as described in the file LICENSE
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+void *operator new(size_t size)
+{
+    return malloc(size);
+}
+
+void *operator new[](size_t size)
+{
+    return malloc(size);
+}
+
+void operator delete(void * ptr)
+{
+    free(ptr);
+}
+
+void operator delete[](void * ptr)
+{
+    free(ptr);
+}

core/include/common_macros.h

@@ -10,6 +10,8 @@
 #ifndef _COMMON_MACROS_H
 #define _COMMON_MACROS_H
 
+#include <sys/cdefs.h>
+
 #define UNUSED __attributed((unused))
 
 #ifndef BIT
@@ -45,7 +47,11 @@
    Important to note: IROM flash can only be accessed via 32-bit word
    aligned reads. It's up to the user of this attribute to ensure this.
 */
-#define IROM __attribute__((section(".irom0.literal"))) const
+#ifdef	__cplusplus
+    #define IROM __attribute__((section(".irom0.literal")))
+#else
+    #define IROM __attribute__((section(".irom0.literal"))) const
+#endif
 
 #define INLINED inline static __attribute__((always_inline)) __attribute__((unused))
 

core/include/esp/gpio.h

@@ -27,28 +27,26 @@ typedef enum {
 INLINED void gpio_enable(const uint8_t gpio_num, const gpio_direction_t direction)
 {
     uint32_t iomux_flags;
-    uint32_t ctrl_val;
 
     switch(direction) {
     case GPIO_INPUT:
         iomux_flags = 0;
-        ctrl_val = 0;
         break;
     case GPIO_OUTPUT:
         iomux_flags = IOMUX_PIN_OUTPUT_ENABLE;
-        ctrl_val = GPIO_CONF_PUSH_PULL;
         break;
     case GPIO_OUT_OPEN_DRAIN:
         iomux_flags = IOMUX_PIN_OUTPUT_ENABLE;
-        ctrl_val = 0;
         break;
     case GPIO_INPUT_PULLUP:
         iomux_flags = IOMUX_PIN_PULLUP;
-        ctrl_val = 0;
         break;
     }
     iomux_set_gpio_function(gpio_num, iomux_flags);
-    GPIO.CONF[gpio_num] = (GPIO.CONF[gpio_num] & FIELD_MASK(GPIO_CONF_INTTYPE)) | ctrl_val;
+    if(direction == GPIO_OUT_OPEN_DRAIN)
+        GPIO.CONF[gpio_num] |= GPIO_CONF_OPEN_DRAIN;
+    else
+        GPIO.CONF[gpio_num] &= ~GPIO_CONF_OPEN_DRAIN;
     if (iomux_flags & IOMUX_PIN_OUTPUT_ENABLE)
         GPIO.ENABLE_OUT_SET = BIT(gpio_num);
     else
@@ -124,7 +122,7 @@ INLINED void gpio_set_interrupt(const uint8_t gpio_num, const gpio_inttype_t int
 /* Return the interrupt type set for a pin */
 INLINED gpio_inttype_t gpio_get_interrupt(const uint8_t gpio_num)
 {
-    return FIELD2VAL(GPIO_CONF_INTTYPE, GPIO.CONF[gpio_num]);
+    return (gpio_inttype_t)FIELD2VAL(GPIO_CONF_INTTYPE, GPIO.CONF[gpio_num]);
 }
 
 #endif

core/include/esp/gpio_regs.h

@@ -76,10 +76,15 @@ _Static_assert(sizeof(struct GPIO_REGS) == 0x74, "GPIO_REGS is the wrong size");
  *     Under what conditions this GPIO input should generate an interrupt.
  *     (see gpio_inttype_t enum below for values)
  *
- * GPIO_CONF_PUSH_PULL (boolean)
- *     When set, a high output state will pull the pin up to +Vcc (3.3V).  When
- *     cleared, output functions in "open drain" mode (low state will pull down
- *     to ground, but high state allows output to "float").
+ * GPIO_CONF_OPEN_DRAIN (boolean)
+ *     If this bit is set, the pin is in "open drain" mode - a high output state
+ *     will leave the pin floating but not source any current. If bit is cleared,
+ *     the pin is in push/pull mode so a high output state will drive the pin up
+ *     to +Vcc (3.3V).  In either case, a low output state will pull the pin down
+ *     to ground.
+ *
+ *     GPIO_CONF_OPEN_DRAIN does not appear to work on all pins.
+ *
  *
  * GPIO_CONF_SOURCE_PWM (boolean)
  *     When set, GPIO pin output will be connected to the sigma-delta PWM
@@ -93,7 +98,7 @@ _Static_assert(sizeof(struct GPIO_REGS) == 0x74, "GPIO_REGS is the wrong size");
 #define GPIO_CONF_WAKEUP_ENABLE  BIT(10)
 #define GPIO_CONF_INTTYPE_M      0x00000007
 #define GPIO_CONF_INTTYPE_S      7
-#define GPIO_CONF_PUSH_PULL      BIT(2)
+#define GPIO_CONF_OPEN_DRAIN     BIT(2)
 #define GPIO_CONF_SOURCE_PWM     BIT(0)
 
 /* Valid values for the GPIO_CONF_INTTYPE field */

core/include/esp/iomux_regs.h

@@ -45,7 +45,7 @@ _Static_assert(sizeof(struct IOMUX_REGS) == 0x44, "IOMUX_REGS is the wrong size"
 #define IOMUX_PIN_FUNC_MASK            0x00001030
 
 /* WARNING: Macro evaluates argument twice */
-#define IOMUX_FUNC(val) (VAL2FIELD(IOMUX_PIN_FUNC_LOW, val) | VAL2FIELD(IOMUX_PIN_FUNC_HIGH, val))
+#define IOMUX_FUNC(val) (VAL2FIELD_M(IOMUX_PIN_FUNC_LOW, val) | VAL2FIELD_M(IOMUX_PIN_FUNC_HIGH, val))
 
 /* WARNING: Macro evaluates argument twice */
 #define IOMUX_FUNC_VALUE(regbits) (FIELD2VAL(IOMUX_PIN_FUNC_LOW, regbits) | FIELD2VAL(IOMUX_PIN_FUNC_HIGH, regbits))

core/include/esp/timer_private.h

@@ -193,7 +193,7 @@ INLINED bool _timer_set_frequency_impl(const timer_frc_t frc, uint32_t freq)
     counts = timer_freq_to_count(frc, freq, div);
     if(counts == 0)
     {
-        printf("ABORT: No counter for timer %u frequency %lu\r\n", frc, freq);
+        printf("ABORT: No counter for timer %u frequency %u\r\n", frc, freq);
         abort();
     }
 

core/newlib_syscalls.c

@@ -6,6 +6,7 @@
  */
 #include <sys/reent.h>
 #include <sys/types.h>
+#include <sys/errno.h>
 #include <espressif/sdk_private.h>
 #include <common_macros.h>
 #include <stdlib.h>
@@ -37,6 +38,10 @@ IRAM caddr_t _sbrk_r (struct _reent *r, int incr)
  */
 long _write_r(struct _reent *r, int fd, const char *ptr, int len )
 {
+    if(fd != r->_stdout->_file) {
+        r->_errno = EBADF;
+        return -1;
+    }
     for(int i = 0; i < len; i++)
 	sdk_os_putc(ptr[i]);
     return len;
@@ -48,29 +53,31 @@ long _write_r(struct _reent *r, int fd, const char *ptr, int len )
  */
 long _read_r( struct _reent *r, int fd, char *ptr, int len )
 {
-  for(int i = 0; i < len; i++) {
-    char ch;
-    while (sdk_uart_rx_one_char(&ch)) ;
-    ptr[i] = ch;
-
-  }
-  return len;
+    if(fd != r->_stdin->_file) {
+        r->_errno = EBADF;
+        return -1;
+    }
+    for(int i = 0; i < len; i++) {
+        char ch;
+        while (sdk_uart_rx_one_char(&ch)) ;
+        ptr[i] = ch;
+    }
+    return len;
 }
 
-/* These are stub implementations for the reentrant syscalls that
- * newlib is configured to expect */
-int _fstat_r(struct _reent *r, int fd, void *buf)
+/* Stub syscall implementations follow, to allow compiling newlib functions that
+   pull these in via various codepaths
+*/
+__attribute__((alias("syscall_returns_enosys"))) int _open_r(struct _reent *r, const char *pathname, int flags, int mode);
+__attribute__((alias("syscall_returns_enosys"))) int _fstat_r(struct _reent *r, int fd, void *buf);
+__attribute__((alias("syscall_returns_enosys"))) int _close_r(struct _reent *r, int fd);
+__attribute__((alias("syscall_returns_enosys"))) off_t _lseek_r(struct _reent *r, int fd, off_t offset, int whence);
+
+/* Generic stub for any newlib syscall that fails with errno ENOSYS
+   ("Function not implemented") and a return value equivalent to
+   (int)-1. */
+static int syscall_returns_enosys(struct _reent *r)
 {
+    r->_errno=ENOSYS;
     return -1;
 }
-
-int _close_r(struct _reent *r, int fd)
-{
-    return -1;
-}
-
-off_t _lseek_r(struct _reent *r, int fd, off_t offset, int whence)
-{
-    return (off_t)-1;
-}
-

core/sdk_compat.c

@@ -14,3 +14,18 @@ void IRAM *zalloc(size_t nbytes)
 {
     return calloc(1, nbytes);
 }
+
+extern void (*__init_array_start)(void);
+extern void (*__init_array_end)(void);
+
+/* Do things which should be done as part of the startup code, but aren't.
+
+   Can be replaced with _start() once we have open source startup code.
+*/
+void sdk_compat_initialise()
+{
+    /* Call C++ constructors or C functions marked with __attribute__((constructor)) */
+    void (**p)(void);
+    for ( p = &__init_array_start; p != &__init_array_end; ++p)
+        (*p)();
+}