deac/osd-contiki
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Removing obsolete directory, moved to cpu/arm/at91sam7s/

Browse source
This commit is contained in:
ksb 2010-02-05 15:07:26 +00:00
parent 217eaaa071
commit cd30fa2b50
60 changed files with 0 additions and 8724 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

172
cpu/at91sam7s/AT91SAM7S64-ROM.ld
View file

@ -1,172 +0,0 @@
/***********************************************************************/
/* */
/* Linker Script File for the AT91SAM7S64 - Code in ROM */
/* */
/***********************************************************************/
/* modified for arm-elf-gcc by Martin Thomas */
/* extensions: - Section for Functions in RAM, */
/* Exeception-Vector remapping */
/* modifications Copyright Martin Thomas 2005 */
/* */
/* */
/* Based on file that has been a part of the uVision/ARM development */
/* tools, Copyright KEIL ELEKTRONIK GmbH 2002-2004 */
/***********************************************************************/
/*
//*** <<< Use Configuration Wizard in Context Menu >>> ***
*/
/*
// <h> Memory Configuration
// <h> Code (Read Only)
// <o> Start <0x0-0xFFFFFFFF>
// <o1> Size <0x0-0xFFFFFFFF>
// </h>
// <h> Data (Read/Write)
// <o2> Start <0x0-0xFFFFFFFF>
// <o3> Size <0x0-0xFFFFFFFF>
// </h>
// </h>
*/
/* Memory Definitions */
MEMORY
{
CODE (rx) : ORIGIN = 0x00100000, LENGTH = 0x00010000
DATA (rw) : ORIGIN = 0x00200000, LENGTH = 0x00004000
}
/* Section Definitions */
SECTIONS
{
/* first section is .text which is used for code */
.text :
{
/* *startup.o (.text) */ /* Startup code */
KEEP(*(.vectrom)) /* added by mthomas */
KEEP(*(.init))
*(.text .text.*)
*(.gnu.linkonce.t.*)
*(.glue_7t .glue_7)
KEEP(*(.fini))
*(.gcc_except_table)
} >CODE =0
. = ALIGN(4);
/* .ctors .dtors are used for c++ constructors/destructors */
/* added by mthomas, based on an Anglia-Designs example for STR7 */
.ctors :
{
PROVIDE(__ctors_start__ = .);
KEEP(*(SORT(.ctors.*)))
KEEP(*(.ctors))
PROVIDE(__ctors_end__ = .);
} >CODE
.dtors :
{
PROVIDE(__dtors_start__ = .);
KEEP(*(SORT(.dtors.*)))
KEEP(*(.dtors))
PROVIDE(__dtors_end__ = .);
} >CODE
/* .rodata section which is used for read-only data (constants) */
.rodata :
{
*(.rodata .rodata.*)
*(.gnu.linkonce.r.*)
} >CODE
. = ALIGN(4);
_etext = . ;
PROVIDE (etext = .);
.data : AT (_etext)
{
_data = . ;
KEEP(*(.vectram)) /* added by mthomas */
*(.data)
SORT(CONSTRUCTORS)
. = ALIGN(4);
*(.fastrun) /* "RAM-Functions" */ /* added by mthomas */
} >DATA
. = ALIGN(4);
_edata = . ;
PROVIDE (edata = .);
/* .bss section which is used for uninitialized data */
.bss :
{
__bss_start = . ;
__bss_start__ = . ;
*(.bss)
*(COMMON)
} >DATA
. = ALIGN(4);
__bss_end__ = . ;
__bss_end__ = . ;
_end = .;
PROVIDE (end = .);
.stack ORIGIN(DATA) + LENGTH(DATA) - 0x0a0c :
{
__stack_start__ = . ;
*(.stack)
. = ALIGN(4);
__stack_end__ = . ;
} >DATA
__heap_start__ = __bss_end__ ;
__heap_end__ = __stack_start__ ;
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
}

1917
cpu/at91sam7s/AT91SAM7S64.h
View file

File diff suppressed because it is too large Load diff

182
cpu/at91sam7s/Makefile.at91sam7s
View file

@ -1,182 +0,0 @@
# Adapted from Makefile.msp430
### Defin the CPU directory
CONTIKI_CPU=$(CONTIKI)/cpu/at91sam7s
### Define the source files we have in the AT91SAM7S port
CONTIKI_CPU_DIRS = . dbg-io loader usb
AT91SAM7S = clock.c debug-uart.c interrupt-utils.c newlib-syscalls.c sys-interrupt.c rtimer-arch.c rtimer-arch-interrupt.c uip-log.c
SYSAPPS = codeprop-otf.c
APPDIRS += $(CONTIKI)/cpu/at91sam7s/loader
ELFLOADER = elfloader-otf.c elfloader-arm.c symtab.c cfs-ram.c
USB = usb-proto.c usb-handler.c usb-interrupt.c cdc-acm.c descriptors.c string-descriptors.c
TARGETLIBS = random.c dbg-printf.c dbg-puts.c dbg-putchar.c dbg-sprintf.c strformat.c
CONTIKI_TARGET_SOURCEFILES += $(AT91SAM7S) $(SYSAPPS) $(ELFLOADER) \
$(TARGETLIBS) $(UIPDRIVERS) $(USB)
CONTIKI_SOURCEFILES += $(CONTIKI_TARGET_SOURCEFILES)
THREADS =
### Compiler definitions
CC = arm-elf-gcc
LD = arm-elf-ld
AS = arm-elf-as
AR = arm-elf-ar
NM = arm-elf-nm
OBJCOPY = arm-elf-objcopy
STRIP = arm-elf-strip
XSLTPROC=xsltproc
PROJECT_OBJECTFILES += ${addprefix $(OBJECTDIR)/,$(CONTIKI_TARGET_MAIN:.c=.o)}
LINKERSCRIPT = $(CONTIKI_CPU)/AT91SAM7S64-ROM.ld
STARTUP=${addprefix $(OBJECTDIR)/,startup-SAM7S.o}
# JTAG program upload
OPENOCD = openocd
OPENOCD_FLASH_CFG = arm7_wig_flash.cfg
OPENOCD_RESET = arm7_wig_reset.cfg
# USB program upload
SAMIAM=Sam_I_Am
SAMIAM_TTY=/dev/ttyACM0
ARCH_FLAGS= -mcpu=arm7tdmi -mthumb-interwork
THUMB_FLAGS=-mthumb
ARM_FLAGS=
CFLAGSNO = -I. -I$(CONTIKI)/core -I$(CONTIKI_CPU) -I$(CONTIKI_CPU)/loader \
-I$(CONTIKI_CPU)/dbg-io \
-I$(CONTIKI)/platform/$(TARGET) \
${addprefix -I,$(APPDIRS)} \
-DWITH_UIP -DWITH_ASCII -DMCK=$(MCK) \
-Wall -Werror $(ARCH_FLAGS) -g
CFLAGS += $(CFLAGSNO) -O -DRUN_AS_SYSTEM -DROM_RUN
LDFLAGS += -T $(LINKERSCRIPT) -nostartfiles
CDEPFLAGS = $(CFLAGS) -D __MAKING_DEPS__
### Setup directory search path for source files
CUSTOM_RULE_C_TO_OBJECTDIR_O=yes
CUSTOM_RULE_C_TO_O=yes
%-interrupt.o: %-interrupt.c
$(CC) $(CFLAGS) $(ARM_FLAGS) $< -c
$(OBJECTDIR)/%-interrupt.o: %-interrupt.c
$(CC) $(CFLAGS) $(ARM_FLAGS) -c $< -o $@
%-arm.o: %-arm.c
$(CC) $(CFLAGS) $(ARM_FLAGS) $< -c
$(OBJECTDIR)/%-arm.o: %-arm.c
$(CC) $(CFLAGS) $(ARM_FLAGS) -c $< -o $@
$(OBJECTDIR)/interrupt-utils.o: interrupt-utils.c
$(CC) $(CFLAGS) $(ARM_FLAGS) $< -c -o $@
%.o: %.c
$(CC) $(CFLAGS) $(THUMB_FLAGS) $< -c
$(OBJECTDIR)/%.o: %.c
$(CC) $(CFLAGS) $(THUMB_FLAGS) -c $< -o $@
CUSTOM_RULE_S_TO_OBJECTDIR_O = yes
%.o: %.S
$(CC) $(CFLAGS) $(ARM_FLAGS) $< -c
$(OBJECTDIR)/%.o: %.S
$(CC) $(CFLAGS) $(ARM_FLAGS) $< -c -o $@
CUSTOM_RULE_C_TO_CO=yes
%.co: %.c
$(CC) $(CFLAGS) $(THUMB_FLAGS) $< -c -o $@
CUSTOM_RULE_C_TO_CE=yes
%.ce: %.o
$(LD) $(LDFLAGS) --relocatable -T $(CONTIKI_CPU)/merge-rodata.ld $< -o $@
$(STRIP) -K _init -K _fini --strip-unneeded -g -x $@
CUSTOM_RULE_LINK=yes
%-stripped.o: %.c
$(CC) $(CFLAGS) -c $< -o $@
$(STRIP) --strip-unneeded -g -x $@
%-stripped.o: %.o
$(STRIP) --strip-unneeded -g -x -o $@ $<
%.o: ${CONTIKI_TARGET}/loader/%.S
$(AS) -o $(notdir $(<:.S=.o)) $<
%-nosyms.$(TARGET): %.co $(PROJECT_OBJECTFILES) contiki-$(TARGET).a $(STARTUP) $(OBJECTDIR)/empty-symbols.o
$(CC) $(LDFLAGS) $(CFLAGS) -nostartfiles -o $@ $(filter-out %.a,$^) $(filter %.a,$^) -lc $(filter %.a,$^)
%.ihex: %.$(TARGET)
$(OBJCOPY) $^ -O ihex $@
%.bin: %.$(TARGET)
$(OBJCOPY) -O binary $< $@
.PHONY: symbols.c
ifdef CORE
%.$(TARGET): %.co $(PROJECT_OBJECTFILES) contiki-$(TARGET).a $(STARTUP) $(OBJECTDIR)/symbols.o
$(CC) $(LDFLAGS) $(CFLAGS) -nostartfiles -o $@ $(filter-out %.a,$^) $(filter %.a,$^) -lc $(filter %.a,$^)
symbols.c: $(CORE)
$(NM) $< | awk -f $(CONTIKI_CPU)/builtins.awk -f $(CONTIKI)/tools/mknmlist > symbols.c
else
%.$(TARGET): %-nosyms.$(TARGET)
ln -sf $< $@
endif
empty-symbols.c:
@${CONTIKI}/tools/make-empty-symbols
$(CONTIKI_CPU)/usb/string-descriptors.c: \
$(CONTIKI_CPU)/usb/string-descriptors.xml
$(XSLTPROC) $(CONTIKI_CPU)/usb/string-descriptors.xslt $^ >$@
upload_ocd_%: %.bin
cp $< /tmp/openocd_write.bin
# Clear lock bits
cd $(CONTIKI_CPU)/openocd;$(OPENOCD) -f $(OPENOCD_FLASH_CFG)
-rm /tmp/openocd_write.bin
upload_%: %.ihex
# Clear lock bits
$(SAMIAM) "open $(SAMIAM_TTY) , writew 0xffffff64 5a000004"
$(SAMIAM) "open $(SAMIAM_TTY) , writew 0xffffff64 5a002004"
$(SAMIAM) "open $(SAMIAM_TTY) , flash $< , go"
ocd_reset:
cd $(CONTIKI_CPU)/openocd;$(OPENOCD) -f $(OPENOCD_RESET)
# Don't use core/loader/elfloader.c, use elfloader-otf.c instead
$(OBJECTDIR)/elfloader.o:
echo -n >$@
.PRECIOUS: %-nosyms.$(TARGET)

4
cpu/at91sam7s/builtins.awk
View file

@ -1,4 +0,0 @@
BEGIN {
builtin["_exit"] = "void _exit()";
builtin["strlen"] = "unsigned long strlen()";
}

62
cpu/at91sam7s/clock.c
View file

@ -1,62 +0,0 @@
#include <sys/clock.h>
#include <sys/cc.h>
#include <sys/etimer.h>
#include <debug-uart.h>
#include <AT91SAM7S64.h>
#include <sys-interrupt.h>
static volatile clock_time_t current_clock = 0;
#define PIV ((MCK/CLOCK_SECOND/16)-1)
static int pit_handler_func()
{
if (!(*AT91C_PITC_PISR & AT91C_PITC_PITS)) return 0; /* Check PIT
Interrupt */
current_clock++;
if(etimer_pending() && etimer_next_expiration_time() <= current_clock) {
etimer_request_poll();
/* dbg_printf("%d,%d\n", clock_time(),etimer_next_expiration_time ()); */
}
(void)*AT91C_PITC_PIVR;
return 1;
}
static SystemInterruptHandler pit_handler = {NULL, pit_handler_func};
void
clock_init()
{
sys_interrupt_append_handler(&pit_handler);
*AT91C_PITC_PIMR = (AT91C_PITC_PITIEN | /* PIT Interrupt Enable */
AT91C_PITC_PITEN | /* PIT Enable */
PIV);
sys_interrupt_enable();
}
clock_time_t
clock_time(void)
{
return current_clock;
}
/* The inner loop takes 4 cycles. The outer 5+SPIN_COUNT*4. */
#define SPIN_TIME 2 /* us */
#define SPIN_COUNT (((MCK*SPIN_TIME/1000000)-5)/4)
#ifndef __MAKING_DEPS__
void
clock_delay(unsigned int t)
{
#ifdef __THUMBEL__
asm volatile("1: mov r1,%2\n2:\tsub r1,#1\n\tbne 2b\n\tsub %0,#1\n\tbne 1b\n":"=l"(t):"0"(t),"l"(SPIN_COUNT));
#else
#error Must be compiled in thumb mode
#endif
}
#endif /* __MAKING_DEPS__ */

30
cpu/at91sam7s/dbg-io/dbg-printf.c
View file

@ -1,30 +0,0 @@
#include <stdio.h>
#include <debug-uart.h>
#include <string.h>
#include <strformat.h>
static StrFormatResult
write_str(void *user_data, const char *data, unsigned int len)
{
dbg_send_bytes((unsigned char*)data, len);
return STRFORMAT_OK;
}
static StrFormatContext ctxt =
{
write_str,
NULL
};
int
printf(const char *fmt, ...)
{
int res;
va_list ap;
va_start(ap, fmt);
res = format_str_v(&ctxt, fmt, ap);
va_end(ap);
return res;
}

26
cpu/at91sam7s/dbg-io/dbg-putchar.c
View file

@ -1,26 +0,0 @@
#include <stdio.h>
#include <debug-uart.h>
#include <string.h>
#undef putchar
#undef putc
int
putchar(int c)
{
dbg_putchar(c);
return c;
}
int
putc(int c, FILE *f)
{
dbg_putchar(c);
return c;
}
int
__sp(struct _reent *_ptr, int c, FILE *_p) {
dbg_putchar(c);
return c;
}

11
cpu/at91sam7s/dbg-io/dbg-puts.c
View file

@ -1,11 +0,0 @@
#include <stdio.h>
#include <debug-uart.h>
#include <string.h>
int
puts(const char *str)
{
dbg_send_bytes((unsigned char*)str, strlen(str));
dbg_putchar('\n');
return 0;
}

26
cpu/at91sam7s/dbg-io/dbg-sprintf.c
View file

@ -1,26 +0,0 @@
#include <stdio.h>
#include <strformat.h>
#include <string.h>
static StrFormatResult
buffer_str(void *user_data, const char *data, unsigned int len)
{
memcpy(*(char**)user_data, data, len);
(*(char**)user_data) += len;
return STRFORMAT_OK;
}
int
sprintf(char *str, const char *format, ...)
{
StrFormatContext ctxt;
int res;
va_list ap;
va_start(ap, format);
ctxt.write_str = buffer_str;
ctxt.user_data = &str;
res = format_str_v(&ctxt, format, ap);
*str = '\0';
va_end(ap);
return res;
}

615
cpu/at91sam7s/dbg-io/strformat.c
View file

@ -1,615 +0,0 @@
#include <strformat.h>
#define HAVE_DOUBLE
#define HAVE_LONGLONG
#ifndef LARGEST_SIGNED
#ifdef HAVE_LONGLONG
#define LARGEST_SIGNED long long int
#else
#define LARGEST_UNSIGNED long int
#endif
#endif
#ifndef LARGEST_UNSIGNED
#ifdef HAVE_LONGLONG
#define LARGEST_UNSIGNED unsigned long long int
#else
#define LARGEST_UNSIGNED unsigned long int
#endif
#endif
#ifndef POINTER_INT
#define POINTER_INT unsigned long
#endif
typedef unsigned int FormatFlags;
#define MAKE_MASK(shift,size) (((1 << size) - 1) << (shift))
#define JUSTIFY_SHIFT 0
#define JUSTIFY_SIZE 1
#define JUSTIFY_RIGHT 0x0000
#define JUSTIFY_LEFT 0x0001
#define JUSTIFY_MASK MAKE_MASK(JUSTIFY_SHIFT,JUSTIFY_SIZE)
/* How a positive number is prefixed */
#define POSITIVE_SHIFT (JUSTIFY_SHIFT + JUSTIFY_SIZE)
#define POSITIVE_NONE (0x0000 << POSITIVE_SHIFT)
#define POSITIVE_SPACE (0x0001 << POSITIVE_SHIFT)
#define POSITIVE_PLUS (0x0003 << POSITIVE_SHIFT)
#define POSITIVE_MASK MAKE_MASK(POSITIVE_SHIFT, POSITIVE_SIZE)
#define POSITIVE_SIZE 2
#define ALTERNATE_FORM_SHIFT (POSITIVE_SHIFT + POSITIVE_SIZE)
#define ALTERNATE_FORM_SIZE 1
#define ALTERNATE_FORM (0x0001 << ALTERNATE_FORM_SHIFT)
#define PAD_SHIFT (ALTERNATE_FORM_SHIFT + ALTERNATE_FORM_SIZE)
#define PAD_SIZE 1
#define PAD_SPACE (0x0000 << PAD_SHIFT)
#define PAD_ZERO (0x0001 << PAD_SHIFT)
#define SIZE_SHIFT (PAD_SHIFT + PAD_SIZE)
#define SIZE_SIZE 3
#define SIZE_CHAR (0x0001 << SIZE_SHIFT)
#define SIZE_SHORT (0x0002 << SIZE_SHIFT)
#define SIZE_INT (0x0000 << SIZE_SHIFT)
#define SIZE_LONG (0x0003 << SIZE_SHIFT)
#define SIZE_LONGLONG (0x0004 << SIZE_SHIFT)
#define SIZE_MASK MAKE_MASK(SIZE_SHIFT,SIZE_SIZE)
#define CONV_SHIFT (SIZE_SHIFT + SIZE_SIZE)
#define CONV_SIZE 3
#define CONV_INTEGER (0x0001 << CONV_SHIFT)
#define CONV_FLOAT (0x0002 << CONV_SHIFT)
#define CONV_POINTER (0x0003 << CONV_SHIFT)
#define CONV_STRING (0x0004 << CONV_SHIFT)
#define CONV_CHAR (0x0005 << CONV_SHIFT)
#define CONV_PERCENT (0x0006 << CONV_SHIFT)
#define CONV_WRITTEN (0x0007 << CONV_SHIFT)
#define CONV_MASK MAKE_MASK(CONV_SHIFT, CONV_SIZE)
#define RADIX_SHIFT (CONV_SHIFT + CONV_SIZE)
#define RADIX_SIZE 2
#define RADIX_DECIMAL (0x0001 << RADIX_SHIFT)
#define RADIX_OCTAL (0x0002 << RADIX_SHIFT)
#define RADIX_HEX (0x0003 << RADIX_SHIFT)
#define RADIX_MASK MAKE_MASK(RADIX_SHIFT,RADIX_SIZE)
#define SIGNED_SHIFT (RADIX_SHIFT + RADIX_SIZE)
#define SIGNED_SIZE 1
#define SIGNED_NO (0x0000 << SIGNED_SHIFT)
#define SIGNED_YES (0x0001 << SIGNED_SHIFT)
#define SIGNED_MASK MAKE_MASK(SIGNED_SHIFT,SIGNED_SIZE)
#define CAPS_SHIFT (SIGNED_SHIFT + SIGNED_SIZE)
#define CAPS_SIZE 1
#define CAPS_NO (0x0000 << CAPS_SHIFT)
#define CAPS_YES (0x0001 << CAPS_SHIFT)
#define CAPS_MASK MAKE_MASK(CAPS_SHIFT,CAPS_SIZE)
#define FLOAT_SHIFT (CAPS_SHIFT + CAPS_SIZE)
#define FLOAT_SIZE 2
#define FLOAT_NORMAL (0x0000 << FLOAT_SHIFT)
#define FLOAT_EXPONENT (0x0001 << FLOAT_SHIFT)
#define FLOAT_DEPENDANT (0x0002 << FLOAT_SHIFT)
#define FLOAT_HEX (0x0003 << FLOAT_SHIFT)
#define FLOAT_MASK MAKE_MASK(FLOAT_SHIFT, FLOAT_SIZE)
static FormatFlags
parse_flags(const char **posp)
{
FormatFlags flags = 0;
const char *pos = *posp;
while (1) {
switch(*pos) {
case '-':
flags |= JUSTIFY_LEFT;
break;
case '+':
flags |= POSITIVE_PLUS;
break;
case ' ':
flags |= POSITIVE_SPACE;
break;
case '#':
flags |= ALTERNATE_FORM;
break;
case '0':
flags |= PAD_ZERO;
break;
default:
*posp = pos;
return flags;
}
pos++;
}
}
static unsigned int
parse_uint(const char **posp)
{
unsigned v = 0;
const char *pos = *posp;
char ch;
while((ch = *pos) >= '0' && ch <= '9') {
v = v * 10 + (ch - '0');
pos++;
}
*posp = pos;
return v;
}
#define MAXCHARS_HEX ((sizeof(LARGEST_UNSIGNED) * 8) / 4 )
/* Largest number of characters needed for converting an unsigned integer.
*/
#define MAXCHARS ((sizeof(LARGEST_UNSIGNED) * 8 + 2) / 3 )
static unsigned int
output_uint_decimal(char **posp, LARGEST_UNSIGNED v)
{
unsigned int len;
char *pos = *posp;
while (v > 0) {
*--pos = (v % 10) + '0';
v /= 10;
}
len = *posp - pos;
*posp = pos;
return len;
}
static unsigned int
output_uint_hex(char **posp, LARGEST_UNSIGNED v, unsigned int flags)
{
unsigned int len;
const char *hex = (flags & CAPS_YES) ?"0123456789ABCDEF":"0123456789abcdef";
char *pos = *posp;
while (v > 0) {
*--pos = hex[(v % 16)];
v /= 16;
}
len = *posp - pos;
*posp = pos;
return len;
}
static unsigned int
output_uint_octal(char **posp, LARGEST_UNSIGNED v)
{
unsigned int len;
char *pos = *posp;
while (v > 0) {
*--pos = (v % 8) + '0';
v /= 8;
}
len = *posp - pos;
*posp = pos;
return len;
}
static StrFormatResult
fill_space(const StrFormatContext *ctxt, unsigned int len)
{
StrFormatResult res;
static const char buffer[16] = " ";
while(len > 16) {
res = ctxt->write_str(ctxt->user_data, buffer, 16);
if (res != STRFORMAT_OK) return res;
len -= 16;
}
if (len == 0) return STRFORMAT_OK;
return ctxt->write_str(ctxt->user_data, buffer, len);
}
static StrFormatResult
fill_zero(const StrFormatContext *ctxt, unsigned int len)
{
StrFormatResult res;
static const char buffer[16] = "0000000000000000";
while(len > 16) {
res = ctxt->write_str(ctxt->user_data, buffer, 16);
if (res != STRFORMAT_OK) return res;
len -= 16;
}
if (len == 0) return STRFORMAT_OK;
return ctxt->write_str(ctxt->user_data, buffer, len);
}
#define CHECKCB(res) {if ((res) != STRFORMAT_OK) {va_end(ap); return -1;}}
int
format_str(const StrFormatContext *ctxt, const char *format, ...)
{
int ret;
va_list ap;
va_start(ap, format);
ret = format_str_v(ctxt, format, ap);
va_end(ap);
return ret;
}
int
format_str_v(const StrFormatContext *ctxt, const char *format, va_list ap)
{
unsigned int written = 0;
const char *pos = format;
while(*pos != '\0') {
FormatFlags flags;
unsigned int minwidth = 0;
int precision = -1; /* Negative means no precision */
char ch;
const char *start = pos;
while( (ch = *pos) != '\0' && ch != '%') pos++;
if (pos != start) {
CHECKCB(ctxt->write_str(ctxt->user_data, start, pos - start));
written += pos - start;
}
if (*pos == '\0') {
va_end(ap);
return written;
}
pos++;
if (*pos == '\0') {
va_end(ap);
return written;
}
flags = parse_flags(&pos);
/* parse width */
if (*pos >= '1' && *pos <= '9') {
minwidth = parse_uint(&pos);
} else if (*pos == '*') {
int w = va_arg(ap,int);
if (w < 0) {
flags |= JUSTIFY_LEFT;
minwidth = w;
} else {
minwidth = w;
}
pos ++;
}
/* parse precision */
if (*pos == '.') {
pos++;
if (*pos >= '0' && *pos <= '9') {
precision = parse_uint(&pos);
} else if (*pos == '*') {
precision = va_arg(ap,int);
}
}
if (*pos == 'l') {
pos++;
if (*pos == 'l') {
flags |= SIZE_LONGLONG;
pos++;
} else {
flags |= SIZE_LONG;
}
} else if (*pos == 'h') {
pos++;
if (*pos == 'h') {
flags |= SIZE_CHAR;
pos++;
} else {
flags |= SIZE_SHORT;
}
}
/* parse conversion specifier */
switch(*pos) {
case 'd':
case 'i':
flags |= CONV_INTEGER | RADIX_DECIMAL | SIGNED_YES;
break;
case 'u':
flags |= CONV_INTEGER | RADIX_DECIMAL | SIGNED_NO;
break;
case 'o':
flags |= CONV_INTEGER | RADIX_OCTAL | SIGNED_NO;
break;
case 'x':
flags |= CONV_INTEGER | RADIX_HEX | SIGNED_NO;
break;
case 'X':
flags |= CONV_INTEGER | RADIX_HEX | SIGNED_NO | CAPS_YES;
break;
#ifdef HAVE_DOUBLE
case 'f':
flags |= CONV_FLOAT | FLOAT_NORMAL;
break;
case 'F':
flags |= CONV_FLOAT | FLOAT_NORMAL | CAPS_YES;
break;
case 'e':
flags |= CONV_FLOAT | FLOAT_EXPONENT;
break;
case 'E':
flags |= CONV_FLOAT | FLOAT_EXPONENT | CAPS_YES;
break;
case 'g':
flags |= CONV_FLOAT | FLOAT_DEPENDANT;
break;
case 'G':
flags |= CONV_FLOAT | FLOAT_DEPENDANT | CAPS_YES;
break;
case 'a':
flags |= CONV_FLOAT | FLOAT_HEX;
break;
case 'A':
flags |= CONV_FLOAT | FLOAT_HEX | CAPS_YES;
break;
#endif
case 'c':
flags |= CONV_CHAR;
break;
case 's':
flags |= CONV_STRING;
break;
case 'p':
flags |= CONV_POINTER;
break;
case 'n':
flags |= CONV_WRITTEN;
break;
case '%':
flags |= CONV_PERCENT;
break;
case '\0':
va_end(ap);
return written;
}
pos++;
switch(flags & CONV_MASK) {
case CONV_PERCENT:
CHECKCB(ctxt->write_str(ctxt->user_data, "%", 1));
written++;
break;
case CONV_INTEGER:
{
/* unsigned integers */
char *prefix = 0; /* sign, "0x" or "0X" */
unsigned int prefix_len = 0;
char buffer[MAXCHARS];
char *conv_pos = buffer + MAXCHARS;
unsigned int conv_len = 0;
unsigned int width = 0;
unsigned int precision_fill;
unsigned int field_fill;
LARGEST_UNSIGNED uvalue = 0;
int negative = 0;
if (precision < 0) precision = 1;
else flags &= ~PAD_ZERO;
if (flags & SIGNED_YES) {
/* signed integers */
LARGEST_SIGNED value = 0;
switch(flags & SIZE_MASK) {
case SIZE_CHAR:
value = (signed char)va_arg(ap, int);
break;
case SIZE_SHORT:
value = (short)va_arg(ap, int);
break;
case SIZE_INT:
value = va_arg(ap, int);
break;
#ifndef HAVE_LONGLONG
case SIZE_LONGLONG: /* Treat long long the same as long */
#endif
case SIZE_LONG:
value = va_arg(ap, long);
break;
#ifdef HAVE_LONGLONG
case SIZE_LONGLONG:
value = va_arg(ap, long long);
break;
#endif
}
if (value < 0) {
uvalue = -value;
negative = 1;
} else {
uvalue = value;
}
} else {
switch(flags & SIZE_MASK) {
case SIZE_CHAR:
uvalue = (unsigned char)va_arg(ap,unsigned int);
break;
case SIZE_SHORT:
uvalue = (unsigned short)va_arg(ap,unsigned int);
break;
case SIZE_INT:
uvalue = va_arg(ap,unsigned int);
break;
#ifndef HAVE_LONGLONG
case SIZE_LONGLONG: /* Treat long long the same as long */
#endif
case SIZE_LONG:
uvalue = va_arg(ap,unsigned long);
break;
#ifdef HAVE_LONGLONG
case SIZE_LONGLONG:
uvalue = va_arg(ap,unsigned long long);
break;
#endif
}
}
switch(flags & (RADIX_MASK)) {
case RADIX_DECIMAL:
conv_len = output_uint_decimal(&conv_pos,uvalue);
break;
case RADIX_OCTAL:
conv_len = output_uint_octal(&conv_pos,uvalue);
break;
case RADIX_HEX:
conv_len = output_uint_hex(&conv_pos,uvalue, flags);
break;
}
width += conv_len;
precision_fill = (precision > conv_len) ? precision - conv_len : 0;
if ((flags & (RADIX_MASK | ALTERNATE_FORM))
== (RADIX_OCTAL | ALTERNATE_FORM)) {
if (precision_fill < 1) precision_fill = 1;
}
width += precision_fill;
if ((flags & (RADIX_MASK | ALTERNATE_FORM))
== (RADIX_HEX | ALTERNATE_FORM) && uvalue != 0) {
prefix_len = 2;
if (flags & CAPS_YES) {
prefix = "0X";
} else {
prefix = "0x";
}
}
if (flags & SIGNED_YES) {
if (negative) {
prefix = "-";
prefix_len = 1;
} else {
switch(flags & POSITIVE_MASK) {
case POSITIVE_SPACE:
prefix = " ";
prefix_len = 1;
break;
case POSITIVE_PLUS:
prefix = "+";
prefix_len = 1;
break;
}
}
}
width += prefix_len;
field_fill = (minwidth > width) ? minwidth - width : 0;
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
if (flags & PAD_ZERO) {
precision_fill += field_fill;
} else {
CHECKCB(fill_space(ctxt,field_fill));
}
}
if (prefix_len > 0)
CHECKCB(ctxt->write_str(ctxt->user_data, prefix, prefix_len));
written += prefix_len;
CHECKCB(fill_zero(ctxt,precision_fill));
written += prefix_len;
CHECKCB(ctxt->write_str(ctxt->user_data, conv_pos,conv_len));
written += conv_len;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written += field_fill;
}
break;
case CONV_STRING:
{
unsigned int field_fill;
unsigned int len;
char *str = va_arg(ap,char *);
if (str) {
char *pos = str;
while(*pos != '\0') pos++;
len = pos - str;
} else {
str = "(null)";
len = 6;
}
if (precision >= 0 && precision < len) len = precision;
field_fill = (minwidth > len) ? minwidth - len : 0;
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt,field_fill));
}
CHECKCB(ctxt->write_str(ctxt->user_data, str,len));
written += len;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written += field_fill;
}
break;
case CONV_POINTER:
{
LARGEST_UNSIGNED uvalue =
(LARGEST_UNSIGNED)(POINTER_INT)va_arg(ap,void *);
char buffer[MAXCHARS_HEX + 3];
char *conv_pos = buffer + MAXCHARS_HEX+3;
unsigned int conv_len;
unsigned int field_fill;
conv_len = output_uint_hex(&conv_pos,uvalue,flags);
if (conv_len == 0) {
*--conv_pos = '0';
conv_len++;
}
*--conv_pos = 'x';
*--conv_pos = '0';
*--conv_pos = '#';
conv_len += 3;
field_fill = (minwidth > conv_len) ? minwidth - conv_len : 0;
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt,field_fill));
}
CHECKCB(ctxt->write_str(ctxt->user_data, conv_pos,conv_len));
written += conv_len;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written += field_fill;
}
break;
case CONV_CHAR:
{
char ch = va_arg(ap,int);
unsigned int field_fill = (minwidth > 1) ? minwidth - 1 : 0;
if ((flags & JUSTIFY_MASK) == JUSTIFY_RIGHT) {
CHECKCB(fill_space(ctxt,field_fill));
written += field_fill;
}
CHECKCB(ctxt->write_str(ctxt->user_data, &ch, 1));
written++;
if ((flags & JUSTIFY_MASK) == JUSTIFY_LEFT) {
CHECKCB(fill_space(ctxt,field_fill));
}
written+= field_fill;
}
break;
case CONV_WRITTEN:
{
int *p = va_arg(ap,int*);
*p = written;
}
break;
}
}
return written;
}

