ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mbed-os/platform/mbed_retarget.cpp

1642 lines
40 KiB
C++
Raw Blame History

/* 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;
}
Reference in New Issue View Git Blame Copy Permalink