Stubs

[Simon Pettersson <simonpe at kth dot se>]

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) {
}