RTC auf true
Diff: platform/mbed_retarget.cpp
- Revision:
- 0:38ceb79fef03
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/platform/mbed_retarget.cpp Wed Nov 28 15:10:15 2018 +0000 @@ -0,0 +1,1641 @@ +/* mbed Microcontroller Library + * Copyright (c) 2006-2015 ARM Limited + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include <time.h> +#include "platform/platform.h" +#include "platform/FilePath.h" +#include "hal/serial_api.h" +#include "hal/us_ticker_api.h" +#include "platform/mbed_toolchain.h" +#include "platform/mbed_semihost_api.h" +#include "platform/mbed_interface.h" +#include "platform/SingletonPtr.h" +#include "platform/PlatformMutex.h" +#include "platform/mbed_error.h" +#include "platform/mbed_stats.h" +#include "platform/mbed_critical.h" +#include "platform/mbed_poll.h" +#include "platform/PlatformMutex.h" +#include "drivers/UARTSerial.h" +#include "us_ticker_api.h" +#include "lp_ticker_api.h" +#include <stdlib.h> +#include <string.h> +#include <limits.h> +#ifndef SSIZE_MAX +#define SSIZE_MAX INT_MAX +#endif +#include <stdio.h> +#include <errno.h> +#include "platform/mbed_retarget.h" + +static SingletonPtr<PlatformMutex> _mutex; + +#if defined(__ARMCC_VERSION) +# if __ARMCC_VERSION >= 6010050 +# include <arm_compat.h> +# endif +# include <rt_sys.h> +# include <rt_misc.h> +# include <stdint.h> +# define PREFIX(x) _sys##x +# define OPEN_MAX _SYS_OPEN +# ifdef __MICROLIB +# pragma import(__use_full_stdio) +# endif + +#elif defined(__ICCARM__) +# include <yfuns.h> +# define PREFIX(x) _##x +# define OPEN_MAX 16 + +# define STDIN_FILENO 0 +# define STDOUT_FILENO 1 +# define STDERR_FILENO 2 + +#else +# include <sys/syslimits.h> +# define PREFIX(x) x +#endif + +#define FILE_HANDLE_RESERVED ((FileHandle*)0xFFFFFFFF) + +/** + * Macros for setting console flow control. + */ +#define CONSOLE_FLOWCONTROL_RTS 1 +#define CONSOLE_FLOWCONTROL_CTS 2 +#define CONSOLE_FLOWCONTROL_RTSCTS 3 +#define mbed_console_concat_(x) CONSOLE_FLOWCONTROL_##x +#define mbed_console_concat(x) mbed_console_concat_(x) +#define CONSOLE_FLOWCONTROL mbed_console_concat(MBED_CONF_TARGET_CONSOLE_UART_FLOW_CONTROL) + +using namespace mbed; + +#if defined(__MICROLIB) && (__ARMCC_VERSION>5030000) +// Before version 5.03, we were using a patched version of microlib with proper names +extern const char __stdin_name[] = ":tt"; +extern const char __stdout_name[] = ":tt"; +extern const char __stderr_name[] = ":tt"; + +#else +extern const char __stdin_name[] = "/stdin"; +extern const char __stdout_name[] = "/stdout"; +extern const char __stderr_name[] = "/stderr"; +#endif + +unsigned char *mbed_heap_start = 0; +uint32_t mbed_heap_size = 0; + +/* newlib has the filehandle field in the FILE struct as a short, so + * we can't just return a Filehandle* from _open and instead have to + * put it in a filehandles array and return the index into that array + */ +static FileHandle *filehandles[OPEN_MAX] = { FILE_HANDLE_RESERVED, FILE_HANDLE_RESERVED, FILE_HANDLE_RESERVED }; +static char stdio_in_prev[OPEN_MAX]; +static char stdio_out_prev[OPEN_MAX]; +static SingletonPtr<PlatformMutex> filehandle_mutex; + +namespace mbed { +void mbed_set_unbuffered_stream(std::FILE *_file); + +void remove_filehandle(FileHandle *file) +{ + filehandle_mutex->lock(); + /* Remove all open filehandles for this */ + for (unsigned int fh_i = 0; fh_i < sizeof(filehandles) / sizeof(*filehandles); fh_i++) { + if (filehandles[fh_i] == file) { + filehandles[fh_i] = NULL; + } + } + filehandle_mutex->unlock(); +} +} + +#if DEVICE_SERIAL +extern int stdio_uart_inited; +extern serial_t stdio_uart; + +/* Private FileHandle to implement backwards-compatible functionality of + * direct HAL serial access for default stdin/stdout/stderr. + * This is not a particularly well-behaved FileHandle for a stream, which + * is why it's not public. People should be using UARTSerial. + */ +class DirectSerial : public FileHandle { +public: + DirectSerial(PinName tx, PinName rx, int baud); + virtual ssize_t write(const void *buffer, size_t size); + virtual ssize_t read(void *buffer, size_t size); + virtual off_t seek(off_t offset, int whence = SEEK_SET) + { + return -ESPIPE; + } + virtual off_t size() + { + return -EINVAL; + } + virtual int isatty() + { + return true; + } + virtual int close() + { + return 0; + } + virtual short poll(short events) const; +}; + +DirectSerial::DirectSerial(PinName tx, PinName rx, int baud) +{ + if (stdio_uart_inited) { + return; + } + serial_init(&stdio_uart, tx, rx); + serial_baud(&stdio_uart, baud); +#if CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTS + serial_set_flow_control(&stdio_uart, FlowControlRTS, STDIO_UART_RTS, NC); +#elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_CTS + serial_set_flow_control(&stdio_uart, FlowControlCTS, NC, STDIO_UART_CTS); +#elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTSCTS + serial_set_flow_control(&stdio_uart, FlowControlRTSCTS, STDIO_UART_RTS, STDIO_UART_CTS); +#endif +} + +ssize_t DirectSerial::write(const void *buffer, size_t size) +{ + const unsigned char *buf = static_cast<const unsigned char *>(buffer); + for (size_t i = 0; i < size; i++) { + serial_putc(&stdio_uart, buf[i]); + } + return size; +} + +ssize_t DirectSerial::read(void *buffer, size_t size) +{ + unsigned char *buf = static_cast<unsigned char *>(buffer); + if (size == 0) { + return 0; + } + buf[0] = serial_getc(&stdio_uart); + return 1; +} + +short DirectSerial::poll(short events) const +{ + short revents = 0; + if ((events & POLLIN) && serial_readable(&stdio_uart)) { + revents |= POLLIN; + } + if ((events & POLLOUT) && serial_writable(&stdio_uart)) { + revents |= POLLOUT; + } + return revents; +} +#endif + +class Sink : public FileHandle { +public: + virtual ssize_t write(const void *buffer, size_t size); + virtual ssize_t read(void *buffer, size_t size); + virtual off_t seek(off_t offset, int whence = SEEK_SET) + { + return ESPIPE; + } + virtual off_t size() + { + return -EINVAL; + } + virtual int isatty() + { + return true; + } + virtual int close() + { + return 0; + } +}; + +ssize_t Sink::write(const void *buffer, size_t size) +{ + // Just swallow the data - this is historical non-DEVICE_SERIAL behaviour + return size; +} + +ssize_t Sink::read(void *buffer, size_t size) +{ + // Produce 1 zero byte - historical behaviour returned 1 without touching + // the buffer + unsigned char *buf = static_cast<unsigned char *>(buffer); + buf[0] = 0; + return 1; +} + + +MBED_WEAK FileHandle *mbed::mbed_target_override_console(int fd) +{ + return NULL; +} + +MBED_WEAK FileHandle *mbed::mbed_override_console(int fd) +{ + return NULL; +} + +static FileHandle *default_console() +{ +#if DEVICE_SERIAL +# if MBED_CONF_PLATFORM_STDIO_BUFFERED_SERIAL + static UARTSerial console(STDIO_UART_TX, STDIO_UART_RX, MBED_CONF_PLATFORM_STDIO_BAUD_RATE); +# if CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTS + console.set_flow_control(SerialBase::RTS, STDIO_UART_RTS, NC); +# elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_CTS + console.set_flow_control(SerialBase::CTS, NC, STDIO_UART_CTS); +# elif CONSOLE_FLOWCONTROL == CONSOLE_FLOWCONTROL_RTSCTS + console.set_flow_control(SerialBase::RTSCTS, STDIO_UART_RTS, STDIO_UART_CTS); +# endif +# else + static DirectSerial console(STDIO_UART_TX, STDIO_UART_RX, MBED_CONF_PLATFORM_STDIO_BAUD_RATE); +# endif +#else // DEVICE_SERIAL + static Sink console; +#endif + return &console; +} + +/* Locate the default console for stdout, stdin, stderr */ +static FileHandle *get_console(int fd) +{ + FileHandle *fh = mbed_override_console(fd); + if (fh) { + return fh; + } + fh = mbed_target_override_console(fd); + if (fh) { + return fh; + } + return default_console(); +} + +/* Deal with the fact C library may not _open descriptors 0, 1, 2 - auto bind */ +static FileHandle *get_fhc(int fd) +{ + if (fd >= OPEN_MAX) { + return NULL; + } + FileHandle *fh = filehandles[fd]; + if (fh == FILE_HANDLE_RESERVED && fd < 3) { + filehandles[fd] = fh = get_console(fd); + } + return fh; +} + +/** + * Sets errno when file opening fails. + * Wipes out the filehandle too. + * + * @param error is a negative error code returned from an mbed function and + * will be negated to store a positive error code in errno + */ +static int handle_open_errors(int error, unsigned filehandle_idx) +{ + errno = -error; + // Free file handle + filehandles[filehandle_idx] = NULL; + return -1; +} + +static inline int openflags_to_posix(int openflags) +{ + int posix = openflags; +#ifdef __ARMCC_VERSION + if (openflags & OPEN_PLUS) { + posix = O_RDWR; + } else if (openflags & OPEN_W) { + posix = O_WRONLY; + } else if (openflags & OPEN_A) { + posix = O_WRONLY | O_APPEND; + } else { + posix = O_RDONLY; + } + /* a, w, a+, w+ all create if file does not already exist */ + if (openflags & (OPEN_A | OPEN_W)) { + posix |= O_CREAT; + } + /* w and w+ truncate */ + if (openflags & OPEN_W) { + posix |= O_TRUNC; + } +#elif defined(__ICCARM__) + switch (openflags & _LLIO_RDWRMASK) { + case _LLIO_RDONLY: + posix = O_RDONLY; + break; + case _LLIO_WRONLY: + posix = O_WRONLY; + break; + case _LLIO_RDWR : + posix = O_RDWR ; + break; + } + if (openflags & _LLIO_CREAT) { + posix |= O_CREAT; + } + if (openflags & _LLIO_APPEND) { + posix |= O_APPEND; + } + if (openflags & _LLIO_TRUNC) { + posix |= O_TRUNC; + } +#elif defined(TOOLCHAIN_GCC) + posix &= ~O_BINARY; +#endif + return posix; +} + +static int reserve_filehandle() +{ + // find the first empty slot in filehandles, after the slots reserved for stdin/stdout/stderr + filehandle_mutex->lock(); + int fh_i; + for (fh_i = 3; fh_i < OPEN_MAX; fh_i++) { + /* Take a next free filehandle slot available. */ + if (filehandles[fh_i] == NULL) { + break; + } + } + if (fh_i >= OPEN_MAX) { + /* Too many file handles have been opened */ + errno = EMFILE; + filehandle_mutex->unlock(); + return -1; + } + filehandles[fh_i] = FILE_HANDLE_RESERVED; + filehandle_mutex->unlock(); + + return fh_i; +} + +int mbed::bind_to_fd(FileHandle *fh) +{ + int fildes = reserve_filehandle(); + if (fildes < 0) { + return fildes; + } + + filehandles[fildes] = fh; + stdio_in_prev[fildes] = 0; + stdio_out_prev[fildes] = 0; + + return fildes; +} + +static int unbind_from_fd(int fd, FileHandle *fh) +{ + if (filehandles[fd] == fh) { + filehandles[fd] = NULL; + return 0; + } else { + errno = EBADF; + return -1; + } +} + +#ifndef __IAR_SYSTEMS_ICC__ +/* IAR provides fdopen itself */ +extern "C" std::FILE *fdopen(int fildes, const char *mode) +{ + // This is to avoid scanf and the bloat it brings. + char buf[1 + sizeof fildes]; /* @(integer) */ + MBED_STATIC_ASSERT(sizeof buf == 5, "Integers should be 4 bytes."); + buf[0] = '@'; + memcpy(buf + 1, &fildes, sizeof fildes); + + std::FILE *stream = std::fopen(buf, mode); + /* newlib-nano doesn't appear to ever call _isatty itself, so + * happily fully buffers an interactive stream. Deal with that here. + */ + if (stream && isatty(fildes)) { + mbed_set_unbuffered_stream(stream); + } + return stream; +} +#endif + +namespace mbed { +std::FILE *fdopen(FileHandle *fh, const char *mode) +{ + // First reserve the integer file descriptor + int fd = bind_to_fd(fh); + if (!fd) { + return NULL; + } + // Then bind that to the C stream. If successful, C library + // takes ownership and responsibility to close. + std::FILE *stream = ::fdopen(fd, mode); + if (!stream) { + unbind_from_fd(fd, fh); + } + return stream; +} +} + +/* @brief standard c library fopen() retargeting function. + * + * This function is invoked by the standard c library retargeting to handle fopen() + * + * @return + * On success, a valid FILEHANDLE is returned. + * On failure, -1 is returned and errno is set to an appropriate value e.g. + * ENOENT file not found (default errno setting) + * EMFILE the maximum number of open files was exceeded. + * + * */ +extern "C" FILEHANDLE PREFIX(_open)(const char *name, int openflags) +{ +#if defined(__MICROLIB) && (__ARMCC_VERSION>5030000) +#if !defined(MBED_CONF_RTOS_PRESENT) + // valid only for mbed 2 + // for ulib, this is invoked after RAM init, prior c++ + // used as hook, as post stack/heap is not active there + extern void mbed_copy_nvic(void); + extern void mbed_sdk_init(void); + + static int mbed_sdk_inited = 0; + if (!mbed_sdk_inited) { + mbed_copy_nvic(); + mbed_sdk_init(); + mbed_sdk_inited = 1; + } +#endif + // Before version 5.03, we were using a patched version of microlib with proper names + // This is the workaround that the microlib author suggested us + static int n = 0; + if (std::strcmp(name, ":tt") == 0 && n < 3) { + return n++; + } +#else + /* Use the posix convention that stdin,out,err are filehandles 0,1,2. + */ + if (std::strcmp(name, __stdin_name) == 0) { + get_fhc(STDIN_FILENO); + return STDIN_FILENO; + } else if (std::strcmp(name, __stdout_name) == 0) { + get_fhc(STDOUT_FILENO); + return STDOUT_FILENO; + } else if (std::strcmp(name, __stderr_name) == 0) { + get_fhc(STDERR_FILENO); + return STDERR_FILENO; + } +#endif +#ifndef __IAR_SYSTEMS_ICC__ + /* FILENAME: "@(integer)" gives an already-allocated descriptor */ + if (name[0] == '@') { + int fd; + memcpy(&fd, name + 1, sizeof fd); + return fd; + } +#endif + return open(name, openflags_to_posix(openflags)); +} + +extern "C" int open(const char *name, int oflag, ...) +{ + int fildes = reserve_filehandle(); + if (fildes < 0) { + return fildes; + } + + FileHandle *res = NULL; + FilePath path(name); + + if (!path.exists()) { + /* The first part of the filename (between first 2 '/') is not a + * registered mount point in the namespace. + */ + return handle_open_errors(-ENODEV, fildes); + } + + if (path.isFile()) { + res = path.file(); + } else { + FileSystemHandle *fs = path.fileSystem(); + if (fs == NULL) { + return handle_open_errors(-ENODEV, fildes); + } + int err = fs->open(&res, path.fileName(), oflag); + if (err) { + return handle_open_errors(err, fildes); + } + } + + filehandles[fildes] = res; + stdio_in_prev[fildes] = 0; + stdio_out_prev[fildes] = 0; + + return fildes; +} + +extern "C" int PREFIX(_close)(FILEHANDLE fh) +{ + return close(fh); +} + +extern "C" int close(int fildes) +{ + FileHandle *fhc = get_fhc(fildes); + filehandles[fildes] = NULL; + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + int err = fhc->close(); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +static bool convert_crlf(int fd) +{ +#if MBED_CONF_PLATFORM_STDIO_CONVERT_TTY_NEWLINES + return isatty(fd); +#elif MBED_CONF_PLATFORM_STDIO_CONVERT_NEWLINES + return fd < 3 && isatty(fd); +#else + return false; +#endif +} + +#if defined(__ICCARM__) +extern "C" size_t __write(int fh, const unsigned char *buffer, size_t length) +{ +#else +extern "C" int PREFIX(_write)(FILEHANDLE fh, const unsigned char *buffer, unsigned int length, int mode) +{ +#endif + +#if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT) + if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) { + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - writing to a file in an ISR or critical section\r\n", fh); + } +#endif + + if (length > SSIZE_MAX) { + errno = EINVAL; + return -1; + } + + ssize_t slength = length; + ssize_t written = 0; + + if (convert_crlf(fh)) { + // local prev is previous in buffer during seek + // stdio_out_prev[fh] is last thing actually written + char prev = stdio_out_prev[fh]; + // Seek for '\n' without preceding '\r'; if found flush + // preceding and insert '\r'. Continue until end of input. + for (ssize_t cur = 0; cur < slength; cur++) { + if (buffer[cur] == '\n' && prev != '\r') { + ssize_t r; + // flush stuff preceding the \n + if (cur > written) { + r = write(fh, buffer + written, cur - written); + if (r < 0) { + return -1; + } + written += r; + if (written < cur) { + // For some reason, didn't write all - give up now + goto finish; + } + stdio_out_prev[fh] = prev; + } + // insert a \r now, leaving the \n still to be written + r = write(fh, "\r", 1); + if (r < 0) { + return -1; + } + if (r < 1) { + goto finish; + } + stdio_out_prev[fh] = '\r'; + } + prev = buffer[cur]; + } + } + + // Flush remaining from conversion, or the whole thing if no conversion + if (written < slength) { + ssize_t r = write(fh, buffer + written, slength - written); + if (r < 0) { + return -1; + } + written += r; + if (written > 0) { + stdio_out_prev[fh] = buffer[written - 1]; + } + } + +finish: +#ifdef __ARMCC_VERSION + if (written >= 0) { + return slength - written; + } else { + return written; + } +#else + return written; +#endif +} + +extern "C" ssize_t write(int fildes, const void *buf, size_t length) +{ + + FileHandle *fhc = get_fhc(fildes); + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + ssize_t ret = fhc->write(buf, length); + if (ret < 0) { + errno = -ret; + return -1; + } else { + return ret; + } +} + +#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050) +extern "C" void PREFIX(_exit)(int return_code) +{ + while (1) {} +} + +extern "C" void _ttywrch(int ch) +{ + char c = ch; + write(STDOUT_FILENO, &c, 1); +} +#endif + +#if defined(__ICCARM__) +extern "C" size_t __read(int fh, unsigned char *buffer, size_t length) +{ +#else +extern "C" int PREFIX(_read)(FILEHANDLE fh, unsigned char *buffer, unsigned int length, int mode) +{ +#endif + +#if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT) + if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) { + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - reading from a file in an ISR or critical section\r\n", fh); + } +#endif + + if (length > SSIZE_MAX) { + errno = EINVAL; + return -1; + } + + ssize_t bytes_read = 0; + + if (convert_crlf(fh)) { + while (true) { + char c; + ssize_t r = read(fh, &c, 1); + if (r < 0) { + return -1; + } + if (r == 0) { + return bytes_read; + } + if ((c == '\r' && stdio_in_prev[fh] != '\n') || + (c == '\n' && stdio_in_prev[fh] != '\r')) { + stdio_in_prev[fh] = c; + *buffer = '\n'; + break; + } else if ((c == '\r' && stdio_in_prev[fh] == '\n') || + (c == '\n' && stdio_in_prev[fh] == '\r')) { + stdio_in_prev[fh] = c; + continue; + } else { + stdio_in_prev[fh] = c; + *buffer = c; + break; + } + } + bytes_read = 1; + } else { + bytes_read = read(fh, buffer, length); + } + +#ifdef __ARMCC_VERSION + if (bytes_read < 0) { + return -1; + } else if (bytes_read == 0) { + return 0x80000000 | length; // weird EOF indication + } else { + return (ssize_t)length - bytes_read; + } +#else + return bytes_read; +#endif +} + +extern "C" ssize_t read(int fildes, void *buf, size_t length) +{ + + FileHandle *fhc = get_fhc(fildes); + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + ssize_t ret = fhc->read(buf, length); + if (ret < 0) { + errno = -ret; + return -1; + } else { + return ret; + } +} + + +#ifdef __ARMCC_VERSION +extern "C" int PREFIX(_istty)(FILEHANDLE fh) +#else +extern "C" int _isatty(FILEHANDLE fh) +#endif +{ + return isatty(fh); +} + +extern "C" int isatty(int fildes) +{ + FileHandle *fhc = get_fhc(fildes); + if (fhc == NULL) { + errno = EBADF; + return 0; + } + + int tty = fhc->isatty(); + if (tty < 0) { + errno = -tty; + return 0; + } else { + return tty; + } +} + +extern "C" +#if defined(__ARMCC_VERSION) +int _sys_seek(FILEHANDLE fh, long offset) +#elif defined(__ICCARM__) +long __lseek(int fh, long offset, int whence) +#else +int _lseek(FILEHANDLE fh, int offset, int whence) +#endif +{ +#if defined(__ARMCC_VERSION) + int whence = SEEK_SET; +#endif + + off_t off = lseek(fh, offset, whence); + // Assuming INT_MAX = LONG_MAX, so we don't care about prototype difference + if (off > INT_MAX) { + errno = EOVERFLOW; + return -1; + } + return off; +} + +extern "C" off_t lseek(int fildes, off_t offset, int whence) +{ + FileHandle *fhc = get_fhc(fildes); + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + off_t off = fhc->seek(offset, whence); + if (off < 0) { + errno = -off; + return -1; + } + return off; +} + +#ifdef __ARMCC_VERSION +extern "C" int PREFIX(_ensure)(FILEHANDLE fh) +{ + return fsync(fh); +} +#endif + +extern "C" int fsync(int fildes) +{ + FileHandle *fhc = get_fhc(fildes); + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + int err = fhc->sync(); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +#ifdef __ARMCC_VERSION +extern "C" long PREFIX(_flen)(FILEHANDLE fh) +{ + FileHandle *fhc = get_fhc(fh); + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + off_t size = fhc->size(); + if (size < 0) { + errno = -size; + return -1; + } + if (size > LONG_MAX) { + errno = EOVERFLOW; + return -1; + } + return size; +} + +extern "C" char Image$$RW_IRAM1$$ZI$$Limit[]; + +extern "C" MBED_WEAK __value_in_regs struct __initial_stackheap _mbed_user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3) +{ + uint32_t zi_limit = (uint32_t)Image$$RW_IRAM1$$ZI$$Limit; + uint32_t sp_limit = __current_sp(); + + zi_limit = (zi_limit + 7) & ~0x7; // ensure zi_limit is 8-byte aligned + + struct __initial_stackheap r; + r.heap_base = zi_limit; + r.heap_limit = sp_limit; + return r; +} + +extern "C" __value_in_regs struct __initial_stackheap __user_setup_stackheap(uint32_t R0, uint32_t R1, uint32_t R2, uint32_t R3) +{ + return _mbed_user_setup_stackheap(R0, R1, R2, R3); +} + +#endif + + +#if !defined(__ARMCC_VERSION) && !defined(__ICCARM__) +extern "C" int _fstat(int fh, struct stat *st) +{ + return fstat(fh, st); +} +#endif + +extern "C" int fstat(int fildes, struct stat *st) +{ + FileHandle *fhc = get_fhc(fildes); + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + st->st_mode = fhc->isatty() ? S_IFCHR : S_IFREG; + st->st_size = fhc->size(); + return 0; +} + +extern "C" int fcntl(int fildes, int cmd, ...) +{ + FileHandle *fhc = get_fhc(fildes); + if (fhc == NULL) { + errno = EBADF; + return -1; + } + + switch (cmd) { + case F_GETFL: { + int flags = 0; + if (fhc->is_blocking()) { + flags |= O_NONBLOCK; + } + return flags; + } + case F_SETFL: { + va_list ap; + va_start(ap, cmd); + int flags = va_arg(ap, int); + va_end(ap); + int ret = fhc->set_blocking(flags & O_NONBLOCK); + if (ret < 0) { + errno = -ret; + return -1; + } + return 0; + } + + default: { + errno = EINVAL; + return -1; + } + } +} + +extern "C" int poll(struct pollfd fds[], nfds_t nfds, int timeout) +{ + if (nfds > OPEN_MAX) { + errno = EINVAL; + return -1; + } + + struct mbed::pollfh fhs[OPEN_MAX]; + for (nfds_t n = 0; n < nfds; n++) { + // Underlying FileHandle poll returns POLLNVAL if given NULL, so + // we don't need to take special action. + fhs[n].fh = get_fhc(fds[n].fd); + fhs[n].events = fds[n].events; + } + int ret = poll(fhs, nfds, timeout); + for (nfds_t n = 0; n < nfds; n++) { + fds[n].revents = fhs[n].revents; + } + return ret; +} + +namespace std { +extern "C" int remove(const char *path) +{ + FilePath fp(path); + FileSystemHandle *fs = fp.fileSystem(); + if (fs == NULL) { + errno = ENODEV; + return -1; + } + + int err = fs->remove(fp.fileName()); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +extern "C" int rename(const char *oldname, const char *newname) +{ + FilePath fpOld(oldname); + FilePath fpNew(newname); + FileSystemHandle *fsOld = fpOld.fileSystem(); + FileSystemHandle *fsNew = fpNew.fileSystem(); + + if (fsOld == NULL) { + errno = ENODEV; + return -1; + } + + /* rename only if both files are on the same FS */ + if (fsOld != fsNew) { + errno = EXDEV; + return -1; + } + + int err = fsOld->rename(fpOld.fileName(), fpNew.fileName()); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +extern "C" char *tmpnam(char *s) +{ + errno = EBADF; + return NULL; +} + +extern "C" FILE *tmpfile() +{ + errno = EBADF; + return NULL; +} +} // namespace std + +#ifdef __ARMCC_VERSION +extern "C" char *_sys_command_string(char *cmd, int len) +{ + return NULL; +} +#endif + +extern "C" DIR *opendir(const char *path) +{ + FilePath fp(path); + FileSystemHandle *fs = fp.fileSystem(); + if (fs == NULL) { + errno = ENODEV; + return NULL; + } + + DirHandle *dir; + int err = fs->open(&dir, fp.fileName()); + if (err < 0) { + errno = -err; + return NULL; + } + + return dir; +} + +extern "C" struct dirent *readdir(DIR *dir) +{ + static struct dirent ent; + int err = dir->read(&ent); + if (err < 1) { + if (err < 0) { + errno = -err; + } + return NULL; + } + + return &ent; +} + +extern "C" int closedir(DIR *dir) +{ + int err = dir->close(); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +extern "C" void rewinddir(DIR *dir) +{ + dir->rewind(); +} + +extern "C" off_t telldir(DIR *dir) +{ + return dir->tell(); +} + +extern "C" void seekdir(DIR *dir, off_t off) +{ + dir->seek(off); +} + +extern "C" int mkdir(const char *path, mode_t mode) +{ + FilePath fp(path); + FileSystemHandle *fs = fp.fileSystem(); + if (fs == NULL) { + errno = ENODEV; + return -1; + } + + int err = fs->mkdir(fp.fileName(), mode); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +extern "C" int stat(const char *path, struct stat *st) +{ + FilePath fp(path); + FileSystemHandle *fs = fp.fileSystem(); + if (fs == NULL) { + errno = ENODEV; + return -1; + } + + int err = fs->stat(fp.fileName(), st); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +extern "C" int statvfs(const char *path, struct statvfs *buf) +{ + FilePath fp(path); + FileSystemHandle *fs = fp.fileSystem(); + if (fs == NULL) { + errno = ENODEV; + return -1; + } + + int err = fs->statvfs(fp.fileName(), buf); + if (err < 0) { + errno = -err; + return -1; + } else { + return 0; + } +} + +#if defined(TOOLCHAIN_GCC) +/* prevents the exception handling name demangling code getting pulled in */ +#include "mbed_error.h" +namespace __gnu_cxx { +void __verbose_terminate_handler() +{ + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_CLIB_EXCEPTION), "Exception", 0); +} +} +extern "C" WEAK void __cxa_pure_virtual(void); +extern "C" WEAK void __cxa_pure_virtual(void) +{ + exit(1); +} + +#endif + +// Provide implementation of _sbrk (low-level dynamic memory allocation +// routine) for GCC_ARM which compares new heap pointer with MSP instead of +// SP. This make it compatible with RTX RTOS thread stacks. +#if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR) + +#if defined(TARGET_CORTEX_A) +extern "C" uint32_t __HeapLimit; +#endif + +// Turn off the errno macro and use actual global variable instead. +#undef errno +extern "C" int errno; + +// Dynamic memory allocation related syscall. +#if defined(TWO_RAM_REGIONS) + +// Overwrite _sbrk() to support two region model (heap and stack are two distinct regions). +// __wrap__sbrk() is implemented in: +// TARGET_STM32L4 targets/TARGET_STM/TARGET_STM32L4/TARGET_STM32L4/l4_retarget.c +extern "C" void *__wrap__sbrk(int incr); +extern "C" caddr_t _sbrk(int incr) +{ + return (caddr_t) __wrap__sbrk(incr); +} +#else +// Linker defined symbol used by _sbrk to indicate where heap should start. +extern "C" uint32_t __end__; +// Weak attribute allows user to override, e.g. to use external RAM for dynamic memory. +extern "C" WEAK caddr_t _sbrk(int incr) +{ + static unsigned char *heap = (unsigned char *)&__end__; + unsigned char *prev_heap = heap; + unsigned char *new_heap = heap + incr; + +#if defined(TARGET_CORTEX_A) + if (new_heap >= (unsigned char *)&__HeapLimit) { /* __HeapLimit is end of heap section */ +#else + if (new_heap >= (unsigned char *)__get_MSP()) { +#endif + errno = ENOMEM; + return (caddr_t) -1; + } + + // Additional heap checking if set + if (mbed_heap_size && (new_heap >= mbed_heap_start + mbed_heap_size)) { + errno = ENOMEM; + return (caddr_t) -1; + } + + heap = new_heap; + return (caddr_t) prev_heap; +} +#endif +#endif + +#if defined(TOOLCHAIN_GCC_ARM) || defined(TOOLCHAIN_GCC_CR) +extern "C" void _exit(int return_code) +{ +#else +namespace std { +extern "C" void exit(int return_code) +{ +#endif + +#if DEVICE_STDIO_MESSAGES +#if MBED_CONF_PLATFORM_STDIO_FLUSH_AT_EXIT + fflush(stdout); + fflush(stderr); +#endif +#endif + +#if DEVICE_SEMIHOST + if (mbed_interface_connected()) { + semihost_exit(); + } +#endif + if (return_code) { + mbed_die(); + } + + while (1); +} + +#if !defined(TOOLCHAIN_GCC_ARM) && !defined(TOOLCHAIN_GCC_CR) +} //namespace std +#endif + +#if defined(TOOLCHAIN_ARM) || defined(TOOLCHAIN_GCC) + +// This series of function disable the registration of global destructors +// in a dynamic table which will be called when the application exit. +// In mbed, program never exit properly, it dies. +// More informations about this topic for ARMCC here: +// http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.faqs/6449.html +extern "C" { + int __aeabi_atexit(void *object, void (*dtor)(void * /*this*/), void *handle) + { + return 1; + } + + int __cxa_atexit(void (*dtor)(void * /*this*/), void *object, void *handle) + { + return 1; + } + + void __cxa_finalize(void *handle) + { + } + +} // end of extern "C" + +#endif + + +#if defined(TOOLCHAIN_GCC) + +/* + * Depending on how newlib is configured, it is often not enough to define + * __aeabi_atexit, __cxa_atexit and __cxa_finalize in order to override the + * behavior regarding the registration of handlers with atexit. + * + * To overcome this limitation, exit and atexit are overriden here. + */ +extern "C" { + + /** + * @brief Retarget of exit for GCC. + * @details Unlike the standard version, this function doesn't call any function + * registered with atexit before calling _exit. + */ + void __wrap_exit(int return_code) + { + _exit(return_code); + } + + /** + * @brief Retarget atexit from GCC. + * @details This function will always fail and never register any handler to be + * called at exit. + */ + int __wrap_atexit(void (*func)()) + { + return 1; + } + +} + +#endif + + + +namespace mbed { + +void mbed_set_unbuffered_stream(std::FILE *_file) +{ +#if defined (__ICCARM__) + char buf[2]; + std::setvbuf(_file, buf, _IONBF, NULL); +#else + setbuf(_file, NULL); +#endif +} + +int mbed_getc(std::FILE *_file) +{ +#if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ < 8000000) + /*This is only valid for unbuffered streams*/ + int res = std::fgetc(_file); + if (res >= 0) { + _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */ + _file->_Rend = _file->_Wend; + _file->_Next = _file->_Wend; + } + return res; +#else + return std::fgetc(_file); +#endif +} + +char *mbed_gets(char *s, int size, std::FILE *_file) +{ +#if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ < 8000000) + /*This is only valid for unbuffered streams*/ + char *str = fgets(s, size, _file); + if (str != NULL) { + _file->_Mode = (unsigned short)(_file->_Mode & ~ 0x1000);/* Unset read mode */ + _file->_Rend = _file->_Wend; + _file->_Next = _file->_Wend; + } + return str; +#else + return std::fgets(s, size, _file); +#endif +} + +} // namespace mbed + +#if defined (__ICCARM__) +// Stub out locks when an rtos is not present +extern "C" WEAK void __iar_system_Mtxinit(__iar_Rmtx *mutex) {} +extern "C" WEAK void __iar_system_Mtxdst(__iar_Rmtx *mutex) {} +extern "C" WEAK void __iar_system_Mtxlock(__iar_Rmtx *mutex) {} +extern "C" WEAK void __iar_system_Mtxunlock(__iar_Rmtx *mutex) {} +extern "C" WEAK void __iar_file_Mtxinit(__iar_Rmtx *mutex) {} +extern "C" WEAK void __iar_file_Mtxdst(__iar_Rmtx *mutex) {} +extern "C" WEAK void __iar_file_Mtxlock(__iar_Rmtx *mutex) {} +extern "C" WEAK void __iar_file_Mtxunlock(__iar_Rmtx *mutex) {} +#if defined(__IAR_SYSTEMS_ICC__ ) && (__VER__ >= 8000000) +#pragma section="__iar_tls$$DATA" +extern "C" WEAK void *__aeabi_read_tp(void) +{ + // Thread Local storage is not supported, using main thread memory for errno + return __section_begin("__iar_tls$$DATA"); +} +#endif +#elif defined(__CC_ARM) +// Do nothing +#elif defined (__GNUC__) +struct _reent; +// Stub out locks when an rtos is not present +extern "C" WEAK void __rtos_malloc_lock(struct _reent *_r) {} +extern "C" WEAK void __rtos_malloc_unlock(struct _reent *_r) {} +extern "C" WEAK void __rtos_env_lock(struct _reent *_r) {} +extern "C" WEAK void __rtos_env_unlock(struct _reent *_r) {} + +extern "C" void __malloc_lock(struct _reent *_r) +{ + __rtos_malloc_lock(_r); +} + +extern "C" void __malloc_unlock(struct _reent *_r) +{ + __rtos_malloc_unlock(_r); +} + +extern "C" void __env_lock(struct _reent *_r) +{ + __rtos_env_lock(_r); +} + +extern "C" void __env_unlock(struct _reent *_r) +{ + __rtos_env_unlock(_r); +} + +#endif + +#if defined (__GNUC__) || defined(__CC_ARM) || (defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)) + +#define CXA_GUARD_INIT_DONE (1 << 0) +#define CXA_GUARD_INIT_IN_PROGRESS (1 << 1) +#define CXA_GUARD_MASK (CXA_GUARD_INIT_DONE | CXA_GUARD_INIT_IN_PROGRESS) + +extern "C" int __cxa_guard_acquire(int *guard_object_p) +{ + uint8_t *guard_object = (uint8_t *)guard_object_p; + if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) { + return 0; + } + singleton_lock(); + if (CXA_GUARD_INIT_DONE == (*guard_object & CXA_GUARD_MASK)) { + singleton_unlock(); + return 0; + } + MBED_ASSERT(0 == (*guard_object & CXA_GUARD_MASK)); + *guard_object = *guard_object | CXA_GUARD_INIT_IN_PROGRESS; + return 1; +} + +extern "C" void __cxa_guard_release(int *guard_object_p) +{ + uint8_t *guard_object = (uint8_t *)guard_object_p; + MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK)); + *guard_object = (*guard_object & ~CXA_GUARD_MASK) | CXA_GUARD_INIT_DONE; + singleton_unlock(); +} + +extern "C" void __cxa_guard_abort(int *guard_object_p) +{ + uint8_t *guard_object = (uint8_t *)guard_object_p; + MBED_ASSERT(CXA_GUARD_INIT_IN_PROGRESS == (*guard_object & CXA_GUARD_MASK)); + *guard_object = *guard_object & ~CXA_GUARD_INIT_IN_PROGRESS; + singleton_unlock(); +} + +#endif + +#if MBED_MEM_TRACING_ENABLED && (defined(__CC_ARM) || defined(__ICCARM__) || (defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050))) + +// If the memory tracing is enabled, the wrappers in mbed_alloc_wrappers.cpp +// provide the implementation for these. Note: this needs to use the wrappers +// instead of malloc()/free() as the caller address would point to wrappers, +// not the caller of "new" or "delete". +extern "C" void *malloc_wrapper(size_t size, const void *caller); +extern "C" void free_wrapper(void *ptr, const void *caller); + +void *operator new (std::size_t count) +{ + void *buffer = malloc_wrapper(count, MBED_CALLER_ADDR()); + if (NULL == buffer) { + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count); + } + return buffer; +} + +void *operator new[](std::size_t count) +{ + void *buffer = malloc_wrapper(count, MBED_CALLER_ADDR()); + if (NULL == buffer) { + error("Operator new[] out of memory\r\n"); + } + return buffer; +} + +void *operator new (std::size_t count, const std::nothrow_t &tag) +{ + return malloc_wrapper(count, MBED_CALLER_ADDR()); +} + +void *operator new[](std::size_t count, const std::nothrow_t &tag) +{ + return malloc_wrapper(count, MBED_CALLER_ADDR()); +} + +void operator delete (void *ptr) +{ + free_wrapper(ptr, MBED_CALLER_ADDR()); +} +void operator delete[](void *ptr) +{ + free_wrapper(ptr, MBED_CALLER_ADDR()); +} + +#elif MBED_MEM_TRACING_ENABLED && defined(__GNUC__) + +#include <reent.h> + +extern "C" void *malloc_wrapper(struct _reent *r, size_t size, void *caller); +extern "C" void free_wrapper(struct _reent *r, void *ptr, void *caller); + +void *operator new (std::size_t count) +{ + void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR()); + if (NULL == buffer) { + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count); + } + return buffer; +} + +void *operator new[](std::size_t count) +{ + void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR()); + if (NULL == buffer) { + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count); + } + return buffer; +} + +void *operator new (std::size_t count, const std::nothrow_t &tag) +{ + return malloc_wrapper(_REENT, count, MBED_CALLER_ADDR()); +} + +void *operator new[](std::size_t count, const std::nothrow_t &tag) +{ + return malloc_wrapper(_REENT, count, MBED_CALLER_ADDR()); +} + +void operator delete (void *ptr) +{ + free_wrapper(_REENT, ptr, MBED_CALLER_ADDR()); +} + +void operator delete[](void *ptr) +{ + free_wrapper(_REENT, ptr, MBED_CALLER_ADDR()); +} + +#else + +void *operator new (std::size_t count) +{ + void *buffer = malloc(count); + if (NULL == buffer) { + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count); + } + return buffer; +} + +void *operator new[](std::size_t count) +{ + void *buffer = malloc(count); + if (NULL == buffer) { + MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new[] out of memory\r\n", count); + } + return buffer; +} + +void *operator new (std::size_t count, const std::nothrow_t &tag) +{ + return malloc(count); +} + +void *operator new[](std::size_t count, const std::nothrow_t &tag) +{ + return malloc(count); +} + +void operator delete (void *ptr) +{ + free(ptr); +} +void operator delete[](void *ptr) +{ + free(ptr); +} + +#endif + +/* @brief standard c library clock() function. + * + * This function returns the number of clock ticks elapsed since the start of the program. + * + * @note Synchronization level: Thread safe + * + * @return + * the number of clock ticks elapsed since the start of the program. + * + * */ +extern "C" clock_t clock() +{ + _mutex->lock(); + clock_t t = ticker_read(get_us_ticker_data()); + t /= 1000000 / CLOCKS_PER_SEC; // convert to processor time + _mutex->unlock(); + return t; +} + +// temporary - Default to 1MHz at 32 bits if target does not have us_ticker_get_info +MBED_WEAK const ticker_info_t *us_ticker_get_info() +{ + static const ticker_info_t info = { + 1000000, + 32 + }; + return &info; +} + +// temporary - Default to 1MHz at 32 bits if target does not have lp_ticker_get_info +MBED_WEAK const ticker_info_t *lp_ticker_get_info() +{ + static const ticker_info_t info = { + 1000000, + 32 + }; + return &info; +}