25
cpu/at91sam7s/dbg-io/strformat.h
View file

@ -1,25 +0,0 @@
#ifndef __STRFORMAT_H__
#define __STRFORMAT_H__
#include <stdarg.h>
#define STRFORMAT_OK 0
#define STRFORMAT_FAILED 1
typedef unsigned int StrFormatResult;
/* The data argument may only be considered valid during the function call */
typedef StrFormatResult (*StrFormatWrite)(void *user_data, const char *data, unsigned int len);
typedef struct _StrFormatContext
{
StrFormatWrite write_str;
void *user_data;
} StrFormatContext;
int format_str(const StrFormatContext *ctxt, const char *format, ...)
__attribute__ ((__format__ (__printf__, 2,3)));
int
format_str_v(const StrFormatContext *ctxt, const char *format, va_list ap);
#endif /* __STRFORMAT_H__ */

196
cpu/at91sam7s/debug-uart.c
View file

@ -1,196 +0,0 @@
#include <debug-uart.h>
#include <sys-interrupt.h>
/* #include <strformat.h> */
#include <AT91SAM7S64.h>
#include <string.h>
#include <interrupt-utils.h>
#ifndef DBG_XMIT_BUFFER_LEN
#define DBG_XMIT_BUFFER_LEN 256
#endif
#ifndef DBG_RECV_BUFFER_LEN
#define DBG_RECV_BUFFER_LEN 256
#endif
static unsigned char dbg_xmit_buffer[DBG_XMIT_BUFFER_LEN];
static unsigned char dbg_recv_buffer[DBG_RECV_BUFFER_LEN];
static unsigned int dbg_recv_buffer_len = 0;
void
dbg_setup_uart()
{
/* Setup PIO ports */
*AT91C_PIOA_OER = AT91C_PA10_DTXD;
*AT91C_PIOA_ODR = AT91C_PA9_DRXD;
*AT91C_PIOA_ASR = AT91C_PA10_DTXD | AT91C_PA9_DRXD;
*AT91C_PIOA_PDR = AT91C_PA10_DTXD | AT91C_PA9_DRXD;
*AT91C_DBGU_MR = AT91C_US_PAR_NONE | AT91C_US_CHMODE_NORMAL;
*AT91C_DBGU_IDR= 0xffffffff;
*AT91C_DBGU_BRGR = MCK / (115200 * 16);
*AT91C_DBGU_CR = AT91C_US_RXEN | AT91C_US_TXEN;
*AT91C_DBGU_TPR = (unsigned int)dbg_xmit_buffer;
*AT91C_DBGU_TNPR = (unsigned int)dbg_xmit_buffer;
}
static void (*input_func)(const char *inp, unsigned int len) = NULL;
static int dbg_recv_handler_func()
{
if (!(*AT91C_DBGU_CSR & AT91C_US_RXRDY)) return 0;
unsigned char c = *AT91C_DBGU_RHR;
/* Leave one byte for '\0' */
if (dbg_recv_buffer_len < (DBG_RECV_BUFFER_LEN -1)) {
dbg_recv_buffer[dbg_recv_buffer_len++] = c;
}
if (c == '\n') {
dbg_recv_buffer[dbg_recv_buffer_len] = '\0';
if (input_func) input_func((char*)dbg_recv_buffer, dbg_recv_buffer_len);
dbg_recv_buffer_len = 0;
}
return 1;
}
static SystemInterruptHandler dbg_recv_handler = {NULL, dbg_recv_handler_func};
void
dbg_set_input_handler(void (*handler)(const char *inp, unsigned int len))
{
input_func = handler;
sys_interrupt_append_handler(&dbg_recv_handler);
sys_interrupt_enable();
*AT91C_DBGU_IER = AT91C_US_RXRDY;
}
static volatile unsigned char mutex = 0;
unsigned int
dbg_send_bytes(const unsigned char *seq, unsigned int len)
{
unsigned short next_count;
unsigned short current_count;
unsigned short left;
unsigned int save = disableIRQ();
if (mutex) {
restoreIRQ(save);
return 0; /* Buffer being updated */
}
mutex = 1; /* Prevent interrupts from messing up the transmission */
*AT91C_DBGU_PTCR =AT91C_PDC_TXTDIS; /* Stop transmitting */
while(*AT91C_DBGU_PTSR & AT91C_PDC_TXTEN); /* Wait until stopped */
next_count = *AT91C_DBGU_TNCR;
current_count = *AT91C_DBGU_TCR;
left = DBG_XMIT_BUFFER_LEN - next_count - current_count;
if (left > 0) {
if (left < len) len = left;
if (next_count > 0) {
/* Buffer is wrapped */
memcpy(&dbg_xmit_buffer[next_count], seq, len);
*AT91C_DBGU_TNCR = next_count + len;
} else {
unsigned char *to = ((unsigned char*)*AT91C_DBGU_TPR) + current_count;
left = &dbg_xmit_buffer[DBG_XMIT_BUFFER_LEN] - to;
if (len > left) {
unsigned int wrapped = len - left;
memcpy(to, seq, left);
memcpy(dbg_xmit_buffer, &seq[left], wrapped);
*AT91C_DBGU_TCR = current_count + left;
*AT91C_DBGU_TNCR = wrapped;
} else {
memcpy(to, seq, len);
*AT91C_DBGU_TCR = current_count + len;
}
}
} else {
len = 0;
}
*AT91C_DBGU_PTCR =AT91C_PDC_TXTEN; /* Restart transmission */
mutex = 0;
restoreIRQ(save);
return len;
}
static unsigned char dbg_write_overrun = 0;
void
dbg_putchar(const char ch)
{
if (dbg_write_overrun) {
if (dbg_send_bytes((const unsigned char*)"^",1) != 1) return;
}
dbg_write_overrun = 0;
if (dbg_send_bytes((const unsigned char*)&ch,1) != 1) {
dbg_write_overrun = 1;
}
}
void
dbg_blocking_putchar(const char ch)
{
if (dbg_write_overrun) {
while (dbg_send_bytes((const unsigned char*)"^",1) != 1);
}
dbg_write_overrun = 0;
while (dbg_send_bytes((const unsigned char*)&ch,1) != 1);
}
#if 0
static StrFormatResult
dbg_write_cb(void *user_data, const char *data, unsigned int len)
{
if (dbg_send_bytes((const unsigned char*)data, len) != len) {
dbg_write_overrun = 1;
return STRFORMAT_FAILED;
}
return STRFORMAT_OK;
}
void
dbg_printf(const char *format, ...)
{
static const StrFormatContext ctxt = {dbg_write_cb, NULL};
va_list ap;
if (dbg_write_overrun) {
if (dbg_send_bytes((const unsigned char*)"^",1) != 1) return;
}
dbg_write_overrun = 0;
va_start(ap, format);
format_str_v(&ctxt, format, ap);
va_end(ap);
}
static StrFormatResult
dbg_write_blocking_cb(void *user_data, const char *data, unsigned int len)
{
unsigned int left = len;
while(left > 0) {
unsigned int sent = dbg_send_bytes((const unsigned char*)data, left);
left -= sent;
data += sent;
}
return STRFORMAT_OK;
}
void
dbg_blocking_printf(const char *format, ...)
{
static const StrFormatContext ctxt = {dbg_write_blocking_cb, NULL};
va_list ap;
if (dbg_write_overrun) {
while (dbg_send_bytes((const unsigned char*)"^",1) != 1);
}
dbg_write_overrun = 0;
va_start(ap, format);
format_str_v(&ctxt, format, ap);
va_end(ap);
}
#endif
void
dbg_drain()
{
while(!(*AT91C_DBGU_CSR & AT91C_US_TXBUFE));
}

33
cpu/at91sam7s/debug-uart.h
View file

@ -1,33 +0,0 @@
#ifndef __DEBUG_UART_H__1V2039076V__
#define __DEBUG_UART_H__1V2039076V__
void
dbg_setup_uart();
void
dbg_set_input_handler(void (*handler)(const char *inp, unsigned int len));
unsigned int
dbg_send_bytes(const unsigned char *seq, unsigned int len);
#if 0
void
dbg_printf(const char *format, ...)
__attribute__ ((__format__ (__printf__, 1,2)));
void
dbg_blocking_printf(const char *format, ...)
__attribute__ ((__format__ (__printf__, 1,2)));
#endif
void
dbg_putchar(const char ch);
void
dbg_blocking_putchar(const char ch);
void
dbg_drain();
#endif /* __DEBUG_UART_H__1V2039076V__ */

96
cpu/at91sam7s/elfloader-arm.c
View file

@ -1,96 +0,0 @@
#include <stdlib.h>
#include <malloc.h>
#include <loader/elfloader-arch-otf.h>
#if 0
#include <stdio.h>
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...) do {} while (0)
#endif
#define ELF32_R_TYPE(info) ((unsigned char)(info))
/* Supported relocations */
#define R_ARM_ABS32 2
#define R_ARM_THM_CALL 10
/* Adapted from elfloader-avr.c */
int
elfloader_arch_relocate(int input_fd,
struct elfloader_output *output,
unsigned int sectionoffset,
char *sectionaddr,
struct elf32_rela *rela, char *addr)
{
unsigned int type;
type = ELF32_R_TYPE(rela->r_info);
cfs_seek(input_fd, sectionoffset + rela->r_offset, CFS_SEEK_SET);
/* PRINTF("elfloader_arch_relocate: type %d\n", type); */
/* PRINTF("Addr: %p, Addend: %ld\n", addr, rela->r_addend); */
switch(type) {
case R_ARM_ABS32:
{
int32_t addend;
cfs_read(input_fd, (char*)&addend, 4);
addr += addend;
elfloader_output_write_segment(output,(char*) &addr, 4);
PRINTF("%p: addr: %p\n", sectionaddr +rela->r_offset,
addr);
}
break;
case R_ARM_THM_CALL:
{
uint16_t instr[2];
int32_t offset;
char *base;
cfs_read(input_fd, (char*)instr, 4);
/* Ignore the addend since it will be zero for calls to symbols,
and I can't think of a case when doing a relative call to
a non-symbol position */
base = sectionaddr + (rela->r_offset + 4);
if (((instr[1]) & 0xe800) == 0xe800) {
/* BL or BLX */
if (((uint32_t)addr) & 0x1) {
/* BL */
instr[1] |= 0x1800;
} else {
#if defined(__ARM_ARCH_4T__)
return ELFLOADER_UNHANDLED_RELOC;
#else
/* BLX */
instr[1] &= ~0x1800;
instr[1] |= 0x0800;
#endif
}
}
/* Adjust address for BLX */
if ((instr[1] & 0x1800) == 0x0800) {
addr = (char*)((((uint32_t)addr) & 0xfffffffd)
| (((uint32_t)base) & 0x00000002));
}
offset = addr - (sectionaddr + (rela->r_offset + 4));
if (offset < -(1<<22) || offset >= (1<<22)) {
PRINTF("elfloader-arm.c: offset %d too large for relative call\n",
(int)offset);
}
/* PRINTF("%p: %04x %04x offset: %d addr: %p\n", sectionaddr +rela->r_offset, instr[0], instr[1], (int)offset, addr); */
instr[0] = (instr[0] & 0xf800) | ((offset>>12)&0x07ff);
instr[1] = (instr[1] & 0xf800) | ((offset>>1)&0x07ff);
elfloader_output_write_segment(output, (char*)instr, 4);
/* PRINTF("cfs_write: %04x %04x\n",instr[0], instr[1]); */
}
break;
default:
PRINTF("elfloader-arm.c: unsupported relocation type %d\n", type);
return ELFLOADER_UNHANDLED_RELOC;
}
return ELFLOADER_OK;
}

84
cpu/at91sam7s/interrupt-utils.c
View file

@ -1,84 +0,0 @@
/******************************************************************************
*
* $RCSfile: interrupt-utils.c,v $
* $Revision: 1.2 $
*
* This module provides the interface routines for setting up and
* controlling the various interrupt modes present on the ARM processor.
* Copyright 2004, R O SoftWare
* No guarantees, warrantees, or promises, implied or otherwise.
* May be used for hobby or commercial purposes provided copyright
* notice remains intact.
*
*****************************************************************************/
#include "interrupt-utils.h"
#define IRQ_MASK 0x00000080
#define FIQ_MASK 0x00000040
#define INT_MASK (IRQ_MASK | FIQ_MASK)
static inline unsigned __get_cpsr(void)
{
unsigned long retval;
asm volatile (" mrs %0, cpsr" : "=r" (retval) : /* no inputs */ );
return retval;
}
static inline void __set_cpsr(unsigned val)
{
asm volatile (" msr cpsr_c, %0" : /* no outputs */ : "r" (val) );
}
unsigned disableIRQ(void)
{
unsigned _cpsr;
_cpsr = __get_cpsr();
__set_cpsr(_cpsr | IRQ_MASK);
return _cpsr;
}
unsigned restoreIRQ(unsigned oldCPSR)
{
unsigned _cpsr;
_cpsr = __get_cpsr();
__set_cpsr((_cpsr & ~IRQ_MASK) | (oldCPSR & IRQ_MASK));
return _cpsr;
}
unsigned enableIRQ(void)
{
unsigned _cpsr;
_cpsr = __get_cpsr();
__set_cpsr(_cpsr & ~IRQ_MASK);
return _cpsr;
}
unsigned disableFIQ(void)
{
unsigned _cpsr;
_cpsr = __get_cpsr();
__set_cpsr(_cpsr | FIQ_MASK);
return _cpsr;
}
unsigned restoreFIQ(unsigned oldCPSR)
{
unsigned _cpsr;
_cpsr = __get_cpsr();
__set_cpsr((_cpsr & ~FIQ_MASK) | (oldCPSR & FIQ_MASK));
return _cpsr;
}
unsigned enableFIQ(void)
{
unsigned _cpsr;
_cpsr = __get_cpsr();
__set_cpsr(_cpsr & ~FIQ_MASK);
return _cpsr;
}

272
cpu/at91sam7s/interrupt-utils.h
View file

@ -1,272 +0,0 @@
/*
* Defines and Macros for Interrupt-Service-Routines
* collected and partly created by
* Martin Thomas <mthomas@rhrk.uni-kl.de>
*
* Copyright 2005 M. Thomas
* No guarantees, warrantees, or promises, implied or otherwise.
* May be used for hobby or commercial purposes provided copyright
* notice remains intact.
*/
#ifndef interrupt_utils_
#define interrupt_utils_
/*
The following defines are usefull for
interrupt service routine declarations.
*/
/*
RAMFUNC
Attribute which defines a function to be located
in memory section .fastrun and called via "long calls".
See linker-skript and startup-code to see how the
.fastrun-section is handled.
The definition is not only useful for ISRs but since
ISRs should be executed fast the macro is defined in
this header.
*/
#define RAMFUNC __attribute__ ((long_call, section (".fastrun")))
/*
INTFUNC
standard attribute for arm-elf-gcc which marks
a function as ISR (for the VIC). Since gcc seems
to produce wrong code if this attribute is used in
thumb/thumb-interwork the attribute should only be
used for "pure ARM-mode" binaries.
*/
#define INTFUNC __attribute__ ((interrupt("IRQ")))
/*
NACKEDFUNC
gcc will not add any code to a function declared
"nacked". The user has to take care to save registers
and add the needed code for ISR functions. Some
macros for this tasks are provided below.
*/
#define NACKEDFUNC __attribute__((naked))
/******************************************************************************
*
* MACRO Name: ISR_STORE()
*
* Description:
* This MACRO is used upon entry to an ISR with interrupt nesting.
* Should be used together with ISR_ENABLE_NEST(). The MACRO
* performs the following steps:
*
* 1 - Save the non-banked registers r0-r12 and lr onto the IRQ stack.
*
*****************************************************************************/
#define ISR_STORE() asm volatile( \
"STMDB SP!,{R0-R12,LR}\n" )
/******************************************************************************
*
* MACRO Name: ISR_RESTORE()
*
* Description:
* This MACRO is used upon exit from an ISR with interrupt nesting.
* Should be used together with ISR_DISABLE_NEST(). The MACRO
* performs the following steps:
*
* 1 - Load the non-banked registers r0-r12 and lr from the IRQ stack.
* 2 - Adjusts resume adress
*
*****************************************************************************/
#define ISR_RESTORE() asm volatile( \
"LDMIA SP!,{R0-R12,LR}\n" \
"SUBS R15,R14,#0x0004\n" )
/******************************************************************************
*
* MACRO Name: ISR_ENABLE_NEST()
*
* Description:
* This MACRO is used upon entry from an ISR with interrupt nesting.
* Should be used after ISR_STORE.
*
*****************************************************************************/
#define ISR_ENABLE_NEST() asm volatile( \
"MRS LR, SPSR \n" \
"STMFD SP!, {LR} \n" \
"MSR CPSR_c, #0x1f \n" \
"STMFD SP!, {LR} " )
/******************************************************************************
*
* MACRO Name: ISR_DISABLE_NEST()
*
* Description:
* This MACRO is used upon entry from an ISR with interrupt nesting.
* Should be used before ISR_RESTORE.
*
*****************************************************************************/
#define ISR_DISABLE_NEST() asm volatile( \
"LDMFD SP!, {LR} \n" \
"MSR CPSR_c, #0x92 \n" \
"LDMFD SP!, {LR} \n" \
"MSR SPSR_cxsf, LR \n" )
/*
* The following marcos are from the file "armVIC.h" by:
*
* Copyright 2004, R O SoftWare
* No guarantees, warrantees, or promises, implied or otherwise.
* May be used for hobby or commercial purposes provided copyright
* notice remains intact.
*
*/
/******************************************************************************
*
* MACRO Name: ISR_ENTRY()
*
* Description:
* This MACRO is used upon entry to an ISR. The current version of
* the gcc compiler for ARM does not produce correct code for
* interrupt routines to operate properly with THUMB code. The MACRO
* performs the following steps:
*
* 1 - Adjust address at which execution should resume after servicing
* ISR to compensate for IRQ entry
* 2 - Save the non-banked registers r0-r12 and lr onto the IRQ stack.
* 3 - Get the status of the interrupted program is in SPSR.
* 4 - Push it onto the IRQ stack as well.
*
*****************************************************************************/
#define ISR_ENTRY() asm volatile(" sub lr, lr,#4\n" \
" stmfd sp!,{r0-r12,lr}\n" \
" mrs r1, spsr\n" \
" stmfd sp!,{r1}")
/******************************************************************************
*
* MACRO Name: ISR_EXIT()
*
* Description:
* This MACRO is used to exit an ISR. The current version of the gcc
* compiler for ARM does not produce correct code for interrupt
* routines to operate properly with THUMB code. The MACRO performs
* the following steps:
*
* 1 - Recover SPSR value from stack
* 2 - and restore its value
* 3 - Pop the return address & the saved general registers from
* the IRQ stack & return
*
*****************************************************************************/
#define ISR_EXIT() asm volatile(" ldmfd sp!,{r1}\n" \
" msr spsr_c,r1\n" \
" ldmfd sp!,{r0-r12,pc}^")
/******************************************************************************
*
* Function Name: disableIRQ()
*
* Description:
* This function sets the IRQ disable bit in the status register
*
* Calling Sequence:
* void
*
* Returns:
* previous value of CPSR
*
*****************************************************************************/
unsigned disableIRQ(void);
/******************************************************************************
*
* Function Name: enableIRQ()
*
* Description:
* This function clears the IRQ disable bit in the status register
*
* Calling Sequence:
* void
*
* Returns:
* previous value of CPSR
*
*****************************************************************************/
unsigned enableIRQ(void);
/******************************************************************************
*
* Function Name: restoreIRQ()
*
* Description:
* This function restores the IRQ disable bit in the status register
* to the value contained within passed oldCPSR
*
* Calling Sequence:
* void
*
* Returns:
* previous value of CPSR
*
*****************************************************************************/
unsigned restoreIRQ(unsigned oldCPSR);
/******************************************************************************
*
* Function Name: disableFIQ()
*
* Description:
* This function sets the FIQ disable bit in the status register
*
* Calling Sequence:
* void
*
* Returns:
* previous value of CPSR
*
*****************************************************************************/
unsigned disableFIQ(void);
/******************************************************************************
*
* Function Name: enableFIQ()
*
* Description:
* This function clears the FIQ disable bit in the status register
*
* Calling Sequence:
* void
*
* Returns:
* previous value of CPSR
*
*****************************************************************************/
unsigned enableFIQ(void);
/******************************************************************************
*
* Function Name: restoreFIQ()
*
* Description:
* This function restores the FIQ disable bit in the status register
* to the value contained within passed oldCPSR
*
* Calling Sequence:
* void
*
* Returns:
* previous value of CPSR
*
*****************************************************************************/
unsigned restoreFIQ(unsigned oldCPSR);
#endif

