I am using the Keil MCB2300 STK with an NXP LPC2378 cpu with the
arm-none-eabi toolkit from Code Sourcery.
I started implementing the newlib stubs but ran into some problems.
I wanted
the LCD row 0 to act as stdio and row 1 as stderr, moreover I
wanted all
four USART to act as files.
I can write to USART0 and USART1 with the following code but when I
try to
read from them with fread my _read stub behaves weird. Essentially
_read
never gets called, it seems like the fread returns 0 before
invoking it.
There is also a similar problem with printf(), here my _write stub
never
gets called but _isatty does.
I cannot find any documentation of what have to be done in the
stubs for
newlibs implementations to work reliably, I hope someone can point
me to
these documents.
Please provide any input you might think is helpful as I have been
stuck
with these problems for a long time now.
Simon Pettersson
Code attachment (please note that this code is nowhere complete, I
just try
to get the basic stuff woring at the moment):
#include <sys/types.h>
#include <sys/times.h>
#include "io.h"
#include "uart.h"
// A pointer to a list of environment variables and their values.
char *__env[1] = { 0 };
char **environ = __env;
// linker script sets heap start and end
extern unsigned int _HEAP_START;
extern unsigned int _HEAP_END;
static caddr_t heap = NULL;
// low level bulk memory allocator - used by malloc
caddr_t _sbrk ( int increment ) {
caddr_t prevHeap;
caddr_t nextHeap;
if (heap == NULL) {
// first allocation
heap = (caddr_t)&_HEAP_START;
}
prevHeap = heap;// Always return data aligned on a 8 byte
boundary
nextHeap = (caddr_t)(((unsigned int)(heap + increment) + 7)
& ~7);
// get current stack pointer
register caddr_t stackPtr asm ("sp");
// Check enough space and there is no collision with stack
coming the
other way
// if stack is above start of heap
if ( (((caddr_t)&_HEAP_START < stackPtr) && (nextHeap >
stackPtr)) ||
(nextHeap >= (caddr_t)&_HEAP_END)) {
return NULL; // error - no more memory
} else {
heap = nextHeap;
return (caddr_t) prevHeap;
}
}
// Close a file
int _close(int file) {
if(file == UART0_FILENO) {
UARTClose(0);
return 1;
}
if(file == UART1_FILENO) {
UARTClose(1);
return 1;
}
return -1;
}
// Transfer control to a new process.
#include <errno.h>
#undef errno
extern int errno;
int _execve(char *name, char **argv, char **env) {
errno = ENOMEM;
return -1;
}
// Create a new process.
#include <errno.h>
#undef errno
extern int errno;
int _fork() {
errno=EAGAIN;
return -1;
}
// Status of an open file.
#include <sys/stat.h>
int _fstat(int file, struct stat *st) {
st->st_mode = S_IFCHR;
return 0;
}
// Process ID
int _getpid() {
return 1;
}
// Query whether output stream is a terminal.
int _isatty(int file) {
return 1;
}
// Send a signal.
#include <errno.h>
#undef errno
extern int errno;
int _kill(int pid, int sig) {
errno=EINVAL;
return -1;
}
// Establish a new name for an existing file.
#include <errno.h>
#undef errno
extern int errno;
int _link(char *old, char *new) {
errno = EMLINK;
return -1;
}
// Set position in a file
int _lseek(int file, int ptr, int dir) {
return 0;
}
// Open a file
int _open(const char *name, int flags, int mode) {
if(strcmp(name,"uart0") == 0) {
if(UARTInitialized(0) || UARTInit(0,9600))
return UART0_FILENO;
}
if(strcmp(name,"uart1") == 0) {
if(UARTInitialized(1) || UARTInit(1,9600))
return UART1_FILENO;
}
return -1;
}
// Status of a file (by name).
int _stat(const char *file, struct stat *st) {
st->st_mode = S_IFCHR;
return 0;
}
// Timing information for current process.
int _times(struct tms *buf) {
return -1;
}
// Remove a file's directory entry.
#include <errno.h>
#undef errno
extern int errno;
int _ulink(char *name) {
errno=ENOENT;
return -1;
}
// Wait for a child process.
#include <errno.h>
#undef errno
extern int errno;
int _wait(int *status) {
errno = ECHILD;
return -1;
}
// Read from a file
int _read(int file, char *ptr, int len){
if(file == UART0_FILENO) {
if(len > UART0Count) len = UART0Count;
memcpy(ptr,UART0Buffer,len);
UART0Count -= len;
memcpy(UART0Buffer,UART0Buffer+len,UART0Count-len);
return len;
}
if(file == UART1_FILENO) {
if(len > UART1Count) len = UART1Count;
memcpy(ptr,UART1Buffer,len);
UART1Count -= len;
memcpy(UART1Buffer,UART1Buffer+len,UART1Count-len);
return len;
}
return 0;
}
// Write a character to a file.
/*
`libc' subroutines will use this system routine for output to all
files,
including stdout---so if you need to generate any output, for
example to a
serial port for
debugging, you should make your minimal write capable of doing this.
The following minimal implementation is an incomplete example; it
relies on
a writechar
subroutine (not shown; typically, you must write this in assembler
from
examples provided
by your hardware manufacturer) to actually perform the output.
*/
int _write(int file, char *ptr, int len){
if(file == UART0_FILENO) {
UARTSend(0,ptr,len);
return len;
}
if(file == UART1_FILENO) {
UARTSend(1,ptr,len);
return len;
}
}
#include <errno.h>
#undef errno
extern int errno;
__attribute__((noreturn)) void _exit(int status) {
}