15
cpu/at91sam7s/io.h
View file

@ -1,15 +0,0 @@
#ifndef __IO_H__7UTLUP9AG6__
#define __IO_H__7UTLUP9AG6__
#include <AT91SAM7S64.h>
#ifndef BV
#define BV(x) (1<<(x))
#endif
int splhigh(void);
void splx(int saved);
#endif /* __IO_H__7UTLUP9AG6__ */

523
cpu/at91sam7s/loader/codeprop-otf.c
View file

@ -1,523 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
* @(#)$Id: codeprop-otf.c,v 1.3 2009/02/27 14:28:02 nvt-se Exp $
*/
/** \addtogroup esb
* @{ */
/**
*
* \file
* Code propagation and storage.
* \author
* Adam Dunkels <adam@sics.se>
*
* This file implements a simple form of code propagation, which
* allows a binary program to be downloaded and propagated throughout
* a network of devices.
*
* Features:
*
* Commands: load code, start code
* Point-to-point download over TCP
* Point-to-multipoint delivery over UDP broadcasts
* Versioning of code modules
*
* Procedure:
*
* 1. Receive code over TCP
* 2. Send code packets over UDP
*
* When a code packet is deemed to be missed, a NACK is sent. If a
* NACK is received, the sending restarts at the point in the
* binary where the NACK pointed to. (This is *not* very efficient,
* but simple to implement...)
*
* States:
*
* Receiving code header -> receiving code -> sending code
*
*/
#include <stdio.h>
#include "contiki-net.h"
#include "cfs/cfs.h"
#include "codeprop-otf.h"
#include "loader/elfloader-otf.h"
#include <string.h>
static const char *err_msgs[] =
{"OK\r\n", "Bad ELF header\r\n", "No symtab\r\n", "No strtab\r\n",
"No text\r\n", "Symbol not found\r\n", "Segment not found\r\n",
"No startpoint\r\n", "Unhandled relocation\r\n",
"Relocation out of range\r\n", "Relocations not sorted\r\n",
"Input error\r\n" , "Ouput error\r\n" };
#define CODEPROP_DATA_PORT 6510
/*static int random_rand(void) { return 1; }*/
#if 0
#define PRINTF(x) printf x
#else
#define PRINTF(x)
#endif
#define START_TIMEOUT 12 * CLOCK_SECOND
#define MISS_NACK_TIMEOUT (CLOCK_SECOND / 8) * (random_rand() % 8)
#define HIT_NACK_TIMEOUT (CLOCK_SECOND / 8) * (8 + random_rand() % 16)
#define NACK_REXMIT_TIMEOUT CLOCK_SECOND * (4 + random_rand() % 4)
#define WAITING_TIME CLOCK_SECOND * 10
#define NUM_SEND_DUPLICATES 2
#define UDPHEADERSIZE 8
#define UDPDATASIZE 32
struct codeprop_udphdr {
u16_t id;
u16_t type;
#define TYPE_DATA 0x0001
#define TYPE_NACK 0x0002
u16_t addr;
u16_t len;
u8_t data[UDPDATASIZE];
};
struct codeprop_tcphdr {
u16_t len;
u16_t pad;
};
static void uipcall(void *state);
PROCESS(codeprop_process, "Code propagator");
struct codeprop_state {
u8_t state;
#define STATE_NONE 0
#define STATE_RECEIVING_TCPDATA 1
#define STATE_RECEIVING_UDPDATA 2
#define STATE_SENDING_UDPDATA 3
u16_t count;
u16_t addr;
u16_t len;
u16_t id;
struct etimer sendtimer;
struct timer nacktimer, timer, starttimer;
u8_t received;
u8_t send_counter;
struct pt tcpthread_pt;
struct pt udpthread_pt;
struct pt recv_udpthread_pt;
};
static int fd;
static struct uip_udp_conn *udp_conn;
static struct codeprop_state s;
void system_log(char *msg);
static clock_time_t send_time;
#define CONNECTION_TIMEOUT (30 * CLOCK_SECOND)
/*---------------------------------------------------------------------*/
void
codeprop_set_rate(clock_time_t time)
{
send_time = time;
}
/*---------------------------------------------------------------------*/
PROCESS_THREAD(codeprop_process, ev, data)
{
PROCESS_BEGIN();
elfloader_init();
s.id = 0/*random_rand()*/;
send_time = CLOCK_SECOND/4;
PT_INIT(&s.udpthread_pt);
PT_INIT(&s.recv_udpthread_pt);
tcp_listen(HTONS(CODEPROP_DATA_PORT));
udp_conn = udp_broadcast_new(HTONS(CODEPROP_DATA_PORT), NULL);
s.state = STATE_NONE;
s.received = 0;
s.addr = 0;
s.len = 0;
fd = cfs_open("codeprop-image", CFS_READ | CFS_WRITE);
while(1) {
PROCESS_YIELD();
if(ev == tcpip_event) {
uipcall(data);
} else if(ev == PROCESS_EVENT_TIMER) {
tcpip_poll_udp(udp_conn);
}
}
PROCESS_END();
}
/*---------------------------------------------------------------------*/
static u16_t
send_udpdata(struct codeprop_udphdr *uh)
{
u16_t len;
uh->type = HTONS(TYPE_DATA);
uh->addr = htons(s.addr);
uh->id = htons(s.id);
if(s.len - s.addr > UDPDATASIZE) {
len = UDPDATASIZE;
} else {
len = s.len - s.addr;
}
cfs_seek(fd, s.addr, CFS_SEEK_SET);
cfs_read(fd, (char*)&uh->data[0], len);
/* eeprom_read(EEPROMFS_ADDR_CODEPROP + s.addr,
&uh->data[0], len);*/
uh->len = htons(s.len);
PRINTF(("codeprop: sending packet from address 0x%04x\n", s.addr));
uip_udp_send(len + UDPHEADERSIZE);
return len;
}
/*---------------------------------------------------------------------*/
static
PT_THREAD(send_udpthread(struct pt *pt))
{
int len;
struct codeprop_udphdr *uh = (struct codeprop_udphdr *)uip_appdata;
PT_BEGIN(pt);
while(1) {
PT_WAIT_UNTIL(pt, s.state == STATE_SENDING_UDPDATA);
for(s.addr = 0; s.addr < s.len; ) {
len = send_udpdata(uh);
s.addr += len;
etimer_set(&s.sendtimer, CLOCK_SECOND/4);
do {
PT_WAIT_UNTIL(pt, uip_newdata() || etimer_expired(&s.sendtimer));
if(uip_newdata()) {
if(uh->type == HTONS(TYPE_NACK)) {
PRINTF(("send_udpthread: got NACK for address 0x%x (now 0x%x)\n",
htons(uh->addr), s.addr));
/* Only accept a NACK if it points to a lower byte. */
if(htons(uh->addr) <= s.addr) {
/* beep();*/
s.addr = htons(uh->addr);
}
}
PT_YIELD(pt);
}
} while(!etimer_expired(&s.sendtimer));
}
s.state = STATE_NONE;
/* process_post(PROCESS_BROADCAST, codeprop_event_quit, (process_data_t)NULL); */
}
PT_END(pt);
}
/*---------------------------------------------------------------------*/
static void
send_nack(struct codeprop_udphdr *uh, unsigned short addr)
{
uh->type = HTONS(TYPE_NACK);
uh->addr = htons(addr);
uip_udp_send(UDPHEADERSIZE);
}
/*---------------------------------------------------------------------*/
static
PT_THREAD(recv_udpthread(struct pt *pt))
{
int len;
struct codeprop_udphdr *uh = (struct codeprop_udphdr *)uip_appdata;
/* if(uip_newdata()) {
PRINTF(("recv_udpthread: id %d uh->id %d\n", s.id, htons(uh->id)));
}*/
PT_BEGIN(pt);
while(1) {
do {
PT_WAIT_UNTIL(pt, uip_newdata() &&
uh->type == HTONS(TYPE_DATA) &&
htons(uh->id) > s.id);
if(htons(uh->addr) != 0) {
s.addr = 0;
send_nack(uh, 0);
}
} while(htons(uh->addr) != 0);
/* leds_on(LEDS_YELLOW);
beep_down(10000);*/
s.addr = 0;
s.id = htons(uh->id);
s.len = htons(uh->len);
timer_set(&s.timer, CONNECTION_TIMEOUT);
/* process_post(PROCESS_BROADCAST, codeprop_event_quit, (process_data_t)NULL); */
while(s.addr < s.len) {
if(htons(uh->addr) == s.addr) {
/* leds_blink();*/
len = uip_datalen() - UDPHEADERSIZE;
if(len > 0) {
/* eeprom_write(EEPROMFS_ADDR_CODEPROP + s.addr,
&uh->data[0], len);*/
cfs_seek(fd, s.addr, CFS_SEEK_SET);
cfs_write(fd, (char*)&uh->data[0], len);
/* beep();*/
PRINTF(("Saved %d bytes at address %d, %d bytes left\n",
uip_datalen() - UDPHEADERSIZE, s.addr,
s.len - s.addr));
s.addr += len;
}
} else if(htons(uh->addr) > s.addr) {
PRINTF(("sending nack since 0x%x != 0x%x\n", htons(uh->addr), s.addr));
send_nack(uh, s.addr);
}
if(s.addr < s.len) {
/* timer_set(&s.nacktimer, NACK_TIMEOUT);*/
do {
timer_set(&s.nacktimer, HIT_NACK_TIMEOUT);
PT_YIELD_UNTIL(pt, timer_expired(&s.nacktimer) ||
(uip_newdata() &&
uh->type == HTONS(TYPE_DATA) &&
htons(uh->id) == s.id));
if(timer_expired(&s.nacktimer)) {
send_nack(uh, s.addr);
}
} while(timer_expired(&s.nacktimer));
}
}
/* leds_off(LEDS_YELLOW);
beep_quick(2);*/
/* printf("Received entire bunary over udr\n");*/
codeprop_start_program();
PT_EXIT(pt);
}
PT_END(pt);
}
/*---------------------------------------------------------------------*/
#define CODEPROP_TCPHDR_SIZE sizeof(struct codeprop_tcphdr)
static
PT_THREAD(recv_tcpthread(struct pt *pt))
{
struct codeprop_tcphdr *th;
int datalen = uip_datalen();
PT_BEGIN(pt);
while(1) {
PT_WAIT_UNTIL(pt, uip_connected());
codeprop_exit_program();
s.state = STATE_RECEIVING_TCPDATA;
s.addr = 0;
s.count = 0;
/* Read the header. */
PT_WAIT_UNTIL(pt, uip_newdata() && uip_datalen() > 0);
if(uip_datalen() < CODEPROP_TCPHDR_SIZE) {
PRINTF(("codeprop: header not found in first tcp segment\n"));
uip_abort();
}
th = (struct codeprop_tcphdr *)uip_appdata;
s.len = htons(th->len);
s.addr = 0;
uip_appdata += CODEPROP_TCPHDR_SIZE;
datalen -= CODEPROP_TCPHDR_SIZE;
/* Read the rest of the data. */
do {
if(datalen > 0) {
/* printf("Got %d bytes\n", datalen); */
if (cfs_seek(fd, s.addr, CFS_SEEK_SET) != s.addr) {
PRINTF(("codeprop: seek in buffer file failed\n"));
uip_abort();
}
if (cfs_write(fd, uip_appdata, datalen) != datalen) {
PRINTF(("codeprop: write to buffer file failed\n"));
uip_abort();
}
s.addr += datalen;
}
if(s.addr < s.len) {
PT_YIELD_UNTIL(pt, uip_newdata());
}
} while(s.addr < s.len);
#if 1
{
static int err;
err = codeprop_start_program();
/* Print out the "OK"/error message. */
do {
if (err >= 0 && err < sizeof(err_msgs)/sizeof(char*)) {
uip_send(err_msgs[err], strlen(err_msgs[err]));
} else {
uip_send("Unknown error\r\n", 15);
}
PT_WAIT_UNTIL(pt, uip_acked() || uip_rexmit() || uip_closed());
} while(uip_rexmit());
/* Close the connection. */
uip_close();
}
#endif
++s.id;
s.state = STATE_SENDING_UDPDATA;
tcpip_poll_udp(udp_conn);
PT_WAIT_UNTIL(pt, s.state != STATE_SENDING_UDPDATA);
/* printf("recv_tcpthread: unblocked\n");*/
}
PT_END(pt);
}
/*---------------------------------------------------------------------*/
void
codeprop_start_broadcast(unsigned int len)
{
s.addr = 0;
s.len = len;
++s.id;
s.state = STATE_SENDING_UDPDATA;
tcpip_poll_udp(udp_conn);
}
/*---------------------------------------------------------------------*/
void
codeprop_exit_program(void)
{
if(elfloader_autostart_processes != NULL) {
autostart_exit(elfloader_autostart_processes);
}
}
/*---------------------------------------------------------------------*/
int
codeprop_start_program(void)
{
int err;
codeprop_exit_program();
err = elfloader_load(fd, codeprop_output);
if(err == ELFLOADER_OK) {
PRINTF(("codeprop: starting %s\n",
elfloader_autostart_processes[0]->name));
autostart_start(elfloader_autostart_processes);
}
return err;
}
/*---------------------------------------------------------------------*/
static void
uipcall(void *state)
{
if(uip_udpconnection()) {
recv_udpthread(&s.recv_udpthread_pt);
send_udpthread(&s.udpthread_pt);
} else {
if(uip_conn->lport == HTONS(CODEPROP_DATA_PORT)) {
if(uip_connected()) {
if(state == NULL) {
s.addr = 0;
s.count = 0;
PT_INIT(&s.tcpthread_pt);
process_poll(&codeprop_process);
tcp_markconn(uip_conn, &s);
/* process_post(PROCESS_BROADCAST, codeprop_event_quit, */
/* (process_data_t)NULL); */
} else {
PRINTF(("codeprop: uip_connected() and state != NULL\n"));
uip_abort();
}
}
recv_tcpthread(&s.tcpthread_pt);
if(uip_closed() || uip_aborted() || uip_timedout()) {
PRINTF(("codeprop: connection down\n"));
tcp_markconn(uip_conn, NULL);
}
}
}
}
/*---------------------------------------------------------------------*/
/** @} */

52
cpu/at91sam7s/loader/codeprop-otf.h
View file

@ -1,52 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
* @(#)$Id: codeprop-otf.h,v 1.1 2007/03/07 16:07:26 ksb Exp $
*/
#ifndef __CODEPROP_H__
#define __CODEPROP_H__
#include "contiki.h"
#define CODEPROP_DATA_PORT 6510
PROCESS_NAME(codeprop_process);
void codeprop_set_rate(clock_time_t time);
void codeprop_start_broadcast(unsigned int len);
void codeprop_exit_program(void);
int codeprop_start_program(void);
/* Segment writing object */
extern struct elfloader_output *codeprop_output;
extern char *codeprop_filesystem;
#endif /* __CODEPROP_H__ */

101
cpu/at91sam7s/loader/elfloader-arch-otf.h
View file

@ -1,101 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* Copyright (c) 2007, Simon Berg
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
* @(#)$Id: elfloader-arch-otf.h,v 1.1 2007/03/07 16:07:26 ksb Exp $
*/
/**
* \addtogroup elfloader
* @{
*/
/**
* \defgroup elfloaderarch Architecture specific functionality for the ELF loader.
*
* The architecture specific functionality for the Contiki ELF loader
* has to be implemented for each processor type Contiki runs on.
*
* Since the ELF format is slightly different for different processor
* types, the Contiki ELF loader is divided into two parts: the
* generic ELF loader module (\ref elfloader) and the architecture
* specific part (this module). The architecture specific part deals
* with memory allocation, code and data relocation, and writing the
* relocated ELF code into program memory.
*
* To port the Contiki ELF loader to a new processor type, this module
* has to be implemented for the new processor type.
*
* @{
*/
/**
* \file
* Header file for the architecture specific parts of the Contiki ELF loader.
*
* \author
* Adam Dunkels <adam@sics.se>
*
*/
#ifndef __ELFLOADER_ARCH_H__
#define __ELFLOADER_ARCH_H__
#include "elfloader-otf.h"
/**
* \brief Perform a relocation.
* \param output The output object for the segment.
* \param sectionoffset The file offset at which the relocation can be found.
* \param sectionaddr The section start address (absolute runtime).
* \param rela A pointer to an ELF32 rela structure (struct elf32_rela).
* \param addr The relocated address.
*
* This function is called from the Contiki ELF loader to
* perform a relocation on a piece of code or data. The
* relocated address is calculated by the Contiki ELF
* loader, based on information in the ELF file, and it is
* the responsibility of this function to patch the
* executable code. The Contiki ELF loader passes a
* pointer to an ELF32 rela structure (struct elf32_rela)
* that contains information about how to patch the
* code. This information is different from processor to
* processor.
*/
int elfloader_arch_relocate(int input_fd,
struct elfloader_output *output,
unsigned int sectionoffset,
char *sectionaddr,
struct elf32_rela *rela, char *addr);
#endif /* __ELFLOADER_ARCH_H__ */
/** @} */
/** @} */

680
cpu/at91sam7s/loader/elfloader-otf.c
View file

@ -1,680 +0,0 @@
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* Copyright (c) 2007, Simon Berg
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
* @(#)$Id: elfloader-otf.c,v 1.2 2009/02/27 14:28:02 nvt-se Exp $
*/
#include "contiki.h"
#include "loader/elfloader-otf.h"
#include "loader/elfloader-arch-otf.h"
#include "cfs/cfs.h"
#include "loader/symtab.h"
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#if 0
#include <stdio.h>
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...) do {} while (0)
#endif
#define EI_NIDENT 16
struct elf32_ehdr {
unsigned char e_ident[EI_NIDENT]; /* ident bytes */
elf32_half e_type; /* file type */
elf32_half e_machine; /* target machine */
elf32_word e_version; /* file version */
elf32_addr e_entry; /* start address */
elf32_off e_phoff; /* phdr file offset */
elf32_off e_shoff; /* shdr file offset */
elf32_word e_flags; /* file flags */
elf32_half e_ehsize; /* sizeof ehdr */
elf32_half e_phentsize; /* sizeof phdr */
elf32_half e_phnum; /* number phdrs */
elf32_half e_shentsize; /* sizeof shdr */
elf32_half e_shnum; /* number shdrs */
elf32_half e_shstrndx; /* shdr string index */
};
/* Values for e_type. */
#define ET_NONE 0 /* Unknown type. */
#define ET_REL 1 /* Relocatable. */
#define ET_EXEC 2 /* Executable. */
#define ET_DYN 3 /* Shared object. */
#define ET_CORE 4 /* Core file. */
struct elf32_shdr {
elf32_word sh_name; /* section name */
elf32_word sh_type; /* SHT_... */
elf32_word sh_flags; /* SHF_... */
elf32_addr sh_addr; /* virtual address */
elf32_off sh_offset; /* file offset */
elf32_word sh_size; /* section size */
elf32_word sh_link; /* misc info */
elf32_word sh_info; /* misc info */
elf32_word sh_addralign; /* memory alignment */
elf32_word sh_entsize; /* entry size if table */
};
/* sh_type */
#define SHT_NULL 0 /* inactive */
#define SHT_PROGBITS 1 /* program defined information */
#define SHT_SYMTAB 2 /* symbol table section */
#define SHT_STRTAB 3 /* string table section */
#define SHT_RELA 4 /* relocation section with addends*/
#define SHT_HASH 5 /* symbol hash table section */
#define SHT_DYNAMIC 6 /* dynamic section */
#define SHT_NOTE 7 /* note section */
#define SHT_NOBITS 8 /* no space section */
#define SHT_REL 9 /* relation section without addends */
#define SHT_SHLIB 10 /* reserved - purpose unknown */
#define SHT_DYNSYM 11 /* dynamic symbol table section */
#define SHT_LOPROC 0x70000000 /* reserved range for processor */
#define SHT_HIPROC 0x7fffffff /* specific section header types */
#define SHT_LOUSER 0x80000000 /* reserved range for application */
#define SHT_HIUSER 0xffffffff /* specific indexes */
struct elf32_rel {
elf32_addr r_offset; /* Location to be relocated. */
elf32_word r_info; /* Relocation type and symbol index. */
};
struct elf32_sym {
elf32_word st_name; /* String table index of name. */
elf32_addr st_value; /* Symbol value. */
elf32_word st_size; /* Size of associated object. */
unsigned char st_info; /* Type and binding information. */
unsigned char st_other; /* Reserved (not used). */
elf32_half st_shndx; /* Section index of symbol. */
};
#define ELF32_R_SYM(info) ((info) >> 8)
#define ELF32_R_TYPE(info) ((unsigned char)(info))
struct relevant_section {
unsigned char number;
unsigned int offset;
char *address;
};
char elfloader_unknown[30]; /* Name that caused link error. */
struct process **elfloader_autostart_processes;
static struct relevant_section bss, data, rodata, text;
const static unsigned char elf_magic_header[] =
{0x7f, 0x45, 0x4c, 0x46, /* 0x7f, 'E', 'L', 'F' */
0x01, /* Only 32-bit objects. */
0x01, /* Only LSB data. */
0x01, /* Only ELF version 1. */
};
/* Copy data from the elf file to a segment */
static int
copy_segment_data(int input_fd, unsigned int offset,
struct elfloader_output *output, unsigned int len)
{
char buffer[16];
int res;
if (cfs_seek(input_fd, offset, CFS_SEEK_SET) != offset) return ELFLOADER_INPUT_ERROR;
while(len > sizeof(buffer)) {
res = cfs_read(input_fd, buffer, sizeof(buffer));
if (res != sizeof(buffer)) return ELFLOADER_INPUT_ERROR;
res = elfloader_output_write_segment(output, buffer, sizeof(buffer));
if (res != sizeof(buffer)) return ELFLOADER_OUTPUT_ERROR;
len -= sizeof(buffer);
}
res = cfs_read(input_fd, buffer, len);
if (res != len) return ELFLOADER_INPUT_ERROR;
res = elfloader_output_write_segment(output, buffer, len);
if (res != len) return ELFLOADER_OUTPUT_ERROR;
return ELFLOADER_OK;
}
static int
seek_read(int fd, unsigned int offset, char *buf, int len)
{
if (cfs_seek(fd, offset, CFS_SEEK_SET) != offset) return -1;
return cfs_read(fd, buf, len);
}
static void *
find_local_symbol(int input_fd, const char *symbol,
unsigned int symtab, unsigned short symtabsize,
unsigned int strtab)
{
struct elf32_sym s;
unsigned int a;
char name[30];
struct relevant_section *sect;
int ret;
for(a = symtab; a < symtab + symtabsize; a += sizeof(s)) {
ret = seek_read(input_fd, a, (char *)&s, sizeof(s));
if (ret < 0) return NULL;
if(s.st_name != 0) {
ret = seek_read(input_fd, strtab + s.st_name, name, sizeof(name));
if (ret < 0) return NULL;
if(strcmp(name, symbol) == 0) {
if(s.st_shndx == bss.number) {
sect = &bss;
} else if(s.st_shndx == data.number) {
sect = &data;
} else if(s.st_shndx == text.number) {
sect = &text;
} else {
return NULL;
}
return &(sect->address[s.st_value]);
}
}
}
return NULL;
}
/*---------------------------------------------------------------------------*/
static int
relocate_section(int input_fd,
struct elfloader_output *output,
unsigned int section, unsigned short size,
unsigned int sectionaddr,
char *sectionbase,
unsigned int strs,
unsigned int strtab,
unsigned int symtab, unsigned short symtabsize,
unsigned char using_relas)
{
/* sectionbase added; runtime start address of current section */
struct elf32_rela rela; /* Now used both for rel and rela data! */
int rel_size = 0;
struct elf32_sym s;
unsigned int a;
char name[30];
char *addr;
struct relevant_section *sect;
int ret;
/* determine correct relocation entry sizes */
if(using_relas) {
rel_size = sizeof(struct elf32_rela);
} else {
rel_size = sizeof(struct elf32_rel);
}
for(a = section; a < section + size; a += rel_size) {
ret = seek_read(input_fd, a, (char *)&rela, rel_size);
if (ret < 0) return ELFLOADER_INPUT_ERROR;
ret = seek_read(input_fd,
(symtab +
sizeof(struct elf32_sym) * ELF32_R_SYM(rela.r_info)),
(char *)&s, sizeof(s));
if (ret < 0) return ELFLOADER_INPUT_ERROR;
if(s.st_name != 0) {
ret = seek_read(input_fd, strtab + s.st_name, name, sizeof(name));
if (ret < 0) return ELFLOADER_INPUT_ERROR;
PRINTF("name: %s\n", name);
addr = (char *)symtab_lookup(name);
/* ADDED */
if(addr == NULL) {
PRINTF("name not found in global: %s\n", name);
addr = find_local_symbol(input_fd, name, symtab, symtabsize, strtab);
PRINTF("found address %p\n", addr);
}
if(addr == NULL) {
if(s.st_shndx == bss.number) {
sect = &bss;
} else if(s.st_shndx == data.number) {
sect = &data;
} else if(s.st_shndx == rodata.number) {
sect = &rodata;
} else if(s.st_shndx == text.number) {
sect = &text;
} else {
PRINTF("elfloader unknown name: '%30s'\n", name);
memcpy(elfloader_unknown, name, sizeof(elfloader_unknown));
elfloader_unknown[sizeof(elfloader_unknown) - 1] = 0;
return ELFLOADER_SYMBOL_NOT_FOUND;
}
addr = sect->address;
}
} else {
if(s.st_shndx == bss.number) {
sect = &bss;
} else if(s.st_shndx == data.number) {
sect = &data;
} else if(s.st_shndx == rodata.number) {
sect = &rodata;
} else if(s.st_shndx == text.number) {
sect = &text;
} else {
return ELFLOADER_SEGMENT_NOT_FOUND;
}
addr = sect->address;
}
#if 0 /* We don't know how big the relocation is or even if we need to read it.
Let the architecture dependant code decide */
if (!using_relas) {
/* copy addend to rela structure */
ret = seek_read(fd, sectionaddr + rela.r_offset, &rela.r_addend, 4);
if (ret < 0) return ELFLOADER_INPUT_ERROR;
}
#endif
{
/* Copy data up to the next relocation */
unsigned int offset = elfloader_output_segment_offset(output);
if (rela.r_offset < offset) {
PRINTF("elfloader relocation out of offset order\n");
}
if (rela.r_offset > offset) {
ret = copy_segment_data(input_fd, offset+sectionaddr, output,
rela.r_offset - offset);
if (ret != ELFLOADER_OK) return ret;
}
}
ret = elfloader_arch_relocate(input_fd, output, sectionaddr, sectionbase,
&rela, addr);
if (ret != ELFLOADER_OK) return ret;
}
return ELFLOADER_OK;
}
/*---------------------------------------------------------------------------*/
static void *
find_program_processes(int input_fd,
unsigned int symtab, unsigned short size,
unsigned int strtab)
{
struct elf32_sym s;
unsigned int a;
char name[30];
for(a = symtab; a < symtab + size; a += sizeof(s)) {
seek_read(input_fd, a, (char *)&s, sizeof(s));
if(s.st_name != 0) {
seek_read(input_fd, strtab + s.st_name, name, sizeof(name));
if(strcmp(name, "autostart_processes") == 0) {
return &data.address[s.st_value];
}
}
}
return NULL;
/* return find_local_symbol(fd, "autostart_processes", symtab, size, strtab); */
}
/*---------------------------------------------------------------------------*/
void
elfloader_init(void)
{
elfloader_autostart_processes = NULL;
}
/*---------------------------------------------------------------------------*/
#if 0
static void
print_chars(unsigned char *ptr, int num)
{
int i;
for(i = 0; i < num; ++i) {
PRINTF("%d", ptr[i]);
if(i == num - 1) {
PRINTF("\n");
} else {
PRINTF(", ");
}
}
}
#endif /* 0 */
static int
copy_segment(int input_fd,
struct elfloader_output *output,
unsigned int section, unsigned short size,
unsigned int sectionaddr,
char *sectionbase,
unsigned int strs,
unsigned int strtab,
unsigned int symtab, unsigned short symtabsize,
unsigned char using_relas,
unsigned int seg_size, unsigned int seg_type)
{
unsigned int offset;
int ret;
ret = elfloader_output_start_segment(output, seg_type,sectionbase, seg_size);
if (ret != ELFLOADER_OK) return ret;
ret = relocate_section(input_fd, output,
section, size,
sectionaddr,
sectionbase,
strs,
strtab,
symtab, symtabsize, using_relas);
if (ret != ELFLOADER_OK) return ret;
offset = elfloader_output_segment_offset(output);
ret = copy_segment_data(input_fd, offset+sectionaddr, output,seg_size - offset);
if (ret != ELFLOADER_OK) return ret;
return elfloader_output_end_segment(output);
}
/*---------------------------------------------------------------------------*/
int
elfloader_load(int input_fd, struct elfloader_output *output)
{
struct elf32_ehdr ehdr;
struct elf32_shdr shdr;
struct elf32_shdr strtable;
unsigned int strs;
unsigned int shdrptr;
unsigned int nameptr;
char name[12];
int i;
unsigned short shdrnum, shdrsize;
unsigned char using_relas = -1;
unsigned short textoff = 0, textsize, textrelaoff = 0, textrelasize;
unsigned short dataoff = 0, datasize, datarelaoff = 0, datarelasize;
unsigned short rodataoff = 0, rodatasize, rodatarelaoff = 0, rodatarelasize;
unsigned short symtaboff = 0, symtabsize;
unsigned short strtaboff = 0, strtabsize;
unsigned short bsssize = 0;
struct process **process;
int ret;
elfloader_unknown[0] = 0;
/* The ELF header is located at the start of the buffer. */
ret = seek_read(input_fd, 0, (char *)&ehdr, sizeof(ehdr));
if (ret != sizeof(ehdr)) return ELFLOADER_INPUT_ERROR;
/* print_chars(ehdr.e_ident, sizeof(elf_magic_header));
print_chars(elf_magic_header, sizeof(elf_magic_header));*/
/* Make sure that we have a correct and compatible ELF header. */
if(memcmp(ehdr.e_ident, elf_magic_header, sizeof(elf_magic_header)) != 0) {
PRINTF("ELF header problems\n");
return ELFLOADER_BAD_ELF_HEADER;
}
/* Grab the section header. */
shdrptr = ehdr.e_shoff;
ret = seek_read(input_fd, shdrptr, (char *)&shdr, sizeof(shdr));
if (ret != sizeof(shdr)) return ELFLOADER_INPUT_ERROR;
/* Get the size and number of entries of the section header. */
shdrsize = ehdr.e_shentsize;
shdrnum = ehdr.e_shnum;
/* The string table section: holds the names of the sections. */
ret = seek_read(input_fd, ehdr.e_shoff + shdrsize * ehdr.e_shstrndx,
(char *)&strtable, sizeof(strtable));
if (ret != sizeof(strtable)) return ELFLOADER_INPUT_ERROR;
/* Get a pointer to the actual table of strings. This table holds
the names of the sections, not the names of other symbols in the
file (these are in the sybtam section). */
strs = strtable.sh_offset;
/* Go through all sections and pick out the relevant ones. The
".text" segment holds the actual code from the ELF file, the
".data" segment contains initialized data, the ".rodata" segment
contains read-only data, the ".bss" segment holds the size of the
unitialized data segment. The ".rel[a].text" and ".rel[a].data"
segments contains relocation information for the contents of the
".text" and ".data" segments, respectively. The ".symtab" segment
contains the symbol table for this file. The ".strtab" segment
points to the actual string names used by the symbol table.
In addition to grabbing pointers to the relevant sections, we
also save the section number for resolving addresses in the
relocator code.
*/
/* Initialize the segment sizes to zero so that we can check if
their sections was found in the file or not. */
textsize = textrelasize = datasize = datarelasize =
rodatasize = rodatarelasize = symtabsize = strtabsize = 0;
bss.number = data.number = rodata.number = text.number = -1;
shdrptr = ehdr.e_shoff;
for(i = 0; i < shdrnum; ++i) {
ret = seek_read(input_fd, shdrptr, (char *)&shdr, sizeof(shdr));
if (ret != sizeof(shdr)) return ELFLOADER_INPUT_ERROR;
/* The name of the section is contained in the strings table. */
nameptr = strs + shdr.sh_name;
ret = seek_read(input_fd, nameptr, name, sizeof(name));
if (ret != sizeof(name)) return ELFLOADER_INPUT_ERROR;
/* Match the name of the section with a predefined set of names
(.text, .data, .bss, .rela.text, .rela.data, .symtab, and
.strtab). */
/* added support for .rodata, .rel.text and .rel.data). */
if(strncmp(name, ".text", 5) == 0) {
textoff = shdr.sh_offset;
textsize = shdr.sh_size;
text.number = i;
text.offset = textoff;
} else if(strncmp(name, ".rel.text", 9) == 0) {
using_relas = 0;
textrelaoff = shdr.sh_offset;
textrelasize = shdr.sh_size;
} else if(strncmp(name, ".rela.text", 10) == 0) {
using_relas = 1;
textrelaoff = shdr.sh_offset;
textrelasize = shdr.sh_size;
} else if(strncmp(name, ".data", 5) == 0) {
dataoff = shdr.sh_offset;
datasize = shdr.sh_size;
data.number = i;
data.offset = dataoff;
} else if(strncmp(name, ".rodata", 7) == 0) {
/* read-only data handled the same way as regular text section */
rodataoff = shdr.sh_offset;
rodatasize = shdr.sh_size;
rodata.number = i;
rodata.offset = rodataoff;
} else if(strncmp(name, ".rel.rodata", 11) == 0) {
/* using elf32_rel instead of rela */
using_relas = 0;
rodatarelaoff = shdr.sh_offset;
rodatarelasize = shdr.sh_size;
} else if(strncmp(name, ".rela.rodata", 12) == 0) {
using_relas = 1;
rodatarelaoff = shdr.sh_offset;
rodatarelasize = shdr.sh_size;
} else if(strncmp(name, ".rel.data", 9) == 0) {
/* using elf32_rel instead of rela */
using_relas = 0;
datarelaoff = shdr.sh_offset;
datarelasize = shdr.sh_size;
} else if(strncmp(name, ".rela.data", 10) == 0) {
using_relas = 1;
datarelaoff = shdr.sh_offset;
datarelasize = shdr.sh_size;
} else if(strncmp(name, ".symtab", 7) == 0) {
symtaboff = shdr.sh_offset;
symtabsize = shdr.sh_size;
} else if(strncmp(name, ".strtab", 7) == 0) {
strtaboff = shdr.sh_offset;
strtabsize = shdr.sh_size;
} else if(strncmp(name, ".bss", 4) == 0) {
bsssize = shdr.sh_size;
bss.number = i;
bss.offset = 0;
}
/* Move on to the next section header. */
shdrptr += shdrsize;
}
if(symtabsize == 0) {
return ELFLOADER_NO_SYMTAB;
}
if(strtabsize == 0) {
return ELFLOADER_NO_STRTAB;
}
if(textsize == 0) {
return ELFLOADER_NO_TEXT;
}
if (bsssize) {
bss.address = (char *)
elfloader_output_alloc_segment(output, ELFLOADER_SEG_BSS, bsssize);
if (!bss.address) return ELFLOADER_OUTPUT_ERROR;
}
if (datasize) {
data.address = (char *)
elfloader_output_alloc_segment(output,ELFLOADER_SEG_DATA,datasize);
if (!data.address) return ELFLOADER_OUTPUT_ERROR;
}
if (textsize) {
text.address = (char *)
elfloader_output_alloc_segment(output,ELFLOADER_SEG_TEXT,textsize);
if (!text.address) return ELFLOADER_OUTPUT_ERROR;
}
if (rodatasize) {
rodata.address = (char *)
elfloader_output_alloc_segment(output,ELFLOADER_SEG_RODATA,rodatasize);
if (!rodata.address) return ELFLOADER_OUTPUT_ERROR;
}
/* printf("bss base address: bss.address = 0x%08x\n", bss.address);
printf("data base address: data.address = 0x%08x\n", data.address);
printf("text base address: text.address = 0x%08x\n", text.address);
printf("rodata base address: rodata.address = 0x%08x\n", rodata.address); */
/* If we have text segment relocations, we process them. */
PRINTF("elfloader: relocate text\n");
if(textrelasize > 0) {
ret = copy_segment(input_fd, output,
textrelaoff, textrelasize,
textoff,
text.address,
strs,
strtaboff,
symtaboff, symtabsize, using_relas,
textsize, ELFLOADER_SEG_TEXT);
if(ret != ELFLOADER_OK) {
return ret;
}
}
/* If we have any rodata segment relocations, we process them too. */
PRINTF("elfloader: relocate rodata\n");
if(rodatarelasize > 0) {
ret = copy_segment(input_fd, output,
rodatarelaoff, rodatarelasize,
rodataoff,
rodata.address,
strs,
strtaboff,
symtaboff, symtabsize, using_relas,
rodatasize, ELFLOADER_SEG_RODATA);
if(ret != ELFLOADER_OK) {
PRINTF("elfloader: data failed\n");
return ret;
}
}
/* If we have any data segment relocations, we process them too. */
PRINTF("elfloader: relocate data\n");
if(datarelasize > 0) {
ret = copy_segment(input_fd, output,
datarelaoff, datarelasize,
dataoff,
data.address,
strs,
strtaboff,
symtaboff, symtabsize, using_relas,
datasize, ELFLOADER_SEG_DATA);
if(ret != ELFLOADER_OK) {
PRINTF("elfloader: data failed\n");
return ret;
}
ret = elfloader_output_end_segment(output);
if (ret != ELFLOADER_OK) return ret;
}
/* Write text and rodata segment into flash and data segment into RAM. */
/* elfloader_arch_write_rom(fd, textoff, textsize, text.address); */
/* elfloader_arch_write_rom(fd, rodataoff, rodatasize, rodata.address); */
/* memset(bss.address, 0, bsssize); */
/* seek_read(fd, dataoff, data.address, datasize); */
{
/* Write zeros to bss segment */
unsigned int len = bsssize;
static const char zeros[16] = {0};
ret = elfloader_output_start_segment(output, ELFLOADER_SEG_BSS,
bss.address,bsssize);
if (ret != ELFLOADER_OK) return ret;
while(len > sizeof(zeros)) {
ret = elfloader_output_write_segment(output, zeros, sizeof(zeros));
if (ret != sizeof(zeros)) return ELFLOADER_OUTPUT_ERROR;
len -= sizeof(zeros);
}
ret = elfloader_output_write_segment(output, zeros, len);
if (ret != len) return ELFLOADER_OUTPUT_ERROR;
}
PRINTF("elfloader: autostart search\n");
process = find_local_symbol(input_fd, "autostart_processes", symtaboff, symtabsize, strtaboff);
if(process != NULL) {
PRINTF("elfloader: autostart found\n");
elfloader_autostart_processes = process;
return ELFLOADER_OK;
} else {
PRINTF("elfloader: no autostart\n");
process = find_program_processes(input_fd, symtaboff, symtabsize, strtaboff);
if(process != NULL) {
PRINTF("elfloader: FOUND PRG\n");
}
return ELFLOADER_NO_STARTPOINT;
}
}
/*---------------------------------------------------------------------------*/

314
cpu/at91sam7s/loader/elfloader-otf.h
View file

@ -1,314 +0,0 @@
/**
* \addtogroup loader
* @{
*/
/**
* \defgroup elfloader The Contiki ELF loader
*
* The Contiki ELF loader links, relocates, and loads ELF
* (Executable Linkable Format) object files into a running Contiki
* system.
*
* ELF is a standard format for relocatable object code and executable
* files. ELF is the standard program format for Linux, Solaris, and
* other operating systems.
*
* An ELF file contains either a standalone executable program or a
* program module. The file contains both the program code, the
* program data, as well as information about how to link, relocate,
* and load the program into a running system.
*
* The ELF file is composed of a set of sections. The sections contain
* program code, data, or relocation information, but can also contain
* debugging information.
*
* To link and relocate an ELF file, the Contiki ELF loader first
* parses the ELF file structure to find the appropriate ELF
* sections. It then allocates memory for the program code and data in
* ROM and RAM, respectively. After allocating memory, the Contiki ELF
* loader starts relocating the code found in the ELF file.
*
* @{
*/
/**
* \file
* Header file for the Contiki ELF loader.
* \author
* Adam Dunkels <adam@sics.se>
* Simon Berg <ksb@users.sourceforge.net>
*
*/
/*
* Copyright (c) 2005, Swedish Institute of Computer Science
* Copyright (c) 2007, Simon Berg
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of the Contiki operating system.
*
*/
#ifndef __ELFLOADER_H__
#define __ELFLOADER_H__
#include "cfs/cfs.h"
/**
* Return value from elfloader_load() indicating that loading worked.
*/
#define ELFLOADER_OK 0
/**
* Return value from elfloader_load() indicating that the ELF file had
* a bad header.
*/
#define ELFLOADER_BAD_ELF_HEADER 1
/**
* Return value from elfloader_load() indicating that no symbol table
* could be find in the ELF file.
*/
#define ELFLOADER_NO_SYMTAB 2
/**
* Return value from elfloader_load() indicating that no string table
* could be find in the ELF file.
*/
#define ELFLOADER_NO_STRTAB 3
/**
* Return value from elfloader_load() indicating that the size of the
* .text segment was zero.
*/
#define ELFLOADER_NO_TEXT 4
/**
* Return value from elfloader_load() indicating that a symbol
* specific symbol could not be found.
*
* If this value is returned from elfloader_load(), the symbol has
* been copied into the elfloader_unknown[] array.
*/
#define ELFLOADER_SYMBOL_NOT_FOUND 5
/**
* Return value from elfloader_load() indicating that one of the
* required segments (.data, .bss, or .text) could not be found.
*/
#define ELFLOADER_SEGMENT_NOT_FOUND 6
/**
* Return value from elfloader_load() indicating that no starting
* point could be found in the loaded module.
*/
#define ELFLOADER_NO_STARTPOINT 7
/**
* Return value from elfloader_load() indicating that the ELF file contained
* a relocation type that the implementation can't handle.
*/
#define ELFLOADER_UNHANDLED_RELOC 8
/**
* Return value from elfloader_load() indicating that the offset for
* a relative addressing mode was too big.
*/
#define ELFLOADER_OUTOF_RANGE 9
/**
* Return value from elfloader_load() indicating that the relocations
* where not sorted by offset
*/
#define ELFLOADER_RELOC_NOT_SORTED 10
/**
* Return value from elfloader_load() indicating that reading from the
* ELF file failed in some way.
*/
#define ELFLOADER_INPUT_ERROR 11
/**
* Return value from elfloader_load() indicating that writing to a segment
* failed.
*/
#define ELFLOADER_OUTPUT_ERROR 12
#define ELFLOADER_SEG_TEXT 1
#define ELFLOADER_SEG_RODATA 2
#define ELFLOADER_SEG_DATA 3
#define ELFLOADER_SEG_BSS 4
/**
* elfloader output object
*
* This object defines methods (callbacks) for writing the segments to memory.
* It can be extended by the user to include any necessary state.
*/
struct elfloader_output {
const struct elfloader_output_ops *ops;
};
/**
* \brief Allocate a new segment
* \param input The output object
* \param type Type of segment
* \param size Size of segment in bytes
* \return A pointer to the start of the segment.
*
* The returned address doesn't need to correspond to any real memory,
* since it's only used for calculating the relocations.
*/
void *elfloader_allocate_segment(struct elfloader_output *output,
unsigned int type, int size);
/**
* \brief Start writing to a new segment
* \param input The output object
* \param type Type of segment
* \param addr Address of segment from elfloader_allocate_segment
* \param size Size of segment in bytes
* \return Returns ELFLOADER_OK if successful, otherwise an error code
*
*/
int elfloader_start_segment(struct elfloader_output *output,
unsigned int type, void *addr, int size);
/**
* \brief Mark end of segment
* \param input The output object
* \return Zero if successful
*/
int elfloader_end_segment(struct elfloader_output *output);
/**
* \brief Write data to a segment
* \param input The output object
* \param buf Data to be written
* \param len Length of data
* \return The number of bytes actually written, or negative if failed.
*/
int elfloader_write_segment(struct elfloader_output *output, const char *buf,
unsigned int len);
/**
* \brief Get the current offset in the file where the next data will
* be written.
* \param input The output object
* \return The current offset.
*/
unsigned int elfloader_segment_offset(struct elfloader_output *output);
#define elfloader_output_alloc_segment(output, type, size) \
((output)->ops->allocate_segment(output, type, size))
#define elfloader_output_start_segment(output, type, addr, size) \
((output)->ops->start_segment(output, type, addr, size))
#define elfloader_output_end_segment(output) \
((output)->ops->end_segment(output))
#define elfloader_output_write_segment(output, buf, len) \
((output)->ops->write_segment(output, buf, len))
#define elfloader_output_segment_offset(output) \
((output)->ops->segment_offset(output))
struct elfloader_output_ops {
void * (*allocate_segment)(struct elfloader_output *output,
unsigned int type, int size);
int (*start_segment)(struct elfloader_output *output,
unsigned int type, void *addr, int size);
int (*end_segment)(struct elfloader_output *output);
int (*write_segment)(struct elfloader_output *output, const char *buf,
unsigned int len);
unsigned int (*segment_offset)(struct elfloader_output *output);
};
/**
* elfloader initialization function.
*
* This function should be called at boot up to initilize the elfloader.
*/
void elfloader_init(void);
/**
* \brief Load and relocate an ELF file.
* \param input Input object defining how to read from the ELF file
* \param output Output object defining how to create and write to seegments.
* \return ELFLOADER_OK if loading and relocation worked.
* Otherwise an error value.
*
* If the function is able to load the ELF file, a pointer
* to the process structure in the model is stored in the
* elfloader_loaded_process variable.
*
*/
int elfloader_load(int input_fd,
struct elfloader_output *output);
/**
* A pointer to the processes loaded with elfloader_load().
*/
extern struct process **elfloader_autostart_processes;
/**
* If elfloader_load() could not find a specific symbol, it is copied
* into this array.
*/
extern char elfloader_unknown[30];
#ifdef ELFLOADER_CONF_DATAMEMORY_SIZE
#define ELFLOADER_DATAMEMORY_SIZE ELFLOADER_CONF_DATAMEMORY_SIZE
#else
#define ELFLOADER_DATAMEMORY_SIZE 0x100
#endif
#ifdef ELFLOADER_CONF_TEXTMEMORY_SIZE
#define ELFLOADER_TEXTMEMORY_SIZE ELFLOADER_CONF_TEXTMEMORY_SIZE
#else
#define ELFLOADER_TEXTMEMORY_SIZE 0x100
#endif
typedef unsigned long elf32_word;
typedef signed long elf32_sword;
typedef unsigned short elf32_half;
typedef unsigned long elf32_off;
typedef unsigned long elf32_addr;
struct elf32_rela {
elf32_addr r_offset; /* Location to be relocated. */
elf32_word r_info; /* Relocation type and symbol index. */
elf32_sword r_addend; /* Addend. */
};
#endif /* __ELFLOADER_H__ */
/** @} */
/** @} */

3
cpu/at91sam7s/loader/empty-symbols.c
View file

@ -1,3 +0,0 @@
#include "symbols.h"
const int symbols_nelts = 0;
const struct symbols symbols[] = {{0,0}};

140
cpu/at91sam7s/loader/ram-segments.c
View file

@ -1,140 +0,0 @@
#ifndef __RAM_SEGMENTS_C__1POIF5E8U4__
#define __RAM_SEGMENTS_C__1POIF5E8U4__
#include <loader/elfloader-otf.h>
#include <loader/codeprop-otf.h>
#include <sys/types.h>
#include <lib/malloc.h>
#include <string.h>
#include <stdio.h>
struct ram_output
{
struct elfloader_output output;
char *base;
unsigned int offset;
void *text;
void *rodata;
void *data;
void *bss;
};
static void *
allocate_segment(struct elfloader_output * const output,
unsigned int type, int size)
{
struct ram_output * const ram = (struct ram_output *)output;
void *block = malloc(size);
if (!block) return NULL;
switch(type) {
case ELFLOADER_SEG_TEXT:
if (ram->text) free(ram->text);
ram->text = block;
break;
case ELFLOADER_SEG_RODATA:
if (ram->rodata) free(ram->rodata);
ram->rodata = block;
break;
case ELFLOADER_SEG_DATA:
if (ram->data) free(ram->data);
ram->data = block;
break;
case ELFLOADER_SEG_BSS:
if (ram->bss) free(ram->bss);
ram->bss = block;
break;
default:
free(block);
return NULL;
}
return block;
}
static int
start_segment(struct elfloader_output *output,
unsigned int type, void *addr, int size)
{
((struct ram_output*)output)->base = addr;
((struct ram_output*)output)->offset = 0;
return ELFLOADER_OK;
}
static int
end_segment(struct elfloader_output *output)
{
return ELFLOADER_OK;
}
static int
write_segment(struct elfloader_output *output, const char *buf,
unsigned int len)
{
struct ram_output * const ram = (struct ram_output *)output;
memcpy(ram->base + ram->offset, buf, len);
ram->offset += len;
return len;
}
static unsigned int
segment_offset(struct elfloader_output *output)
{
return ((struct ram_output*)output)->offset;
}
static const struct elfloader_output_ops elf_output_ops =
{
allocate_segment,
start_segment,
end_segment,
write_segment,
segment_offset
};
static struct ram_output seg_output = {
{&elf_output_ops},
NULL,
0,
NULL,
NULL,
NULL,
NULL
};
PROCESS(ram_segments_cleanup_process, "RAM segments cleanup process");
PROCESS_THREAD(ram_segments_cleanup_process, ev, data)
{
PROCESS_BEGIN();
while(1) {
PROCESS_WAIT_EVENT_UNTIL(ev == PROCESS_EVENT_EXITED
|| ev == PROCESS_EVENT_EXIT);
if (ev == PROCESS_EVENT_EXIT) break;
if (elfloader_autostart_processes ||
elfloader_autostart_processes[0] == data) {
PROCESS_PAUSE(); /* Let the process exit */
if (seg_output.text) {
free(seg_output.text);
seg_output.text = NULL;
}
if (seg_output.rodata) {
free(seg_output.rodata);
seg_output.rodata = NULL;
}
if (seg_output.data) {
free(seg_output.data);
seg_output.data = NULL;
}
if (seg_output.bss) {
free(seg_output.bss);
seg_output.bss = NULL;
}
elfloader_autostart_processes = NULL;
}
}
PROCESS_END();
}
struct elfloader_output *codeprop_output = &seg_output.output;
#endif /* __RAM_SEGMENTS_C__1POIF5E8U4__ */

6
cpu/at91sam7s/loader/ram-segments.h
View file

@ -1,6 +0,0 @@
#ifndef __RAM_SEGMENTS_H__8EDB9N09UD__
#define __RAM_SEGMENTS_H__8EDB9N09UD__
PROCESS_NAME(ram_segments_cleanup_process);
#endif /* __RAM_SEGMENTS_H__8EDB9N09UD__ */

8
cpu/at91sam7s/merge-rodata.ld
View file

@ -1,8 +0,0 @@
SECTIONS
{
.text :
{
*(.text)
*(.rodata.* .rodata)
}
}

124
cpu/at91sam7s/newlib-syscalls.c
View file

@ -1,124 +0,0 @@
#include <debug-uart.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
int
_open(const char *name, int flags, int mode) {
errno = ENOENT;
return -1;
}
int
_close(int file)
{
if (file == 1 || file == 2) {
dbg_drain();
return 0;
}
errno = EBADF;
return -1;
}
int
isatty(int file)
{
if (file >= 0 && file <= 2) return 1;
return 0;
}
int
_read(int file, char *ptr, int len){
return 0;
}
int
_write(int file, const char *ptr, int len){
int sent = -1;
if (file == 1 || file == 2) {
sent = dbg_send_bytes((const unsigned char*)ptr, len);
}
return sent;
}
int
_lseek(int file, int ptr, int dir){
return 0;
}
int
_fstat(int file, struct stat *st) {
if (file >= 0 && file <= 2) {
st->st_mode = S_IFCHR;
return 0;
}
errno = EBADF;
return -1;
}
int
_stat(char *file, struct stat *st) {
errno = ENOENT;
return -1;
}
caddr_t
_sbrk(int incr)
{
extern char __heap_start__; /* Defined by the linker */
extern char __heap_end__; /* Defined by the linker */
static char *heap_end = &__heap_start__;
char *prev_heap_end;
prev_heap_end = heap_end;
if (heap_end + incr > &__heap_end__) {
printf("Heap full (requested %d, available %d)\n",
incr, (int)(&__heap_end__ - heap_end));
errno = ENOMEM;
return (caddr_t)-1;
}
heap_end += incr;
return (caddr_t) prev_heap_end;
}
int
fsync(int fd)
{
if (fd == 1 || fd == 2) {
dbg_drain();
return 0;
}
if (fd == 0) return 0;
errno = EBADF;
return -1;
}
void
_exit(int status)
{
while(1);
}
void
_abort()
{
while(1);
}
void
_kill()
{
while(1);
}
pid_t
_getpid(void)
{
return 1;
}
const unsigned long
bkpt_instr = 0xe1200070;

1
cpu/at91sam7s/openocd/AT91SAM7x_init.script
View file

@ -1 +0,0 @@
arm7_9 force_hw_bkpts enable

30
cpu/at91sam7s/openocd/arm7_wig.cfg
View file

@ -1,30 +0,0 @@
#daemon configuration
telnet_port 4444
gdb_port 3333
#interface
interface parport
parport_port 0
parport_cable wiggler
jtag_speed 0
#use combined on interfaces or targets that can't set TRST/SRST separately
reset_config srst_only
#jtag scan chain
#format L IRC IRCM IDCODE (Length, IR Capture, IR Capture Mask, IDCODE)
jtag_device 4 0x1 0xf 0xe
#target configuration
daemon_startup reset
#target <type> <startup mode>
#target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
target arm7tdmi little run_and_init 0 arm7tdmi_r4
#target_script 0 reset h2294_init.script
target_script 0 reset AT91SAM7x_init.script
run_and_halt_time 0 30
working_area 0 0x40000000 0x4000 nobackup
#flash configuration
#flash bank lpc2000 0x0 0x40000 0 0 lpc2000_v1 0 14765 calc_checksum
#flash bank cfi 0x80000000 0x400000 2 2 0
flash bank at91sam7 0 0 0 0 0

30
cpu/at91sam7s/openocd/arm7_wig_flash.cfg
View file

@ -1,30 +0,0 @@
#daemon configuration
telnet_port 4444
gdb_port 3333
#interface
interface parport
parport_port 0
parport_cable wiggler
jtag_speed 0
#use combined on interfaces or targets that can't set TRST/SRST separately
reset_config srst_only
#jtag scan chain
#format L IRC IRCM IDCODE (Length, IR Capture, IR Capture Mask, IDCODE)
jtag_device 4 0x1 0xf 0xe
#target configuration
daemon_startup reset
#target <type> <startup mode>
#target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
target arm7tdmi little run_and_init 0 arm7tdmi_r4
#target_script 0 reset h2294_init.script
target_script 0 reset openocd_flash
run_and_halt_time 0 30
working_area 0 0x40000000 0x4000 nobackup
#flash configuration
#flash bank lpc2000 0x0 0x40000 0 0 lpc2000_v1 0 14765 calc_checksum
#flash bank cfi 0x80000000 0x400000 2 2 0
flash bank at91sam7 0 0 0 0 0

30
cpu/at91sam7s/openocd/arm7_wig_reset.cfg
View file

@ -1,30 +0,0 @@
#daemon configuration
telnet_port 4444
gdb_port 3333
#interface
interface parport
parport_port 0
parport_cable wiggler
jtag_speed 0
#use combined on interfaces or targets that can't set TRST/SRST separately
reset_config srst_only
#jtag scan chain
#format L IRC IRCM IDCODE (Length, IR Capture, IR Capture Mask, IDCODE)
jtag_device 4 0x1 0xf 0xe
#target configuration
daemon_startup reset
#target <type> <startup mode>
#target arm7tdmi <reset mode> <chainpos> <endianness> <variant>
target arm7tdmi little run_and_init 0 arm7tdmi_r4
#target_script 0 reset h2294_init.script
target_script 0 reset openocd_reset
run_and_halt_time 0 30
working_area 0 0x40000000 0x4000 nobackup
#flash configuration
#flash bank lpc2000 0x0 0x40000 0 0 lpc2000_v1 0 14765 calc_checksum
#flash bank cfi 0x80000000 0x400000 2 2 0
flash bank at91sam7 0 0 0 0 0

10
cpu/at91sam7s/openocd/openocd_flash
View file

@ -1,10 +0,0 @@
poll
mww 0xffffff64 0x5a000004
sleep 250
mww 0xffffff64 0x5a002004
sleep 250
flash probe 0
flash write 0 /tmp/openocd_write.bin 0x0
reset run
sleep 500
shutdown

4
cpu/at91sam7s/openocd/openocd_reset
View file

@ -1,4 +0,0 @@
poll
reset run
sleep 500
shutdown

22
cpu/at91sam7s/pit-interrupt.h
View file

@ -1,22 +0,0 @@
volatile unsigned int pit_count = 0;
static void NACKEDFUNC ATTR system_int (void) { /* System Interrupt Handler */
ISR_ENTRY();
if (*AT91C_PITC_PISR & AT91C_PITC_PITS) { /* Check PIT Interrupt */
pit_count++;
/*
if ((pit_count % 100) == 0) {
unsigned int led_state = (pit_count % 300) / 100;
*AT91C_PIOA_ODSR = ~(1<<led_state);
}
*/
*AT91C_AIC_EOICR = *AT91C_PITC_PIVR; /* Ack & End of Interrupt */
} else {
*AT91C_AIC_EOICR = 0; /* End of Interrupt */
}
ISR_EXIT();
}

34
cpu/at91sam7s/rtimer-arch-interrupt.c
View file

@ -1,34 +0,0 @@
#include "rtimer-arch-interrupt.h"
#include "rtimer-arch.h"
#include <interrupt-utils.h>
#include <AT91SAM7S64.h>
#define DEBUG 1
#if DEBUG
#include <stdio.h>
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...)
#endif
/* Here we have a proper stack frame and can use local variables */
static void rtimer_int_safe() __attribute((noinline));
static void
rtimer_int_safe()
{
unsigned int status;
status = RTIMER_ARCH_TIMER_BASE->TC_SR;
if (status & AT91C_TC_CPAS) {
rtimer_run_next();
}
*AT91C_AIC_EOICR = 0;
}
void NACKEDFUNC
rtimer_interrupt (void) {
ISR_STORE();
ISR_ENABLE_NEST();
rtimer_int_safe();
ISR_DISABLE_NEST();
ISR_RESTORE();
}

6
cpu/at91sam7s/rtimer-arch-interrupt.h
View file

@ -1,6 +0,0 @@
#ifndef __RTIMER_ARCH_INTERRUPT_H__P0PXG70757__
#define __RTIMER_ARCH_INTERRUPT_H__P0PXG70757__
void rtimer_interrupt (void);
#endif /* __RTIMER_ARCH_INTERRUPT_H__P0PXG70757__ */

49
cpu/at91sam7s/rtimer-arch.c
View file

@ -1,49 +0,0 @@
#include "rtimer-arch.h"
#include <AT91SAM7S64.h>
#include "rtimer-arch-interrupt.h"
#define DEBUG 1
#if DEBUG
#include <stdio.h>
#define PRINTF(...) printf(__VA_ARGS__)
#else
#define PRINTF(...)
#endif
static rtimer_clock_t offset;
void
rtimer_arch_init(void)
{
offset = 0;
RTIMER_ARCH_TIMER_BASE->TC_CMR =
(AT91C_TC_WAVE | AT91C_TC_WAVESEL_UP | AT91C_TC_CLKS_TIMER_DIV5_CLOCK);
RTIMER_ARCH_TIMER_BASE->TC_RA = 0xffff;
RTIMER_ARCH_TIMER_BASE->TC_IER = AT91C_TC_CPAS;
*AT91C_PMC_PCER = (1 << RTIMER_ARCH_TIMER_ID);
AT91C_AIC_SMR[RTIMER_ARCH_TIMER_ID] =
AT91C_AIC_SRCTYPE_INT_POSITIVE_EDGE | 6;
AT91C_AIC_SVR[RTIMER_ARCH_TIMER_ID] = (unsigned long)rtimer_interrupt;
*AT91C_AIC_IECR = (1 << RTIMER_ARCH_TIMER_ID);
RTIMER_ARCH_TIMER_BASE->TC_CCR = AT91C_TC_SWTRG | AT91C_TC_CLKEN;
PRINTF("rtimer_arch_init: Done\n");
}
void
rtimer_arch_schedule(rtimer_clock_t t)
{
RTIMER_ARCH_TIMER_BASE->TC_RA = t + offset;
PRINTF("rtimer_arch_schedule: %d\n",t);
}
void
rtimer_arch_set(rtimer_clock_t t)
{
offset = t - RTIMER_ARCH_TIMER_BASE->TC_CV;
}
rtimer_clock_t
rtimer_arch_now(void)
{
return RTIMER_ARCH_TIMER_BASE->TC_CV + offset;
}

22
cpu/at91sam7s/rtimer-arch.h
View file

@ -1,22 +0,0 @@
/**
* \file
* Header file for the AT91SAM7S-specific rtimer code
* \author
* Simon Berg <ksb@users.sourceforge.net>
*/
#ifndef __RTIMER_ARCH_H__
#define __RTIMER_ARCH_H__
#include "sys/rtimer.h"
#define RTIMER_ARCH_TIMER_ID AT91C_ID_TC1
#define RTIMER_ARCH_TIMER_BASE AT91C_BASE_TC1
#define RTIMER_ARCH_SECOND (MCK/1024)
void rtimer_arch_set(rtimer_clock_t t);
rtimer_clock_t rtimer_arch_now(void);
#endif /* __RTIMER_ARCH_H__ */

517
cpu/at91sam7s/startup-SAM7S.S
View file

@ -1,517 +0,0 @@
/***********************************************************************/
/* */
/* startup_SAM7S.S: Startup file for Atmel AT91SAM7S device series */
/* */
/***********************************************************************/
/* ported to arm-elf-gcc / WinARM by Martin Thomas, KL, .de */
/* <eversmith@heizung-thomas.de> */
/* modifications Copyright Martin Thomas 2005 */
/* */
/* Based on a file that has been a part of the uVision/ARM */
/* development tools, Copyright KEIL ELEKTRONIK GmbH 2002-2004 */
/***********************************************************************/
/*
Modifications by Martin Thomas:
- added handling of execption vectors in RAM ("ramfunc")
- added options to remap the interrupt vectors to RAM
(see makefile for switch-option)
- replaced all ";" and "#" for comments with // or / * * /
- added C++ ctor handling
- .text in RAM for debugging (RAM_RUN)
*/
/*
Modifications by Simon Berg
- added stack segment
- running program as system by defining RUN_AS_SYSTEM
*/
// mt: this file should not be used with the Configuration Wizard
// since a lot of changes have been done for the WinARM/gcc example
/*
// *** <<< Use Configuration Wizard in Context Menu >>> ***
*/
// *** Startup Code (executed after Reset) ***
// Standard definitions of Mode bits and Interrupt (I & F) flags in PSRs
.equ Mode_USR, 0x10
.equ Mode_FIQ, 0x11
.equ Mode_IRQ, 0x12
.equ Mode_SVC, 0x13
.equ Mode_ABT, 0x17
.equ Mode_UND, 0x1B
.equ Mode_SYS, 0x1F
.equ I_Bit, 0x80 /* when I bit is set, IRQ is disabled */
.equ F_Bit, 0x40 /* when F bit is set, FIQ is disabled */
// Internal Memory Base Addresses
.equ FLASH_BASE, 0x00100000
.equ RAM_BASE, 0x00200000
/*
// <h> Stack Configuration
// <o> Top of Stack Address <0x0-0xFFFFFFFF:4>
// <h> Stack Sizes (in Bytes)
// <o1> Undefined Mode <0x0-0xFFFFFFFF:4>
// <o2> Supervisor Mode <0x0-0xFFFFFFFF:4>
// <o3> Abort Mode <0x0-0xFFFFFFFF:4>
// <o4> Fast Interrupt Mode <0x0-0xFFFFFFFF:4>
// <o5> Interrupt Mode <0x0-0xFFFFFFFF:4>
// <o6> User/System Mode <0x0-0xFFFFFFFF:4>
// </h>
// </h>
*/
.equ Top_Stack, 0x00204000
.equ UND_Stack_Size, 0x00000004
.equ SVC_Stack_Size, 0x00000200
.equ ABT_Stack_Size, 0x00000004
.equ FIQ_Stack_Size, 0x00000004
.equ IRQ_Stack_Size, 0x00000400
.equ USR_Stack_Size, 0x00000400
.bss
.section .stack , "aw", %nobits
USR_Stack_Start:
.skip USR_Stack_Size
USR_Stack_End:
IRQ_Stack_Start:
.skip IRQ_Stack_Size
IRQ_Stack_End:
FIQ_Stack_Start:
.skip FIQ_Stack_Size
FIQ_Stack_End:
ABT_Stack_Start:
.skip ABT_Stack_Size
ABT_Stack_End:
SVC_Stack_Start:
.skip SVC_Stack_Size
SVC_Stack_End:
UND_Stack_Start:
.skip UND_Stack_Size
UND_Stack_End:
// Embedded Flash Controller (EFC) definitions
.equ EFC_BASE, 0xFFFFFF00 /* EFC Base Address */
.equ EFC_FMR, 0x60 /* EFC_FMR Offset */
/*
// <e> Embedded Flash Controller (EFC)
// <o1.16..23> FMCN: Flash Microsecond Cycle Number <0-255>
// <i> Number of Master Clock Cycles in 1us
// <o1.8..9> FWS: Flash Wait State
// <0=> Read: 1 cycle / Write: 2 cycles
// <1=> Read: 2 cycle / Write: 3 cycles
// <2=> Read: 3 cycle / Write: 4 cycles
// <3=> Read: 4 cycle / Write: 4 cycles
// </e>
*/
.equ EFC_SETUP, 1
.equ EFC_FMR_Val, 0x00320100
// Watchdog Timer (WDT) definitions
.equ WDT_BASE, 0xFFFFFD40 /* WDT Base Address */
.equ WDT_MR, 0x04 /* WDT_MR Offset */
/*
// <e> Watchdog Timer (WDT)
// <o1.0..11> WDV: Watchdog Counter Value <0-4095>
// <o1.16..27> WDD: Watchdog Delta Value <0-4095>
// <o1.12> WDFIEN: Watchdog Fault Interrupt Enable
// <o1.13> WDRSTEN: Watchdog Reset Enable
// <o1.14> WDRPROC: Watchdog Reset Processor
// <o1.28> WDDBGHLT: Watchdog Debug Halt
// <o1.29> WDIDLEHLT: Watchdog Idle Halt
// <o1.15> WDDIS: Watchdog Disable
// </e>
*/
.equ WDT_SETUP, 1
.equ WDT_MR_Val, 0x00008000 // Disable watchdog
// Power Mangement Controller (PMC) definitions
.equ PMC_BASE, 0xFFFFFC00 /* PMC Base Address */
.equ PMC_MOR, 0x20 /* PMC_MOR Offset */
.equ PMC_MCFR, 0x24 /* PMC_MCFR Offset */
.equ PMC_PLLR, 0x2C /* PMC_PLLR Offset */
.equ PMC_MCKR, 0x30 /* PMC_MCKR Offset */
.equ PMC_SR, 0x68 /* PMC_SR Offset */
.equ PMC_MOSCEN, (1<<0) /* Main Oscillator Enable */
.equ PMC_OSCBYPASS, (1<<1) /* Main Oscillator Bypass */
.equ PMC_OSCOUNT, (0xFF<<8) /* Main OScillator Start-up Time */
.equ PMC_DIV, (0xFF<<0) /* PLL Divider */
.equ PMC_PLLCOUNT, (0x3F<<8) /* PLL Lock Counter */
.equ PMC_OUT, (0x03<<14) /* PLL Clock Frequency Range */
.equ PMC_MUL, (0x7FF<<16) /* PLL Multiplier */
.equ PMC_USBDIV, (0x03<<28) /* USB Clock Divider */
.equ PMC_CSS, (3<<0) /* Clock Source Selection */
.equ PMC_PRES, (7<<2) /* Prescaler Selection */
.equ PMC_MOSCS, (1<<0) /* Main Oscillator Stable */
.equ PMC_LOCK, (1<<2) /* PLL Lock Status */
/*
// <e> Power Mangement Controller (PMC)
// <h> Main Oscillator
// <o1.0> MOSCEN: Main Oscillator Enable
// <o1.1> OSCBYPASS: Oscillator Bypass
// <o1.8..15> OSCCOUNT: Main Oscillator Startup Time <0-255>
// </h>
// <h> Phase Locked Loop (PLL)
// <o2.0..7> DIV: PLL Divider <0-255>
// <o2.16..26> MUL: PLL Multiplier <0-2047>
// <i> PLL Output is multiplied by MUL+1
// <o2.14..15> OUT: PLL Clock Frequency Range
// <0=> 80..160MHz <1=> Reserved
// <2=> 150..220MHz <3=> Reserved
// <o2.8..13> PLLCOUNT: PLL Lock Counter <0-63>
// <o2.28..29> USBDIV: USB Clock Divider
// <0=> None <1=> 2 <2=> 4 <3=> Reserved
// </h>
// <o3.0..1> CSS: Clock Source Selection
// <0=> Slow Clock
// <1=> Main Clock
// <2=> Reserved
// <3=> PLL Clock
// <o3.2..4> PRES: Prescaler
// <0=> None
// <1=> Clock / 2 <2=> Clock / 4
// <3=> Clock / 8 <4=> Clock / 16
// <5=> Clock / 32 <6=> Clock / 64
// <7=> Reserved
// </e>
*/
.equ PMC_SETUP, 1
.equ PMC_MOR_Val, 0x00000601 /* Enable main oscilator,
48 cycles startup */
.equ PMC_PLLR_Val, 0x00191C05 /* 28 cycles startup,
PLL = 5.2* * main clock */
.equ PMC_MCKR_Val, 0x0000000B /* MCK = PLL/4 */
/* Reset controller */
.equ RSTC_BASE, 0xfffffd00
.equ RSTC_CR, 0x00
.equ RSTC_SR, 0x04
.equ RSTC_MR, 0x08
.equ RSTC_SETUP, 1
.equ RSTC_MR_Val, 0xa5000001 /* Enable user reset */
/* Advanced interrupt controller */
.equ AIC_SETUP, 1
.equ AIC_BASE, 0xfffff000
.equ AIC_EOICR, 0x130
.equ AIC_SPU, 0x134
#if (defined(VECTORS_IN_RAM) && defined(ROM_RUN)) || defined(USE_SAMBA)
/*
Exception Vectors to be placed in RAM - added by mt
-> will be used after remapping in ROM_RUN
-> not needed for RAM_RUN
-> moved to address 0 after remapping
Mapped to Address 0 after remapping in ROM_RUN
Absolute addressing mode must be used.
Dummy Handlers are implemented as infinite loops which can be modified.
VECTORS_IN_RAM defined in makefile/by commandline
*/
.text
.arm
.section .vectram, "ax"
VectorsRAM: LDR PC,Reset_AddrR
LDR PC,Undef_AddrR
LDR PC,SWI_AddrR
LDR PC,PAbt_AddrR
LDR PC,DAbt_AddrR
NOP /* Reserved Vector */
LDR PC,[PC,#-0xF20] /* Vector From AIC_IVR */
LDR PC,[PC,#-0xF20] /* Vector From AIC_FVR */
Reset_AddrR: .word Reset_Handler
Undef_AddrR: .word Undef_HandlerR
SWI_AddrR: .word SWI_HandlerR
PAbt_AddrR: .word PAbt_HandlerR
DAbt_AddrR: .word DAbt_HandlerR
// .word 0xdeadbeef /* Test Reserved Address */
.word 0 /* Reserved Address */
IRQ_AddrR: .word IRQ_HandlerR
FIQ_AddrR: .word FIQ_HandlerR
Undef_HandlerR: B Undef_HandlerR
SWI_HandlerR: B SWI_HandlerR
PAbt_HandlerR: B PAbt_HandlerR
DAbt_HandlerR: B DAbt_HandlerR
IRQ_HandlerR: B IRQ_HandlerR
FIQ_HandlerR: B FIQ_HandlerR
VectorsRAM_end:
#endif /* VECTORS_IN_RAM && ROM_RUN */
#ifndef USE_SAMBA
/*
Exception Vectors
- for ROM_RUN: placed in 0x00000000
- for RAM_RUN: placed at 0x00200000 (on AT91SAM7S64)
- for USE_SAMBA: not used
-> will be used during startup before remapping with target ROM_RUN
-> will be used "always" in code without remapping or with target RAM_RUN
Mapped to Address relative address 0 of .text
Absolute addressing mode must be used.
Dummy Handlers are implemented as infinite loops which can be modified.
*/
.text
.arm
.section .vectrom, "ax"
Vectors: LDR PC,Reset_Addr
LDR PC,Undef_Addr
LDR PC,SWI_Addr
LDR PC,PAbt_Addr
LDR PC,DAbt_Addr
NOP /* Reserved Vector */
// LDR PC,IRQ_Addr
LDR PC,[PC,#-0xF20] /* Vector From AIC_IVR */
// LDR PC,FIQ_Addr
LDR PC,[PC,#-0xF20] /* Vector From AIC_FVR */
Reset_Addr: .word Reset_Handler
Undef_Addr: .word Undef_Handler
SWI_Addr: .word SWI_Handler
PAbt_Addr: .word PAbt_Handler
DAbt_Addr: .word DAbt_Handler
.word 0 /* Reserved Address */
IRQ_Addr: .word IRQ_Handler
FIQ_Addr: .word FIQ_Handler
Undef_Handler: B Undef_Handler
SWI_Handler: B SWI_Handler
PAbt_Handler: B PAbt_Handler
DAbt_Handler: B DAbt_Handler
IRQ_Handler: B IRQ_Handler
FIQ_Handler: B FIQ_Handler
#endif
// Spurious interrupt handler
SPU_Handler:
STMDB SP!, {R0}
LDR R0, =AIC_BASE
STR R0, [R0, #AIC_EOICR]
LDMIA SP!, {R0}
SUBS PC, LR, #4
// Starupt Code must be linked first at Address at which it expects to run.
.text
.arm
.section .init, "ax"
.global _startup
.func _startup
_startup:
// Reset Handler
LDR pc, =Reset_Handler
Reset_Handler:
// Setup EFC
.if EFC_SETUP
LDR R0, =EFC_BASE
LDR R1, =EFC_FMR_Val
STR R1, [R0, #EFC_FMR]
.endif
// Setup WDT
.if WDT_SETUP
LDR R0, =WDT_BASE
LDR R1, =WDT_MR_Val
STR R1, [R0, #WDT_MR]
.endif
// Setup reset controller
.if RSTC_SETUP
LDR R0, =RSTC_BASE
LDR R1, =RSTC_MR_Val
STR R1, [R0, #RSTC_MR]
.endif
// Setup PMC
.if PMC_SETUP
LDR R0, =PMC_BASE
// Setup Main Oscillator
LDR R1, =PMC_MOR_Val
STR R1, [R0, #PMC_MOR]
// Wait until Main Oscillator is stablilized
.if (PMC_MOR_Val & PMC_MOSCEN)
MOSCS_Loop: LDR R2, [R0, #PMC_SR]
ANDS R2, R2, #PMC_MOSCS
BEQ MOSCS_Loop
.endif
// Setup the PLL
.if (PMC_PLLR_Val & PMC_MUL)
LDR R1, =PMC_PLLR_Val
STR R1, [R0, #PMC_PLLR]
// Wait until PLL is stabilized
PLL_Loop: LDR R2, [R0, #PMC_SR]
ANDS R2, R2, #PMC_LOCK
BEQ PLL_Loop
.endif
// Select Clock
LDR R1, =PMC_MCKR_Val
STR R1, [R0, #PMC_MCKR]
.endif
// Setup Stack for each mode
LDR R0, =Top_Stack
// Enter Undefined Instruction Mode and set its Stack Pointer
MSR CPSR_c, #Mode_UND|I_Bit|F_Bit
LDR SP, =UND_Stack_End
// Enter Abort Mode and set its Stack Pointer
MSR CPSR_c, #Mode_ABT|I_Bit|F_Bit
LDR SP, =ABT_Stack_End
// Enter FIQ Mode and set its Stack Pointer
MSR CPSR_c, #Mode_FIQ|I_Bit|F_Bit
LDR SP, =FIQ_Stack_End
// Enter IRQ Mode and set its Stack Pointer
MSR CPSR_c, #Mode_IRQ|I_Bit|F_Bit
LDR SP, =IRQ_Stack_End
// Enter Supervisor Mode and set its Stack Pointer
MSR CPSR_c, #Mode_SVC|I_Bit|F_Bit
LDR SP, =SVC_Stack_End
// Enter User Mode and set its Stack Pointer
#ifdef RUN_AS_SYSTEM
MSR CPSR_c, #Mode_SYS
#else
MSR CPSR_c, #Mode_USR
#endif
LDR SP, =USR_Stack_End
// Setup a default Stack Limit (when compiled with "-mapcs-stack-check")
LDR SL, =USR_Stack_End
#ifdef ROM_RUN
// Relocate .data section (Copy from ROM to RAM)
LDR R1, =_etext
LDR R2, =_data
LDR R3, =_edata
LoopRel: CMP R2, R3
LDRLO R0, [R1], #4
STRLO R0, [R2], #4
BLO LoopRel
#endif
// Clear .bss section (Zero init)
MOV R0, #0
LDR R1, =__bss_start__
LDR R2, =__bss_end__
LoopZI: CMP R1, R2
STRLO R0, [R1], #4
BLO LoopZI
#if defined(VECTORS_IN_RAM) || defined(RAM_RUN)
/*
*** Remap ***
ROM_RUN: exception vectors for RAM have been already copied
to 0x00200000 by the .data copy-loop
RAM_RUN: exception vectors are already placed at 0x0020000 by
linker settings
*/
.equ MC_BASE,0xFFFFFF00 /* MC Base Address */
.equ MC_RCR, 0x00 /* MC_RCR Offset */
LDR R0, =MC_BASE
MOV R1, #1
STR R1, [R0, #MC_RCR] // Remap
#endif /* VECTORS_IN_RAM || RAM_RUN */
#ifdef USE_SAMBA
// Copy interrupt vectors to RAM, that has previously been mapped to 0
MOV R1, #0
LDR R2, = VectorsRAM
LDR R3, = VectorsRAM_end
LoopVectCopy: CMP R2, R3
LDRLO R0, [R2], #4
STRLO R0, [R1], #4
BLO LoopVectCopy
#endif
.if AIC_SETUP
LDR R1, =AIC_BASE
LDR R0, = SPU_Handler
STR R0, [R1, #AIC_SPU]
.endif
/*
Call C++ constructors (for objects in "global scope")
added by Martin Thomas based on a Anglia Design
example-application for STR7 ARM
*/
LDR r0, =__ctors_start__
LDR r1, =__ctors_end__
ctor_loop:
CMP r0, r1
BEQ ctor_end
LDR r2, [r0], #4 /* this ctor's address */
STMFD sp!, {r0-r1} /* save loop counters */
MOV lr, pc /* set return address */
// MOV pc, r2
BX r2 /* call ctor */
LDMFD sp!, {r0-r1} /* restore loop counters */
B ctor_loop
ctor_end:
// Enter the C code
mov r0,#0 // no arguments (argc = 0)
mov r1,r0
mov r2,r0
mov fp,r0 // null frame pointer
mov r7,r0 // null frame pointer for thumb
ldr r10,=main
adr lr, __main_exit
bx r10 // enter main()
__main_exit: B __main_exit
.size _startup, . - _startup
.endfunc
.end

100
cpu/at91sam7s/sys-interrupt.c
View file

@ -1,100 +0,0 @@
#include <sys-interrupt.h>
#include <interrupt-utils.h>
#include <AT91SAM7S64.h>
#define ATTR
#ifndef NULL
#define NULL 0
#endif
static SystemInterruptHandler *handlers = NULL;
static void
system_int_safe (void) __attribute__((noinline));
static void
system_int_safe (void)
{
SystemInterruptHandler *h;
h = handlers;
while (h) {
if (h->handler()) break;
h = h->next;
}
}
static void NACKEDFUNC ATTR
system_int (void) /* System Interrupt Handler */
{
ISR_ENTRY();
system_int_safe();
*AT91C_AIC_EOICR = 0; /* End of Interrupt */
ISR_EXIT();
}
static unsigned int enabled = 0; /* Number of times the system
interrupt has been enabled */
#define DIS_INT *AT91C_AIC_IDCR = (1 << AT91C_ID_SYS)
#define EN_INT if (enabled > 0) *AT91C_AIC_IECR = (1 << AT91C_ID_SYS)
void
sys_interrupt_enable()
{
if (enabled++ == 0) {
/* Level trigged at priority 5 */
AT91C_AIC_SMR[AT91C_ID_SYS] = AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL | 5;
/* Interrupt vector */
AT91C_AIC_SVR[AT91C_ID_SYS] = (unsigned long) system_int;
/* Enable */
EN_INT;
}
}
void
sys_interrupt_disable()
{
if (--enabled == 0) {
DIS_INT;
}
}
void
sys_interrupt_append_handler(SystemInterruptHandler *handler)
{
SystemInterruptHandler **h = &handlers;
while(*h) {
h = &(*h)->next;
}
DIS_INT;
*h = handler;
handler->next = NULL;
EN_INT;
}
void
sys_interrupt_prepend_handler(SystemInterruptHandler *handler)
{
DIS_INT;
handler->next = handlers;
handlers = handler;
EN_INT;
}
void
sys_interrupt_remove_handler(SystemInterruptHandler *handler)
{
SystemInterruptHandler **h = &handlers;
while(*h) {
if (*h == handler) {
DIS_INT;
*h = handler->next;
EN_INT;
break;
}
h = &(*h)->next;
}
}

31
cpu/at91sam7s/sys-interrupt.h
View file

@ -1,31 +0,0 @@
#ifndef __SYS_INTERRUPT_H__QIHZ66NP8K__
#define __SYS_INTERRUPT_H__QIHZ66NP8K__
/* Returns true if it handled an activbe interrupt */
typedef int (*SystemInterruptFunc)();
typedef struct _SystemInterruptHandler SystemInterruptHandler;
struct _SystemInterruptHandler
{
SystemInterruptHandler *next;
SystemInterruptFunc handler;
};
void
sys_interrupt_enable();
void
sys_interrupt_disable();
void
sys_interrupt_append_handler(SystemInterruptHandler *handler);
void
sys_interrupt_prepend_handler(SystemInterruptHandler *handler);
void
sys_interrupt_remove_handler(SystemInterruptHandler *handler);
#endif /* __SYS_INTERRUPT_H__QIHZ66NP8K__ */

6
cpu/at91sam7s/uip-log.c
View file

@ -1,6 +0,0 @@
#include <stdio.h>
void uip_log(char *msg)
{
printf("uip: %s\n", msg);
}

83
cpu/at91sam7s/usb/cdc-acm.c
View file

@ -1,83 +0,0 @@
#include <cdc-acm.h>
#include <cdc.h>
#include <usb-proto.h>
#include <stdio.h>
static unsigned int
handle_cdc_acm_requests()
{
printf("CDC request %02x %02x\n", usb_setup_buffer.bmRequestType, usb_setup_buffer.bRequest);
switch(usb_setup_buffer.bmRequestType) {
case 0x21: /* CDC interface OUT requests */
/* Check if it's the right interface */
if (usb_setup_buffer.wIndex != 0) return 0;
switch(usb_setup_buffer.bRequest) {
case SET_CONTROL_LINE_STATE:
if (usb_setup_buffer.wValue & 0x02) {
puts("Carrier on");
} else {
puts("Carrier off");
}
if (usb_setup_buffer.wValue & 0x01) {
puts("DTE on");
} else {
puts("DTE off");
}
usb_send_ctrl_status();
return 1;
case SEND_ENCAPSULATED_COMMAND:
printf("Got CDC command: length %d\n", usb_ctrl_data_len);
usb_send_ctrl_status();
return 1;
case SET_LINE_CODING:
if (usb_ctrl_data_len == 7) {
static const char parity_char[] = {'N', 'O', 'E', 'M', 'S'};
static const char *stop_bits_str[] = {"1","1.5","2"};
const struct usb_cdc_line_coding *coding =
(const struct usb_cdc_line_coding *)usb_ctrl_data_buffer;
char parity = ((coding->bParityType > 4)
? '?' : parity_char[coding->bParityType]);
const char *stop_bits = ((coding->bCharFormat > 2)
? "?" : stop_bits_str[coding->bCharFormat]);
printf("Got CDC line coding: %ld/%d/%c/%s\n",
coding->dwDTERate, coding->bDataBits, parity, stop_bits);
usb_send_ctrl_status();
} else {
return 0;
}
return 1;
}
break;
case 0xa1: /* CDC interface IN requests */
if (usb_setup_buffer.wIndex != 0) return 0;
switch(usb_setup_buffer.bRequest) {
case GET_ENCAPSULATED_RESPONSE:
printf("CDC response");
usb_send_ctrl_status();
return 1;
}
}
return 0;
}
static const struct USBRequestHandler cdc_acm_request_handler =
{
0x21, 0x7f,
0x00, 0x00,
handle_cdc_acm_requests
};
static struct USBRequestHandlerHook cdc_acm_request_hook =
{
NULL,
&cdc_acm_request_handler
};
void
usb_cdc_acm_setup()
{
usb_register_request_handler(&cdc_acm_request_hook);
}

7
cpu/at91sam7s/usb/cdc-acm.h
View file

@ -1,7 +0,0 @@
#ifndef __CDC_ACM_H__UFV6K50827__
#define __CDC_ACM_H__UFV6K50827__
void
usb_cdc_acm_setup();
#endif /* __CDC_ACM_H__UFV6K50827__ */

202
cpu/at91sam7s/usb/cdc.h
View file

@ -1,202 +0,0 @@
#ifndef __CDC_H__K1Q26ESJOC__
#define __CDC_H__K1Q26ESJOC__
#include <usb.h>
/* Communication Class */
/* Class code */
#define CDC 0x02
/* Interface subclass codes */
#define CDC_RESERVED 0x00
#define DIRECT_LINE_CONTROL_MODEL 0x01
#define ABSTRACT_CONTROL_MODEL 0x02
#define TELEPHONE_CONTROL_MODEL 0x03
#define MULTI_CHANNEL_CONTROL_MODEL 0x04
#define CAPI_CONTROL_MODEL 0x05
#define ETHERNET_NETWORKING_CONTROL_MODEL 0x06
#define ATM_NETWORKING_CONTROL_MODEL 0x07
/* Protocols */
#define V_25TER_PROTOCOL 0x01
/* Requests */
#define SEND_ENCAPSULATED_COMMAND 0x00
#define GET_ENCAPSULATED_RESPONSE 0x01
#define SET_COMM_FEATURE 0x02
#define GET_COMM_FEATURE 0x03
#define CLEAR_COMM_FEATURE 0x04
#define SET_AUX_LINE_STATE 0x10
#define SET_HOOK_STATE 0x11
#define PULSE_SETUP 0x12
#define SEND_PULSE 0x13
#define SET_PULSE_TIME 0x14
#define RING_AUX_JACK 0x15
#define SET_LINE_CODING 0x20
#define GET_LINE_CODING 0x21
#define SET_CONTROL_LINE_STATE 0x22
#define SEND_BREAK 0x23
#define SET_RINGER_PARMS 0x30
#define GET_RINGER_PARMS 0x31
#define SET_OPERATION_PARMS 0x32
#define GET_OPERATION_PARMS 0x33
#define SET_LINE_PARMS 0x34
#define GET_LINE_PARMS 0x35
#define DIAL_DIGITS 0x36
#define SET_UNIT_PARAMETER 0x37
#define GET_UNIT_PARAMETER 0x38
#define CLEAR_UNIT_PARAMETER 0x39
#define GET_PROFILE 0x3a
#define SET_ETHERNET_MULTICAST_FILTERS 0x40
#define GET_ETHERNET_MULTICAST_FILTERS 0x41
#define GET_ETHERNET_POWER_MANAGEMENT_PATTERN_FILTER 0x42
#define SET_ETHERNET_POWER_MANAGEMENT_PATTERN_FILTER 0x43
#define GET_ETHERNET_STATISTIC 0x44
#define SET_ATM_D ATA_FORMAT 0x50
#define GET_ATM_DEVICE_STATISTICS 0x51
#define SET_ATM_DEFAULT_VC 0x52
#define GET_ATM_VC_STATISTICS 0x53
/* Notifications */
#define NETWORK_CONNECTION 0x00
#define RESPONSE_AVAILABLE 0x01
#define AUX_JACK_HOOK_STATE 0x08
#define RING_DETECT 0x09
#define SERIAL_STATE 0x20
#define CALL_STATE_CHANGE 0x28
#define LINE_STATE_CHANGE 0x29
#define CONNECTION_SPEED_CHANGE 0x2a
/* Data interface */
/* Class code */
#define CDC_DATA 0x0a
/* Protocols */
#define I_430_PROTOCOL 0x30
#define ISO_IEC_3_1993_PROTOCOL 0x31
#define TRANSPARENT_PROTOCOL 0x32
#define Q_921M_PROTOCOL 0x50
#define Q_921_PROTOCOL 0x51
#define Q_921TM_PROTOCOL 0x52
#define V_42BIS_PROTOCOL 0x90
#define Q_931_PROTOCOL 0x91
#define V_120_PROTOCOL 0x93
#define CDC_PROTOCOL 0xfe
/* Descriptor subtypes */
#define CDC_FUNC_DESCR_HEADER 0x00
#define CDC_FUNC_DESCR_CALL_MGMNT 0x01
#define CDC_FUNC_DESCR_ABSTRACT_CTRL_MGMNT 0x02
#define CDC_FUNC_DESCR_DIRECT_LINE_MGMNT 0x03
#define CDC_FUNC_DESCR_RINGER_MGMNT 0x04
#define CDC_FUNC_DESCR_TEL_STATE 0x05
#define CDC_FUNC_DESCR_UNION 0x06
#define CDC_FUNC_DESCR_COUNTRY 0x07
#define CDC_FUNC_DESCR_TEL_MODE 0x08
#define CDC_FUNC_DESCR_USB_TERM 0x09
#define CDC_FUNC_DESCR_NET_TERM 0x0a
#define CDC_FUNC_DESCR_PROTOCOL_UNIT 0x0b
#define CDC_FUNC_DESCR_EXTENSION_UNIT 0x0c
#define CDC_FUNC_DESCR_MULTICH_MGMNT 0x0d
#define CDC_FUNC_DESCR_CAPI_MGMNT 0x0e
#define CDC_FUNC_DESCR_ETHERNET 0x0f
#define CDC_FUNC_DESCR_ATM 0x10
struct usb_cdc_header_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_HEADER subtype */
Uint16 bcdCDC; /* Revision of class specification */
} BYTE_ALIGNED;
struct usb_cdc_call_mgmnt_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_CALL_MGMNT subtype */
Uchar bmCapabilities; /* Capabilities */
Uchar bDataInterface; /* Management data interface */
} BYTE_ALIGNED;
struct usb_cdc_abstract_ctrl_mgmnt_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_ABSTRACT_CTRL_MGMNT subtype*/
Uchar bmCapabilities; /* Capabilities */
} BYTE_ALIGNED;
struct usb_cdc_direct_line_mgmnt_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_DIRECT_LINE_MGMNT subtype*/
Uchar bmCapabilities; /* Capabilities */
} BYTE_ALIGNED;
struct usb_cdc_ringer_mgmnt_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_RINGER_MGMNT subtype*/
Uchar bRingerVolSteps; /* Ringer volume steps */
Uchar bNumRingerPatterns; /* Number of ringer patterns supported */
} BYTE_ALIGNED;
struct usb_cdc_tel_mode_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_TEL_MODE subtype*/
Uchar bmCapabilities; /* Capabilities */
} BYTE_ALIGNED;
struct usb_cdc_tel_state_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_TEL_STATE subtype*/
Uchar bmCapabilities; /* Capabilities */
} BYTE_ALIGNED;
struct usb_cdc_union_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_UNION subtype*/
Uchar bMasterInterface; /* Master interface for union */
Uchar bSlaveInterface[1]; /* Slave interfaces in union */
} BYTE_ALIGNED;
struct usb_cdc_country_func_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* CS_INTERFACE descriptor type */
Uchar bDescriptorSubtype; /* CDC_FUNC_DESCR_COUNTRY subtype*/
Uchar iCountryCodeRelDate; /* Release date for country codes */
Uint16 wCountryCode[1]; /* Country codes */
} BYTE_ALIGNED;
struct usb_cdc_line_coding
{
Uint32 dwDTERate;
Uchar bCharFormat;
Uchar bParityType;
Uchar bDataBits;
} BYTE_ALIGNED;
#endif /* __CDC_H__K1Q26ESJOC__ */

124
cpu/at91sam7s/usb/descriptors.c
View file

@ -1,124 +0,0 @@
#include "descriptors.h"
#include <cdc.h>
const struct usb_st_device_descriptor device_descriptor =
{
sizeof(struct usb_st_device_descriptor),
DEVICE,
0x0210,
CDC,
0,
0,
CTRL_EP_SIZE,
0xffff,
0xffff,
0x0030,
2,
1,
3,
1
};
const struct configuration_st {
struct usb_st_configuration_descriptor configuration;
struct usb_st_interface_descriptor comm;
struct usb_cdc_header_func_descriptor header;
struct usb_cdc_abstract_ctrl_mgmnt_func_descriptor abstract_ctrl;
struct usb_cdc_union_func_descriptor union_descr;
struct usb_cdc_call_mgmnt_func_descriptor call_mgmt;
#if 1
struct usb_st_endpoint_descriptor ep_notification;
#endif
struct usb_st_interface_descriptor data;
struct usb_st_endpoint_descriptor ep_in;
struct usb_st_endpoint_descriptor ep_out;
} BYTE_ALIGNED configuration_block =
{
/* Configuration */
{
sizeof(configuration_block.configuration),
CONFIGURATION,
sizeof(configuration_block),
2,
1,
0,
0x80,
50
},
{
sizeof(configuration_block.comm),
INTERFACE,
0,
0,
1,
CDC,
ABSTRACT_CONTROL_MODEL,
V_25TER_PROTOCOL,
0
},
{
sizeof(configuration_block.header),
CS_INTERFACE,
CDC_FUNC_DESCR_HEADER,
0x0110
},
{
sizeof(configuration_block.abstract_ctrl),
CS_INTERFACE,
CDC_FUNC_DESCR_ABSTRACT_CTRL_MGMNT,
0
},
{
sizeof(configuration_block.union_descr),
CS_INTERFACE,
CDC_FUNC_DESCR_UNION,
0, /* Master */
{1} /* Slave */
},
{
sizeof(configuration_block.call_mgmt),
CS_INTERFACE,
CDC_FUNC_DESCR_CALL_MGMNT,
0x02,
1 /* data interface */
},
{
sizeof(configuration_block.ep_notification),
ENDPOINT,
0x83,
0x03,
8,
100
},
{
sizeof(configuration_block.data),
INTERFACE,
1,
0,
2,
CDC_DATA,
0,
TRANSPARENT_PROTOCOL,
0
},
{
sizeof(configuration_block.ep_in),
ENDPOINT,
0x81,
0x02,
64,
0
},
{
sizeof(configuration_block.ep_out),
ENDPOINT,
0x02,
0x02,
64,
0
}
};
const struct usb_st_configuration_descriptor const *configuration_head =
(struct usb_st_configuration_descriptor const*)&configuration_block;

9
cpu/at91sam7s/usb/descriptors.h
View file

@ -1,9 +0,0 @@
#ifndef __DESCRIPTORS_H__RPFUB8O7OV__
#define __DESCRIPTORS_H__RPFUB8O7OV__
#include "usb.h"
#include <usb-config.h>
extern const struct usb_st_device_descriptor device_descriptor;
extern const struct usb_st_configuration_descriptor const *configuration_head;
#endif /* __DESCRIPTORS_H__RPFUB8O7OV__ */

49
cpu/at91sam7s/usb/string-descriptors.c
View file

@ -1,49 +0,0 @@
#include "string-descriptors.h"
static const struct {
struct usb_st_string_descriptor base;
Uint16 chars[15];
} string_descriptor_1_en= {{34, 3, {'S'}}, {
'e', 'r', 'i', 'a', 'l', ' ', 'i', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e'}};
static const struct {
struct usb_st_string_descriptor base;
Uint16 chars[8];
} string_descriptor_1_sv= {{20, 3, {'S'}}, {
'e', 'r', 'i', 'e', 'p', 'o', 'r', 't'}};
static const struct {
struct usb_st_string_descriptor base;
Uint16 chars[8];
} string_descriptor_2_all= {{20, 3, {'F'}}, {
'l', 'u', 'f', 'f', 'w', 'a', 'r', 'e'}};
static const struct {
struct usb_st_string_descriptor base;
Uint16 chars[3];
} string_descriptor_3_all= {{10, 3, {'0'}}, {
'.', '0', '1'}};
static const struct usb_st_string_descriptor * string_table_en[] =
{
&string_descriptor_1_en.base,
&string_descriptor_2_all.base,
&string_descriptor_3_all.base,
};
static const struct usb_st_string_descriptor * string_table_sv[] =
{
&string_descriptor_1_sv.base,
&string_descriptor_2_all.base,
&string_descriptor_3_all.base,
};
static const struct {
struct usb_st_language_descriptor base;
Uint16 langs[1];
} language_descriptor =
{
{6, 3, {0x0409}},
{0x041d, }};
static const struct {
struct usb_st_string_languages base;
struct usb_st_string_language_map map[1];
} string_languages_full={{2, 3, &language_descriptor.base,
{{0x0409, string_table_en}}}, {
{0x041d, string_table_sv},
}
};
const struct usb_st_string_languages * const string_languages = &string_languages_full.base;

15
cpu/at91sam7s/usb/string-descriptors.dtd
View file

@ -1,15 +0,0 @@
<?xml version="1.0" encoding="utf-8" ?>
<!ELEMENT descriptors (languages, strings)>
<!ELEMENT languages (lang+) >
<!ELEMENT lang (#PCDATA) >
<!ATTLIST lang
id CDATA "all"
>
<!ELEMENT strings (string+) >
<!ELEMENT string (lang+) >

16
cpu/at91sam7s/usb/string-descriptors.h
View file

@ -1,16 +0,0 @@
#include "usb.h"
struct usb_st_string_language_map
{
Uint16 lang_id;
const struct usb_st_string_descriptor * const *descriptors;
};
struct usb_st_string_languages
{
Uchar num_lang;
Uchar max_index;
const struct usb_st_language_descriptor *lang_descr;
const struct usb_st_string_language_map map[1];
};
extern const struct usb_st_string_languages * const string_languages;

19
cpu/at91sam7s/usb/string-descriptors.xml
View file

@ -1,19 +0,0 @@
<?xml version="1.0" encoding="utf-8" ?>
<descriptors>
<languages>
<lang id="en">0x0409</lang>
<lang id="sv">0x041d</lang>
</languages>
<strings>
<string> <!-- 1 -->
<lang id="en">Serial interface</lang>
<lang id="sv">Serieport</lang>
</string>
<string> <!-- 2 -->
<lang>Fluffware</lang>
</string>
<string> <!-- 3 -->
<lang>0.01</lang>
</string>
</strings>
</descriptors>

129
cpu/at91sam7s/usb/string-descriptors.xslt
View file

@ -1,129 +0,0 @@
<?xml version="1.0" encoding="utf-8" ?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
<xsl:output method="text" encoding="iso-8859-1"/>
<xsl:template match="descriptors">
<xsl:variable name="num_lang" select="count(languages/lang)"/>
<xsl:text>#include "string-descriptors.h"&#10;</xsl:text>
<!-- string descriptors -->
<xsl:for-each select="strings/string/lang">
<xsl:text>static const struct {&#10;</xsl:text>
<xsl:text> struct usb_st_string_descriptor base;&#10;</xsl:text>
<xsl:text> Uint16 chars[</xsl:text>
<xsl:value-of select="string-length(text()) -1"/>
<xsl:text>];&#10;</xsl:text>
<xsl:text>} string_descriptor_</xsl:text>
<xsl:number count="/descriptors/strings/string" format="1"/>
<xsl:text>_</xsl:text>
<xsl:choose>
<xsl:when test="@id">
<xsl:value-of select="@id"/>
</xsl:when>
<xsl:otherwise>
<xsl:text>all</xsl:text>
</xsl:otherwise>
</xsl:choose>
<xsl:text>= {{</xsl:text>
<xsl:value-of select="string-length(text())*2 + 2"/>
<xsl:text>, 3, {'</xsl:text>
<xsl:value-of select="substring(text(), 1,1)"/>
<xsl:text>'}}, {&#10;</xsl:text>
<xsl:call-template name="output-UCS2">
<xsl:with-param name="string" select="substring(text(), 2)"/>
</xsl:call-template>
<xsl:text>}};&#10;</xsl:text>
</xsl:for-each>
<!-- string tables -->
<xsl:for-each select="/descriptors/languages/lang">
<xsl:variable name="id" select="@id"/>
<xsl:text>static const struct usb_st_string_descriptor * string_table_</xsl:text>
<xsl:value-of select="$id"/>
<xsl:text>[] =&#10;{&#10;</xsl:text>
<xsl:for-each select="/descriptors/strings/string">
<xsl:text> &amp;string_descriptor_</xsl:text>
<xsl:number count="/descriptors/strings/string" format="1"/>
<xsl:text>_</xsl:text>
<xsl:choose>
<xsl:when test="lang[@id = $id]">
<xsl:value-of select="$id"/>
</xsl:when>
<xsl:when test="lang[@id = 'all' or count(@id) = 0]">
<xsl:text>all</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:message terminate="yes">
<xsl:text>No string found for index </xsl:text>
<xsl:number count="/descriptors/strings/string" format="1"/>
<xsl:text> and language </xsl:text>
<xsl:value-of select="$id"/>
</xsl:message>
</xsl:otherwise>
</xsl:choose>
<xsl:text>.base,&#10;</xsl:text>
</xsl:for-each>
<xsl:text>};&#10;</xsl:text>
</xsl:for-each>
<!-- language descriptor -->
<xsl:text>static const struct {&#10;</xsl:text>
<xsl:text> struct usb_st_language_descriptor base;&#10;</xsl:text>
<xsl:text> Uint16 langs[</xsl:text>
<xsl:value-of select="$num_lang -1"/>
<xsl:text>];&#10;</xsl:text>
<xsl:text>} language_descriptor =&#10;{&#10;</xsl:text>
<xsl:text> {</xsl:text>
<xsl:value-of select="$num_lang*2 + 2"/>
<xsl:text>, 3, {</xsl:text>
<xsl:value-of select="languages/lang[1]/text()"/>
<xsl:text>}},&#10; {</xsl:text>
<xsl:for-each select="languages/lang[position() > 1]">
<xsl:value-of select="text()"/>
<xsl:text>, </xsl:text>
</xsl:for-each>
<xsl:text>}};&#10;</xsl:text>
<!-- language lookup table -->
<xsl:text>static const struct {&#10;</xsl:text>
<xsl:text> struct usb_st_string_languages base;&#10;</xsl:text>
<xsl:text> struct usb_st_string_language_map map[</xsl:text>
<xsl:value-of select="$num_lang - 1"/>
<xsl:text>];&#10;} </xsl:text>
<xsl:text>string_languages_full={{</xsl:text>
<xsl:value-of select="$num_lang"/>
<xsl:text>, </xsl:text>
<xsl:value-of select="count(strings/string)"/>
<xsl:text>, &amp;language_descriptor.base</xsl:text>
<xsl:text>, &#10; {{</xsl:text>
<xsl:value-of select="languages/lang[1]/text()"/>
<xsl:text>, string_table_</xsl:text>
<xsl:value-of select="languages/lang[1]/@id"/>
<xsl:text>}}}, {&#10;</xsl:text>
<xsl:for-each select="languages/lang[position() > 1]">
<xsl:text> {</xsl:text>
<xsl:value-of select="text()"/>
<xsl:text>, string_table_</xsl:text>
<xsl:value-of select="@id"/>
<xsl:text>},&#10;</xsl:text>
</xsl:for-each>
<xsl:text> }&#10;};&#10;</xsl:text>
<xsl:text>const struct usb_st_string_languages * const string_languages = &amp;string_languages_full.base;&#10;</xsl:text>
</xsl:template>
<xsl:template name="output-UCS2">
<xsl:param name="string"/>
<xsl:if test="string-length($string) &gt; 0">
<xsl:text>'</xsl:text>
<xsl:value-of select="substring($string, 1,1)"/>
<xsl:text>'</xsl:text>
<xsl:if test="string-length($string) &gt; 1">
<xsl:text>, </xsl:text>
</xsl:if>
<xsl:call-template name="output-UCS2">
<xsl:with-param name="string" select="substring($string, 2)"/>
</xsl:call-template>
</xsl:if>
</xsl:template>
</xsl:stylesheet>

60
cpu/at91sam7s/usb/usb-api.h
View file

@ -1,60 +0,0 @@
#ifndef __USB_API_H__SYN81IFYBN__
#define __USB_API_H__SYN81IFYBN__
#include <sys/process.h>
void
usb_setup(void);
void
usb_set_user_process(struct process *p);
void
usb_setup_bulk_endpoint(unsigned char addr,
unsigned char *buffer, unsigned int buf_size);
void
usb_setup_interrupt_endpoint(unsigned char addr,
unsigned char *buffer, unsigned int buf_size);
/* Get a pointer to a buffer dat of length lenp.
To which USB data can be written. */
void
usb_send_buffer_get(unsigned char ep_addr, unsigned int offset,
unsigned char **dat, unsigned int *lenp);
/* Notify the USB subsystem that data has been written to the buffer returned
by usb_send_buffer_get. */
void
usb_send_buffer_commit(unsigned char ep_addr, unsigned int len);
unsigned int
usb_send_data(unsigned char ep_addr,
const unsigned char *dat, unsigned int len);
unsigned int
usb_recv_data(unsigned char ep_addr, unsigned char *dat, unsigned int len);
void
usb_disable_endpoint(unsigned char addr);
/* Asynchronous */
#define USB_USER_MSG_TYPE_CONFIG 0x01
#define USB_USER_MSG_TYPE_SUSPEND 0x02
#define USB_USER_MSG_TYPE_RESUME 0x03
/* Synchronous, the supplied data is only valid during the event */
#define USB_USER_MSG_TYPE_EP_OUT(ep_addr) ((((ep_addr) & 0x7f)<<4) | 0x01)
#define USB_USER_MSG_TYPE_EP_IN(ep_addr) ((((ep_addr) & 0x7f)<<4) | 0x02)
struct usb_user_msg {
unsigned int type;
union {
/* For EPx_OUT */
unsigned short length;
/* For CONFIG */
unsigned char config;
} data;
};
#endif /* __USB_API_H__SYN81IFYBN__ */

16
cpu/at91sam7s/usb/usb-config.h
View file

@ -1,16 +0,0 @@
#ifndef __USB_CONFIG_H__LEIURX7H18__
#define __USB_CONFIG_H__LEIURX7H18__
#ifndef CTRL_EP_SIZE
#define CTRL_EP_SIZE 8
#endif
#ifndef NON_CTRL_XFER_SIZE
#define NON_CTRL_XFER_SIZE 64
#endif
#ifndef MAX_CTRL_DATA
#define MAX_CTRL_DATA 128
#endif
#endif /* __USB_CONFIG_H__LEIURX7H18__ */

424
cpu/at91sam7s/usb/usb-handler.c
View file

@ -1,424 +0,0 @@
#include <AT91SAM7S64.h>
#include <interrupt-utils.h>
#include <usb-interrupt.h>
#include <usb-proto.h>
#include <usb-api.h>
#include <stdio.h>
#include <sys/process.h>
#include <stdio.h>
#include <descriptors.h>
#include <string-descriptors.h>
#define USB_PULLUP_PIN AT91C_PIO_PA16
static unsigned short usb_device_status;
static unsigned char usb_configuration_value;
static struct process * user_process = NULL;
static struct USBRequestHandlerHook *usb_request_handler_hooks = NULL;
static const unsigned char zero_byte = 0;
static const unsigned short zero_word = 0;
static void
notify_user(struct usb_user_msg* msg)
{
if (user_process) {
process_post(user_process, PROCESS_EVENT_MSG, msg);
}
}
void
usb_set_user_process(struct process *p)
{
user_process = p;
}
static void
get_device_descriptor()
{
usb_send_ctrl_response((unsigned char*)&device_descriptor, sizeof(device_descriptor));
}
static void
get_string_descriptor()
{
if (LOW_BYTE(usb_setup_buffer.wValue) == 0) {
usb_send_ctrl_response((const unsigned char*)string_languages->lang_descr,
string_languages->lang_descr->bLength);
} else {
unsigned char l;
const struct usb_st_string_descriptor *descriptor;
const struct usb_st_string_descriptor * const *table;
const struct usb_st_string_language_map *map;
if (LOW_BYTE(usb_setup_buffer.wValue) > string_languages->max_index) {
usb_error_stall();
return;
}
l = string_languages->num_lang;
map = string_languages->map;
table = map->descriptors; /* Use first table if language not found */
while (l > 0) {
if (map->lang_id == usb_setup_buffer.wIndex) {
table = map->descriptors;
break;
}
map++;
l--;
}
printf("Lang id %04x = table %p\n", usb_setup_buffer.wIndex, (void*)table);
descriptor = table[LOW_BYTE(usb_setup_buffer.wValue) - 1];
usb_send_ctrl_response((const unsigned char*)descriptor,
descriptor->bLength);
}
}
static void
get_configuration_descriptor()
{
usb_send_ctrl_response((unsigned char*)configuration_head,
configuration_head->wTotalLength);
}
static void
get_configuration()
{
usb_send_ctrl_response((unsigned char*)&usb_configuration_value,
sizeof(usb_configuration_value));
}
/* Returns true if the configuration value changed */
static int
set_configuration()
{
if (usb_configuration_value != LOW_BYTE(usb_setup_buffer.wValue)) {
usb_configuration_value = LOW_BYTE(usb_setup_buffer.wValue);
if (usb_configuration_value > 0) {
*AT91C_UDP_GLBSTATE |= AT91C_UDP_CONFG;
} else {
*AT91C_UDP_GLBSTATE &= ~AT91C_UDP_CONFG;
}
usb_send_ctrl_status();
return 1;
} else {
usb_send_ctrl_status();
return 0;
}
}
static void
get_device_status()
{
puts("get_device_status");
usb_send_ctrl_response((const unsigned char*)&usb_device_status,
sizeof(usb_device_status));
}
static void
get_endpoint_status()
{
puts("get_endpoint_status");
if ((usb_setup_buffer.wIndex & 0x7f) == 0) {
usb_send_ctrl_response((const unsigned char*)&zero_word,
sizeof(zero_word));
} else {
volatile USBEndpoint *ec;
ec = usb_find_endpoint(usb_setup_buffer.wIndex);
if (ec) {
usb_send_ctrl_response((const unsigned char*)&ec->status, sizeof(ec->status));
} else {
usb_error_stall();
}
}
}
static void
get_interface_status()
{
puts("get_interface_status");
usb_send_ctrl_response((const unsigned char*)&zero_word,
sizeof(zero_word));
}
static void
get_interface()
{
puts("get_interface");
if (usb_configuration_value == 0) usb_error_stall();
else {
usb_send_ctrl_response(&zero_byte,
sizeof(zero_byte));
}
}
static struct usb_user_msg config_msg = {USB_USER_MSG_TYPE_CONFIG};
static struct usb_user_msg io_msg[3];
static unsigned int
handle_standard_requests()
{
switch(usb_setup_buffer.bmRequestType) {
case 0x80: /* standard device IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_DESCRIPTOR:
switch (HIGH_BYTE(usb_setup_buffer.wValue)) {
case DEVICE:
get_device_descriptor();
break;
case CONFIGURATION:
get_configuration_descriptor();
break;
case STRING:
get_string_descriptor();
break;
default:
/* Unknown descriptor */
return 0;
}
break;
case GET_CONFIGURATION:
get_configuration();
break;
case GET_STATUS:
get_device_status();
break;
case GET_INTERFACE:
get_interface();
break;
default:
return 0;
}
break;
case 0x81: /* standard interface IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_STATUS:
get_interface_status();
break;
#ifdef HID_ENABLED
case GET_DESCRIPTOR:
switch (USB_setup_buffer.wValue.byte.high) {
case REPORT:
get_report_descriptor();
break;
}
break;
#endif
default:
return 0;
}
break;
case 0x82: /* standard endpoint IN requests */
switch(usb_setup_buffer.bRequest) {
case GET_STATUS:
get_endpoint_status();
break;
default:
return 0;
}
break;
case 0x00: /* standard device OUT requests */
switch(usb_setup_buffer.bRequest) {
case SET_ADDRESS:
printf("Address: %d\n", LOW_BYTE(usb_setup_buffer.wValue));
usb_set_address();
usb_send_ctrl_status();
break;
#if SETABLE_STRING_DESCRIPTORS > 0
case SET_DESCRIPTOR:
if (usb_setup_buffer.wValue.byte.high == STRING) {
set_string_descriptor();
} else {
return 0;
}
break;
#endif
case SET_CONFIGURATION:
if (set_configuration()) {
config_msg.data.config = LOW_BYTE(usb_setup_buffer.wValue);
notify_user(&config_msg);
}
break;
default:
return 0;
}
break;
case 0x02:
switch(usb_setup_buffer.bRequest) {
case SET_FEATURE:
case CLEAR_FEATURE:
if (usb_setup_buffer.wValue == ENDPOINT_HALT_FEATURE) {
volatile USBEndpoint *ep = usb_find_endpoint(usb_setup_buffer.wIndex);
if (ep) {
usb_halt_endpoint(ep->addr, usb_setup_buffer.bRequest== SET_FEATURE);
usb_send_ctrl_status();
} else {
usb_error_stall();
}
} else {
usb_error_stall();
}
break;
default:
return 0;
}
break;
#ifdef HID_ENABLED
case 0xa1: /* class specific interface IN request*/
switch(USB_setup_buffer.bRequest) {
case GET_HID_REPORT:
puts("Get report\n");
send_ctrl_response((code u_int8_t*)&zero_byte,
sizeof(zero_byte));
break;
case GET_HID_IDLE:
puts("Get idle\n");
send_ctrl_response((code u_int8_t*)&zero_byte,
sizeof(zero_byte));
break;
default:
return 0;
}
break;
case 0x21: /* class specific interface OUT request*/
switch(USB_setup_buffer.bRequest) {
case SET_HID_IDLE:
puts("Set idle\n");
send_ctrl_status();
break;
default:
return 0;
}
break;
#endif
default:
return 0;
}
return 1;
}
static const struct USBRequestHandler standard_request_handler =
{
0x00, 0x60,
0x00, 0x00,
handle_standard_requests
};
static struct USBRequestHandlerHook standard_request_hook =
{
NULL,
&standard_request_handler
};
PROCESS(usb_process, "USB process");
PROCESS_THREAD(usb_process, ev , data)
{
PROCESS_BEGIN();
puts("USB process started");
while(1) {
PROCESS_WAIT_EVENT();
if (ev == PROCESS_EVENT_EXIT) break;
if (ev == PROCESS_EVENT_POLL) {
if (usb_events & USB_EVENT_RESET) {
printf("Reset\n");
usb_clear_events(USB_EVENT_RESET);
}
if (usb_events & USB_EVENT_EP(0)) {
/* puts("Endpoint 0"); */
if (usb_endpoint_events[0] & USB_EP_EVENT_SETUP) {
struct USBRequestHandlerHook *hook = usb_request_handler_hooks;
#if 0
puts("Setup");
{
unsigned int i;
for (i = 0; i< 8; i++) printf(" %02x", ((unsigned char*)&usb_setup_buffer)[i]);
putchar('\n');
}
#endif
while(hook) {
const struct USBRequestHandler *handler = hook->handler;
/* Check if the handler matches the request */
if (((handler->request_type ^ usb_setup_buffer.bmRequestType)
& handler->request_type_mask) == 0
&& ((handler->request ^ usb_setup_buffer.bRequest)
& handler->request_mask) == 0) {
if (handler->handler_func()) break;
}
hook = hook->next;
}
if (!hook) {
/* No handler found */
usb_error_stall();
}
usb_clear_ep_events(0, USB_EP_EVENT_SETUP);
}
usb_clear_events(USB_EVENT_EP(0));
}
{
unsigned int e;
for (e = 1; e <= 3; e++) {
if (usb_events & USB_EVENT_EP(e)) {
if (usb_endpoint_events[e] & (USB_EP_EVENT_OUT|USB_EP_EVENT_IN)) {
volatile USBEndpoint *ep = usb_find_endpoint(e);
struct usb_user_msg *msg = &io_msg[e-1];
if (usb_endpoint_events[e] & USB_EP_EVENT_OUT) {
msg->type = USB_USER_MSG_TYPE_EP_OUT(e);
msg->data.length = ep->buf_len;
} else {
msg->type = USB_USER_MSG_TYPE_EP_IN(e);
msg->data.length = ep->buf_size_mask + 1 - ep->buf_len;
}
notify_user(msg);
usb_clear_ep_events(e, USB_EP_EVENT_OUT|USB_EP_EVENT_IN);
usb_clear_events(USB_EVENT_EP(ep->addr));
}
}
}
}
}
}
PROCESS_END();
}
void
usb_setup(void)
{
/* Assume 96MHz PLL frequency */
*AT91C_CKGR_PLLR = ((*AT91C_CKGR_PLLR & ~AT91C_CKGR_USBDIV)
| AT91C_CKGR_USBDIV_1);
/* Enable 48MHz USB clock */
*AT91C_PMC_SCER = AT91C_PMC_UDP;
/* Enable USB main clock */
*AT91C_PMC_PCER = (1 << AT91C_ID_UDP);
/* Enable pullup */
*AT91C_PIOA_PER = USB_PULLUP_PIN;
*AT91C_PIOA_OER = USB_PULLUP_PIN;
*AT91C_PIOA_CODR = USB_PULLUP_PIN;
usb_register_request_handler(&standard_request_hook);
process_start(&usb_process, NULL);
usb_handler_process = &usb_process;
/* Enable usb_interrupt */
AT91C_AIC_SMR[AT91C_ID_UDP] = AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL | 4;
AT91C_AIC_SVR[AT91C_ID_UDP] = (unsigned long) usb_int;
*AT91C_AIC_IECR = (1 << AT91C_ID_UDP);
usb_init_endpoints();
}
void
usb_register_request_handler(struct USBRequestHandlerHook *hook)
{
struct USBRequestHandlerHook **prevp = &usb_request_handler_hooks;
/* Find last hook */
while(*prevp) {
prevp = &(*prevp)->next;
}
/* Add last */
*prevp = hook;
hook->next = NULL;
}

52
cpu/at91sam7s/usb/usb-interrupt.c
View file

@ -1,52 +0,0 @@
#include <AT91SAM7S64.h>
#include <interrupt-utils.h>
#include <usb-interrupt.h>
#include <usb-proto.h>
#include <stdio.h>
static void
usb_int_safe (void) __attribute__((noinline));
static void
usb_int_safe (void)
{
unsigned int int_status;
/* putchar('*'); */
int_status = *AT91C_UDP_ISR & *AT91C_UDP_IMR;
if (int_status & (AT91C_UDP_EP1 | AT91C_UDP_EP2 | AT91C_UDP_EP3)) {
usb_epx_int();
} else if (int_status & AT91C_UDP_ENDBUSRES) {
usb_reset();
*AT91C_UDP_ICR = AT91C_UDP_ENDBUSRES;
} else if (int_status & AT91C_UDP_RXSUSP) {
/* puts("Suspend"); */
*AT91C_UDP_ICR = AT91C_UDP_RXSUSP;
} else if (int_status & AT91C_UDP_RXRSM) {
/* puts("Resume"); */
*AT91C_UDP_ICR = AT91C_UDP_RXRSM;
} else if (int_status & AT91C_UDP_SOFINT) {
/* puts("SOF"); */
*AT91C_UDP_ICR = AT91C_UDP_SOFINT;
} else if (int_status & AT91C_UDP_WAKEUP) {
/* puts("Wakeup"); */
*AT91C_UDP_ICR = AT91C_UDP_WAKEUP;
} else if (int_status & AT91C_UDP_EP0) {
usb_ep0_int();
} else {
puts("Other USB interrupt");
}
/* putchar('<'); */
}
void NACKEDFUNC
usb_int (void)
{
ISR_STORE();
ISR_ENABLE_NEST();
usb_int_safe();
ISR_DISABLE_NEST();
*AT91C_AIC_EOICR = 0;
ISR_RESTORE();
}

7
cpu/at91sam7s/usb/usb-interrupt.h
View file

@ -1,7 +0,0 @@
#ifndef __USB_INTERRUPT_H__Z1DQCUBTAL__
#define __USB_INTERRUPT_H__Z1DQCUBTAL__
void
usb_int (void);
#endif /* __USB_INTERRUPT_H__Z1DQCUBTAL__ */

600
cpu/at91sam7s/usb/usb-proto.c
View file

@ -1,600 +0,0 @@
#include <AT91SAM7S64.h>
#include <usb-api.h>
#include <usb-proto.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/process.h>
#include<interrupt-utils.h>
#ifndef AT91C_UDP_STALLSENT
#define AT91C_UDP_STALLSENT AT91C_UDP_ISOERROR
#endif
/* Bits that won't effect the state if they're written at a specific level.
*/
/* Bits that should be written as 1 */
#define NO_EFFECT_BITS (AT91C_UDP_TXCOMP | AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RXSETUP \
| AT91C_UDP_ISOERROR | AT91C_UDP_RX_DATA_BK1)
/* Also includes bits that should be written as 0 */
#define NO_EFFECT_MASK (NO_EFFECT_BITS | AT91C_UDP_TXPKTRDY)
#define RXBYTECNT(s) (((s)>>16)&0x7ff)
/* Index in endpoint array */
#define EP_INDEX(addr) (((addr) & 0x7f) - 1)
/* Number of hardware endpoint */
#define EP_HW_NUM(addr) ((addr) & 0x7f)
static inline void
udp_set_ep_ctrl_flags(AT91_REG *reg, unsigned int flags,
unsigned int write_mask, unsigned int check_mask)
{
while ( (*reg & check_mask) != (flags & check_mask)) {
*reg = (*reg & ~write_mask) | flags;
}
}
#define UDP_SET_EP_CTRL_FLAGS(reg, flags, mask) \
udp_set_ep_ctrl_flags((reg), \
(NO_EFFECT_BITS & ~(mask)) | ((flags) & (mask)), (mask) | NO_EFFECT_MASK,\
(mask))
void
usb_error_stall()
{
/* Disable all USB events */
*AT91C_AIC_IDCR = (1 << AT91C_ID_UDP);
/* Set stall state */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],
AT91C_UDP_FORCESTALL, AT91C_UDP_FORCESTALL);
/* Reenable interrupt */
*AT91C_AIC_IECR = (1 << AT91C_ID_UDP);
puts("Stalled");
}
volatile unsigned char usb_events = 0;
struct process *usb_handler_process = NULL;
#define NUM_EP 4
volatile unsigned char usb_endpoint_events[NUM_EP] = {0,0,0,0};
static volatile USBEndpoint usb_endpoints[NUM_EP - 1];
volatile unsigned char usb_flags = 0;
#define USB_FLAG_ADDRESS_PENDING 0x01
#define USB_FLAG_RECEIVING_CTRL 0x04
#define USB_FLAG_SEND_ZLP 0x08 /* If the last packet has max length,
then it needs to be followed by a
zero length packet to mark the
end. */
static unsigned short usb_ctrl_send_len = 0;
static const unsigned char *usb_ctrl_send_pos = NULL;
unsigned char usb_ctrl_data_buffer[MAX_CTRL_DATA];
unsigned short usb_ctrl_data_len = 0;
static void
write_endpoint(unsigned int hw_ep,
const unsigned char *buffer, unsigned short len)
{
AT91_REG *fdr = &AT91C_UDP_FDR[hw_ep];
{
#if 0
unsigned int i;
printf("Sending: ");
for (i = 0; i< len; i++) printf(" %02x", buffer[i]);
putchar('\n');
#endif
}
while(len > 0) {
*fdr = *buffer++;
len--;
}
/* Start transmission */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[hw_ep],
AT91C_UDP_TXPKTRDY, AT91C_UDP_TXPKTRDY);
}
static void
write_ctrl()
{
if (usb_ctrl_send_pos) {
unsigned int xfer_len = usb_ctrl_send_len;
/* Check if FIFO is ready */
if (AT91C_UDP_CSR[0] & AT91C_UDP_TXPKTRDY) return;
if (xfer_len > CTRL_EP_SIZE) xfer_len = CTRL_EP_SIZE;
write_endpoint(0, usb_ctrl_send_pos, xfer_len);
if (xfer_len < CTRL_EP_SIZE) {
/* Last packet, stop sending */
usb_ctrl_send_pos = NULL;
} else {
usb_ctrl_send_pos += xfer_len;
usb_ctrl_send_len -= xfer_len;
if (usb_ctrl_send_len == 0 && !(usb_flags & USB_FLAG_SEND_ZLP)) {
usb_ctrl_send_pos = NULL;
}
}
}
}
static unsigned char
read_buffered_endpoint(volatile USBEndpoint *ep)
{
unsigned char len;
unsigned char mask = ep->buf_size_mask;
unsigned char *buffer = ep->buffer;
unsigned char pos = (ep->buf_pos + ep->buf_len) & mask;
AT91_REG *fdr = &AT91C_UDP_FDR[EP_HW_NUM(ep->addr)];
len = RXBYTECNT(AT91C_UDP_CSR[EP_HW_NUM(ep->addr)]);
if (mask + 1 - ep->buf_len < len) return 0;
ep->buf_len += len;
while(len-- > 0) {
buffer[pos] = *fdr;
pos = (pos + 1) & mask;
}
return 1;
}
unsigned int
usb_recv_data(unsigned char ep_addr, unsigned char *dat, unsigned int len)
{
volatile USBEndpoint *ep = &usb_endpoints[EP_INDEX(ep_addr)];
unsigned char mask = ep->buf_size_mask;
*AT91C_UDP_IDR = 1<<EP_HW_NUM(ep_addr);
{
unsigned char l;
unsigned char *to = ep->buffer;
unsigned char pos = ep->buf_pos;
if (ep->buf_len < len) len = ep->buf_len;
ep->buf_len -= len;
l = len;
while(l-- > 0) {
*dat++ = to[pos];
pos = (pos + 1) & mask;
}
ep->buf_pos = pos;
}
ep->flags &= ~USB_EP_FLAGS_RECV_BLOCKED;
*AT91C_UDP_IER = 1<<EP_HW_NUM(ep_addr);
return len;
}
void
write_buffered_endpoint(volatile USBEndpoint *ep)
{
unsigned int irq = disableIRQ();
{
unsigned int pos = ep->buf_pos;
unsigned int xfer_len = ep->buf_len;
unsigned int mask = ep->buf_size_mask;
const unsigned char *buf_tmp = ep->buffer;
AT91_REG *fdr = &AT91C_UDP_FDR[EP_HW_NUM(ep->addr)];
if (!(ep->flags & USB_EP_FLAGS_TRANSMITTING)
&& !(AT91C_UDP_CSR[EP_HW_NUM(ep->addr)] & AT91C_UDP_TXPKTRDY)) {
if (xfer_len > NON_CTRL_XFER_SIZE) xfer_len = NON_CTRL_XFER_SIZE;
ep->buf_len -= xfer_len;
/* printf("Writing %d to 0x%02x\n", xfer_len, ep->addr); */
while(xfer_len > 0) {
*fdr = buf_tmp[pos];
pos = (pos + 1) & mask;
xfer_len--;
}
ep->flags |= USB_EP_FLAGS_TRANSMITTING;
/* Start transmission */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[EP_HW_NUM(ep->addr)],
AT91C_UDP_TXPKTRDY, AT91C_UDP_TXPKTRDY);
ep->buf_pos = pos;
}
}
restoreIRQ(irq);
}
static void
write_send_buffer(unsigned char *buffer, const unsigned char *dat,
unsigned int len)
{
while(len-- > 0) {
*buffer++ = *dat++;
}
}
void
usb_send_buffer_get(unsigned char ep_addr, unsigned int offset,
unsigned char **dat, unsigned int *lenp)
{
unsigned int pos;
volatile USBEndpoint *ep = &usb_endpoints[EP_INDEX(ep_addr)];
unsigned int size = ep->buf_size_mask + 1;
unsigned int len;
*AT91C_UDP_IDR = 1<<EP_HW_NUM(ep_addr);
len = size - ep->buf_len;
pos = (ep->buf_pos + offset + ep->buf_len) & (size - 1);
*AT91C_UDP_IER = 1<<EP_HW_NUM(ep_addr);
if (offset >= len) {
len = 0;
} else {
len -= offset;
}
if (pos + len > size) len = size - pos;
*dat = &ep->buffer[pos];
*lenp = len;
}
void
usb_send_buffer_commit(unsigned char ep_addr, unsigned int len)
{
volatile USBEndpoint *ep = &usb_endpoints[EP_INDEX(ep_addr)];
*AT91C_UDP_IDR = 1<<EP_HW_NUM(ep_addr);
ep->buf_len += len;
write_buffered_endpoint(ep);
*AT91C_UDP_IER = 1<<EP_HW_NUM(ep_addr);
}
unsigned int
usb_send_data(unsigned char ep_addr, const unsigned char *dat, unsigned int len)
{
unsigned char *write_pos;
unsigned int write_len;
unsigned int full_len = len;
/* printf("usb_send_data %02x: IMR=%08x\n",ep_addr, *AT91C_UDP_IMR); */
while(len > 0) {
usb_send_buffer_get(ep_addr, 0, &write_pos, &write_len);
if (write_len == 0) break;
if (write_len > len) write_len = len;
write_send_buffer(write_pos, dat, write_len);
/* printf("Pos: %p, len %d\n", write_pos, write_len); */
usb_send_buffer_commit(ep_addr, write_len);
dat += write_len;
len -= write_len;
}
return full_len - len;
}
void
usb_send_ctrl_response(const unsigned char *buffer, unsigned short len)
{
if (AT91C_UDP_CSR[0] & AT91C_UDP_TXPKTRDY) return;
*AT91C_UDP_IDR = AT91C_UDP_EP0;
if (len >= usb_setup_buffer.wLength) {
len = usb_setup_buffer.wLength; /* Truncate if too long */
usb_flags &= ~USB_FLAG_SEND_ZLP;
} else {
/* Send ZLP if the response is shorter than requested */
usb_flags |= USB_FLAG_SEND_ZLP;
}
usb_ctrl_send_pos = buffer;
usb_ctrl_send_len = len;
write_ctrl();
*AT91C_UDP_IER = AT91C_UDP_EP0;
}
void
usb_send_ctrl_status()
{
*AT91C_UDP_IDR = AT91C_UDP_EP0;
/* Start transmission */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],
AT91C_UDP_TXPKTRDY, AT91C_UDP_TXPKTRDY);
*AT91C_UDP_IER = AT91C_UDP_EP0;
}
static void
notify_process(unsigned char events)
{
usb_events |= events;
if (usb_handler_process) {
process_poll(usb_handler_process);
}
}
void
usb_reset()
{
/* Setup endpoint 0 */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],
AT91C_UDP_EPTYPE_CTRL | AT91C_UDP_EPEDS,
AT91C_UDP_EPTYPE | AT91C_UDP_EPEDS);
/* Enable interrupt for control endpoint */
*AT91C_UDP_IER = AT91C_UDP_EP0;
notify_process(USB_EVENT_RESET);
}
struct USB_request_st usb_setup_buffer;
static void
read_fifo0(unsigned char *buffer, unsigned int length)
{
unsigned int r;
for (r = 0; r < length; r++) {
*buffer++ = AT91C_UDP_FDR[0];
}
}
void
usb_ep0_int()
{
unsigned int status;
status = AT91C_UDP_CSR[0];
#if 0
printf("status: %08x\n", status);
#endif
if (status & AT91C_UDP_STALLSENT) {
/* Acknowledge */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],0, AT91C_UDP_STALLSENT);
}
if (status & AT91C_UDP_RXSETUP) {
usb_ctrl_send_pos = NULL; /* Cancel any pending control data
transmission */
if (RXBYTECNT(status) == 8) {
read_fifo0((unsigned char*)&usb_setup_buffer, 8);
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],
((usb_setup_buffer.bmRequestType & 0x80)
? AT91C_UDP_DIR : 0),
AT91C_UDP_DIR);
usb_ctrl_data_len = 0;
if ((usb_setup_buffer.bmRequestType & 0x80) != 0
|| usb_setup_buffer.wLength == 0) {
usb_endpoint_events[0] |= USB_EP_EVENT_SETUP;
notify_process(USB_EVENT_EP(0));
} else {
if (usb_setup_buffer.wLength > MAX_CTRL_DATA) {
/* stall */
usb_error_stall();
} else {
usb_flags |= USB_FLAG_RECEIVING_CTRL;
}
}
} else {
usb_error_stall();
}
/* Acknowledge SETUP */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],0, AT91C_UDP_RXSETUP);
} else if (status & (AT91C_UDP_RX_DATA_BK1 | AT91C_UDP_RX_DATA_BK0)) {
puts("IN");
if (usb_flags & USB_FLAG_RECEIVING_CTRL) {
unsigned int len;
unsigned int left = MAX_CTRL_DATA - usb_ctrl_data_len;
len = RXBYTECNT(status);
if (len > left) {
/* stall */
usb_error_stall();
} else {
unsigned char *buf_tmp = usb_ctrl_data_buffer + usb_ctrl_data_len;
usb_ctrl_data_len += len;
if (usb_ctrl_data_len == usb_setup_buffer.wLength
|| len < CTRL_EP_SIZE) {
usb_flags &= ~USB_FLAG_RECEIVING_CTRL;
usb_endpoint_events[0] |= USB_EP_EVENT_SETUP;
notify_process(USB_EVENT_EP(0));
}
while(len-- > 0) *buf_tmp++ = AT91C_UDP_FDR[0];
}
} else {
if (RXBYTECNT(status) > 0) {
puts("Discarded input");
}
}
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],0,
AT91C_UDP_RX_DATA_BK1 | AT91C_UDP_RX_DATA_BK0);
}
if (status & AT91C_UDP_TXCOMP) {
/* puts("TX complete"); */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[0],0, AT91C_UDP_TXCOMP);
if (usb_flags & USB_FLAG_ADDRESS_PENDING) {
*AT91C_UDP_FADDR = AT91C_UDP_FEN | LOW_BYTE(usb_setup_buffer.wValue);
*AT91C_UDP_GLBSTATE |= AT91C_UDP_FADDEN;
usb_flags &= ~USB_FLAG_ADDRESS_PENDING;
printf("Address changed: %d\n", *AT91C_UDP_FADDR & 0x7f);
} else {
if(usb_ctrl_send_pos) {
write_ctrl();
}
}
}
}
void
usb_epx_int()
{
unsigned int ep_index;
/* Handle enabled interrupts */
unsigned int int_status = *AT91C_UDP_ISR & *AT91C_UDP_IMR;
for (ep_index = 0; ep_index < NUM_EP-1; ep_index++) {
volatile USBEndpoint *ep = &usb_endpoints[ep_index];
unsigned int ep_num = EP_HW_NUM(ep->addr);
unsigned int ep_mask;
if (ep->addr != 0) { /* skip if not configured */
ep_mask = 1<<ep_num;
if (int_status & ep_mask) {
unsigned int status;
status = AT91C_UDP_CSR[ep_num];
#if 0
printf("EP %d status: %08x\n", ep->addr, status);
#endif
if (status & AT91C_UDP_STALLSENT) {
/* Acknowledge */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[ep_num],0, AT91C_UDP_STALLSENT);
}
if (status & AT91C_UDP_TXCOMP) {
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[ep_num],0, AT91C_UDP_TXCOMP);
ep->flags &= ~USB_EP_FLAGS_TRANSMITTING;
if (ep->buf_len > 0) {
write_buffered_endpoint(ep);
/* Tell the application that there's more room in the buffer */
usb_endpoint_events[ep_num] |= USB_EP_EVENT_IN;
notify_process(USB_EVENT_EP(ep_num));
}
}
if (status & (AT91C_UDP_RX_DATA_BK0 | AT91C_UDP_RX_DATA_BK1)) {
unsigned char read_cnt;
read_cnt = read_buffered_endpoint(ep);
if (read_cnt == 0) {
*AT91C_UDP_IDR = 1<<ep_num;
ep->flags |= USB_EP_FLAGS_RECV_BLOCKED;
} else {
if (status & AT91C_UDP_RX_DATA_BK1) {
/* Ping-pong */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[ep_num],0,
(ep->flags & USB_EP_FLAGS_BANK_1_RECV_NEXT)
? AT91C_UDP_RX_DATA_BK1
: AT91C_UDP_RX_DATA_BK0);
ep->flags ^= USB_EP_FLAGS_BANK_1_RECV_NEXT;
} else {
/* Ping-pong or single buffer */
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[ep_num],0,
AT91C_UDP_RX_DATA_BK0);
ep->flags |= USB_EP_FLAGS_BANK_1_RECV_NEXT;
}
}
usb_endpoint_events[ep_num] |= USB_EP_EVENT_OUT;
notify_process(ep_mask);
}
}
}
}
}
/* Clear usb events from non-interrupt code */
void
usb_clear_events(unsigned events)
{
/* Disable allUSB events */
*AT91C_AIC_IDCR = (1 << AT91C_ID_UDP);
usb_events &= ~events;
/* Reenable interrupt */
*AT91C_AIC_IECR = (1 << AT91C_ID_UDP);
}
void
usb_clear_ep_events(unsigned int ep, unsigned int events)
{
/* Disable all USB events */
*AT91C_AIC_IDCR = (1 << AT91C_ID_UDP);
usb_endpoint_events[ep] &= ~events;
/* Reenable interrupt */
*AT91C_AIC_IECR = (1 << AT91C_ID_UDP);
}
void
usb_set_address()
{
usb_flags |= USB_FLAG_ADDRESS_PENDING;
/* The actual setting of the address is done when the status packet
is sent. */
}
static void
setup_endpoint(unsigned char addr,
unsigned char *buffer, unsigned int buf_size,
unsigned int type)
{
volatile USBEndpoint *ep;
/* Check if the address points to an existing endpoint */
if (EP_INDEX(addr) >= (sizeof(usb_endpoints)/sizeof(usb_endpoints[0]))) {
return;
}
ep = &usb_endpoints[EP_INDEX(addr)];
ep->addr = addr;
ep->buf_size_mask = buf_size - 1;
ep->buffer = buffer;
ep->buf_len = 0;
ep->buf_pos = 0;
ep->status = 0;
*AT91C_UDP_IDR = 1<<EP_HW_NUM(addr);
{
unsigned int ep_num = EP_HW_NUM(addr);
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[ep_num],
type | AT91C_UDP_EPEDS,
AT91C_UDP_EPTYPE | AT91C_UDP_EPEDS);
}
*AT91C_UDP_IER = 1<<EP_HW_NUM(addr);
}
void
usb_setup_bulk_endpoint(unsigned char addr,
unsigned char *buffer, unsigned int buf_size)
{
setup_endpoint(addr, buffer, buf_size,
(addr & 0x80) ? AT91C_UDP_EPTYPE_BULK_IN
:AT91C_UDP_EPTYPE_BULK_OUT);
}
void
usb_setup_interrupt_endpoint(unsigned char addr,
unsigned char *buffer, unsigned int buf_size)
{
setup_endpoint(addr, buffer, buf_size,
(addr & 0x80) ? AT91C_UDP_EPTYPE_INT_IN
:AT91C_UDP_EPTYPE_INT_OUT);
}
void
usb_disable_endpoint(unsigned char addr)
{
/* Check if the address points to an existing endpoint */
if (EP_INDEX(addr) >= (sizeof(usb_endpoints)/sizeof(usb_endpoints[0]))) {
return;
}
*AT91C_UDP_IDR = 1<<EP_HW_NUM(addr);
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[EP_HW_NUM(addr)], 0, AT91C_UDP_EPEDS);
usb_endpoints[EP_INDEX(addr)].addr = 0;
}
static void
init_ep(volatile USBEndpoint *ctxt)
{
ctxt->addr = 0;
ctxt->buf_size_mask = 0;
ctxt->buf_len = 0;
ctxt->buf_pos = 0;
ctxt->buffer = 0;
ctxt->status = 0;
ctxt->flags = 0;
}
void
usb_init_endpoints()
{
unsigned int i;
for (i = 0; i < NUM_EP-1; i++) {
init_ep(&usb_endpoints[i]);
}
}
volatile USBEndpoint*
usb_find_endpoint(unsigned char epaddr)
{
if (EP_INDEX(epaddr) >= NUM_EP - 1) return 0;
return &usb_endpoints[EP_INDEX(epaddr)];
}
void
usb_halt_endpoint(unsigned char ep_addr, unsigned int halt)
{
*AT91C_UDP_IDR = 1<<EP_HW_NUM(ep_addr);
if (halt) {
UDP_SET_EP_CTRL_FLAGS(&AT91C_UDP_CSR[EP_HW_NUM(ep_addr)],
AT91C_UDP_FORCESTALL, AT91C_UDP_FORCESTALL);
usb_endpoints[EP_INDEX(ep_addr)].status |= 0x01;
} else {
*AT91C_UDP_RSTEP = 1<<EP_HW_NUM(ep_addr);
usb_endpoints[EP_INDEX(ep_addr)].status &= ~0x01;
}
*AT91C_UDP_IER = 1<<EP_HW_NUM(ep_addr);
}

118
cpu/at91sam7s/usb/usb-proto.h
View file

@ -1,118 +0,0 @@
#ifndef __USB_PROTO_H__RVJQ2JAGM4__
#define __USB_PROTO_H__RVJQ2JAGM4__
#include <usb.h>
#include <usb-config.h>
#ifndef NULL
#define NULL 0
#endif
typedef struct _USBEndpoint USBEndpoint;
struct _USBEndpoint
{
unsigned char addr;
unsigned char buf_size_mask; /* mask for the buffer index. This implies
that the buffer size must be a power of
2 */
unsigned char buf_len;
unsigned char buf_pos;
unsigned char* buffer;
unsigned short status;
unsigned short flags;
};
#define USB_EP_FLAGS_BANK_1_RECV_NEXT 0x01 /* The next packet received
should be read from bank 1
if possible */
#define USB_EP_FLAGS_RECV_BLOCKED 0x02 /* Recetpion is blocked.
Interrupt turned off */
#define USB_EP_FLAGS_TRANSMITTING 0x04 /* Waiting for TXCOMP before sending
more data */
/* Read only */
struct USBRequestHandler
{
unsigned char request_type;
unsigned char request_type_mask;
unsigned char request;
unsigned char request_mask;
/* Returns true if it handled the request, if false let another handler try*/
unsigned int (*handler_func)();
};
/* Must be writeable */
struct USBRequestHandlerHook
{
struct USBRequestHandlerHook *next;
const struct USBRequestHandler * const handler;
};
void
usb_register_request_handler(struct USBRequestHandlerHook *hook);
void
usb_reset();
void
usb_ep0_int();
void
usb_epx_int();
void
usb_clear_events(unsigned events);
void
usb_clear_ep_events(unsigned int ep, unsigned int events);
void
usb_error_stall();
void
usb_send_ctrl_response(const unsigned char *buffer, unsigned short len);
void
usb_send_ctrl_status();
void
usb_set_address();
void
usb_set_configuration_value(unsigned char c);
unsigned char
usb_get_configuration_value();
void
usb_init_endpoints();
volatile USBEndpoint*
usb_find_endpoint(unsigned char epaddr);
void
usb_halt_endpoint(unsigned char ep_addr, unsigned int halt);
extern volatile unsigned char usb_events;
extern struct process *usb_handler_process;
extern struct USB_request_st usb_setup_buffer;
extern unsigned char usb_ctrl_data_buffer[];
extern unsigned short usb_ctrl_data_len;
#define USB_EVENT_EP(ep) (0x01<<(ep))
#define USB_EVENT_RESET 0x10
#define USB_EVENT_SUPEND 0x20
#define USB_EVENT_RESUME 0x40
#define USB_EVENT_CONFIG 0x08
extern volatile unsigned char usb_endpoint_events[];
#define USB_EP_EVENT_SETUP 0x01
#define USB_EP_EVENT_OUT 0x02
#define USB_EP_EVENT_IN 0x04
#endif /* __USB_PROTO_H__RVJQ2JAGM4__ */

185
cpu/at91sam7s/usb/usb.h
View file

@ -1,185 +0,0 @@
#ifndef __USB_H__6PFTDPIMZM__
#define __USB_H__6PFTDPIMZM__
#include <stdint.h>
/* Adapted from usb_kbd_enum.h in c5131-usb-kbd-light-1_0_2 package from
Atmel */
/* These definitions assume a little endian architecture */
#ifdef __GNUC__
#define BYTE_ALIGNED __attribute__ ((__packed__))
#else
#define BYTE_ALIGNED
#endif
#define LOW_BYTE(x) ((unsigned char)x)
#define HIGH_BYTE(x) ((unsigned char)(x>>8))
typedef uint8_t Uchar;
typedef uint16_t Uint16;
typedef uint32_t Uint32;
/*_____ S T A N D A R D R E Q U E S T S __________________________________*/
#define GET_STATUS 0x00
#define GET_DEVICE 0x01
#define CLEAR_FEATURE 0x01 /* see FEATURES below */
#define GET_STRING 0x03
#define SET_FEATURE 0x03 /* see FEATURES below */
#define SET_ADDRESS 0x05
#define GET_DESCRIPTOR 0x06
#define SET_DESCRIPTOR 0x07
#define GET_CONFIGURATION 0x08
#define SET_CONFIGURATION 0x09
#define GET_INTERFACE 0x0A
#define SET_INTERFACE 0x0B
#define SYNCH_FRAME 0x0C
#define GET_DEVICE_DESCRIPTOR 1
#define GET_CONFIGURATION_DESCRIPTOR 4
#define REQUEST_DEVICE_STATUS 0x80
#define REQUEST_INTERFACE_STATUS 0x81
#define REQUEST_ENDPOINT_STATUS 0x82
#define ZERO_TYPE 0x00
#define INTERFACE_TYPE 0x01
#define ENDPOINT_TYPE 0x02
/*_____ D E S C R I P T O R T Y P E S ____________________________________*/
#define DEVICE 0x01
#define CONFIGURATION 0x02
#define STRING 0x03
#define INTERFACE 0x04
#define ENDPOINT 0x05
/* HID specific */
#define HID 0x21
#define REPORT 0x22
/* *** */
/*_____ S T A N D A R D F E A T U R E S __________________________________*/
#define DEVICE_REMOTE_WAKEUP_FEATURE 0x01
#define ENDPOINT_HALT_FEATURE 0x00
/*_____ D E V I C E S T A T U S ___________________________________________*/
#define SELF_POWERED 1
/*_____ D E V I C E S T A T E _____________________________________________*/
#define ATTACHED 0
#define POWERED 1
#define DEFAULT 2
#define ADDRESSED 3
#define CONFIGURED 4
#define SUSPENDED 5
#define USB_CONFIG_BUSPOWERED 0x80
#define USB_CONFIG_SELFPOWERED 0x40
#define USB_CONFIG_REMOTEWAKEUP 0x20
/* Class specific */
#define CS_INTERFACE 0x24
#define CS_ENDPOINT 0x25
/*_________________________________________________________ S T R U C T _____*/
/*_____ U S B D E V I C E R E Q U E S T _________________________________*/
struct USB_request_st
{
Uchar bmRequestType; /* Characteristics of the request */
Uchar bRequest; /* Specific request */
Uint16 wValue;
Uint16 wIndex; /* field that varies according to request */
Uint16 wLength; /* Number of bytes to transfer if Data */
};
/*_____ U S B D E V I C E D E S C R I P T O R ___________________________*/
struct usb_st_device_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* DEVICE descriptor type */
Uint16 bscUSB; /* Binay Coded Decimal Spec. release */
Uchar bDeviceClass; /* Class code assigned by the USB */
Uchar bDeviceSubClass; /* Sub-class code assigned by the USB */
Uchar bDeviceProtocol; /* Protocol code assigned by the USB */
Uchar bMaxPacketSize0; /* Max packet size for EP0 */
Uint16 idVendor; /* Vendor ID. ATMEL = 0x03EB */
Uint16 idProduct; /* Product ID assigned by the manufacturer */
Uint16 bcdDevice; /* Device release number */
Uchar iManufacturer; /* Index of manu. string descriptor */
Uchar iProduct; /* Index of prod. string descriptor */
Uchar iSerialNumber; /* Index of S.N. string descriptor */
Uchar bNumConfigurations; /* Number of possible configurations */
} BYTE_ALIGNED;
/*_____ U S B C O N F I G U R A T I O N D E S C R I P T O R _____________*/
struct usb_st_configuration_descriptor
{
Uchar bLength; /* size of this descriptor in bytes */
Uchar bDescriptorType; /* CONFIGURATION descriptor type */
Uint16 wTotalLength; /* total length of data returned */
Uchar bNumInterfaces; /* number of interfaces for this conf. */
Uchar bConfigurationValue; /* value for SetConfiguration resquest */
Uchar iConfiguration; /* index of string descriptor */
Uchar bmAttibutes; /* Configuration characteristics */
Uchar MaxPower; /* maximum power consumption */
} BYTE_ALIGNED;
/*_____ U S B I N T E R F A C E D E S C R I P T O R _____________________*/
struct usb_st_interface_descriptor
{
Uchar bLength; /* size of this descriptor in bytes */
Uchar bDescriptorType; /* INTERFACE descriptor type */
Uchar bInterfaceNumber; /* Number of interface */
Uchar bAlternateSetting; /* value to select alternate setting */
Uchar bNumEndpoints; /* Number of EP except EP 0 */
Uchar bInterfaceClass; /* Class code assigned by the USB */
Uchar bInterfaceSubClass; /* Sub-class code assigned by the USB */
Uchar bInterfaceProtocol; /* Protocol code assigned by the USB */
Uchar iInterface; /* Index of string descriptor */
} BYTE_ALIGNED;
/*_____ U S B E N D P O I N T D E S C R I P T O R _______________________*/
struct usb_st_endpoint_descriptor
{
Uchar bLength; /* Size of this descriptor in bytes */
Uchar bDescriptorType; /* ENDPOINT descriptor type */
Uchar bEndpointAddress; /* Address of the endpoint */
Uchar bmAttributes; /* Endpoint's attributes */
Uint16 wMaxPacketSize; /* Maximum packet size for this EP */
Uchar bInterval; /* Interval for polling EP in ms */
/* Uchar bRefresh; */
/* Uchar bSynchAddress; */
} BYTE_ALIGNED;
/*_____ U S B S T R I N G D E S C R I P T O R _______________*/
struct usb_st_string_descriptor
{
Uchar bLength; /* size of this descriptor in bytes */
Uchar bDescriptorType; /* STRING descriptor type */
Uint16 wstring[1];/* unicode characters */
} BYTE_ALIGNED;
struct usb_st_language_descriptor
{
Uchar bLength; /* size of this descriptor in bytes */
Uchar bDescriptorType; /* STRING descriptor type */
Uint16 wlangid[1]; /* language id */
} BYTE_ALIGNED;
#endif /* __USB_H__6PFTDPIMZM__ */