jens/vhdl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial version

Browse Source 
Committed on the Free edition of March Hare Software CVSNT Server.
Upgrade to CVS Suite for more features and support:
http://march-hare.com/cvsnt/


git-svn-id: http://moon:8086/svn/vhdl/trunk@272 cc03376c-175c-47c8-b038-4cd826a8556b
This commit is contained in:
jens
2009-01-21 08:52:05 +00:00
parent 25e3d4f36f
commit 8867efa451
50 changed files with 11439 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/CPUs/MIPS/bsp/examples/Bessel.c
+87
View File
@@ -0,0 +1,87 @@
/************************************************************************/
/* Ein Programm zur Berechnung der Bessel-Koeffizienten Jn
/* Dateiname : Bessel.cpp
/* Autoren : T. Burr, J. Ahrensfeld
/* Datum : 28.10.1999
/* letzte Änderung : 28.01.2000
/* Version : 1.0
/************************************************************************/
#include "stdio.h"
#include "math.h"
#include "stdlib.h"
#define MAX_SUM 25
#define VERSION "1.0"
/************************************************************************/
/* Funktionsdeklarationen */
/************************************************************************/
// Fakultätsberechnung
double fak (int N)
{
int index;
double erg=1;
for (index = 1; index <= N; index++)
erg = erg * index;
return erg;
}
// Bessel()
// Berechnung von Jn von mfm
double bessel(int n, double mfm)
{
int m;
double Jn=0;
for (m=0; m < MAX_SUM; m++)
{
Jn = Jn + (pow(-1.0,m)/(fak(m)*fak(m+n))*pow(mfm/2.0,(2*m+n)));
}
return Jn;
}
/************************************************************************/
/* Das Hauptprogramm
/************************************************************************/
void main()
{
int N, Nmax;
double erg;
float mfm;
printf("\n\t Besselfunktion Version %s",VERSION);
printf("\n\t ~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
printf("\n\tCopyright by J. Ahrensfeld & T. Burr\n\n");
// ---------------------------------------------------------------------------------
// Benutzereingaben
printf("\nBerechnungen fuer J = 0...");
if(scanf("%d",&Nmax)==0)
exit (-1);
printf("Bitte Modulationsindex eingeben : ");
if(scanf("%f",&mfm)==0)
exit(-1);
printf("\n");
// ---------------------------------------------------------------------------------
// Berechnung
for (N=0; N <= Nmax; N++)
{
erg = bessel(N,(double)mfm);
printf("J(%d) = %10.8f\n",N,erg);
}
printf("FERTIG.\n");
}
/************************************************************************/
lib/CPUs/MIPS/bsp/examples/Makefile
+112
View File
@@ -0,0 +1,112 @@
TOOLS_DIR=../../tools
CFLAGS=-G 0 -msoft-float -O2 -march=r3000 -I.
LFLAGS=-G0 -M -T link.ld
LIB_DIRS=-L /usr/local/mipsel-elf/lib -L /usr/local/lib/gcc/mipsel-elf/4.3.0
LIBS=-lc -lm -lgcc
CC=mipsel-elf-gcc
LD=mipsel-elf-ld
PROG = hello testbench test_irq dhry queens stanford paranoia rmd160_test Bessel whet phrasen
all: $(PROG)
libsys: startup.S init.S kernel.S libsys.c xcpt.c irq.o
$(CC) $(CFLAGS) -c startup.S -o startup.o
$(CC) $(CFLAGS) -c init.S -o init.o
$(CC) $(CFLAGS) -c kernel.S -o kernel.o
$(CC) $(CFLAGS) -c libsys.c -o libsys.o
$(CC) $(CFLAGS) -c xcpt.c -o xcpt.o
$(CC) $(CFLAGS) -c irq.c -o irq.o
hello: libsys hello.c
$(CC) $(CFLAGS) -Os -g -c hello.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o hello.o -o hello.elf $(LIBS) >hello.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
testbench: libsys testbench.c
$(CC) $(CFLAGS) -Os -g -c testbench.c paranoia.c -DNOSIGNAL -DBATCHMODE -DNOMAIN
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o paranoia.o testbench.o -o testbench.elf $(LIBS) >testbench.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
test_irq: libsys test_irq.c
$(CC) $(CFLAGS) -Os -g -c test_irq.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o test_irq.o -o test_irq.elf $(LIBS) >test_irq.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
dhry: libsys dhry_1.c dhry_2.c dhry.h
$(CC) $(CFLAGS) -g -DHZ=1000 -c dhry_1.c dhry_2.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o dhry_1.o dhry_2.o -o dhry.elf $(LIBS) >dhry.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
queens: libsys queens.c
$(CC) $(CFLAGS) -DUNIX_Old -DHZ=1000 -g -c queens.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o queens.o -o queens.elf $(LIBS) >queens.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
stanford: libsys stanford.c
$(CC) $(CFLAGS) -g -DHZ=1000 -c stanford.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o stanford.o -o stanford.elf $(LIBS) >stanford.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
paranoia: libsys paranoia.c
$(CC) $(CFLAGS) -DNOSIGNAL -DBATCHMODE -g -c paranoia.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o paranoia.o -o paranoia.elf $(LIBS) >paranoia.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
rmd160_test: libsys rmd160_test.c rmd160.c rmd160.h
$(CC) $(CFLAGS) -DNOSIGNAL -DBATCHMODE -g -c rmd160.c rmd160_test.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o rmd160.o rmd160_test.o -o rmd160_test.elf $(LIBS) >rmd160.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
Bessel: libsys Bessel.c
$(CC) $(CFLAGS) -g -c Bessel.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o Bessel.o -o Bessel.elf $(LIBS) >Bessel.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
whet: libsys whet.c
$(CC) $(CFLAGS) -g -c whet.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o whet.o -o whet.elf $(LIBS) >whet.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
phrasen: libsys phrasen.c
$(CC) $(CFLAGS) -g -c phrasen.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o xcpt.o irq.o libsys.o phrasen.o -o phrasen.elf $(LIBS) >phrasen.map
mipsel-elf-objdump -d $@.elf > $@.dis
mipsel-elf-objcopy $@.elf -O binary $@.bin
mipsel-elf-objcopy -O srec $@.elf $@.srec
$(TOOLS_DIR)/flashgen $@.bin
clean:
rm -rf *.a *.o *.bin *.map *.dis *.srec *.elf $(PROG) > /dev/null
lib/CPUs/MIPS/bsp/examples/bootloader.c
+403
View File
@@ -0,0 +1,403 @@
#include "libsys.h"
#include "cfiflash.h"
typedef struct _ssrec_t
{
UINT32 addr;
UINT32 size;
UINT32 type;
UINT8 *data;
} srec_t;
enum srec_type
{
srec_err, srec_sob, srec_data, srec_rec, srec_eob
};
UINT8 h2i(UINT8 *c)
{
int i;
UINT8 t, b = 0;
for (i=0; i < 2; i++)
{
t = c[i];
if (t >= 'A')
t = t - 'A' + 10;
else
t -= '0';
b = (b << 4) | t;
}
return b;
}
int decode_srec(srec_t *pRec, UINT8 *pBuf, int buflen)
{
UINT8 chksum, byte;
int alen, i;
if (!buflen)
return srec_err;
pRec->type = srec_rec;
alen = 0;
if ((pBuf[1] > '0') && (pBuf[1] < '4'))
{
alen = pBuf[1] - '0' + 1;
pRec->type = srec_data;
}
else if ((pBuf[1] >= '7') && (pBuf[1] <= '9'))
{
alen = 11 - (pBuf[1] - '0');
pRec->type = srec_eob;
}
else if (pBuf[1] == '0')
{
alen = 2;
pRec->type = srec_sob;
}
byte = h2i(&pBuf[2]);
pRec->size = byte;
chksum = byte;
pRec->addr = 0;
for (i=0; i < alen; i++)
{
byte = h2i(&pBuf[4+2*i]);
pRec->addr = pRec->addr << 8 | byte;
chksum += byte;
}
pRec->size -= (alen+1);
pRec->data = (UINT8*) &pBuf[4 + 2*alen];
for (i=0; i < (int)pRec->size; i++)
{
byte = h2i(&pRec->data[2*i]);
pRec->data[i] = byte;
chksum += byte;
}
chksum = ~chksum;
byte = h2i(&pRec->data[2*i]);
if (chksum != byte)
return 0;
return pRec->type;
}
int srec_getline(UINT8 *pLine)
{
char c;
int i = 0;
do
{
c = readchar();
} while ((c != 's') && (c != 'S'));
while(((c != 0x0D) && (c != 0x0A)))
{
pLine[i++] = c;
c = readchar();
};
return i;
}
void Exec_at(void *pEntry)
{
__asm
(
".set noreorder\n"
"mfc0 $26, $12\n" // change exception vector
"li $27, 0xFFBFFFFF\n"
"and $26, $27\n"
"mtc0 $26, $12\n"
"jr $4\n" // jump entry
"rfe\n"
".set reorder\n"
);
}
void PrintCPUinfo(void)
{
int result, rev_id;
char *cpu_type_str[7] = {"invalid", "R2000", "R3000", "R6000", "R4000", "reserved", "R6000A"};
// Print Status register
result = CP0_SR_read();
sputs("Status : ");
print_word(result);
sputs("\n");
// Print Revision
result = CP0_PRID_read();
rev_id = (result >> 8) & 0xFF;
sputs("CPU type: ");
if ((rev_id > 0) && (rev_id < 0x07))
{
sputs(cpu_type_str[rev_id]);
sputs(" Rev.");
rev_id = result & 0xFF;
print_byte((char)rev_id);
}
else
sputs("Unknown");
sputs("\n");
}
#define TEST_SIZE (1024*1024) // bytes
//#define TEST_SIZE (1024) // bytes
#define SDRAM_BASE 0x40000000
#define IMAGE_OFFSET 0x01000000
#define FLASH_OFFSET 0x00700000
int main(int argc, char *argv[])
{
UINT8 buf[256];
srec_t srec;
int result, i;
UINT32 haddr, addr;
flash_t flash;
volatile UINT32 *pReg = (UINT32*)sys_led_port;
volatile UINT32 *pBtn = (UINT32*)sys_gpio0;
volatile UINT8 *pMem;
volatile UINT32 *pROM32;
volatile UINT32 *pMem32;
volatile UINT32 *pFlash = (UINT32*)sys_flash_io;
volatile UINT32 *pUSB = (UINT32*)sys_usb_data;
volatile UINT8 *ram8 = (UINT8*)SDRAM_BASE;
volatile UINT16 *ram16 = (UINT16*)SDRAM_BASE;
volatile UINT32 *ram32 = (UINT32*)SDRAM_BASE;
*pReg = 0;
haddr = 0;
/*
__asm __volatile
(
".set noreorder\n"
"li $a0, 0xA0020000\n"
"li $t0, 0x12345678\n"
"li $t1, 0x5555AAAA\n"
"sw $t0, 0($a0)\n"
// "nop\n"
"sw $t1, 4($a0)\n"
// "nop\n"
"lw $v0, 0($a0)\n"
// "nop\n"
"lw $v0, 4($a0)\n"
// "nop\n"
"sw $t0, 0($a0)\n"
// "nop\n"
"lw $v0, 4($a0)\n"
// "nop\n"
"sw $t1, 4($a0)\n"
// "nop\n"
"lw $v0, 0($a0)\n"
".set reorder\n"
);
__asm __volatile
(
".set noreorder\n"
"lui $v1, 0xA002\n"
"lui $v0,0x70\n"
"ori $v0,$v0,0x70\n"
"sw $v0,0($v1)\n"
"lui $a0,0x4002\n"
"lw $a1,0($v1)\n"
"lw $ra,12($sp)\n"
"lw $s1,8($sp)\n"
"lw $s0,4($sp)\n"
".set reorder\n"
);
*/
// PrintCPUinfo();
/*
*(pFlash+0) = 0x12345678;
*(pFlash+1) = 0xAAAA5555;
*(pFlash+2) = 0xFFFF0000;
*(pFlash+3) = 0x0000FFFF;
*pReg = *(pFlash+0);
*pReg = *(pFlash+1);
*pReg = *(pFlash+2);
*pReg = *(pFlash+3);
*(pUSB+0) = 0x12345678;
*(pUSB+1) = 0xAAAA5555;
*(pUSB+2) = 0xFFFF0000;
*(pUSB+3) = 0x0000FFFF;
*pReg = *(pUSB+0);
*pReg = *(pUSB+1);
*pReg = *(pUSB+2);
*pReg = *(pUSB+3);
sputs("BOOT ");
pMem32 = (UINT32*)0x40000000;
pROM32 = (UINT32*)0x00000000;
for (i=0; i < 0x3500; i+=4)
*pMem32++ = *pROM32++;
Exec_at((void*)0x40000000);
// Memtest BEGIN
sputs("SDRAM Memory Test\r\n");
sputs("Write (8-Bit access)...");
for (i=0; i < TEST_SIZE; i++)
ram8[i] = (UINT8)i;
sputs("done\r\n");
sputs("Verify (8-Bit access)...");
for (i=TEST_SIZE-1; i >= 0; i--)
if (ram8[i] != (UINT8)i)
break;
i++;
if (i)
sputs("failed\r\n");
else
sputs("passed\r\n");
sputs("Write (16-Bit access)...");
for (i=0; i < TEST_SIZE/2; i++)
ram16[i] = (UINT16)i;
sputs("done\r\n");
sputs("Verify (16-Bit access)...");
for (i=TEST_SIZE/2-1; i >= 0; i--)
if (ram16[i] != (UINT16)i)
break;
i++;
if (i)
sputs("failed\r\n");
else
sputs("passed\r\n");
sputs("Write (32-Bit access)...");
for (i=0; i < TEST_SIZE/4; i++)
ram32[i] = (UINT32)i;
sputs("done\r\n");
sputs("Verify (32-Bit access)...");
for (i=TEST_SIZE/4-1; i >= 0; i--)
if (ram32[i] != (UINT32)i)
break;
i++;
if (i)
sputs("failed\r\n");
else
sputs("passed\r\n");
for (i=0; i < TEST_SIZE/4; i++)
ram32[i] = 0;
// Memtest END
// ----------------------------------------------------------
*/
ram32 = (UINT32*)(SDRAM_BASE + IMAGE_OFFSET);
pFlash = (UINT32*)(sys_flash_io + FLASH_OFFSET);
print_word((UINT32)*pBtn);
if (!*pBtn)
{
sputs("Booting from flash..");
for (i=0; i < TEST_SIZE/4; i++)
ram32[i] = pFlash[i];
sputs("done");
Exec_at((void*)ram32);
}
else
{
sputs("SDRAM erase at : ");
print_word((UINT32)ram32);
sputs("\n");
for (i=0; i < TEST_SIZE/4; i++)
ram32[i] = 0;
cfi_init(&flash, sys_flash_io);
if (cfi_find(&flash) < 0)
return 1;
sputs("Found Flash at ");
print_word((UINT32)flash.pBase);
sputs("\n");
addr = FLASH_OFFSET;
sputs("Flash erase at : ");
print_word(addr);
sputs("\n");
cfi_block_erase(&flash, addr/4);
while(1)
{
sputs("BOOT ");
while(1)
{
result = srec_getline(buf);
result = decode_srec(&srec, buf, result);
*pReg = 0;
srec.addr += IMAGE_OFFSET;
switch (result)
{
case srec_data:
if ((srec.addr + srec.size) > haddr)
haddr = srec.addr + srec.size;
pMem = (UINT8*)srec.addr;
for (i=0; i < srec.size; i++)
*pMem++ = srec.data[i];
break;
case srec_eob:
*pReg = 1;
print_word(srec.addr);
sputs(" to ");
print_word(haddr-4);
sputs("\n");
addr = FLASH_OFFSET;
sputs("Program Flash at : ");
print_word(addr);
sputs("\n");
cfi_program_multi(&flash, addr/4, (UINT32*)ram32, TEST_SIZE/4);
// Exec_at((void*)srec.addr);
break;
default:
break;
}
if (result == srec_err)
{
*pReg = 0x40000000;
break;
}
};
}
}
return 0;
}
lib/CPUs/MIPS/bsp/examples/bootloader/Makefile
+30
View File
@@ -0,0 +1,30 @@
ROM_WORDADDR_WIDTH=11
TOOLS_DIR=../../../tools
CFLAGS=-G 0 -O2 -I. -I../ -msoft-float -march=r3000
LFLAGS=-G0 -M -T bootloader.ld
LIB_DIRS=-L /usr/local/mipsel-elf/lib -L /usr/local/lib/gcc/mipsel-elf/4.3.0
LIBS=-lc -lm -lgcc
CC=mipsel-elf-gcc
LD=mipsel-elf-ld
all: bootloader
libsys: startup_boot.S init_boot.S kernel_boot.S libsys_boot.c
$(CC) $(CFLAGS) -c startup_boot.S -o startup.o
$(CC) $(CFLAGS) -c init_boot.S -o init.o
$(CC) $(CFLAGS) -c kernel_boot.S -o kernel.o
$(CC) $(CFLAGS) -c libsys_boot.c -o libsys.o
bootloader: libsys bootloader.c
$(CC) $(CFLAGS) -g -c bootloader.c
$(CC) $(CFLAGS) -g -c ../cfiflash.c
$(LD) $(LFLAGS) $(LIB_DIRS) startup.o init.o kernel.o libsys.o cfiflash.o bootloader.o -o bootloader.elf $(LIBS) >bootloader.map
mipsel-elf-objdump -d bootloader.elf > bootloader.dis
mipsel-elf-objcopy bootloader.elf -O binary bootloader.ROM.bin
mipsel-elf-objcopy -O srec bootloader.elf bootloader.srec
$(TOOLS_DIR)/romgen bootloader.ROM.bin $(ROM_WORDADDR_WIDTH)
clean:
rm -rf *.o *.bin *.map *.dis *.srec *.elf *.vhd* *.tcl bootloader > /dev/null
lib/CPUs/MIPS/bsp/examples/bootloader/bootloader.c
+360
View File
@@ -0,0 +1,360 @@
#include "libsys_boot.h"
#include "cfiflash.h"
typedef struct _ssrec_t
{
UINT32 addr;
UINT32 size;
UINT32 type;
UINT8 *data;
} srec_t;
typedef struct _sflash_img_hdr_t
{
UINT8 magic[4];
UINT32 target_addr;
UINT32 img_offset;
UINT32 img_size;
UINT32 hdr_next;
UINT8 img_name[128];
UINT8 res[108];
} flash_img_hdr_t;
enum srec_type
{
srec_err, srec_sob, srec_data, srec_rec, srec_eob
};
UINT8 h2i(UINT8 *c)
{
int i;
UINT8 t, b = 0;
for (i=0; i < 2; i++)
{
t = c[i];
if (t >= 'A')
t = t - 'A' + 10;
else
t -= '0';
b = (b << 4) | t;
}
return b;
}
int decode_srec(srec_t *pRec, UINT8 *pBuf, int buflen)
{
UINT8 chksum, byte;
int alen, i;
if (!buflen)
return srec_err;
pRec->type = srec_rec;
alen = 0;
if ((pBuf[1] > '0') && (pBuf[1] < '4'))
{
alen = pBuf[1] - '0' + 1;
pRec->type = srec_data;
}
else if ((pBuf[1] >= '7') && (pBuf[1] <= '9'))
{
alen = 11 - (pBuf[1] - '0');
pRec->type = srec_eob;
}
else if (pBuf[1] == '0')
{
alen = 2;
pRec->type = srec_sob;
}
byte = h2i(&pBuf[2]);
pRec->size = byte;
chksum = byte;
pRec->addr = 0;
for (i=0; i < alen; i++)
{
byte = h2i(&pBuf[4+2*i]);
pRec->addr = pRec->addr << 8 | byte;
chksum += byte;
}
pRec->size -= (alen+1);
pRec->data = (UINT8*) &pBuf[4 + 2*alen];
for (i=0; i < (int)pRec->size; i++)
{
byte = h2i(&pRec->data[2*i]);
pRec->data[i] = byte;
chksum += byte;
}
chksum = ~chksum;
byte = h2i(&pRec->data[2*i]);
if (chksum != byte)
return 0;
return pRec->type;
}
int srec_getline(UINT8 *pLine)
{
char c;
int i = 0;
do
{
c = readchar();
} while ((c != 's') && (c != 'S'));
while(((c != 0x0D) && (c != 0x0A)))
{
pLine[i++] = c;
c = readchar();
};
return i;
}
void Jump_to(void *pEntry)
{
__asm
(
".set noreorder\n"
);
__asm
(
"jr %[pEntry]\n" // jump entry
:
: [pEntry] "r" (pEntry)
);
__asm
(
"nop\n"
);
__asm
(
".set reorder\n"
);
}
void Exec_at(void *pEntry)
{
__asm
(
".set noreorder\n"
);
__asm
(
"mfc0 $26, $12\n" // change exception vector
"li $27, 0xFFBFFFFF\n"
"and $26, $27\n"
"mtc0 $26, $12\n"
);
__asm
(
"jr %[pEntry]\n" // jump entry
:
: [pEntry] "r" (pEntry)
);
__asm
(
"rfe\n"
);
__asm
(
".set reorder\n"
);
}
void PrintCPUinfo(void)
{
int result, rev_id;
char *cpu_type_str[7] = {"invalid", "R2000", "R3000", "R6000", "R4000", "reserved", "R6000A"};
// Print Status register
result = CP0_SR_read();
sputs("Status : ");
print_word(result);
sputs("\n");
// Print Revision
result = CP0_PRID_read();
rev_id = (result >> 8) & 0xFF;
sputs("CPU type: ");
if ((rev_id > 0) && (rev_id < 0x07))
{
sputs(cpu_type_str[rev_id]);
sputs(" Rev.");
rev_id = result & 0xFF;
print_byte((char)rev_id);
}
else
sputs("Unknown");
sputs("\n");
}
#define MAX_IMG_SIZE (1024*1024) // bytes
#define SDRAM_BASE 0x40000000
#define FLASH_OFFSET 0x00000000
int main(int argc, char *argv[])
{
UINT8 buf[256];
srec_t srec;
int result, srec_state, i;
UINT32 haddr;
flash_t flash;
flash_img_hdr_t img_hdr = {0};
flash_img_hdr_t *pImg_hdr;
UINT32 img_size;
volatile UINT32 *pReg = (UINT32*)sys_led_port;
volatile UINT32 *pBtn = (UINT32*)sys_gpio0;
volatile UINT8 *pMem;
volatile UINT32 *pROM32;
volatile UINT32 *pMem32;
volatile UINT32 *pFlash = (UINT32*)sys_flash_io;
volatile UINT32 *pUSB = (UINT32*)sys_usb_data;
volatile UINT8 *ram8 = (UINT8*)SDRAM_BASE;
volatile UINT16 *ram16 = (UINT16*)SDRAM_BASE;
volatile UINT32 *ram32 = (UINT32*)SDRAM_BASE;
*pReg = 0;
haddr = 0;
// ----------------------------------------------------------
ram32 = (UINT32*)(SDRAM_BASE);
pFlash = (UINT32*)(sys_flash_io + FLASH_OFFSET);
if (!*pBtn)
{
sputs("\n\n");
sputs("Booting from flash...");
pImg_hdr = (flash_img_hdr_t*)pFlash;
ram32 = (UINT32*)pImg_hdr->target_addr;
pFlash = (UINT32*)(sys_flash_io + pImg_hdr->img_offset);
img_size = pImg_hdr->img_size;
for (i=0; i < img_size/4; i++)
ram32[i] = pFlash[i];
sputs("done\n\n");
Exec_at((void*)ram32);
}
else
{
if (flash_find(&flash, sys_flash_io) < 0)
{
sputs("Cannot find flash device. Exit now!\n\n");
return 1;
}
// Erase SDRAM
for (i=0; i < MAX_IMG_SIZE/4; i++)
ram32[i] = 0;
sputs("\n\n");
sputs("Booting from UART..");
while(1)
{
sputs(".");
while(1)
{
result = srec_getline(buf);
srec_state = decode_srec(&srec, buf, result);
*pReg = 0;
switch (srec_state)
{
case srec_data:
if ((srec.addr + srec.size) > haddr)
haddr = srec.addr + srec.size;
pMem = (UINT8*)srec.addr;
for (i=0; i < srec.size; i++)
*pMem++ = srec.data[i];
break;
case srec_eob:
sputs("done\n\n");
img_hdr.magic[0] = 'J';
img_hdr.magic[1] = 'F';
img_hdr.magic[2] = 'I';
img_hdr.magic[3] = '1';
img_hdr.target_addr = srec.addr;
img_hdr.img_size = haddr - srec.addr;
img_hdr.img_offset = FLASH_OFFSET + sizeof(flash_img_hdr_t);
img_hdr.hdr_next = FLASH_OFFSET;
sputs("Flash erase...");
result = flash_erase(&flash, FLASH_OFFSET, img_hdr.img_size + sizeof(flash_img_hdr_t));
if (result < 0)
{
sputs("failed!\n");
break;
}
sputs("done\n");
sputs("Flash write...");
result = flash_program(&flash, FLASH_OFFSET, (UINT8*)&img_hdr, sizeof(flash_img_hdr_t));
if (result < 0)
{
sputs("failed!\n");
break;
}
result = flash_program(&flash, img_hdr.img_offset, (UINT8*)ram32, img_hdr.img_size);
if (result < 0)
{
sputs("failed!\n");
break;
}
sputs("done\n");
sputs("Flash verify...");
result = flash_verify(&flash, img_hdr.img_offset, (UINT8*)ram32, img_hdr.img_size);
if (result < 0)
{
sputs("failed!\n");
break;
}
sputs("passed\n");
Jump_to((void*)0xBFC00000);
// sputs("\nPush reset button to boot!\n");
// *pReg = 1;
break;
default:
result = -1;
break;
}
if (result < 0)
{
*pReg = 0x40000000;
break;
}
};
}
}
return 0;
}
lib/CPUs/MIPS/bsp/examples/bootloader/bootloader.ld
+47
View File
@@ -0,0 +1,47 @@
MEMORY
{
rom : ORIGIN = 0xBFC00000, LENGTH = 0x00002000 /* 8K */
sram : ORIGIN = 0x40000000, LENGTH = 0x02000000 /* 32M */
}
stack_ptr = 0x7FFFFFF0;
baudrate = 0x0D;
sys_led_port = 0xA0000000;
sys_uart_data = 0xA0010000;
sys_uart_stat = 0xA0010004;
sys_uart_baud = 0xA0010008;
sys_timer_usec = 0xA000008;
sys_timer_sec = 0xA000000C;
SECTIONS
{
.stext ORIGIN(rom) :
{
start = ALIGN(4);
entry = ALIGN(4);
_entry = ALIGN(4);
__entry = ALIGN(4);
*(.stext)
} > rom
.ktext ORIGIN(rom) + 0x180 :
{
*(.ktext)
} > rom
.text . :
{
*(.text)
} > rom
.rodata . :
{
*(.rodata*)
} > rom
.data ORIGIN(rom) :
{
*(.data)
} > rom
}
lib/CPUs/MIPS/bsp/examples/bootloader/init_boot.S
+208
View File
@@ -0,0 +1,208 @@
.file "init.S"
.text
.align 2
.globl _init
.extern end
_init:
.set noreorder
# set uart
la $26, sys_uart_baud
addiu $27, $0, baudrate
sb $27, 0($26)
# set stack pointer
la $sp, stack_ptr
# j $jmain
# TEST
li $26, +5
beqz $26, _terminate
li $26, -5
beqz $26, _terminate
li $26, 0
beqz $26, $_L11
nop
j _terminate
nop
$_L11:
li $26, +5
li $27, +6
beq $26, $27, _terminate
li $26, -5
beq $26, $27, _terminate
li $26, 0
beq $26, $27, _terminate
li $26, +6
beq $26, $27, $_L12
nop
j _terminate
nop
$_L12:
li $26, -5
bgez $26, _terminate
li $26, +5
bgez $26, $_L13
nop
j _terminate
$_L13: li $26, 0
bgez $26, $_L14
nop
j _terminate
$_L14:
li $26, -5
bgtz $26, _terminate
li $26, 0
bgtz $26, _terminate
li $26, +5
bgtz $26, $_L15
nop
j _terminate
$_L15:
li $26, +5
blez $26, _terminate
li $26, 0
blez $26, $_L16
nop
j _terminate
$_L16: li $26, -5
blez $26, $_L17
nop
j _terminate
$_L17:
li $26, +5
bltz $26, _terminate
li $26, 0
bltz $26, _terminate
li $26, -5
bltz $26, $_L18
nop
j _terminate
$_L18:
li $26, +5
li $27, +6
bne $26, $27, $_L19
nop
j _terminate
$_L19: li $26, -5
bne $26, $27, $_L20
nop
j _terminate
$_L20: li $26, -6
bne $26, $27, $_L21
nop
j _terminate
$_L21: li $26, 0
bne $26, $27, $_L22
nop
j _terminate
$_L22: li $26, +6
bne $26, $27, _terminate
li $26, +5
bnez $26, $_L23
nop
j _terminate
$_L23: li $26, -5
bnez $26, $_L24
nop
j _terminate
$_L24: li $26, 0
bnez $26, _terminate
$_L25:
li $27, +5
sltiu $26,$27,+6
sltiu $26,$27,-6
li $27, -5
sltiu $26,$27,+6
sltiu $26,$27,-6
li $27, +6
sltiu $26,$27,+5
sltiu $26,$27,-5
li $27, -6
sltiu $26,$27,+5
sltiu $26,$27,-5
li $27, +5
slti $26,$27,+6
slti $26,$27,-6
li $27, -5
slti $26,$27,+6
slti $26,$27,-6
li $27, +6
slti $26,$27,+5
slti $26,$27,-5
li $27, -6
slti $26,$27,+5
slti $26,$27,-5
li $26, +5
li $27, +6
sltu $26,$26,$27
li $26, +5
li $27, -6
sltu $26,$26,$27
li $26, -5
li $27, +6
sltu $26,$26,$27
li $26, -5
li $27, -6
sltu $26,$26,$27
li $26, +6
li $27, +5
sltu $26,$26,$27
li $26, +6
li $27, -5
sltu $26,$26,$27
li $26, -6
li $27, +5
sltu $26,$26,$27
li $26, -6
li $27, -5
sltu $26,$26,$27
li $26, +5
li $27, +6
slt $26,$26,$27
li $26, +5
li $27, -6
slt $26,$26,$27
li $26, -5
li $27, +6
slt $26,$26,$27
li $26, -5
li $27, -6
slt $26,$26,$27
li $26, +6
li $27, +5
slt $26,$26,$27
li $26, +6
li $27, -5
slt $26,$26,$27
li $26, -6
li $27, +5
slt $26,$26,$27
li $26, -6
li $27, -5
slt $26,$26,$27
# TEST
# jump main
$jmain: la $26, main
jalr $26
_terminate:
nop
j _terminate
nop
.set reorder
lib/CPUs/MIPS/bsp/examples/bootloader/kernel_boot.S
+45
View File
@@ -0,0 +1,45 @@
.file "kernel.S"
.section .ktext,"ax"
.align 2
.macro kpush reg
addiu $sp, 4
sw \reg, 0($sp)
.endm
.macro kpop reg
lw \reg, 0($sp)
addiu $sp, -4
.endm
_exc_handler:
.set noreorder
# Set Error LED and ExcCode LEDs
# Get Cause
mfc0 $26, $13
la $27, sys_led_port
srl $26, 2
andi $26, 0x000F
or $26, $27
sw $26, 0($27)
# wait for all interrupts = 0
$w4x: mfc0 $26, $13
nop
srl $26, 8
andi $26, 0xFF
bnez $26, $w4x
nop
# Get return address
mfc0 $26, $14
# Return
nop
jr $26
rfe
.set reorder
lib/CPUs/MIPS/bsp/examples/bootloader/libsys_boot.c
+142
View File
@@ -0,0 +1,142 @@
#include <sys/times.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include "libsys_boot.h"
// ---------------------------------------------------------------------------------
// MIPS specific
UINT32 CP0_SR_read(void)
{
UINT32 result;
__asm
(
"mfc0 %[val], $12\n"
: [val] "=r" (result)
);
return result;
}
void CP0_SR_write(UINT32 val)
{
__asm
(
"mtc0 %[val], $12\n"
: /* no output */
: [val] "r" (val)
);
}
UINT32 CP0_CR_read(void)
{
UINT32 result;
__asm
(
"mfc0 %[val], $13\n"
: [val] "=r" (result)
);
return result;
}
void CP0_CR_write(UINT32 val)
{
__asm
(
"mtc0 %[val], $13\n"
:
: [val] "r" (val)
);
}
UINT32 CP0_PRID_read(void)
{
UINT32 result;
__asm
(
"mfc0 %[val], $15\n"
: [val] "=r" (result)
);
return result;
}
// ---------------------------------------------------------------------------------
char readchar(void)
{
volatile UINT32 *pUART_stat = (UINT32*)sys_uart_stat;
volatile UINT32 *pUART_data = (UINT32*)sys_uart_data;
while(!(0x10 & *pUART_stat));
return (char)*pUART_data;
}
void writechar(char c)
{
volatile UINT32 *pUART_stat = (UINT32*)sys_uart_stat;
volatile UINT32 *pUART_data = (UINT32*)sys_uart_data;
while((0x02 & *pUART_stat) != 0);
*pUART_data = (UINT32)c;
}
void _putchar(char c)
{
if (c == 0x0A)
{
writechar(0x0D);
}
writechar(c);
}
int sputs(char *pStr)
{
char *start;
start = pStr;
while(*pStr)
_putchar(*(pStr++));
return pStr - start;
}
void print_byte(char byte)
{
int i;
unsigned char c, nibble;
for (i=0; i < 2; i++)
{
nibble = (char)((byte >> 4) & 0xF);
byte <<= 4;
if (nibble < 10)
c = nibble + '0';
else
c = nibble + 'A' - 10;
_putchar(c);
}
}
void print_word(int word)
{
int i;
unsigned char c, nibble;
for (i=0; i < 4; i++)
{
c = (char) (word >> 24);
print_byte(c);
word <<= 8;
}
}
lib/CPUs/MIPS/bsp/examples/bootloader/libsys_boot.h
+50
View File
@@ -0,0 +1,50 @@
#ifndef LIBSYS_H
#define LIBSYS_H
// ---------------------------------------------------------
// Types
// ---------------------------------------------------------
#define INT8 char
#define INT16 short
#define INT32 long
#define UINT8 unsigned char
#define UINT16 unsigned short
#define UINT32 unsigned long
#define INT int
#define UINT unsigned int
#define FLOAT32 float
#define FLOAT64 double
#define sys_gpio0 0xA0000000
#define sys_gpio1 0xA0000004
#define sys_led_port sys_gpio0
#define sys_usb_ctrl sys_gpio1
#define sys_timer_usec 0xA0000008
#define sys_timer_sec 0xA000000C
#define sys_uart_data 0xA0010000
#define sys_uart_stat 0xA0010004
#define sys_uart_baud 0xA0010008
#define sys_usb_data 0xA0020000
#define sys_usb_mbx 0xA0020004
#define sys_usb_addr 0xA0020008
#define sys_usb_status 0xA002000C
#define sys_flash_io 0xA4000000
// MIPS specific
UINT32 CP0_SR_read(void);
void CP0_SR_write(UINT32 val);
UINT32 CP0_CR_read(void);
void CP0_CR_write(UINT32 val);
UINT32 CP0_PRID_read(void);
// General
char readchar(void);
void writechar(char c);
int write(int file, char *ptr, int len);
int sputs(char *pStr);
void print_byte(char byte);
void print_word(int word);
#endif // LIBSYS_H
lib/CPUs/MIPS/bsp/examples/bootloader/startup_boot.S
+25
View File
@@ -0,0 +1,25 @@
.file "startup.S"
.section .stext,"ax"
.extern _init
.align 2
_start:
.set noreorder
# Set Kernel mode
li $26, 0x1040000C
mtc0 $26, $12
li $26, 0x00000000
mtc0 $26, $13
mfc0 $26, $15
nop
mtc0 $26, $31
# jump init
la $26, _init
jr $26
nop
.set reorder
lib/CPUs/MIPS/bsp/examples/cfiflash.c
+253
View File
@@ -0,0 +1,253 @@
#include <stdio.h>
#include <stdlib.h>
#include "libsys.h"
#include "cfiflash.h"
UINT32 cfi_get_status(flash_t *pObj)
{
volatile UINT32 *pF;
UINT32 status;
pF = (UINT32*)pObj->pBase;
*pF = 0x00700070;
status = *pF;
*pF = 0x00FF00FF;
return status;
}
void cfi_init(flash_t *pObj, UINT32 base_addr)
{
int i;
UINT8 *pInfo;
pObj->pBase = (void*)base_addr;
pInfo = (UINT8*)&pObj->info;
for (i=0; i < sizeof(flash_info_t); i++)
{
pInfo[i] = 0;
}
}
UINT32 cfi_find(flash_t *pObj)
{
int i;
volatile UINT32 *pF;
volatile UINT16 *pF16;
UINT8 qry_ref[12] = {0x51, 0x00, 0x51, 0x00, 0x52, 0x00, 0x52, 0x00, 0x59, 0x00, 0x59, 0x00};
UINT32 size;
pF = (UINT32*)pObj->pBase;
pF16 = (UINT16*)pObj->pBase;
// Look for flash
*pF = 0x00980098;
for (i=0; i < sizeof(qry_ref); i++)
if (((UINT8*)(&pF[0x10]))[i] != qry_ref[i])
return (UINT32)-1;
*pF = 0x00FF00FF;
*pF = 0x00900090;
/*
printf("ManID : %8.8X\n", (UINT32)pF[0]);
printf("Device code : %8.8X\n", (UINT32)pF[1]);
printf("Block info : %8.8X\n", (UINT32)pF[2]);
printf("VCC(min) : %8.8X\n", (UINT32)pF[0x1B]);
printf("VCC(max) : %8.8X\n", (UINT32)pF[0x1C]);
printf("VPP(min) : %8.8X\n", (UINT32)pF[0x1D]);
printf("VPP(max) : %8.8X\n", (UINT32)pF[0x1E]);
printf("Device Layout : %8.8X\n", (UINT32)pF[0x27]);
printf("Interface type : %8.8X %8.8X\n", (UINT32)pF[0x28], (UINT32)pF[0x29]);
printf("Write buffer size : %8.8X %8.8X\n", (UINT32)pF[0x2A], (UINT32)pF[0x2B]);
printf("Num. erase blocks : %8.8X\n", (UINT32)pF[0x2C]);
printf("Erase block info : %8.8X %8.8X %8.8X %8.8X\n", (UINT32)pF[0x2D], (UINT32)pF[0x2E], (UINT32)pF[0x2F], (UINT32)pF[0x30]);
*/
pObj->info.num_flash = 2;
pObj->info.if_width = 32;
size = (UINT32)pF16[2*0x27];
pObj->info.flashsize = pObj->info.num_flash;
for (i=0; i < size; i++)
pObj->info.flashsize *= 2;
size = (UINT32)(pF16[2*0x2B] << 8 | pF16[2*0x2A]);
pObj->info.wbuf_size = pObj->info.num_flash;
for (i=0; i < size; i++)
pObj->info.wbuf_size *= 2;
pObj->info.nblocks = pObj->info.num_flash * ((UINT32)(pF16[2*0x2E] << 8 | pF16[2*0x2D]) + 1);
pObj->info.blocksize = pObj->info.num_flash * ((UINT32)(pF16[2*0x30] << 8 | pF16[2*0x2F]) * 256);
*pF = 0x00FF00FF;
return 0;
}
UINT32 cfi_block_erase(flash_t *pObj, UINT32 word_index)
{
volatile UINT32 *pF;
UINT32 status, block_index, block_mask;
pF = (UINT32*)pObj->pBase;
if (word_index >= (pObj->info.flashsize/4))
return -1;
block_mask = ((pObj->info.nblocks-1) << 16);
block_index = word_index & block_mask;
pF[block_index] = 0x00200020;
pF[block_index] = 0x00D000D0;
do
{
status = pF[block_index];
} while((status & SR_BIT_ISMS) != SR_BIT_ISMS);
pF[block_index] = 0x00FF00FF;
return 0;
}
UINT32 cfi_program_single(flash_t *pObj, UINT32 word_index, UINT32 word)
{
volatile UINT32 *pF;
UINT32 status;
pF = (UINT32*)pObj->pBase;
if (word_index >= (pObj->info.flashsize/4))
return -1;
pF[word_index] = 0x00400040;
pF[word_index] = word;
do
{
status = pF[word_index];
} while((status & SR_BIT_ISMS) != SR_BIT_ISMS);
pF[word_index] = 0x00FF00FF;
return 0;
}
UINT32 cfi_program_multi(flash_t *pObj, UINT32 word_index, UINT32 *pWords, UINT32 num_words)
{
int i, j, k;
volatile UINT32 *pF;
UINT32 status, bcurr, bnext, block_mask, nblock_write, nbuf_write;
pF = (UINT32*)pObj->pBase;
if (word_index >= (pObj->info.flashsize/4))
return -1;
block_mask = ((pObj->info.nblocks-1) << 16);
k = 0;
while(num_words)
{
bcurr = word_index & block_mask;
bnext = bcurr + (1 << 16);
nblock_write = bnext - word_index;
if (nblock_write > num_words)
nblock_write = num_words;
// printf("bcurr : %8.8X\n", bcurr);
// printf("bnext : %8.8X\n", bnext);
// printf("windex : %8.8X\n", word_index);
// printf("num_words : %d\n", num_words);
// printf("nblock_write : %d\n", nblock_write);
while(nblock_write)
{
pF[bcurr] = 0x00E800E8;
do
{
status = pF[bcurr];
// printf("status : %8.8X\n", status);
} while((status & SR_BIT_ISMS) != SR_BIT_ISMS);
nbuf_write = nblock_write;
if (nblock_write > pObj->info.wbuf_size/4)
nbuf_write = pObj->info.wbuf_size/4;
// printf("nbuf_write : %d\n", nbuf_write);
pF[bcurr] = (nbuf_write-1) << 16 | (nbuf_write-1);
for (j=0; j < nbuf_write; j++)
pF[word_index+j] = pWords[k++];
word_index += j;
nblock_write -= j;
num_words -= j;
pF[bcurr] = 0x00D000D0;
do
{
status = pF[bcurr];
// printf("status : %8.8X\n", status);
} while((status & SR_BIT_ISMS) != SR_BIT_ISMS);
pF[bcurr] = 0x00FF00FF;
}
bcurr = bnext;
}
return 0;
}
UINT32 flash_find(flash_t *pObj, UINT32 base_addr)
{
cfi_init(pObj, base_addr);
return cfi_find(pObj);
}
UINT32 flash_erase(flash_t *pObj, UINT32 offset, UINT32 size)
{
int i;
UINT32 offset_end;
offset_end = offset + size;
for (i=offset; i < offset_end; i += pObj->info.blocksize)
if (cfi_block_erase(pObj, i/4) < 0)
return -1;
return 0;
}
UINT32 flash_program(flash_t *pObj, UINT32 offset, UINT8 *pData, UINT32 size)
{
return cfi_program_multi(pObj, offset/4, (UINT32*)pData, size/4);
}
UINT32 flash_verify(flash_t *pObj, UINT32 offset, UINT8 *pData, UINT32 size)
{
int i;
UINT8 *pF;
pF = (UINT8*)(pObj->pBase + offset);
for (i=0; i < size; i++)
if (pF[i] != pData[i])
return -1;
return 0;
}
lib/CPUs/MIPS/bsp/examples/cfiflash.h
+44
View File
@@ -0,0 +1,44 @@
/************************************************************************/
#ifndef CFIFLASH_H
#define CFIFLASH_H
#include "libsys.h"
#define SR_BIT_DPS 0x00020002
#define SR_BIT_PSS 0x00040004
#define SR_BIT_VPENS 0x00080008
#define SR_BIT_PSLBS 0x00100010
#define SR_BIT_ECLBS 0x00200020
#define SR_BIT_ESS 0x00400040
#define SR_BIT_ISMS 0x00800080
typedef struct _sflash_info_t
{
UINT32 flashsize;
UINT32 blocksize;
UINT32 nblocks;
UINT32 wbuf_size;
UINT32 if_width;
UINT32 num_flash;
} flash_info_t;
typedef struct _sflash_t
{
void *pBase;
flash_info_t info;
} flash_t;
void cfi_init(flash_t *pObj, UINT32 base_addr);
UINT32 cfi_find(flash_t *pObj);
UINT32 cfi_block_erase(flash_t *pObj, UINT32 word_index);
UINT32 cfi_program_single(flash_t *pObj, UINT32 word_index, UINT32 word);
UINT32 cfi_program_multi(flash_t *pObj, UINT32 word_index, UINT32 *pWords, UINT32 num_words);
UINT32 flash_find(flash_t *pObj, UINT32 base_addr);
UINT32 flash_erase(flash_t *pObj, UINT32 offset, UINT32 size);
UINT32 flash_program(flash_t *pObj, UINT32 offset, UINT8 *pData, UINT32 size);
UINT32 flash_verify(flash_t *pObj, UINT32 offset, UINT8 *pData, UINT32 size);
#endif // CFIFLASH_H
lib/CPUs/MIPS/bsp/examples/dhry.h
+430
View File
@@ -0,0 +1,430 @@
/*
****************************************************************************
*
* "DHRYSTONE" Benchmark Program
* -----------------------------
*
* Version: C, Version 2.1
*
* File: dhry.h (part 1 of 3)
*
* Date: May 25, 1988
*
* Author: Reinhold P. Weicker
* Siemens AG, E STE 35
* Postfach 3240
* 8520 Erlangen
* Germany (West)
* Phone: [xxx-49]-9131-7-20330
* (8-17 Central European Time)
* Usenet: ..!mcvax!unido!estevax!weicker
*
* Original Version (in Ada) published in
* "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
* pp. 1013 - 1030, together with the statistics
* on which the distribution of statements etc. is based.
*
* In this C version, the following C library functions are used:
* - strcpy, strcmp (inside the measurement loop)
* - printf, scanf (outside the measurement loop)
* In addition, Berkeley UNIX system calls "times ()" or "time ()"
* are used for execution time measurement. For measurements
* on other systems, these calls have to be changed.
*
* Collection of Results:
* Reinhold Weicker (address see above) and
*
* Rick Richardson
* PC Research. Inc.
* 94 Apple Orchard Drive
* Tinton Falls, NJ 07724
* Phone: (201) 389-8963 (9-17 EST)
* Usenet: ...!uunet!pcrat!rick
*
* Please send results to Rick Richardson and/or Reinhold Weicker.
* Complete information should be given on hardware and software used.
* Hardware information includes: Machine type, CPU, type and size
* of caches; for microprocessors: clock frequency, memory speed
* (number of wait states).
* Software information includes: Compiler (and runtime library)
* manufacturer and version, compilation switches, OS version.
* The Operating System version may give an indication about the
* compiler; Dhrystone itself performs no OS calls in the measurement loop.
*
* The complete output generated by the program should be mailed
* such that at least some checks for correctness can be made.
*
***************************************************************************
*
* History: This version C/2.1 has been made for two reasons:
*
* 1) There is an obvious need for a common C version of
* Dhrystone, since C is at present the most popular system
* programming language for the class of processors
* (microcomputers, minicomputers) where Dhrystone is used most.
* There should be, as far as possible, only one C version of
* Dhrystone such that results can be compared without
* restrictions. In the past, the C versions distributed
* by Rick Richardson (Version 1.1) and by Reinhold Weicker
* had small (though not significant) differences.
*
* 2) As far as it is possible without changes to the Dhrystone
* statistics, optimizing compilers should be prevented from
* removing significant statements.
*
* This C version has been developed in cooperation with
* Rick Richardson (Tinton Falls, NJ), it incorporates many
* ideas from the "Version 1.1" distributed previously by
* him over the UNIX network Usenet.
* I also thank Chaim Benedelac (National Semiconductor),
* David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
* Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
* for their help with comments on earlier versions of the
* benchmark.
*
* Changes: In the initialization part, this version follows mostly
* Rick Richardson's version distributed via Usenet, not the
* version distributed earlier via floppy disk by Reinhold Weicker.
* As a concession to older compilers, names have been made
* unique within the first 8 characters.
* Inside the measurement loop, this version follows the
* version previously distributed by Reinhold Weicker.
*
* At several places in the benchmark, code has been added,
* but within the measurement loop only in branches that
* are not executed. The intention is that optimizing compilers
* should be prevented from moving code out of the measurement
* loop, or from removing code altogether. Since the statements
* that are executed within the measurement loop have NOT been
* changed, the numbers defining the "Dhrystone distribution"
* (distribution of statements, operand types and locality)
* still hold. Except for sophisticated optimizing compilers,
* execution times for this version should be the same as
* for previous versions.
*
* Since it has proven difficult to subtract the time for the
* measurement loop overhead in a correct way, the loop check
* has been made a part of the benchmark. This does have
* an impact - though a very minor one - on the distribution
* statistics which have been updated for this version.
*
* All changes within the measurement loop are described
* and discussed in the companion paper "Rationale for
* Dhrystone version 2".
*
* Because of the self-imposed limitation that the order and
* distribution of the executed statements should not be
* changed, there are still cases where optimizing compilers
* may not generate code for some statements. To a certain
* degree, this is unavoidable for small synthetic benchmarks.
* Users of the benchmark are advised to check code listings
* whether code is generated for all statements of Dhrystone.
*
* Version 2.1 is identical to version 2.0 distributed via
* the UNIX network Usenet in March 1988 except that it corrects
* some minor deficiencies that were found by users of version 2.0.
* The only change within the measurement loop is that a
* non-executed "else" part was added to the "if" statement in
* Func_3, and a non-executed "else" part removed from Proc_3.
*
***************************************************************************
*
* Defines: The following "Defines" are possible:
* -DREG=register (default: Not defined)
* As an approximation to what an average C programmer
* might do, the "register" storage class is applied
* (if enabled by -DREG=register)
* - for local variables, if they are used (dynamically)
* five or more times
* - for parameters if they are used (dynamically)
* six or more times
* Note that an optimal "register" strategy is
* compiler-dependent, and that "register" declarations
* do not necessarily lead to faster execution.
* -DNOSTRUCTASSIGN (default: Not defined)
* Define if the C compiler does not support
* assignment of structures.
* -DNOENUMS (default: Not defined)
* Define if the C compiler does not support
* enumeration types.
* -DTIMES (default)
* -DTIME
* The "times" function of UNIX (returning process times)
* or the "time" function (returning wallclock time)
* is used for measurement.
* For single user machines, "time ()" is adequate. For
* multi-user machines where you cannot get single-user
* access, use the "times ()" function. If you have
* neither, use a stopwatch in the dead of night.
* "printf"s are provided marking the points "Start Timer"
* and "Stop Timer". DO NOT use the UNIX "time(1)"
* command, as this will measure the total time to
* run this program, which will (erroneously) include
* the time to allocate storage (malloc) and to perform
* the initialization.
* -DHZ=nnn
* In Berkeley UNIX, the function "times" returns process
* time in 1/HZ seconds, with HZ = 60 for most systems.
* CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY
* A VALUE.
*
***************************************************************************
*
* Compilation model and measurement (IMPORTANT):
*
* This C version of Dhrystone consists of three files:
* - dhry.h (this file, containing global definitions and comments)
* - dhry_1.c (containing the code corresponding to Ada package Pack_1)
* - dhry_2.c (containing the code corresponding to Ada package Pack_2)
*
* The following "ground rules" apply for measurements:
* - Separate compilation
* - No procedure merging
* - Otherwise, compiler optimizations are allowed but should be indicated
* - Default results are those without register declarations
* See the companion paper "Rationale for Dhrystone Version 2" for a more
* detailed discussion of these ground rules.
*
* For 16-Bit processors (e.g. 80186, 80286), times for all compilation
* models ("small", "medium", "large" etc.) should be given if possible,
* together with a definition of these models for the compiler system used.
*
**************************************************************************
*
* Dhrystone (C version) statistics:
*
* [Comment from the first distribution, updated for version 2.
* Note that because of language differences, the numbers are slightly
* different from the Ada version.]
*
* The following program contains statements of a high level programming
* language (here: C) in a distribution considered representative:
*
* assignments 52 (51.0 %)
* control statements 33 (32.4 %)
* procedure, function calls 17 (16.7 %)
*
* 103 statements are dynamically executed. The program is balanced with
* respect to the three aspects:
*
* - statement type
* - operand type
* - operand locality
* operand global, local, parameter, or constant.
*
* The combination of these three aspects is balanced only approximately.
*
* 1. Statement Type:
* ----------------- number
*
* V1 = V2 9
* (incl. V1 = F(..)
* V = Constant 12
* Assignment, 7
* with array element
* Assignment, 6
* with record component
* --
* 34 34
*
* X = Y +|-|"&&"|"|" Z 5
* X = Y +|-|"==" Constant 6
* X = X +|- 1 3
* X = Y *|/ Z 2
* X = Expression, 1
* two operators
* X = Expression, 1
* three operators
* --
* 18 18
*
* if .... 14
* with "else" 7
* without "else" 7
* executed 3
* not executed 4
* for ... 7 | counted every time
* while ... 4 | the loop condition
* do ... while 1 | is evaluated
* switch ... 1
* break 1
* declaration with 1
* initialization
* --
* 34 34
*
* P (...) procedure call 11
* user procedure 10
* library procedure 1
* X = F (...)
* function call 6
* user function 5
* library function 1
* --
* 17 17
* ---
* 103
*
* The average number of parameters in procedure or function calls
* is 1.82 (not counting the function values aX *
*
* 2. Operators
* ------------
* number approximate
* percentage
*
* Arithmetic 32 50.8
*
* + 21 33.3
* - 7 11.1
* * 3 4.8
* / (int div) 1 1.6
*
* Comparison 27 42.8
*
* == 9 14.3
* /= 4 6.3
* > 1 1.6
* < 3 4.8
* >= 1 1.6
* <= 9 14.3
*
* Logic 4 6.3
*
* && (AND-THEN) 1 1.6
* | (OR) 1 1.6
* ! (NOT) 2 3.2
*
* -- -----
* 63 100.1
*
*
* 3. Operand Type (counted once per operand reference):
* ---------------
* number approximate
* percentage
*
* Integer 175 72.3 %
* Character 45 18.6 %
* Pointer 12 5.0 %
* String30 6 2.5 %
* Array 2 0.8 %
* Record 2 0.8 %
* --- -------
* 242 100.0 %
*
* When there is an access path leading to the final operand (e.g. a record
* component), only the final data type on the access path is counted.
*
*
* 4. Operand Locality:
* -------------------
* number approximate
* percentage
*
* local variable 114 47.1 %
* global variable 22 9.1 %
* parameter 45 18.6 %
* value 23 9.5 %
* reference 22 9.1 %
* function result 6 2.5 %
* constant 55 22.7 %
* --- -------
* 242 100.0 %
*
*
* The program does not compute anything meaningful, but it is syntactically
* and semantically correct. All variables have a value assigned to them
* before they are used as a source operand.
*
* There has been no explicit effort to account for the effects of a
* cache, or to balance the use of long or short displacements for code or
* data.
*
***************************************************************************
*/
/* Compiler and system dependent definitions: */
#ifndef TIME
#undef TIMES
#define TIMES
#endif
/* Use times(2) time function unless */
/* explicitly defined otherwise */
#ifdef MSC_CLOCK
#undef HZ
#undef TIMES
#include <time.h>
#define HZ CLK_TCK
#endif
/* Use Microsoft C hi-res clock */
#ifdef TIMES
#include <sys/types.h>
#include <sys/times.h>
/* for "times" */
#endif
#define Mic_secs_Per_Second 1000000.0
/* Berkeley UNIX C returns process times in seconds/HZ */
#ifdef NOSTRUCTASSIGN
#define structassign(d, s) memcpy(&(d), &(s), sizeof(d))
#else
#define structassign(d, s) d = s
#endif
#ifdef NOENUM
#define Ident_1 0
#define Ident_2 1
#define Ident_3 2
#define Ident_4 3
#define Ident_5 4
typedef int Enumeration;
#else
typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
Enumeration;
#endif
/* for boolean and enumeration types in Ada, Pascal */
/* General definitions: */
#include <stdio.h>
/* for strcpy, strcmp */
#define Null 0
/* Value of a Null pointer */
#define true 1
#define false 0
typedef int One_Thirty;
typedef int One_Fifty;
typedef char Capital_Letter;
typedef int Boolean;
typedef char Str_30 [31];
typedef int Arr_1_Dim [50];
typedef int Arr_2_Dim [50] [50];
typedef struct record
{
struct record *Ptr_Comp;
Enumeration Discr;
union {
struct {
Enumeration Enum_Comp;
int Int_Comp;
char Str_Comp [31];
} var_1;
struct {
Enumeration E_Comp_2;
char Str_2_Comp [31];
} var_2;
struct {
char Ch_1_Comp;
char Ch_2_Comp;
} var_3;
} variant;
} Rec_Type, *Rec_Pointer;
lib/CPUs/MIPS/bsp/examples/dhry_1.c
+402
View File
@@ -0,0 +1,402 @@
/*
****************************************************************************
*
* "DHRYSTONE" Benchmark Program
* -----------------------------
*
* Version: C, Version 2.1
*
* File: dhry_1.c (part 2 of 3)
*
* Date: May 25, 1988
*
* Author: Reinhold P. Weicker
*
****************************************************************************
*/
#include "dhry.h"
/* Global Variables: */
Rec_Pointer Ptr_Glob,
Next_Ptr_Glob;
int Int_Glob;
Boolean Bool_Glob;
char Ch_1_Glob,
Ch_2_Glob;
int Arr_1_Glob [50];
int Arr_2_Glob [50] [50];
extern char *malloc ();
Enumeration Func_1 ();
/* forward declaration necessary since Enumeration may not simply be int */
#ifndef REG
Boolean Reg = false;
#define REG
/* REG becomes defined as empty */
/* i.e. no register variables */
#else
Boolean Reg = true;
#endif
/* variables for time measurement: */
#ifdef TIMES
struct tms time_info;
/* see library function "times" */
#define Too_Small_Time (2*HZ)
/* Measurements should last at least about 2 seconds */
#endif
#ifdef TIME
extern long time();
/* see library function "time" */
#define Too_Small_Time 2
/* Measurements should last at least 2 seconds */
#endif
#ifdef MSC_CLOCK
extern clock_t clock();
#define Too_Small_Time (2*HZ)
#endif
long Begin_Time,
End_Time,
User_Time;
float Microseconds,
Dhrystones_Per_Second;
/* end of variables for time measurement */
main ()
/*****/
/* main program, corresponds to procedures */
/* Main and Proc_0 in the Ada version */
{
One_Fifty Int_1_Loc;
REG One_Fifty Int_2_Loc;
One_Fifty Int_3_Loc;
REG char Ch_Index;
Enumeration Enum_Loc;
Str_30 Str_1_Loc;
Str_30 Str_2_Loc;
REG int Run_Index;
REG int Number_Of_Runs;
/* Initializations */
Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
Ptr_Glob->Discr = Ident_1;
Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
Ptr_Glob->variant.var_1.Int_Comp = 40;
strcpy (Ptr_Glob->variant.var_1.Str_Comp,
"DHRYSTONE PROGRAM, SOME STRING");
strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
Arr_2_Glob [8][7] = 10;
/* Was missing in published program. Without this statement, */
/* Arr_2_Glob [8][7] would have an undefined value. */
/* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
/* overflow may occur for this array element. */
/*
printf ("\n");
printf ("Dhrystone Benchmark, Version 2.1 (Language: C)\n");
printf ("\n");
if (Reg)
{
printf ("Program compiled with 'register' attribute\n");
printf ("\n");
}
else
{
printf ("Program compiled without 'register' attribute\n");
printf ("\n");
}
printf ("Please give the number of runs through the benchmark: ");
{
int n;
scanf ("%d", &n);
Number_Of_Runs = n;
}
printf ("\n");
*/
#ifdef NRUNS
Number_Of_Runs = NRUNS;
#else
Number_Of_Runs = 2000000;
#endif
printf ("Execution starts, %d runs through Dhrystone\n", Number_Of_Runs);
/***************/
/* Start timer */
/***************/
#ifdef TIMES
times (&time_info);
Begin_Time = (long) time_info.tms_utime;
#endif
#ifdef TIME
Begin_Time = time ( (long *) 0);
#endif
#ifdef MSC_CLOCK
Begin_Time = clock();
#endif
for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
{
Proc_5();
Proc_4();
/* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
Int_1_Loc = 2;
Int_2_Loc = 3;
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
Enum_Loc = Ident_2;
Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
/* Bool_Glob == 1 */
while (Int_1_Loc < Int_2_Loc) /* loop body executed once */
{
Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
/* Int_3_Loc == 7 */
Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
/* Int_3_Loc == 7 */
Int_1_Loc += 1;
} /* while */
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
/* Int_Glob == 5 */
Proc_1 (Ptr_Glob);
for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
/* loop body executed twice */
{
if (Enum_Loc == Func_1 (Ch_Index, 'C'))
/* then, not executed */
{
Proc_6 (Ident_1, &Enum_Loc);
strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
Int_2_Loc = Run_Index;
Int_Glob = Run_Index;
}
}
/* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
Int_2_Loc = Int_2_Loc * Int_1_Loc;
Int_1_Loc = Int_2_Loc / Int_3_Loc;
Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
/* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
Proc_2 (&Int_1_Loc);
/* Int_1_Loc == 5 */
} /* loop "for Run_Index" */
/**************/
/* Stop timer */
/**************/
#ifdef TIMES
times (&time_info);
End_Time = (long) time_info.tms_utime;
#endif
#ifdef TIME
End_Time = time ( (long *) 0);
#endif
#ifdef MSC_CLOCK
End_Time = clock();
#endif
/*
printf ("Execution ends\n");
printf ("\n");
printf ("Final values of the variables used in the benchmark:\n");
printf ("\n");
printf ("Int_Glob: %d\n", Int_Glob);
printf (" should be: %d\n", 5);
printf ("Bool_Glob: %d\n", Bool_Glob);
printf (" should be: %d\n", 1);
printf ("Ch_1_Glob: %c\n", Ch_1_Glob);
printf (" should be: %c\n", 'A');
printf ("Ch_2_Glob: %c\n", Ch_2_Glob);
printf (" should be: %c\n", 'B');
printf ("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]);
printf (" should be: %d\n", 7);
printf ("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]);
printf (" should be: Number_Of_Runs + 10\n");
printf ("Ptr_Glob->\n");
printf (" Ptr_Comp: %d\n", (int) Ptr_Glob->Ptr_Comp);
printf (" should be: (implementation-dependent)\n");
printf (" Discr: %d\n", Ptr_Glob->Discr);
printf (" should be: %d\n", 0);
printf (" Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
printf (" should be: %d\n", 2);
printf (" Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp);
printf (" should be: %d\n", 17);
printf (" Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp);
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
printf ("Next_Ptr_Glob->\n");
printf (" Ptr_Comp: %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
printf (" should be: (implementation-dependent), same as above\n");
printf (" Discr: %d\n", Next_Ptr_Glob->Discr);
printf (" should be: %d\n", 0);
printf (" Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
printf (" should be: %d\n", 1);
printf (" Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
printf (" should be: %d\n", 18);
printf (" Str_Comp: %s\n",
Next_Ptr_Glob->variant.var_1.Str_Comp);
printf (" should be: DHRYSTONE PROGRAM, SOME STRING\n");
printf ("Int_1_Loc: %d\n", Int_1_Loc);
printf (" should be: %d\n", 5);
printf ("Int_2_Loc: %d\n", Int_2_Loc);
printf (" should be: %d\n", 13);
printf ("Int_3_Loc: %d\n", Int_3_Loc);
printf (" should be: %d\n", 7);
printf ("Enum_Loc: %d\n", Enum_Loc);
printf (" should be: %d\n", 1);
printf ("Str_1_Loc: %s\n", Str_1_Loc);
printf (" should be: DHRYSTONE PROGRAM, 1'ST STRING\n");
printf ("Str_2_Loc: %s\n", Str_2_Loc);
printf (" should be: DHRYSTONE PROGRAM, 2'ND STRING\n");
printf ("\n");
*/
User_Time = End_Time - Begin_Time;
if (User_Time < Too_Small_Time)
{
printf ("Measured time too small to obtain meaningful results\n");
printf ("Please increase number of runs\n");
printf ("\n");
}
else
{
#ifdef TIME
Microseconds = (float) User_Time * Mic_secs_Per_Second
/ (float) Number_Of_Runs;
Dhrystones_Per_Second = (float) Number_Of_Runs / (float) User_Time;
#else
Microseconds = (float) User_Time * Mic_secs_Per_Second
/ ((float) HZ * ((float) Number_Of_Runs));
Dhrystones_Per_Second = ((float) HZ * (float) Number_Of_Runs)
/ (float) User_Time;
#endif
printf ("Microseconds for one run through Dhrystone: ");
printf ("%6.1f \n", Microseconds);
printf ("Dhrystones per Second: ");
printf ("%6.1f \n", Dhrystones_Per_Second);
printf ("\n");
printf ("This equals to %6.1f DMIPS\n", Dhrystones_Per_Second/1757);
}
}
Proc_1 (Ptr_Val_Par)
/******************/
REG Rec_Pointer Ptr_Val_Par;
/* executed once */
{
REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
/* == Ptr_Glob_Next */
/* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */
/* corresponds to "rename" in Ada, "with" in Pascal */
structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
Ptr_Val_Par->variant.var_1.Int_Comp = 5;
Next_Record->variant.var_1.Int_Comp
= Ptr_Val_Par->variant.var_1.Int_Comp;
Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
Proc_3 (&Next_Record->Ptr_Comp);
/* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
== Ptr_Glob->Ptr_Comp */
if (Next_Record->Discr == Ident_1)
/* then, executed */
{
Next_Record->variant.var_1.Int_Comp = 6;
Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
&Next_Record->variant.var_1.Enum_Comp);
Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
&Next_Record->variant.var_1.Int_Comp);
}
else /* not executed */
structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
} /* Proc_1 */
Proc_2 (Int_Par_Ref)
/******************/
/* executed once */
/* *Int_Par_Ref == 1, becomes 4 */
One_Fifty *Int_Par_Ref;
{
One_Fifty Int_Loc;
Enumeration Enum_Loc;
Int_Loc = *Int_Par_Ref + 10;
do /* executed once */
if (Ch_1_Glob == 'A')
/* then, executed */
{
Int_Loc -= 1;
*Int_Par_Ref = Int_Loc - Int_Glob;
Enum_Loc = Ident_1;
} /* if */
while (Enum_Loc != Ident_1); /* true */
} /* Proc_2 */
Proc_3 (Ptr_Ref_Par)
/******************/
/* executed once */
/* Ptr_Ref_Par becomes Ptr_Glob */
Rec_Pointer *Ptr_Ref_Par;
{
if (Ptr_Glob != Null)
/* then, executed */
*Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
} /* Proc_3 */
Proc_4 () /* without parameters */
/*******/
/* executed once */
{
Boolean Bool_Loc;
Bool_Loc = Ch_1_Glob == 'A';
Bool_Glob = Bool_Loc | Bool_Glob;
Ch_2_Glob = 'B';
} /* Proc_4 */
Proc_5 () /* without parameters */
/*******/
/* executed once */
{
Ch_1_Glob = 'A';
Bool_Glob = false;
} /* Proc_5 */
/* Procedure for the assignment of structures, */
/* if the C compiler doesn't support this feature */
#ifdef NOSTRUCTASSIGN
memcpy (d, s, l)
register char *d;
register char *s;
register int l;
{
while (l--) *d++ = *s++;
}
#endif
lib/CPUs/MIPS/bsp/examples/dhry_2.c
+192
View File
@@ -0,0 +1,192 @@
/*
****************************************************************************
*
* "DHRYSTONE" Benchmark Program
* -----------------------------
*
* Version: C, Version 2.1
*
* File: dhry_2.c (part 3 of 3)
*
* Date: May 25, 1988
*
* Author: Reinhold P. Weicker
*
****************************************************************************
*/
#include "dhry.h"
#ifndef REG
#define REG
/* REG becomes defined as empty */
/* i.e. no register variables */
#endif
extern int Int_Glob;
extern char Ch_1_Glob;
Proc_6 (Enum_Val_Par, Enum_Ref_Par)
/*********************************/
/* executed once */
/* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
Enumeration Enum_Val_Par;
Enumeration *Enum_Ref_Par;
{
*Enum_Ref_Par = Enum_Val_Par;
if (! Func_3 (Enum_Val_Par))
/* then, not executed */
*Enum_Ref_Par = Ident_4;
switch (Enum_Val_Par)
{
case Ident_1:
*Enum_Ref_Par = Ident_1;
break;
case Ident_2:
if (Int_Glob > 100)
/* then */
*Enum_Ref_Par = Ident_1;
else *Enum_Ref_Par = Ident_4;
break;
case Ident_3: /* executed */
*Enum_Ref_Par = Ident_2;
break;
case Ident_4: break;
case Ident_5:
*Enum_Ref_Par = Ident_3;
break;
} /* switch */
} /* Proc_6 */
Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
/**********************************************/
/* executed three times */
/* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3, */
/* Int_Par_Ref becomes 7 */
/* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
/* Int_Par_Ref becomes 17 */
/* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
/* Int_Par_Ref becomes 18 */
One_Fifty Int_1_Par_Val;
One_Fifty Int_2_Par_Val;
One_Fifty *Int_Par_Ref;
{
One_Fifty Int_Loc;
Int_Loc = Int_1_Par_Val + 2;
*Int_Par_Ref = Int_2_Par_Val + Int_Loc;
} /* Proc_7 */
Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
/*********************************************************************/
/* executed once */
/* Int_Par_Val_1 == 3 */
/* Int_Par_Val_2 == 7 */
Arr_1_Dim Arr_1_Par_Ref;
Arr_2_Dim Arr_2_Par_Ref;
int Int_1_Par_Val;
int Int_2_Par_Val;
{
REG One_Fifty Int_Index;
REG One_Fifty Int_Loc;
Int_Loc = Int_1_Par_Val + 5;
Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
Int_Glob = 5;
} /* Proc_8 */
Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
/*************************************************/
/* executed three times */
/* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
/* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
/* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
Capital_Letter Ch_1_Par_Val;
Capital_Letter Ch_2_Par_Val;
{
Capital_Letter Ch_1_Loc;
Capital_Letter Ch_2_Loc;
Ch_1_Loc = Ch_1_Par_Val;
Ch_2_Loc = Ch_1_Loc;
if (Ch_2_Loc != Ch_2_Par_Val)
/* then, executed */
return (Ident_1);
else /* not executed */
{
Ch_1_Glob = Ch_1_Loc;
return (Ident_2);
}
} /* Func_1 */
Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
/*************************************************/
/* executed once */
/* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
/* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
Str_30 Str_1_Par_Ref;
Str_30 Str_2_Par_Ref;
{
REG One_Thirty Int_Loc;
Capital_Letter Ch_Loc;
Int_Loc = 2;
while (Int_Loc <= 2) /* loop body executed once */
if (Func_1 (Str_1_Par_Ref[Int_Loc],
Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
/* then, executed */
{
Ch_Loc = 'A';
Int_Loc += 1;
} /* if, while */
if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
/* then, not executed */
Int_Loc = 7;
if (Ch_Loc == 'R')
/* then, not executed */
return (true);
else /* executed */
{
if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
/* then, not executed */
{
Int_Loc += 7;
Int_Glob = Int_Loc;
return (true);
}
else /* executed */
return (false);
} /* if Ch_Loc */
} /* Func_2 */
Boolean Func_3 (Enum_Par_Val)
/***************************/
/* executed once */
/* Enum_Par_Val == Ident_3 */
Enumeration Enum_Par_Val;
{
Enumeration Enum_Loc;
Enum_Loc = Enum_Par_Val;
if (Enum_Loc == Ident_3)
/* then, executed */
return (true);
else /* not executed */
return (false);
} /* Func_3 */
lib/CPUs/MIPS/bsp/examples/hello.c
+18
View File
@@ -0,0 +1,18 @@
#include "libsys.h"
int main (void)
{
UINT32 *pGPIO0 = (UINT32*)sys_gpio0;
UINT32 *pGPIO1 = (UINT32*)sys_gpio1;
*pGPIO0 = 0x55555555;
*pGPIO1 = 0x55555555;
sputs("Hello world!");
*pGPIO0 = 0xAAAAAAAA;
*pGPIO1 = 0xAAAAAAAA;
return 0;
}
lib/CPUs/MIPS/bsp/examples/init.S
+44
View File
@@ -0,0 +1,44 @@
.file "init.S"
.text
.align 2
.globl _init
.extern end
_init:
.set noreorder
# set uart
la $8, sys_uart_baud
addiu $9, $0, baudrate
sb $9, 0($8)
# set stack pointer
la $sp, stack_ptr
# zero bss
la $8, __bss_start
la $9, __bss_end
$zeroise:
sw $0, 0($8)
bne $8, $9, $zeroise
addiu $8, 4
# zero sbss
# la $8, __sbss_start
# la $9, __sbss_end
#$szeroise:
# sw $0, 0($8)
# bne $8, $9, $szeroise
# addiu $8, 4
# jump main
la $8, main
jalr $8
_terminate:
nop
j _terminate
nop
.set reorder
lib/CPUs/MIPS/bsp/examples/irq.c
+91
View File
@@ -0,0 +1,91 @@
#include <sys/times.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include "libsys.h"
#include "regdef.h"
#include "xcpt.h"
#include "irq.h"
static fp_t g_irq_handler[MAX_NUM_IRQ] = {NULL};
int _irq_dispatch(struct xcptcontext * xcp)
{
int i, ip;
ip = (xcp->cr >> 8) & 0xFF;
for (i=0; i < MAX_NUM_IRQ; i++)
{
if (ip & 1)
if (g_irq_handler[i])
(g_irq_handler[i])();
ip >>= 1;
}
return 0;
}
void interrupt_register(int irq_num, fp_t fp)
{
if ((irq_num >= 0) && (irq_num < MAX_NUM_IRQ))
g_irq_handler[irq_num] = fp;
}
void interrupt_enable(int irq_num)
{
reg_t reg, im;
if ((irq_num >= 0) && (irq_num < MAX_NUM_IRQ))
{
im = 1 << irq_num;
reg = CP0_SR_read();
reg |= (SR_MASK_IM & (im << 8));
CP0_SR_write(reg);
}
}
void interrupt_disable(int irq_num)
{
reg_t reg, im;
if ((irq_num >= 0) && (irq_num < MAX_NUM_IRQ))
{
im = 1 << irq_num;
reg = CP0_SR_read();
reg &= ~(SR_MASK_IM & (im << 8));
CP0_SR_write(reg);
}
}
void interrupt_set(int irq_num)
{
reg_t reg, ip;
if ((irq_num >= 0) && (irq_num < MAX_NUM_IRQ))
{
ip = 1 << irq_num;
reg = CP0_CR_read();
reg |= (CR_MASK_IP & (ip << 8));
CP0_CR_write(reg);
}
}
void interrupt_clr(int irq_num)
{
reg_t reg, ip;
if ((irq_num >= 0) && (irq_num < MAX_NUM_IRQ))
{
ip = 1 << irq_num;
reg = CP0_CR_read();
reg &= ~(CR_MASK_IP & (ip << 8));
CP0_CR_write(reg);
}
}
lib/CPUs/MIPS/bsp/examples/irq.h
+15
View File
@@ -0,0 +1,15 @@
#ifndef IRQ_H
#define IRQ_H
#include "xcpt.h"
#define MAX_NUM_IRQ 8
typedef void (*fp_t)(void);
int _irq_dispatch(struct xcptcontext * xcp);
void interrupt_register(int irq_num, fp_t fp);
void interrupt_enable(int irq_num);
void interrupt_disable(int irq_num);
#endif // IRQ_H
lib/CPUs/MIPS/bsp/examples/kernel.S
+180
View File
@@ -0,0 +1,180 @@
#include <regdef.h>
#include <xcpt_asm.h>
.section .ktext,"ax"
LEAF(xcptlow_handler)
.set noreorder
.set noat
/* Note: exceptions do not save and restore registers k0 and k1.
* on entry, k1 = exception class.
*/
/* allocate exception stack frame (on 8-byte boundary) */
subu k1, sp, XCP_SIZE
srl k1, 3 /* shift right/left -> alligned on boundary */
sll k1, 3
/* save enough registers to get by */
sw AT, XCP_AT(k1)
sw v0, XCP_V0(k1)
sw v1, XCP_V1(k1)
sw a0, XCP_A0(k1)
sw a1, XCP_A1(k1)
sw a2, XCP_A2(k1)
sw a3, XCP_A3(k1)
sw sp, XCP_SP(k1)
sw ra, XCP_RA(k1)
/* get coprocessor 0 exception state */
mfc0 a0, CP0_CR
mfc0 a1, CP0_SR
mfc0 a2, CP0_BADDR
mfc0 a3, CP0_EPC
/* we can safely use AT now */
.set at
/* switch to using sp to point at exception frame */
move sp, k1
/* nothing sensible to store for k0/k1, store zero */
sw zero, XCP_K0(sp)
sw zero, XCP_K1(sp)
/* we are now interruptible: dump all remaining state
* into the exception stack frame.
*/
/* coprocessor exception state */
sw a0, XCP_CR(sp)
sw a1, XCP_SR(sp)
sw a2, XCP_BADDR(sp)
sw a3, XCP_EPC(sp)
/* mdhi and mdlo */
mfhi v0
mflo v1
sw v0, XCP_MDHI(sp)
sw v1, XCP_MDLO(sp)
/* Save all the other general registers.
* We save zero, s0-s7 and s8 as well, as instruction emulators (e.g. FP
* operations) and debuggers rely on all registers stored together in
* well-defined structure.
*/
sw zero, XCP_ZERO(sp)
sw t0, XCP_T0(sp)
sw t1, XCP_T1(sp)
sw t2, XCP_T2(sp)
sw t3, XCP_T3(sp)
sw t4, XCP_T4(sp)
sw t5, XCP_T5(sp)
sw t6, XCP_T6(sp)
sw t7, XCP_T7(sp)
sw s0, XCP_S0(sp)
sw s1, XCP_S1(sp)
sw s2, XCP_S2(sp)
sw s3, XCP_S3(sp)
sw s4, XCP_S4(sp)
sw s5, XCP_S5(sp)
sw s6, XCP_S6(sp)
sw s7, XCP_S7(sp)
sw t8, XCP_T8(sp)
sw t9, XCP_T9(sp)
sw gp, XCP_GP(sp)
sw s8, XCP_S8(sp)
/* I don't know what the following does. [rb] */
/* load our _gp pointer */
# la gp, _gp
/* and call the C exception handler */
move a0, sp # arg1 = &xcp
subu sp, 16 # (arg save area)
j _xcptcall
move ra, zero # fake return address
/* This strange call to _xcptcall with zero return address is to
* help exception-aware debuggers to trace back over the exception event.
* We are basically interposing a bogus stackframe (with a zero return
* address) between the C exception handler and the actual machine
* exception.
*/
xcptrest:
.set noat
add AT, sp, 16
/* at points to exception frame */
xcptrestother:
/* restore all state */
/* restore most general registers */
lw t0, XCP_T0(AT)
lw t1, XCP_T1(AT)
lw t2, XCP_T2(AT)
lw t3, XCP_T3(AT)
lw t4, XCP_T4(AT)
lw t5, XCP_T5(AT)
lw t6, XCP_T6(AT)
lw t7, XCP_T7(AT)
lw s0, XCP_S0(AT)
lw s1, XCP_S1(AT)
lw s2, XCP_S2(AT)
lw s3, XCP_S3(AT)
lw s4, XCP_S4(AT)
lw s5, XCP_S5(AT)
lw s6, XCP_S6(AT)
lw s7, XCP_S7(AT)
lw t8, XCP_T8(AT)
lw t9, XCP_T9(AT)
lw gp, XCP_GP(AT)
lw s8, XCP_S8(AT)
/* mdhi and mdlo */
lw v0, XCP_MDHI(AT)
lw v1, XCP_MDLO(AT)
mthi v0
mtlo v1
/* remaining general registers */
lw a0, XCP_A0(AT)
lw a1, XCP_A1(AT)
lw a2, XCP_A2(AT)
lw a3, XCP_A3(AT)
lw ra, XCP_RA(AT)
/* restore the exception-time status register */
.set noreorder
lw v0, XCP_SR(AT)
nop
mtc0 v0, CP0_SR
lw v1, XCP_V1(AT)
lw v0, XCP_V0(AT)
lw sp, XCP_SP(AT)
/* we are not uninterruptible and can use k1 safely */
lw k1, XCP_EPC(AT)
lw AT, XCP_AT(AT)
mtc0 k1, CP0_EPC
j k1
rfe
.set reorder
.set at
END(xcptlow_handler)
LEAF(_xcptcall)
/* on entry: a0 == &xcp */
subu sp, 24
sw ra, 16(sp)
/* punt out to _xcpt_deliver */
jal _xcpt_deliver
nop
lw ra, 16(sp)
addu sp, 24
beqz ra, xcptrest
nop
j ra
nop
END(_xcptcall)
lib/CPUs/MIPS/bsp/examples/kernel_sim.S
+260
View File
@@ -0,0 +1,260 @@
.file "kernel.s"
.equ stack_ptr, 0x7FFFEFFC
.equ baudrate, 0x0D
.equ sys_led_port, 0xA0000000
.equ sys_uart_baud, 0xA0000009
.equ sys_uart_stat, 0xA0000008
.equ sys_uart_data, 0xA0000004
.equ sys_timer_sec, 0xA0000014
.equ sys_timer_usec, 0xA0000010
.section .kdata,"a"
.align 2
_k_stack: .space 256, 0
_k_msg1: .asciiz "Exception at "
_k_msg2: .asciiz "EPC : "
_k_msg3: .asciiz "Cause : "
_k_msg4: .asciiz "Status : "
_k_msg5: .asciiz "BadVAddr : "
_k_crlf: .asciiz "\r\n"
_k_hextbl: .ascii "0123456789ABCDEF"
.section .ktext,"ax"
.align 2
.globl _kputs
.macro kpush reg
addiu $sp, 4
sw \reg, 0($sp)
.endm
.macro kpop reg
lw \reg, 0($sp)
addiu $sp, -4
.endm
_exc_handler:
sw $sp, _k_stack
la $sp, _k_stack
kpush $8
kpush $9
kpush $10
kpush $11
kpush $12
kpush $31
.set noreorder
# # Get BadVAddr
# mfc0 $10, $8
# kpush $10
# # Get Status
# mfc0 $10, $12
# kpush $10
# # Get Cause
# mfc0 $10, $13
# kpush $10
# srl $10, 29
# andi $11, $10, 4
# # Get EPC
# mfc0 $10, $14
# kpush $10
#
# # Get real EPC
# addu $10, $11
# kpush $10
#
# # set uart
# la $26, sys_uart_baud
# addiu $27, $0, baudrate
# sb $27, 0($26)
#
# # Print CRLF
# la $11, _k_crlf
# jal _kputs
# nop
#
# # Print real EPC
# la $11, _k_msg1
# jal _kputs
# nop
# kpop $10
# jal _kprint_word
# nop
# la $11, _k_crlf
# jal _kputs
# nop
#
# # Print EPC
# la $11, _k_msg2
# jal _kputs
# nop
# kpop $10
# jal _kprint_word
# nop
# la $11, _k_crlf
# jal _kputs
# nop
#
# # Print Cause
# la $11, _k_msg3
# jal _kputs
# nop
# kpop $10
# jal _kprint_word
# nop
# la $11, _k_crlf
# jal _kputs
# nop
#
# # Print Status
# la $11, _k_msg4
# jal _kputs
# nop
# kpop $10
# jal _kprint_word
# nop
# la $11, _k_crlf
# jal _kputs
# nop
#
# # Print BadVAddr
# la $11, _k_msg5
# jal _kputs
# nop
# kpop $10
# jal _kprint_word
# nop
# la $11, _k_crlf
# jal _kputs
# nop
#
# Set Error LED and ExcCode LEDs
# Get Cause
# mfc0 $26, $13
# la $27, sys_led_port
# srl $26, 2
# andi $26, 0x000F
# or $26, $27
# sw $26, 0($27)
# wait for all interrupts = 0
#$w4x: mfc0 $26, $13
# mfc0 $27, $12
# srl $26, 8
# srl $27, 8
# and $26, $27
# bnez $26, $w4x
# Get return address
mfc0 $26, $14
$no_int: kpop $31
kpop $12
kpop $11
kpop $10
kpop $9
kpop $8
lw $sp, _k_stack
# Return
jr $26
rfe
.set reorder
# word = $10
_kprint_word:
.set noreorder
kpush $31
kpush $10
srl $10, 16
jal _kprint_halfword
nop
kpop $10
jal _kprint_halfword
nop
kpop $31
jr $31
nop
.set noreorder
# halfword = $10
_kprint_halfword:
.set noreorder
kpush $31
kpush $10
srl $10, 8
jal _kprint_byte
nop
kpop $10
jal _kprint_byte
nop
kpop $31
jr $31
nop
.set noreorder
# byte = $10
_kprint_byte:
.set noreorder
kpush $31
kpush $10
srl $10, 4
jal _kprint_nibble
nop
kpop $10
jal _kprint_nibble
nop
kpop $31
jr $31
nop
.set noreorder
_kprint_nibble:
.set noreorder
kpush $31
kpush $10
la $12, _k_hextbl
andi $10, 0xF
addu $12, $10
lbu $10, 0($12)
jal _ksaus
nop
kpop $10
kpop $31
jr $31
nop
.set noreorder
# char = $10
_ksaus:
.set noreorder
la $8, sys_uart_stat
lbu $8, 0($8)
la $9, sys_uart_data
andi $8, 0x02
bnez $8, _ksaus
nop
j $31
sb $10, 0($9)
.set reorder
_kputs:
.set noreorder
kpush $11
kpush $31
$kpl: lbu $10, 0($11)
addiu $11, 1
blez $10, $kpex
nop
jal _ksaus
nop
j $kpl
nop
$kpex: kpop $31
kpop $11
jr $31
nop
.set reorder
lib/CPUs/MIPS/bsp/examples/libsys.c
+440
View File
@@ -0,0 +1,440 @@
#include <sys/times.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include "libsys.h"
// ---------------------------------------------------------------------------------
// MIPS specific
UINT32 CP0_SR_read(void)
{
UINT32 result;
__asm
(
"mfc0 %[val], $12\n"
: [val] "=r" (result)
);
return result;
}
void CP0_SR_write(UINT32 val)
{
__asm
(
"mtc0 %[val], $12\n"
: /* no output */
: [val] "r" (val)
);
}
UINT32 CP0_CR_read(void)
{
UINT32 result;
__asm
(
"mfc0 %[val], $13\n"
: [val] "=r" (result)
);
return result;
}
void CP0_CR_write(UINT32 val)
{
__asm
(
"mtc0 %[val], $13\n"
:
: [val] "r" (val)
);
}
UINT32 CP0_TR_read(void)
{
UINT32 result;
__asm
(
"mfc0 %[val], $31\n"
: [val] "=r" (result)
);
return result;
}
void CP0_TR_write(UINT32 val)
{
__asm
(
"mtc0 %[val], $31\n"
:
: [val] "r" (val)
);
}
UINT32 CP0_PRID_read(void)
{
UINT32 result;
__asm
(
"mfc0 %[val], $15\n"
: [val] "=r" (result)
);
return result;
}
// ---------------------------------------------------------------------------------
char readchar(void)
{
volatile UINT32 *pUART_stat = (UINT32*)sys_uart_stat;
volatile UINT32 *pUART_data = (UINT32*)sys_uart_data;
while(!(0x10 & *pUART_stat));
return (char)*pUART_data;
}
void writechar(char c)
{
volatile UINT32 *pUART_stat = (UINT32*)sys_uart_stat;
volatile UINT32 *pUART_data = (UINT32*)sys_uart_data;
while((0x01 & *pUART_stat) != 0);
*pUART_data = (UINT32)c;
}
void _putchar(char c)
{
if (c == 0x0A)
{
writechar(0x0D);
}
writechar(c);
}
void cg_writechar(char c)
{
volatile UINT32 *pCG_data = (UINT32*)sys_vga_data;
while (!(*pCG_data & 1));
*pCG_data = (UINT32)c;
}
void cg_clr_line(void)
{
volatile UINT32 *pCG_clrline = (UINT32*)sys_vga_clrline;
while (!(*pCG_clrline & 1));
*pCG_clrline = 1;
}
void _cg_putchar(char c)
{
if (c == 0x0A)
{
cg_writechar(0x0D);
}
cg_writechar(c);
if (c == 0x0A)
cg_clr_line();
}
void _exit (int exitcode)
{
sputs("_exit(");
print_word(exitcode);
sputs(")\n");
while(1);
}
void sleep(unsigned ms)
{
unsigned stop;
struct tms t;
times(&t);
stop = t.tms_utime + ms;
do
{
times(&t);
} while (t.tms_utime < stop);
}
int getrusage(int who, struct rusage *usage)
{
volatile long *pReg_usec = (long*)sys_timer_usec;
volatile long *pReg_sec = (long*)sys_timer_sec;
// who: RUSAGE_SELF or RUSAGE_CHILDREN
usage->ru_utime.tv_usec = *pReg_usec;
usage->ru_utime.tv_sec = *pReg_sec;
usage->ru_stime.tv_usec = *pReg_usec;
usage->ru_stime.tv_sec = *pReg_sec;
}
clock_t times(struct tms *buffer)
{
volatile long *pReg_usec = (long*)sys_timer_usec;
volatile long *pReg_sec = (long*)sys_timer_sec;
long sec;
long usec;
sec = *pReg_sec;
usec = *pReg_usec;
if (buffer)
{
buffer->tms_utime = sec*1000 + usec/1000;
buffer->tms_stime = 0;
buffer->tms_cutime = 0;
buffer->tms_cstime = 0;
}
return (clock_t)sec;
}
int gettimeofday(struct timeval *tp, void *tzp)
{
volatile long *pReg_usec = (long*)sys_timer_usec;
volatile long *pReg_sec = (long*)sys_timer_sec;
if (tp)
{
tp->tv_sec = *pReg_sec;
tp->tv_usec = *pReg_usec;
}
return 0;
}
int settimeofday(const struct timeval *tp, const struct timezone *tzp)
{
volatile long *pReg_usec = (long*)sys_timer_usec;
volatile long *pReg_sec = (long*)sys_timer_sec;
div_t res;
res = div(tp->tv_usec, 1E6);
if (tp)
{
*pReg_usec = res.rem;
*pReg_sec = tp->tv_sec + res.quot;
}
return 0;
}
caddr_t sbrk(int incr)
{
extern char end;
static char *heap_end;
char *prev_heap_end;
if (heap_end == 0)
heap_end = &end;
prev_heap_end = heap_end;
// if (heap_end + incr > stack_ptr)
// {
// sputs("Heap and stack collision\r\n");
// abort();
// }
// sputs("\n");
// print_word((int)prev_heap_end);
// sputs("\n");
heap_end += incr;
return (caddr_t) prev_heap_end;
}
int fstat(int file, struct stat *st)
{
// sputs("Fstat()\n");
st->st_mode = S_IFCHR;
st->st_blksize = 0;
return 0;
}
int lseek(int file, int ptr, int dir)
{
sputs("Lseek()\n");
errno = ESPIPE;
return -1;
}
int open(const char *name, int flags, int mode)
{
sputs("Open()\n");
errno = EIO;
return -1;
}
int close(int file)
{
sputs("Close()\n");
return 0;
}
int read(int file, char *ptr, int len)
{
int i;
// sputs("Read()\n");
for (i = 0; i < len; i++)
{
ptr[i] = readchar();
if ((ptr[i] == '\n') || (ptr[i] == '\r'))
{
i++;
writechar(0x0D);
writechar(0x0A);
break;
}
writechar(ptr[i]);
}
return i;
}
int write(int file, char *ptr, int len)
{
int i;
if (file == 1)
{
for (i=0; i < len; i++)
STDOUT_FUNCTION(*ptr++);
}
if (file == 2)
{
for (i=0; i < len; i++)
STDERR_FUNCTION(*ptr++);
}
return i;
}
int isatty(int file)
{
// sputs("Isatty()\n");
return 1;
}
int sputs(char *pStr)
{
char *start;
start = pStr;
while(*pStr)
_putchar(*(pStr++));
return pStr - start;
}
void print_byte(char byte)
{
int i;
unsigned char c, nibble;
for (i=0; i < 2; i++)
{
nibble = (char)((byte >> 4) & 0xF);
byte <<= 4;
if (nibble < 10)
c = nibble + '0';
else
c = nibble + 'A' - 10;
_putchar(c);
}
}
void print_word(int word)
{
int i;
unsigned char c, nibble;
for (i=0; i < 4; i++)
{
c = (char) (word >> 24);
print_byte(c);
word <<= 8;
}
}
// ---------------------------------------------------------------------------------
// PrintBuffer8()
// Prints byte buffer as hex and ascii interpretation
// ---------------------------------------------------------------------------------
// _Parameters :
// pBuf: : IN: Buffer to display
// nbpr : Number of bytes per row to display
// len : Length of input buffer
// _Return: none
//
// ---------------------------------------------------------------------------
void PrintBuffer8(UINT8 *pBuf, int nbpr, int len)
{
int i, j, cnt_hex, cnt_asc;
unsigned char c;
i = j = 0;
cnt_hex = len;
cnt_asc = len;
do
{
print_word(i);
sputs(": ");
for (j=0; j < nbpr; j++)
{
if (cnt_hex)
{
print_byte(pBuf[i+j]);
sputs(" ");
cnt_hex--;
}
else
{
sputs(" ");
break;
}
}
sputs(" ");
for (j=0; j < nbpr; j++)
{
if (cnt_asc)
{
c = pBuf[i+j];
if((c < 0x20) || (c > 0x7F))
c = '.';
_putchar(c);
cnt_asc--;
}
else
{
sputs(" ");
break;
}
}
sputs("\n");
i += nbpr;
} while (cnt_hex);
}
lib/CPUs/MIPS/bsp/examples/libsys.h
+77
View File
@@ -0,0 +1,77 @@
#ifndef LIBSYS_H
#define LIBSYS_H
// ---------------------------------------------------------
// Types
// ---------------------------------------------------------
#define INT8 signed char
#define INT16 signed short
#define INT32 signed int
#define INT64 signed long long
#define UINT8 unsigned char
#define UINT16 unsigned short
#define UINT32 unsigned int
#define UINT64 unsigned long long
#define INT INT32
#define UINT UINT32
#define FLOAT32 float
#define FLOAT64 double
#define sys_gpio0 0xA0000000
#define sys_gpio1 0xA0000004
#define sys_led_port sys_gpio0
#define sys_usb_ctrl sys_gpio1
#define sys_timer_usec 0xA0000008
#define sys_timer_sec 0xA000000C
#define sys_uart_data 0xA0010000
#define sys_uart_stat 0xA0010004
#define sys_uart_baud 0xA0010008
#define sys_usb_data 0xA0020000
#define sys_usb_mbx 0xA0020004
#define sys_usb_addr 0xA0020008
#define sys_usb_status 0xA002000C
#define sys_vga_data 0xA0030004
#define sys_vga_posx 0xA0030008
#define sys_vga_posy 0xA0030010
#define sys_vga_clrscr 0xA0030020
#define sys_vga_clrline 0xA0030040
#define sys_vga_mctrl 0xA0030100
#define sys_vga_moffs 0xA0030200
#define sys_ac97_stat 0xA0040000
#define sys_ac97_ctrl 0xA0040000
#define sys_ac97_acstat 0xA0040400
#define sys_ac97_acctrl 0xA0040600
#define sys_ac97_pcm 0xA0040800
#define sys_ac97_wavin sys_ac97_pcm
#define sys_ac97_wavout sys_ac97_pcm
#define sys_flash_io 0xA4000000
#define sys_ssram_io 0xA8000000
//#define STDOUT_FUNCTION _cg_putchar // Video character
//#define STDERR_FUNCTION _putchar // Serial output
#define STDOUT_FUNCTION _putchar // Serial output
#define STDERR_FUNCTION _putchar // Serial output
UINT32 CP0_SR_read(void);
void CP0_SR_write(UINT32 val);
UINT32 CP0_CR_read(void);
void CP0_CR_write(UINT32 val);
UINT32 CP0_PRID_read(void);
UINT32 CP0_TR_read(void);
void CP0_TR_write(UINT32 val);
char readchar(void);
void writechar(char c);
int write(int file, char *ptr, int len);
int sputs(char *pStr);
void print_byte(char byte);
void print_word(int word);
void _exit (int exitcode);
void sleep(unsigned ms);
void PrintBuffer8(UINT8 *pBuf, int nbpr, int len);
#endif // LIBSYS_H
lib/CPUs/MIPS/bsp/examples/link.ld
+64
View File
@@ -0,0 +1,64 @@
MEMORY
{
reg : ORIGIN = 0xA0000000, LENGTH = 0x04000000 /* 64M */
flash_io : ORIGIN = 0xA4000000, LENGTH = 0x00800000 /* 8M */
ssram_io : ORIGIN = 0xA8000000, LENGTH = 0x00800000 /* 8M */
sdram : ORIGIN = 0x40000000, LENGTH = 0x04000000 /* 64M */
}
stack_ptr = 0x7FFFEFF0;
baudrate = 0x0D;
sys_led_port = 0xA0000000;
sys_uart_data = 0xA0010000;
sys_uart_stat = 0xA0010004;
sys_uart_baud = 0xA0010008;
sys_timer_usec = 0xA000008;
sys_timer_sec = 0xA000000C;
SECTIONS
{
.etext ORIGIN(sdram) :
{
start = ALIGN(2);
entry = ALIGN(2);
_entry = ALIGN(2);
__entry = ALIGN(2);
*(.etext)
} > sdram
.ktext ORIGIN(sdram) + 0x180 :
{
*(.ktext)
} > sdram
.text . : ALIGN(2)
{
*(.text*)
} > sdram
.data . : ALIGN(2)
{
*(.rodata*) *(.data*) *(.kdata) *(.sdata*) *(COMMON) *(.gcc*)
} > sdram
.ctors . : ALIGN(2)
{
*(.ctor*)
} > sdram
.eh_frame . : ALIGN(2)
{
*(.eh_frame)
} > sdram
.bss . : ALIGN(2)
{
__bss_start = ALIGN(2);
*(.*bss*)
__bss_end = ALIGN(2);
end = ALIGN(2);
_end = ALIGN(2);
} > sdram
}
lib/CPUs/MIPS/bsp/examples/paranoia.c
+2302
View File
File diff suppressed because it is too large Load Diff
lib/CPUs/MIPS/bsp/examples/phrasen.c
+298
View File
@@ -0,0 +1,298 @@
#include <stdio.h>
#include <stdlib.h>
#include "libsys.h"
struct substantive
{
char *subst;
int sex;
};
struct verben
{
char *verb_k;
char *verb_gr;
int art;
};
struct adjektive
{
char *adj;
};
char *art[4]={"er","ie","as","en"};
char getch(void)
{
return readchar();
}
void randomize(void)
{
srand(clock());
}
struct substantive namen[]=
{
{"Gerhard Schröder",1},{"Helmut Kohl",1},{"Rudolf Scharping",1},
{"Claudia Nolte",2}, {"Johannes Rau",1},{"Wolfgang Schäuble",1},
{"Joschka Fischer",1},{"Toni Blair",1},{"Kleopatra",2},
{"Claudia Schiffer",2},{"Hannelore Kohl",2},{"Konrad Adenauer",1},
{"Michael Jackson",1},{"Karl Marx",1}, {"Helmut Kohl",1},{"Heino",1},
{"Gerhard Schröder",1},{"Donald Duck",1},{"Madonna",2},{"Jesus",1},
{"Gott",1},{"Sheryl Crow",2},{"Verona Feldbusch",2},{"Pipi Langstrumpf",2},
{"Bill Gates",1},{"Bill Clinton",1},{"Cleopatra",2},{"Winnetou",1},
{"Käpt'n Blaubär",1},{"Rita Süssmuth",2},{"Boris Becker",1},
{"Lilo Wanders",2},{"Queen Elizabeth",2},{"Lady Di",2},{"Steffi Graf",2},
{"Frank Zappa",1},{"Dolly Buster",2},{"Mao Tse Tung",1},{"Ghandi",1},
{"Dalai Lama",1},{"Teufel",1},{"Lenin",1},{"Edmund Stoiber",1},
{"Ludwig van Beethoven",1},{"Wolfgang Amadeus Mozart",1},
{"Richard Wagner",1},{"Erich Honecker",1},{"Adam Riese",1},
{"Bill Clinton",1},{"Josef Stalin",1},{"Willy Brandt",1},
{"John F. Kennedy",1},{"E.T.",1},{"Donald Duck",1},{"Lothar Matthäus",1},
{"Hans Dietrich Genscher",1},{"Franz Josef Strauss",1},{"Sting",1},
{"Hermann Hesse",1},{"Albert Einstein",1},{"Max Planck",1},
{"Tom Jones",1},{"Heidi Kabel",2},{"Homer Simpson",1},{"Zeus",1},
{"Helmut Schmidt",1},{"Antje Vollmer",2},{"Politiker",1},{"Papst",1},
{"Bundeskanzler",1},{"Arzt",1},{"Friseuse",2},{"Teufel",1},
{"Sandmännchen",3},{"Mutter",2},{"Vater",1},{"Säufer",1},{"Student",1},
{"Bauer",1},{"Leiche",2},{"Polizist",1},{"Patientin",2},{"Bäcker",1},
{"Wirt",1}, {"Schlachter",1},{"Baby",3},{"Reporter",1},{"Politiker",1},
{"Beamtin",2},{"Oma",2},{"Putzfrau",2},{"Blinde",2},{"Wahnsinnige",2},
{"Mörder",1},{"Psychiater",1},{"Prinz Charles",1},{"Onkel",1},{"Tante",2}
};
struct substantive sachen[]=
{
{"Haus",3},{"Buch",3},{"Fahrrad",3},{"Schule",2},{"Auto",3},{"Nase",2},
{"Mund",1},{"Kopf",1},{"Kaffee",1},{"Telephon",3},{"Tasse",2},{"Katze",2},
{"Hund",1},{"Maus",2},{"Stuhl",1},{"Mann",1},{"Frau",2},{"Kind",3},
{"Idiotin",2},{"Lampe",2},{"Panzer",1},{"Klavier",3},{"Gitarre",2},
{"Straße",2},{"Wasser",3},{"Luft",2},{"Feuer",3},{"Erde",2},{"Mond",1},
{"Sonne",2},{"Bild",3},{"Stadt",2},{"Land",3},{"Fluss",1},
{"Bundeskanzler",1},{"Ball",1},{"Hut",1},{"Hose",2},{"Hemd",3},{"Tod",1},
{"Geld",3},{"Tisch",1},{"Hand",2},{"Baum",1},{"Bier",3},{"Ratte",2},
{"Esel",1},{"Musik",2},{"Blech",3},{"Dose",2},{"Zahn",1},{"Humor",1},
{"Unterhose",2},{"Gift",3},{"Gesicht",3},{"Fuß",1},{"Auge",3},{"Warze",2},
{"Ohr",3},{"Kanone",2},{"Milch",2},{"Messer",3},{"Papier",3},{"Haar",3},
{"Welt",2},{"Motor",1},{"Langeweile",2},{"Grab",3},{"Schnaps",1},
{"Vogel",1},{"Fisch",1},{"Meer",3},{"Banane",2},{"Brot",3},
{"Sitzung",2},{"Labor",3},{"Kurzschluß",1},{"Lüge",2},{"Axt",2},
{"Abstimmung",2},{"Toilette",2},{"Zigarette",2},{"Winter",1},
{"Torte",2},{"Bahnhof",1},{"Sarg",1},{"Imbiss",1},{"Mund",1},{"Seife",2},
{"Fernseher",1},{"Flasche",2},{"Eimer",1},{"Uhr",2},{"Irrenhaus",3},
{"Wüste",2},{"Klumpen",1},{"Glück",3},{"Schiff",3},{"Käse",1},{"Quark",1},
{"Sommer",1},{"Witz",1},{"Idee",2},{"Nacht",2},{"Dreck",1},{"Meer",3},
{"Blut",3},{"Herz",3},{"Apfel",1},{"Banane",2},{"Mist",1},{"Atom",3},
{"Note",2},{"Gehirn",3},{"Gefühl",3},{"Bombe",2},{"Vakuum",3},
{"Zahl",2},{"Wort",3},{"Programm",3},{"Computer",1},{"Orient",1},
{"Gabelstapler",1}
};
struct adjektive ad[]=
{
{"schön"},{"doof"},{"gut"},{"schlecht"},{"gelb"},{"grün"},{"rot"},
{"blau"},{"schnell"},{"lang"},{"kurz"},{"hell"},{"düster"},{"sanft"},
{"hart"},{"langsam"},{"bitter"},{"süß"},{"kaputt"},{"nett"},{"groß"},
{"klein"},{"leicht"},{"schwer"},{"dick"},{"dünn"},{"rund"},{"eckig"},
{"heiß"},{"kalt"},{"schlau"},{"elektrisch"},{"nass"},{"trocken"},{"ratlos"},
{"abartig"},{"genial"},{"bestechlich"},{"irr"},{"steif"},{"angespannt"},
{"laut"},{"leis"},{"warm"},{"wütend"},{"sauber"},{"schmutzig"},{"arm"},
{"ätzend"},{"langweilig"},{"interessant"},{"erfahren"},{"abgewählt"},
{"durchgeknallt"},{"angenehm"},{"widerwärtig"},{"willig"},{"mutig"},
{"schwach"},{"stark"},{"nervend"},{"spießig"},{"alt"},{"neu"},{"spitz"},
{"stumpf"},{"teuflisch"},{"scharf"},{"lecker"},{"übelriechend"},{"halb"},
{"ganz"},{"bleich"},{"peinlich"},{"taktlos"},{"gewieft"},{"windig"},
{"größenwahnsinnig"},{"verrückt"},{"uralt"},{"aalglatt"},{"korrekt"},
{"kompetent"},{"einfühlsam"},{"tot"},{"schleimig"},{"gestört"},{"hohl"},
{"beknackt"},{"nackt"},{"barfüßig"},{"schwitzend"},{"laufend"},{"knackig"},
{"unverschämt"},{"schläfrig"},{"wohlgeformt"},{"kugelförmig"},{"rauh"},
{"degeneriert"},{"ekelhaft"},{"brutal"},{"gemein"},{"aggressiv"},
{"aufdringlich"},{"betroffen"},{"geliebt"},{"gehasst"},{"beharrlich"},
{"unmenschlich"},{"verblödet"},{"wichtig"},{"gigantisch"},{"winzig"},
{"witzig"},{"komisch"},{"pervers"},{"fett"},{"stinkend"},{"lausig"},
{"wendig"},{"breit"},{"locker"},{"einzigartig"},{"sterbend"},{"munter"},
{"ungepflegt"},{"eisern"},{"echt"},{"besser"},{"wild"},{"ächzend"},
{"frohlockend"},{"unscheinbar"},{"nebulös"},{"skandalös"},{"obzön"},
{"beschränkt"},{"genervt"},{"hilflos"},{"unwürdig"},{"geleckt"},
{"betrunken"},{"unwürdig"},{"bissig"},{"verkalkt"},{"senil"},
{"jungfräulich"},{"ausgeleiert"},{"beleibt"},{"nachtragend"},{"errötend"},
{"kahl"},{"würgend"},{"abwesend"},{"ruhig"},{"albern"},{"trostlos"},
{"salzig"},{"lachend"},{"merkwürdig"},{"behaart"},{"leblos"},{"aufgeblasen"},
{"frech"},{"kopflos"},{"schmierig"}
};
struct verben verb[]=
{
{"geht","gehen",6},{"steht","stehen",2},{"sitzt","sitzen",2},
{"spielt","spielen",7},{"singt","singen",2},{"trinkt","trinken",3},
{"redet","reden",2}, {"liebt","lieben",7},{"schläft","schlafen",2},
{"ißt","essen",3},{"lacht","lachen",2},{"tötet","töten",7},
{"lügt","lügen",2},{"fliegt","fliegen",2},{"überfährt","überfahren",7},
{"sieht","sehen",3},{"hört","hören",3},{"spricht","sprechen",2},
{"berechnet","rechnen",3},{"schwimmt","schwimmen",2},
{"zerschneidet","zerschnitten werden",3},{"raucht","rauchen",3},
{"spaltet","spalten",3},{"verbrennt","verbrennen",2},{"ist","sein",2},
{"hat","haben",1},{"zerbricht","zerbrechen",3},{"muss","müssen",4},
{"kann","können",4},{"darf","dürfen",4},{"will","wollen",5},
{"klaut","klauen",1},{"soll","sollen",4},{"studiert","studieren",3},
{"reibt","reiben",3},{"liest","lesen",2},{"irrt","irren",2},
{"spendiert","spendieren",1},{"schlägt","schlagen",3},{"fragt","fragen",7},
{"zerstört","zerstören",1},{"erschießt","sich erschießen",1},
{"überlegt","überlegen",2},{"trifft","treffen",7},{"leckt","lecken",1},
{"wirft","werfen",1},{"vergiftet","vergiftet werden",1},
{"öffnet","öffnen",1},{"schreit","schreien",2},{"sprengt","explodieren",3},
{"erwürgt","würgen",7},{"arbeitet","arbeiten",2},{"erlegt","erlegen",1},
{"putzt","putzen",1},{"stirbt","sterben",2}, {"kauft","kaufen",1},
{"brüllt","brüllen",2},{"versteht","es verstehen",7},
{"zertritt","zertreten werden",1},{"verendet","verenden",2},
{"labert","labern",2},{"kratzt","kratzen",1},{"wird","nichts werden",2},
{"entkleidet","sich entkleiden",7},{"verbiegt","sich verbiegen",1},
{"verschenkt","es verschenken",7},{"vergisst","es vergessen",1},
{"ergreift","greifen",1},{"baut","bauen",1},{"betet","beten",},
{"rollt","rollen",3},{"bleibt","bleiben",2},{"wäscht","sich waschen",1},
{"heiratet","heiraten",7},{"hebt","heben",1},{"denkt","nachdenken",2}
};
void end_sach_aus(void);
void nam_aus(void);
void end_nam_aus(void);
void adj_aus(void);
int verb_aus_k(void);
int verb_aus_gr(void);
int zufall(int);
int main()
{
int vindx;
int rem=0;
char end;
setbuf(stdout, NULL);
randomize();
printf("\n\t\t************************");
printf("\n\t\t* DER ELEKTRISCHE POET *");
printf("\n\t\t************************\n");
printf("\n\tCopyright by J. Ahrensfeld & T. Burr");
printf("\n\n\tFür die Texte ist Ihr Computer verantwortlich :-)\n");
printf("\n\tZum beenden des Programmes 'x' eingeben!\n");
printf("\n\tWeiter mit beliebiger Taste!\n");
end = getch();
while(end != 'x')
{
if(rem >= 10)
{
printf("\n\n\tZum beenden des Programmes 'x' eingeben!\n");
rem = 0;
if(getch() == 'x')
break;
}
printf("\n\n");
nam_aus();
vindx=verb_aus_k();
switch (vindx)
{
case 1: end_sach_aus(); break;
case 2: adj_aus(); break;
case 3: end_sach_aus(); break;
case 4: verb_aus_gr(); break;
case 5: verb_aus_gr(); break;
case 6: adj_aus(); break;
case 7: end_nam_aus(); break;
}
printf(".");
end = getch();
rem++;
}
printf("\n\n\tDas ist das Ende!");
return 0;
}
int zufall(int max)
{
return (rand()%max);
}
void adj_aus(void)
{
printf("%s", ad[zufall((sizeof(ad)/sizeof(*ad)))].adj);
return;
}
void end_sach_aus(void)
{
int index;
index = zufall(sizeof(sachen)/sizeof(*sachen));
if (sachen[index].sex==1)
printf("d%s", art[3]);
else
printf("d%s", art[(sachen[index].sex)-1]);
printf(" ");
adj_aus();
if (sachen[index].sex==1)
printf("en %s", sachen[index].subst);
else
printf("e %s", sachen[index].subst);
return;
}
void nam_aus(void)
{
int index;
index = zufall(sizeof(namen)/sizeof(*namen));
printf("D%s", art[(namen[index].sex)-1]);
printf(" ");
adj_aus();
printf("e %s " ,namen[index].subst);
return;
}
void end_nam_aus(void)
{
int index;
index = zufall(sizeof(namen)/sizeof(*namen));
if (namen[index].sex==1)
printf("d%s", art[3]);
else
printf("d%s", art[(namen[index].sex)-1]);
printf(" ");
adj_aus();
if (namen[index].sex==1)
printf("en %s", namen[index].subst);
else
printf("e %s", namen[index].subst);
return;
}
int verb_aus_k(void)
{
int index;
index = zufall(sizeof(verb)/sizeof(*verb));
printf("%s ", verb[index].verb_k);
return (verb[index].art);
}
int verb_aus_gr(void)
{
int index;
index = zufall(sizeof(verb)/sizeof(*verb));
printf("%s", verb[index].verb_gr);
return index;
}
lib/CPUs/MIPS/bsp/examples/queens.c
+856
View File
@@ -0,0 +1,856 @@
/*
** Queens.c -- Find solutions to the Eight-Queens chess problem.
** Roberto Sierra 7/25/93 Version 1.1
** 3/19/84 Version 1.0
**
** Description:
** This program finds all the possible ways that N queens can
** be placed on an NxN chessboard so that the queens cannot
** capture one another -- that is, so that no rank, file or
** diagonal is occupied by more than one queen. By default,
** the program prints the first solution it finds. You can
** use the -a option to print all solutions, or the -c option
** just to count them. The program allows the chess board
** to be from 1x1 (trivial case) to 100x100. Warning: the
** larger the chess board, the longer it typically takes to
** find each solution, even though there may be more of them.
**
** This is a terrific example of the utility of recursion. The
** algorithm uses recursion to drastically limit the number
** of board positions that are tested. The program is able
** to find all 8x8 queen solutions in a fraction of a second
** (not counting print time). The code makes no attempt to
** eliminate symmetrical solutions, so the number of solutions
** reported will always be higher than the actual number of
** distinct solutions.
**
**
** Usage:
** Queens [-ac] n
**
** n number of queens (rows and columns).
** An integer from 1 to 100.
** -a Find (and print) all solutions.
** -c Count all solutions, but do not print them.
**
** The output is sent to stdout. All errors messages are
** sent to stderr. If a problem arises, the return code is -1.
**
**
** Examples:
**
** Queens 8 ## Show an 8x8 solution
** 8 queens on a 8x8 board...
** Q - - - - - - -
** - - - - Q - - -
** - - - - - - - Q
** - - - - - Q - -
** - - Q - - - - -
** - - - - - - Q -
** - Q - - - - - -
** - - - Q - - - -
**
** Queens -c 8 ## Count all 8x8 solutions
** 8 queens on a 8x8 board...
** ...there are 92 solutions.
**
** Queens -a 4 ## Show all 4x4 solutions
** 4 queens on a 4x4 board...
**
** Solution #1:
** - Q - -
** - - - Q
** Q - - -
** - - Q -
**
** Solution #2:
** - - Q -
** Q - - -
** - - - Q
** - Q - -
**
** ...there are 2 solutions.
**
**
** Build Instructions:
** You'll need an ANSI C compiler (or the willingness to edit
** the program a bit). If you've got Gnu C, then you can
** compile and load the program as follows:
**
** gcc Queens.c -ansi -o Queens
**
** [If you're using MPW on the Mac, define '-d MPW' on the
** compile line so that background processing will occur.]
**
**
** Algorithm:
** In a 1984 Byte article, I ran across an interesting letter
** from a high school student who was attempting to solve the
** Eight Queens problem using a BASIC interpreter. He had
** developed a program which placed eight queens successively
** on all sixty-four squares, testing for conflicts at each
** iteration. Of course, such a program would require 64^8
** iterations (about 2.8x10^14 iterations). Even in C on a,
** fast CPU, this could take months or years. Byte's answer was
** to alter the loops so that the queens resided on separate
** ranks, thereby reducing the number of iterations required
** to find all solutions to 8^8 iterations (about 16 million).
** More reasonable, but still requiring a chunk of CPU time.
**
** I puzzled about this problem a bit, and came to realize that
** this was still wasting a lot of CPU cycles. Though I'm sure
** others have come up with good algorithms, I decided to come
** up with my own, with a particular eye on efficiency. The
** resulting algorithm finds all 8x8 solutions in a fraction
** of a second (there are 92 solutions, including rotations).
** On a Sun 4, it'll find all 365,596 solutions on a 14x14 board
** in a bit over 2 minutes (printing them out requires extra
** time, of course). Even Byte's solution would require 14^14
** iterations (about 10^16) which would take aeons.
**
** My algorithm works as follows:
** (1) Place a queen in the top left corner.
** (2) Place another queen immediately below.
** (3) Test for conflicts. If the second queen conflicts (it
** does at first), then move it one square to the right.
** (4) Loop step 3 until there are no conflicts. Place
** the next queen on the board and recurse.
** (5) If any queen reaches the right edge of the board,
** remove it and 'pop' to the previous recursion level.
** (6) Now repeat these steps recursively until all eight
** queens (or however many) have been placed without
** conflict -- the result is a solution to the problem,
** which is counted and optionally printed.
**
** Because conflicts are tested as the recursion proceeds,
** this has the effect of 'pruning' the recursion so that
** a large number of board positions are not even attempted.
** The result is that the algorithm runs in reasonable time.
**
** I used a few tricks to make the test-for-conflict code
** extremely efficient -- there is no 'inner' loop to search
** along ranks, files, or diagonals. A series of arrays are
** maintained instead which indicate which queen currently
** 'owns' each rank, file or diagonal. This makes the
** algorithm really fly, though the code is a little hard to
** read. Lastly, pointer arithmetic is used to reduce the
** number of implicit multiplications used in array addressing.
**
**
** Contact:
** For queries regarding this program, contact Roberto Sierra
** at any of the following addresses:
**
** Roberto Sierra
** bert@netcom.com (preferred address)
** 73557.2101@compuserve.com
**
** Tempered MicroDesigns
** P.O. Box 170638
** San Francisco, CA 94117
**
**
** Fine Print:
** This program is in the public domain and can be used for
** any purpose whatsoever, including commercial application.
** [I'd like to hear what you do with it, though.]
** Absolutely no warranty or liability is implied or extended
** by the author.
**
**
** Modification History:
** PRS 3/19/84 v1.0 -- Original version.
** PRS 7/25/93 v1.1 -- ANSIfied the code. More efficient pointers.
**
*/
/***************************************************************/
/* Timer options. You MUST uncomment one of the options below */
/* or compile, for example, with the '-DUNIX' option. */
/***************************************************************/
/* #define Amiga */
/* #define UNIX */
/* #define UNIX_Old */
/* #define VMS */
/* #define BORLAND_C */
/* #define MSC */
/* #define MAC */
/* #define IPSC */
/* #define FORTRAN_SEC */
/* #define GTODay */
/* #define CTimer */
/* #define UXPM */
/* #define MAC_TMgr */
/* #define PARIX */
/* #define POSIX */
/* #define WIN32 */
/* #define POSIX1 */
/***********************/
#include <stdio.h> /* Need standard I/O functions */
#include <stdlib.h> /* Need exit() routine interface */
#include <string.h> /* Need strcmp() interface */
#ifdef MPW /* Macintosh MPW ONLY */
#include <CursorCtl.h> /* Need cursor control interfaces */
#endif
#define MAXQUEENS 100 /* Maximum number of queens */
#define MAXRANKS MAXQUEENS /* Maximum number of ranks (rows) */
#define MAXFILES MAXQUEENS /* Maximum number of files (columns) */
#define MAXDIAGS (MAXRANKS+MAXFILES-1) /* Maximum number of diagonals */
#define EMPTY (MAXQUEENS+1) /* Marks unoccupied file or diagonal */
/* GLOBAL VARIABLES */
int queens; /* Number of queens to place */
int ranks; /* Number of ranks (rows) */
int files; /* Number of files (columns) */
int printing = 1; /* TRUE if printing positions */
int findall = 0; /* TRUE if finding all solutions */
unsigned long solutions = 0; /* Number of solutions found */
int queen[MAXRANKS]; /* File on which each queen is located */
int file[MAXFILES]; /* Which queen 'owns' each file */
int fordiag[MAXDIAGS]; /* Which queen 'owns' forward diagonals */
int bakdiag[MAXDIAGS]; /* Which queen 'owns' reverse diagonals */
char *progname = 0; /* The name of this program */
/***********************/
/**** ROUTINES ****/
/***********************/
/* Internal prototypes */
//void main(int argc,char **argv); /* Main program */
void find(int level); /* Algorithm to find solutions */
void pboard(void); /* Print a solution */
void run_queens(int argc,char **argv);
/*---------------------- main() ---------------------------
** MAIN program. The main purpose of this routine is
** to deal with decoding the command line arguments,
** initializing the various arrays, and starting the
** recursive search routine.
*/
int main(void)
{
char *args[] = {"queens", "-c", "12"};
run_queens(3, args);
}
void run_queens(int argc,char **argv)
{
register int i; /* Loop variable */
register char *p; /* Pointer to argument */
double starttime, benchtime, dtime();
#ifdef MPW /* Macintosh MPW ONLY */
InitCursorCtl(0); /* Enable cursor control */
#endif
progname = argv[0]; /* The name of the program */
/**** DECODE COMMAND LINE ARGUMENTS ****/
for (i=1; i<argc; ++i) { /* Scan through arguments */
p = argv[i]; /* Pointer to base of argument */
if (*p == '-') { /* Command line option? */
while (*++p) { /* Loop through characters */
switch (*p) { /* What is the character */
case 'a': /* '-a' option */
findall = 1; /* Set flag to find all solutions */
break;
case 'c': /* '-c' option */
printing = 0; /* Counting, not printing */
findall = 1; /* Also forces findall option */
break;
default: /* Illegal option */
fprintf(stderr,"%s: Illegal option '%s'\n",progname,argv[i]);
fprintf(stderr,"usage: %s [-ac] queens\n",progname);
exit(-1);
} /* End of switch */
} /* End of loop */
} else { /* End of option test */
if (sscanf(p,"%d",&queens) != 1) { /* Read integer argument */
fprintf(stderr,"%s: non-integer argument '%s'\n",progname,p);
exit(-1);
}
if (queens <= 0) { /* N must be positive */
fprintf(stderr,"%s: queens must be positive integer\n",progname);
exit(-1);
}
if (queens > MAXQUEENS) { /* N can't be too large */
fprintf(stderr,"%s: can't have more than %d queens\n",
progname, MAXQUEENS);
exit(-1);
}
} /* End of argument test */
} /* End of argument scan loop */
if (queens == 0) {
fprintf(stderr,"%s: missing queens argument\n",progname);
fprintf(stderr,"usage: %s [-ac] queens\n",progname);
exit(-1);
}
ranks = files = queens; /* NxN board for N queens */
printf("%d queen%s on a %dx%d board...\n",
queens, queens>1? "s" : "", ranks, files);
fflush(stdout);
starttime = dtime();
/* Initialization */
solutions = 0; /* No solutions yet */
for (i=0; i<MAXFILES; ++i) file[i] = EMPTY;
for (i=0; i<MAXDIAGS; ++i) fordiag[i] = bakdiag[i] = EMPTY;
/* Find all solutions (begin recursion) */
find(0);
if (printing && solutions) putchar('\n');
/* Report results */
if (solutions == 1) {
printf("...there is 1 solution\n");
} else {
printf("...there are %ld solutions\n", solutions);
}
benchtime = dtime() - starttime;
printf("Run Time (sec) = %9.3lf\n\n",benchtime);
exit(0); /* No errors */
} /* End of main() */
/*-------------------------- find() ----------------------------
** FIND is the recursive heart of the program, and finds all
** solutions given a set of level-1 fixed queen positions.
** The routine moves a single queen through all files (columns)
** at the current rank (recursion level). As the queen is moved,
** conflict tests are made. If the queen can be placed without
** conflict, then the routine recurses to the next level. When
** all queens have been placed without conflict, a solution is
** counted and reported.
*/
void find(register int level)
{
register int f; /* Indexes through files */
register int *fp,*fdp,*bdp; /* Ptrs to file/diagonal entries */
#ifdef MPW /* Macintosh MPW ONLY */
if (level & 7 == 0) { /* Periodically break for... */
SpinCursor(1); /* background processing */
}
#endif
if (level == queens) { /* Placed all queens? Stop. */
++solutions; /* Congrats, this is a solution! */
if (printing) pboard(); /* Print board if printing */
if (!findall) exit(0); /* May stop after first solution */
#ifdef MPW /* Macintosh MPW ONLY */
SpinCursor(1); /* Allow background processing */
#endif
} else { /* Not at final level yet */
for ( /* MOVE QUEEN THROUGH ALL FILES */
f = 0, /* Queen starts at left (file 0) */
fp = file, /* Ptr to base of file array */
fdp = &fordiag[level], /* Ptr to first fwd diag entry */
bdp = &bakdiag[level+files-1] /* Ptr to first bak diag entry */
;
f < files /* Loop through all files */
;
++f, /* Advance index */
++fp, ++fdp, --bdp /* Advance pointers */
) {
if (*fp >= level && /* No queen on the file? */
*fdp >= level && *bdp >= level /* No queens on diagonals? */
) {
queen[level] = f; /* Note new position of queen */
*fp = *fdp = *bdp = level; /* Place queen on file & diags */
find(level+1); /* This level OK, recurse to next */
*fp = *fdp = *bdp = EMPTY; /* Remove queen from file & diags */
} /* End of conflict test */
} /* End of file loop */
} /* End if (level == queens) */
} /* End of find() */
/*------------------------- pboard() -----------------------
** This routines prints the board for a particular solution.
** The output is sent to stdout.
*/
void pboard(void)
{
register int i,j; /* Rank/File indices */
if (findall) { /* Only if searching for all */
printf("\nSolution #%lu:\n",solutions); /* Print solution number */
}
for (i=0; i<ranks; ++i) { /* Loop through all ranks */
for (j=0; j<files; ++j) { /* Loop through all files */
putchar(' '); /* Output a space */
if (j==queen[i]) putchar('Q'); /* Output Q for queen... */
else putchar('-'); /* or '-' if empty */
}
putchar('\n'); /* Break line */
}
fflush(stdout); /* Flush solution to output */
} /* End of pboard() */
/*****************************************************/
/* Various timer routines. */
/* Al Aburto, aburto@nosc.mil, 18 Feb 1997 */
/* */
/* t = dtime() outputs the current time in seconds. */
/* Use CAUTION as some of these routines will mess */
/* up when timing across the hour mark!!! */
/* */
/* For timing I use the 'user' time whenever */
/* possible. Using 'user+sys' time is a separate */
/* issue. */
/* */
/* Example Usage: */
/* [timer options added here] */
/* main() */
/* { */
/* double starttime,benchtime,dtime(); */
/* */
/* starttime = dtime(); */
/* [routine to time] */
/* benchtime = dtime() - starttime; */
/* } */
/* */
/* [timer code below added here] */
/*****************************************************/
/*********************************/
/* Timer code. */
/*********************************/
/*******************/
/* Amiga dtime() */
/*******************/
#ifdef Amiga
#include <ctype.h>
#define HZ 50
double dtime()
{
double q;
struct tt
{
long days;
long minutes;
long ticks;
} tt;
DateStamp(&tt);
q = ((double)(tt.ticks + (tt.minutes * 60L * 50L))) / (double)HZ;
return q;
}
#endif
/*****************************************************/
/* UNIX dtime(). This is the preferred UNIX timer. */
/* Provided by: Markku Kolkka, mk59200@cc.tut.fi */
/* HP-UX Addition by: Bo Thide', bt@irfu.se */
/*****************************************************/
#ifdef UNIX
#include <sys/time.h>
#include <sys/resource.h>
#ifdef hpux
#include <sys/syscall.h>
#define getrusage(a,b) syscall(SYS_getrusage,a,b)
#endif
struct rusage rusage;
double dtime()
{
double q;
getrusage(RUSAGE_SELF,&rusage);
q = (double)(rusage.ru_utime.tv_sec);
q = q + (double)(rusage.ru_utime.tv_usec) * 1.0e-06;
return q;
}
#endif
/***************************************************/
/* UNIX_Old dtime(). This is the old UNIX timer. */
/* Make sure HZ is properly defined in param.h !! */
/***************************************************/
#ifdef UNIX_Old
#include <sys/types.h>
#include <sys/times.h>
#include <sys/param.h>
#ifndef HZ
#define HZ 60
#endif
struct tms tms;
double dtime()
{
double q;
times(&tms);
q = (double)(tms.tms_utime) / (double)HZ;
return q;
}
#endif
/*********************************************************/
/* VMS dtime() for VMS systems. */
/* Provided by: RAMO@uvphys.phys.UVic.CA */
/* Some people have run into problems with this timer. */
/*********************************************************/
#ifdef VMS
#include time
#ifndef HZ
#define HZ 100
#endif
struct tbuffer_t
{
int proc_user_time;
int proc_system_time;
int child_user_time;
int child_system_time;
};
struct tbuffer_t tms;
double dtime()
{
double q;
times(&tms);
q = (double)(tms.proc_user_time) / (double)HZ;
return q;
}
#endif
/******************************/
/* BORLAND C dtime() for DOS */
/******************************/
#ifdef BORLAND_C
#include <ctype.h>
#include <dos.h>
#include <time.h>
#define HZ 100
struct time tnow;
double dtime()
{
double q;
gettime(&tnow);
q = 60.0 * (double)(tnow.ti_min);
q = q + (double)(tnow.ti_sec);
q = q + (double)(tnow.ti_hund)/(double)HZ;
return q;
}
#endif
/**************************************/
/* Microsoft C (MSC) dtime() for DOS */
/**************************************/
#ifdef MSC
#include <time.h>
#include <ctype.h>
#define HZ CLOCKS_PER_SEC
clock_t tnow;
double dtime()
{
double q;
tnow = clock();
q = (double)tnow / (double)HZ;
return q;
}
#endif
/*************************************/
/* Macintosh (MAC) Think C dtime() */
/*************************************/
#ifdef MAC
#include <time.h>
#define HZ 60
double dtime()
{
double q;
q = (double)clock() / (double)HZ;
return q;
}
#endif
/************************************************************/
/* iPSC/860 (IPSC) dtime() for i860. */
/* Provided by: Dan Yergeau, yergeau@gloworm.Stanford.EDU */
/************************************************************/
#ifdef IPSC
extern double dclock();
double dtime()
{
double q;
q = dclock();
return q;
}
#endif
/**************************************************/
/* FORTRAN dtime() for Cray type systems. */
/* This is the preferred timer for Cray systems. */
/**************************************************/
#ifdef FORTRAN_SEC
fortran double second();
double dtime()
{
double q;
second(&q);
return q;
}
#endif
/***********************************************************/
/* UNICOS C dtime() for Cray UNICOS systems. Don't use */
/* unless absolutely necessary as returned time includes */
/* 'user+system' time. Provided by: R. Mike Dority, */
/* dority@craysea.cray.com */
/***********************************************************/
#ifdef CTimer
#include <time.h>
double dtime()
{
double q;
clock_t clock(void);
q = (double)clock() / (double)CLOCKS_PER_SEC;
return q;
}
#endif
/********************************************/
/* Another UNIX timer using gettimeofday(). */
/* However, getrusage() is preferred. */
/********************************************/
#ifdef GTODay
#include <sys/time.h>
struct timeval tnow;
double dtime()
{
double q;
gettimeofday(&tnow,NULL);
q = (double)tnow.tv_sec + (double)tnow.tv_usec * 1.0e-6;
return q;
}
#endif
/*****************************************************/
/* Fujitsu UXP/M timer. */
/* Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */
/*****************************************************/
#ifdef UXPM
#include <sys/types.h>
#include <sys/timesu.h>
struct tmsu rusage;
double dtime()
{
double q;
timesu(&rusage);
q = (double)(rusage.tms_utime) * 1.0e-06;
return q;
}
#endif
/**********************************************/
/* Macintosh (MAC_TMgr) Think C dtime() */
/* requires Think C Language Extensions or */
/* #include <MacHeaders> in the prefix */
/* provided by Francis H Schiffer 3rd (fhs) */
/* skipschiffer@genie.geis.com */
/**********************************************/
#ifdef MAC_TMgr
#include <Timer.h>
#include <stdlib.h>
static TMTask mgrTimer;
static Boolean mgrInited = false;
static double mgrClock;
#define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer )
#define MAX_TIME 1800000000L
/* MAX_TIME limits time between calls to */
/* dtime( ) to no more than 30 minutes */
/* this limitation could be removed by */
/* creating a completion routine to sum */
/* 30 minute segments (fhs 1994 feb 9) */
static void Remove_timer( )
{
RMV_TIMER;
mgrInited = false;
}
double dtime( )
{
if( mgrInited ) {
RMV_TIMER;
mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6;
} else {
if( _atexit( &Remove_timer ) == 0 ) mgrInited = true;
mgrClock = 0.0;
}
if ( mgrInited )
{
mgrTimer.tmAddr = NULL;
mgrTimer.tmCount = 0;
mgrTimer.tmWakeUp = 0;
mgrTimer.tmReserved = 0;
InsTime( (QElemPtr)&mgrTimer );
PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME );
}
return( mgrClock );
}
#endif
/***********************************************************/
/* Parsytec GCel timer. */
/* Provided by: Georg Wambach, gw@informatik.uni-koeln.de */
/***********************************************************/
#ifdef PARIX
#include <sys/time.h>
double dtime()
{
double q;
q = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH;
return q;
}
#endif
/************************************************/
/* Sun Solaris POSIX dtime() routine */
/* Provided by: Case Larsen, CTLarsen.lbl.gov */
/************************************************/
#ifdef POSIX
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/rusage.h>
#ifdef __hpux
#include <sys/syscall.h>
#endif
struct rusage rusage;
double dtime()
{
double q;
getrusage(RUSAGE_SELF,&rusage);
q = (double)(rusage.ru_utime.tv_sec);
q = q + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09;
return q;
}
#endif
/****************************************************/
/* Windows NT (32 bit) dtime() routine */
/* Provided by: Piers Haken, piersh@microsoft.com */
/****************************************************/
#ifdef WIN32
#include <windows.h>
double dtime(void)
{
double q;
q = (double)GetTickCount() * 1.0e-03;
return q;
}
#endif
/*****************************************************/
/* Time according to POSIX.1 - <J.Pelan@qub.ac.uk> */
/* Ref: "POSIX Programmer's Guide" O'Reilly & Assoc.*/
/*****************************************************/
#ifdef POSIX1
#define _POSIX_SOURCE 1
#include <unistd.h>
#include <limits.h>
#include <sys/times.h>
struct tms tms;
double dtime()
{
double q;
times(&tms);
q = (double)tms.tms_utime / (double)CLK_TCK;
return q;
}
#endif
/*-------- End of queens.c, Say goodnight Linda! --------*/
lib/CPUs/MIPS/bsp/examples/random.c
+86
View File
@@ -0,0 +1,86 @@
/* random.c
Author: Numerical recipes (ran1, gaussian), Jon Hamkins (others)
Revised by: Jon Hamkins
Date: 4-16-98
*/
#include <math.h>
#define IA 16807
#define IM 2147483647
#define AM (1.0/IM)
#define IQ 127773
#define IR 2836
#define NTAB 32
#define NDIV (1+(IM-1)/NTAB)
#define EPS 1.2e-14
#define RNMX (1.0-EPS)
/* From Numerical Recipes, p. 280, modified from float to double */
/* returns a uniform deviate in (0,1) */
double ran1(long *idum)
{
int j;
long k;
static long iy=0;
static long iv[NTAB];
double temp;
if (*idum <=0 || !iy) {
if (-(*idum) < 1) *idum=1;
else *idum = -(*idum);
for (j=NTAB+7; j>=0; j--) {
k=(*idum)/IQ;
*idum=IA*(*idum-k*IQ)-IR*k;
if (*idum < 0) *idum += IM;
if (j < NTAB) iv[j] = *idum;
}
iy = iv[0];
}
k=(*idum)/IQ;
*idum=IA*(*idum-k*IQ)-IR*k;
if (*idum < 0) *idum += IM;
j=iy/NDIV;
iy=iv[j];
iv[j] = *idum;
if ((temp=AM*iy) > RNMX) return RNMX;
else return temp;
}
#undef IA
#undef IM
#undef AM
#undef IQ
#undef IR
#undef NTAB
#undef NDIV
#undef EPS
#undef RNMX
/* Generate a N(0,1) r.v. */
double gaussian(long *idum)
{
static int iset=0;
static double gset;
double fac,r,v1,v2;
double ran1();
if (iset == 0) {
do {
v1=2.0*ran1(idum)-1.0;
v2=2.0*ran1(idum)-1.0;
r=v1*v1+v2*v2;
} while (r >= 1.0 || r == 0.0);
fac=sqrt(-2.0*log(r)/r);
gset=v1*fac;
iset=1;
return v2*fac;
} else {
iset=0;
return gset;
}
}
/* generate a random bit */
int random_bit(long *idum)
{
return((ran1(idum)<0.5) ? 0 : 1);
}
lib/CPUs/MIPS/bsp/examples/random.h
+6
View File
@@ -0,0 +1,6 @@
/* random.h */
/* functions provided by random.c */
extern double ran1(long *idum);
extern double gaussian(long *idum);
extern int random_bit(long *idum);
lib/CPUs/MIPS/bsp/examples/regdef.h
+81
View File
@@ -0,0 +1,81 @@
/*
* This file is subject to the terms and conditions of the GNU General Public
* License. See the file "COPYING" in the main directory of this archive
* for more details.
*
* Copyright (C) 1985 MIPS Computer Systems, Inc.
* Copyright (C) 1994, 95, 99, 2003 by Ralf Baechle
* Copyright (C) 1990 - 1992, 1999 Silicon Graphics, Inc.
*/
#ifndef _ASM_REGDEF_H
#define _ASM_REGDEF_H
/*
* Symbolic register names for 32 bit ABI
*/
#define zero $0 /* wired zero */
#define AT $1 /* assembler temp - uppercase because of ".set at" */
#define v0 $2 /* return value */
#define v1 $3
#define a0 $4 /* argument registers */
#define a1 $5
#define a2 $6
#define a3 $7
#define t0 $8 /* caller saved */
#define t1 $9
#define t2 $10
#define t3 $11
#define t4 $12
#define t5 $13
#define t6 $14
#define t7 $15
#define s0 $16 /* callee saved */
#define s1 $17
#define s2 $18
#define s3 $19
#define s4 $20
#define s5 $21
#define s6 $22
#define s7 $23
#define t8 $24 /* caller saved */
#define t9 $25
#define jp $25 /* PIC jump register */
#define k0 $26 /* kernel scratch */
#define k1 $27
#define gp $28 /* global pointer */
#define sp $29 /* stack pointer */
#define fp $30 /* frame pointer */
#define s8 $30 /* same like fp! */
#define ra $31 /* return address */
/* CP0 registers */
#define CP0_INDEX $0 /* R3000 available */
#define CP0_RANDOM $1 /* R3000 available */
#define CP0_ENTRYLO $2 /* R3000 available */
#define CP0_CONTEXT $4 /* R3000 available */
#define CP0_BADDR $8 /* R3000 available */
#define CP0_ENTRYHI $10 /* R3000 available */
#define CP0_SR $12 /* R3000 available */
#define CP0_CR $13 /* R3000 available */
#define CP0_EPC $14 /* R3000 available */
#define CP0_PRID $15 /* R3000 available */
/* Status register masks */
#define SR_MASK_IEC 0x00000001
#define SR_MASK_KUC 0x00000002
#define SR_MASK_IEP 0x00000004
#define SR_MASK_KUP 0x00000008
#define SR_MASK_IEO 0x00000010
#define SR_MASK_KUO 0x00000020
#define SR_MASK_IM 0x0000FF00
#define SR_MASK_DS 0x00FF0000
#define SR_MASK_RE 0x01000000
#define SR_MASK_CU 0xF0000000
/* Cause register masks */
#define CR_MASK_EXC 0x0000007C
#define CR_MASK_IP 0x0000FF00
#define CR_MASK_CE 0x40000000
#define CR_MASK_BD 0x80000000
#endif /* _ASM_REGDEF_H */
lib/CPUs/MIPS/bsp/examples/rmd160.c
+294
View File
@@ -0,0 +1,294 @@
/********************************************************************\
*
* FILE: rmd160.c
*
* CONTENTS: A sample C-implementation of the RIPEMD-160
* hash-function.
* TARGET: any computer with an ANSI C compiler
*
* AUTHOR: Antoon Bosselaers, ESAT-COSIC
* DATE: 1 March 1996
* VERSION: 1.0
*
* Copyright (c) Katholieke Universiteit Leuven
* 1996, All Rights Reserved
*
* Conditions for use of the RIPEMD-160 Software
*
* The RIPEMD-160 software is freely available for use under the terms and
* conditions described hereunder, which shall be deemed to be accepted by
* any user of the software and applicable on any use of the software:
*
* 1. K.U.Leuven Department of Electrical Engineering-ESAT/COSIC shall for
* all purposes be considered the owner of the RIPEMD-160 software and of
* all copyright, trade secret, patent or other intellectual property
* rights therein.
* 2. The RIPEMD-160 software is provided on an "as is" basis without
* warranty of any sort, express or implied. K.U.Leuven makes no
* representation that the use of the software will not infringe any
* patent or proprietary right of third parties. User will indemnify
* K.U.Leuven and hold K.U.Leuven harmless from any claims or liabilities
* which may arise as a result of its use of the software. In no
* circumstances K.U.Leuven R&D will be held liable for any deficiency,
* fault or other mishappening with regard to the use or performance of
* the software.
* 3. User agrees to give due credit to K.U.Leuven in scientific publications
* or communications in relation with the use of the RIPEMD-160 software
* as follows: RIPEMD-160 software written by Antoon Bosselaers,
* available at http://www.esat.kuleuven.be/~cosicart/ps/AB-9601/.
*
\********************************************************************/
/* header files */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "rmd160.h"
/********************************************************************/
void MDinit(dword *MDbuf)
{
MDbuf[0] = 0x67452301UL;
MDbuf[1] = 0xefcdab89UL;
MDbuf[2] = 0x98badcfeUL;
MDbuf[3] = 0x10325476UL;
MDbuf[4] = 0xc3d2e1f0UL;
return;
}
/********************************************************************/
void compress(dword *MDbuf, dword *X)
{
dword aa = MDbuf[0], bb = MDbuf[1], cc = MDbuf[2],
dd = MDbuf[3], ee = MDbuf[4];
dword aaa = MDbuf[0], bbb = MDbuf[1], ccc = MDbuf[2],
ddd = MDbuf[3], eee = MDbuf[4];
/* round 1 */
FF(aa, bb, cc, dd, ee, X[ 0], 11);
FF(ee, aa, bb, cc, dd, X[ 1], 14);
FF(dd, ee, aa, bb, cc, X[ 2], 15);
FF(cc, dd, ee, aa, bb, X[ 3], 12);
FF(bb, cc, dd, ee, aa, X[ 4], 5);
FF(aa, bb, cc, dd, ee, X[ 5], 8);
FF(ee, aa, bb, cc, dd, X[ 6], 7);
FF(dd, ee, aa, bb, cc, X[ 7], 9);
FF(cc, dd, ee, aa, bb, X[ 8], 11);
FF(bb, cc, dd, ee, aa, X[ 9], 13);
FF(aa, bb, cc, dd, ee, X[10], 14);
FF(ee, aa, bb, cc, dd, X[11], 15);
FF(dd, ee, aa, bb, cc, X[12], 6);
FF(cc, dd, ee, aa, bb, X[13], 7);
FF(bb, cc, dd, ee, aa, X[14], 9);
FF(aa, bb, cc, dd, ee, X[15], 8);
/* round 2 */
GG(ee, aa, bb, cc, dd, X[ 7], 7);
GG(dd, ee, aa, bb, cc, X[ 4], 6);
GG(cc, dd, ee, aa, bb, X[13], 8);
GG(bb, cc, dd, ee, aa, X[ 1], 13);
GG(aa, bb, cc, dd, ee, X[10], 11);
GG(ee, aa, bb, cc, dd, X[ 6], 9);
GG(dd, ee, aa, bb, cc, X[15], 7);
GG(cc, dd, ee, aa, bb, X[ 3], 15);
GG(bb, cc, dd, ee, aa, X[12], 7);
GG(aa, bb, cc, dd, ee, X[ 0], 12);
GG(ee, aa, bb, cc, dd, X[ 9], 15);
GG(dd, ee, aa, bb, cc, X[ 5], 9);
GG(cc, dd, ee, aa, bb, X[ 2], 11);
GG(bb, cc, dd, ee, aa, X[14], 7);
GG(aa, bb, cc, dd, ee, X[11], 13);
GG(ee, aa, bb, cc, dd, X[ 8], 12);
/* round 3 */
HH(dd, ee, aa, bb, cc, X[ 3], 11);
HH(cc, dd, ee, aa, bb, X[10], 13);
HH(bb, cc, dd, ee, aa, X[14], 6);
HH(aa, bb, cc, dd, ee, X[ 4], 7);
HH(ee, aa, bb, cc, dd, X[ 9], 14);
HH(dd, ee, aa, bb, cc, X[15], 9);
HH(cc, dd, ee, aa, bb, X[ 8], 13);
HH(bb, cc, dd, ee, aa, X[ 1], 15);
HH(aa, bb, cc, dd, ee, X[ 2], 14);
HH(ee, aa, bb, cc, dd, X[ 7], 8);
HH(dd, ee, aa, bb, cc, X[ 0], 13);
HH(cc, dd, ee, aa, bb, X[ 6], 6);
HH(bb, cc, dd, ee, aa, X[13], 5);
HH(aa, bb, cc, dd, ee, X[11], 12);
HH(ee, aa, bb, cc, dd, X[ 5], 7);
HH(dd, ee, aa, bb, cc, X[12], 5);
/* round 4 */
II(cc, dd, ee, aa, bb, X[ 1], 11);
II(bb, cc, dd, ee, aa, X[ 9], 12);
II(aa, bb, cc, dd, ee, X[11], 14);
II(ee, aa, bb, cc, dd, X[10], 15);
II(dd, ee, aa, bb, cc, X[ 0], 14);
II(cc, dd, ee, aa, bb, X[ 8], 15);
II(bb, cc, dd, ee, aa, X[12], 9);
II(aa, bb, cc, dd, ee, X[ 4], 8);
II(ee, aa, bb, cc, dd, X[13], 9);
II(dd, ee, aa, bb, cc, X[ 3], 14);
II(cc, dd, ee, aa, bb, X[ 7], 5);
II(bb, cc, dd, ee, aa, X[15], 6);
II(aa, bb, cc, dd, ee, X[14], 8);
II(ee, aa, bb, cc, dd, X[ 5], 6);
II(dd, ee, aa, bb, cc, X[ 6], 5);
II(cc, dd, ee, aa, bb, X[ 2], 12);
/* round 5 */
JJ(bb, cc, dd, ee, aa, X[ 4], 9);
JJ(aa, bb, cc, dd, ee, X[ 0], 15);
JJ(ee, aa, bb, cc, dd, X[ 5], 5);
JJ(dd, ee, aa, bb, cc, X[ 9], 11);
JJ(cc, dd, ee, aa, bb, X[ 7], 6);
JJ(bb, cc, dd, ee, aa, X[12], 8);
JJ(aa, bb, cc, dd, ee, X[ 2], 13);
JJ(ee, aa, bb, cc, dd, X[10], 12);
JJ(dd, ee, aa, bb, cc, X[14], 5);
JJ(cc, dd, ee, aa, bb, X[ 1], 12);
JJ(bb, cc, dd, ee, aa, X[ 3], 13);
JJ(aa, bb, cc, dd, ee, X[ 8], 14);
JJ(ee, aa, bb, cc, dd, X[11], 11);
JJ(dd, ee, aa, bb, cc, X[ 6], 8);
JJ(cc, dd, ee, aa, bb, X[15], 5);
JJ(bb, cc, dd, ee, aa, X[13], 6);
/* parallel round 1 */
JJJ(aaa, bbb, ccc, ddd, eee, X[ 5], 8);
JJJ(eee, aaa, bbb, ccc, ddd, X[14], 9);
JJJ(ddd, eee, aaa, bbb, ccc, X[ 7], 9);
JJJ(ccc, ddd, eee, aaa, bbb, X[ 0], 11);
JJJ(bbb, ccc, ddd, eee, aaa, X[ 9], 13);
JJJ(aaa, bbb, ccc, ddd, eee, X[ 2], 15);
JJJ(eee, aaa, bbb, ccc, ddd, X[11], 15);
JJJ(ddd, eee, aaa, bbb, ccc, X[ 4], 5);
JJJ(ccc, ddd, eee, aaa, bbb, X[13], 7);
JJJ(bbb, ccc, ddd, eee, aaa, X[ 6], 7);
JJJ(aaa, bbb, ccc, ddd, eee, X[15], 8);
JJJ(eee, aaa, bbb, ccc, ddd, X[ 8], 11);
JJJ(ddd, eee, aaa, bbb, ccc, X[ 1], 14);
JJJ(ccc, ddd, eee, aaa, bbb, X[10], 14);
JJJ(bbb, ccc, ddd, eee, aaa, X[ 3], 12);
JJJ(aaa, bbb, ccc, ddd, eee, X[12], 6);
/* parallel round 2 */
III(eee, aaa, bbb, ccc, ddd, X[ 6], 9);
III(ddd, eee, aaa, bbb, ccc, X[11], 13);
III(ccc, ddd, eee, aaa, bbb, X[ 3], 15);
III(bbb, ccc, ddd, eee, aaa, X[ 7], 7);
III(aaa, bbb, ccc, ddd, eee, X[ 0], 12);
III(eee, aaa, bbb, ccc, ddd, X[13], 8);
III(ddd, eee, aaa, bbb, ccc, X[ 5], 9);
III(ccc, ddd, eee, aaa, bbb, X[10], 11);
III(bbb, ccc, ddd, eee, aaa, X[14], 7);
III(aaa, bbb, ccc, ddd, eee, X[15], 7);
III(eee, aaa, bbb, ccc, ddd, X[ 8], 12);
III(ddd, eee, aaa, bbb, ccc, X[12], 7);
III(ccc, ddd, eee, aaa, bbb, X[ 4], 6);
III(bbb, ccc, ddd, eee, aaa, X[ 9], 15);
III(aaa, bbb, ccc, ddd, eee, X[ 1], 13);
III(eee, aaa, bbb, ccc, ddd, X[ 2], 11);
/* parallel round 3 */
HHH(ddd, eee, aaa, bbb, ccc, X[15], 9);
HHH(ccc, ddd, eee, aaa, bbb, X[ 5], 7);
HHH(bbb, ccc, ddd, eee, aaa, X[ 1], 15);
HHH(aaa, bbb, ccc, ddd, eee, X[ 3], 11);
HHH(eee, aaa, bbb, ccc, ddd, X[ 7], 8);
HHH(ddd, eee, aaa, bbb, ccc, X[14], 6);
HHH(ccc, ddd, eee, aaa, bbb, X[ 6], 6);
HHH(bbb, ccc, ddd, eee, aaa, X[ 9], 14);
HHH(aaa, bbb, ccc, ddd, eee, X[11], 12);
HHH(eee, aaa, bbb, ccc, ddd, X[ 8], 13);
HHH(ddd, eee, aaa, bbb, ccc, X[12], 5);
HHH(ccc, ddd, eee, aaa, bbb, X[ 2], 14);
HHH(bbb, ccc, ddd, eee, aaa, X[10], 13);
HHH(aaa, bbb, ccc, ddd, eee, X[ 0], 13);
HHH(eee, aaa, bbb, ccc, ddd, X[ 4], 7);
HHH(ddd, eee, aaa, bbb, ccc, X[13], 5);
/* parallel round 4 */
GGG(ccc, ddd, eee, aaa, bbb, X[ 8], 15);
GGG(bbb, ccc, ddd, eee, aaa, X[ 6], 5);
GGG(aaa, bbb, ccc, ddd, eee, X[ 4], 8);
GGG(eee, aaa, bbb, ccc, ddd, X[ 1], 11);
GGG(ddd, eee, aaa, bbb, ccc, X[ 3], 14);
GGG(ccc, ddd, eee, aaa, bbb, X[11], 14);
GGG(bbb, ccc, ddd, eee, aaa, X[15], 6);
GGG(aaa, bbb, ccc, ddd, eee, X[ 0], 14);
GGG(eee, aaa, bbb, ccc, ddd, X[ 5], 6);
GGG(ddd, eee, aaa, bbb, ccc, X[12], 9);
GGG(ccc, ddd, eee, aaa, bbb, X[ 2], 12);
GGG(bbb, ccc, ddd, eee, aaa, X[13], 9);
GGG(aaa, bbb, ccc, ddd, eee, X[ 9], 12);
GGG(eee, aaa, bbb, ccc, ddd, X[ 7], 5);
GGG(ddd, eee, aaa, bbb, ccc, X[10], 15);
GGG(ccc, ddd, eee, aaa, bbb, X[14], 8);
/* parallel round 5 */
FFF(bbb, ccc, ddd, eee, aaa, X[12] , 8);
FFF(aaa, bbb, ccc, ddd, eee, X[15] , 5);
FFF(eee, aaa, bbb, ccc, ddd, X[10] , 12);
FFF(ddd, eee, aaa, bbb, ccc, X[ 4] , 9);
FFF(ccc, ddd, eee, aaa, bbb, X[ 1] , 12);
FFF(bbb, ccc, ddd, eee, aaa, X[ 5] , 5);
FFF(aaa, bbb, ccc, ddd, eee, X[ 8] , 14);
FFF(eee, aaa, bbb, ccc, ddd, X[ 7] , 6);
FFF(ddd, eee, aaa, bbb, ccc, X[ 6] , 8);
FFF(ccc, ddd, eee, aaa, bbb, X[ 2] , 13);
FFF(bbb, ccc, ddd, eee, aaa, X[13] , 6);
FFF(aaa, bbb, ccc, ddd, eee, X[14] , 5);
FFF(eee, aaa, bbb, ccc, ddd, X[ 0] , 15);
FFF(ddd, eee, aaa, bbb, ccc, X[ 3] , 13);
FFF(ccc, ddd, eee, aaa, bbb, X[ 9] , 11);
FFF(bbb, ccc, ddd, eee, aaa, X[11] , 11);
/* combine results */
ddd += cc + MDbuf[1]; /* final result for MDbuf[0] */
MDbuf[1] = MDbuf[2] + dd + eee;
MDbuf[2] = MDbuf[3] + ee + aaa;
MDbuf[3] = MDbuf[4] + aa + bbb;
MDbuf[4] = MDbuf[0] + bb + ccc;
MDbuf[0] = ddd;
return;
}
/********************************************************************/
void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen)
{
unsigned int i; /* counter */
dword X[16]; /* message words */
memset(X, 0, 16*sizeof(dword));
/* put bytes from strptr into X */
for (i=0; i<(lswlen&63); i++) {
/* byte i goes into word X[i div 4] at pos. 8*(i mod 4) */
X[i>>2] ^= (dword) *strptr++ << (8 * (i&3));
}
/* append the bit m_n == 1 */
X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7);
if ((lswlen & 63) > 55) {
/* length goes to next block */
compress(MDbuf, X);
memset(X, 0, 16*sizeof(dword));
}
/* append length in bits*/
X[14] = lswlen << 3;
X[15] = (lswlen >> 29) | (mswlen << 3);
compress(MDbuf, X);
return;
}
/************************ end of file rmd160.c **********************/
lib/CPUs/MIPS/bsp/examples/rmd160.h
+154
View File
@@ -0,0 +1,154 @@
/********************************************************************\
*
* FILE: rmd160.h
*
* CONTENTS: Header file for a sample C-implementation of the
* RIPEMD-160 hash-function.
* TARGET: any computer with an ANSI C compiler
*
* AUTHOR: Antoon Bosselaers, ESAT-COSIC
* DATE: 1 March 1996
* VERSION: 1.0
*
* Copyright (c) Katholieke Universiteit Leuven
* 1996, All Rights Reserved
*
* Conditions for use of the RIPEMD-160 Software
*
* The RIPEMD-160 software is freely available for use under the terms and
* conditions described hereunder, which shall be deemed to be accepted by
* any user of the software and applicable on any use of the software:
*
* 1. K.U.Leuven Department of Electrical Engineering-ESAT/COSIC shall for
* all purposes be considered the owner of the RIPEMD-160 software and of
* all copyright, trade secret, patent or other intellectual property
* rights therein.
* 2. The RIPEMD-160 software is provided on an "as is" basis without
* warranty of any sort, express or implied. K.U.Leuven makes no
* representation that the use of the software will not infringe any
* patent or proprietary right of third parties. User will indemnify
* K.U.Leuven and hold K.U.Leuven harmless from any claims or liabilities
* which may arise as a result of its use of the software. In no
* circumstances K.U.Leuven R&D will be held liable for any deficiency,
* fault or other mishappening with regard to the use or performance of
* the software.
* 3. User agrees to give due credit to K.U.Leuven in scientific publications
* or communications in relation with the use of the RIPEMD-160 software
* as follows: RIPEMD-160 software written by Antoon Bosselaers,
* available at http://www.esat.kuleuven.be/~cosicart/ps/AB-9601/.
*
\********************************************************************/
#ifndef RMD160H /* make sure this file is read only once */
#define RMD160H
/********************************************************************/
/* typedef 8 and 32 bit types, resp. */
/* adapt these, if necessary,
for your operating system and compiler */
typedef unsigned char byte;
typedef unsigned long dword;
/********************************************************************/
/* macro definitions */
/* collect four bytes into one word: */
#define BYTES_TO_DWORD(strptr) \
(((dword) *((strptr)+3) << 24) | \
((dword) *((strptr)+2) << 16) | \
((dword) *((strptr)+1) << 8) | \
((dword) *(strptr)))
/* ROL(x, n) cyclically rotates x over n bits to the left */
/* x must be of an unsigned 32 bits type and 0 <= n < 32. */
#define ROL(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/* the five basic functions F(), G() and H() */
#define F(x, y, z) ((x) ^ (y) ^ (z))
#define G(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define H(x, y, z) (((x) | ~(y)) ^ (z))
#define I(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define J(x, y, z) ((x) ^ ((y) | ~(z)))
/* the ten basic operations FF() through III() */
#define FF(a, b, c, d, e, x, s) {\
(a) += F((b), (c), (d)) + (x);\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define GG(a, b, c, d, e, x, s) {\
(a) += G((b), (c), (d)) + (x) + 0x5a827999UL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define HH(a, b, c, d, e, x, s) {\
(a) += H((b), (c), (d)) + (x) + 0x6ed9eba1UL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define II(a, b, c, d, e, x, s) {\
(a) += I((b), (c), (d)) + (x) + 0x8f1bbcdcUL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define JJ(a, b, c, d, e, x, s) {\
(a) += J((b), (c), (d)) + (x) + 0xa953fd4eUL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define FFF(a, b, c, d, e, x, s) {\
(a) += F((b), (c), (d)) + (x);\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define GGG(a, b, c, d, e, x, s) {\
(a) += G((b), (c), (d)) + (x) + 0x7a6d76e9UL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define HHH(a, b, c, d, e, x, s) {\
(a) += H((b), (c), (d)) + (x) + 0x6d703ef3UL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define III(a, b, c, d, e, x, s) {\
(a) += I((b), (c), (d)) + (x) + 0x5c4dd124UL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
#define JJJ(a, b, c, d, e, x, s) {\
(a) += J((b), (c), (d)) + (x) + 0x50a28be6UL;\
(a) = ROL((a), (s)) + (e);\
(c) = ROL((c), 10);\
}
/********************************************************************/
/* function prototypes */
void MDinit(dword *MDbuf);
/*
* initializes MDbuffer to "magic constants"
*/
void compress(dword *MDbuf, dword *X);
/*
* the compression function.
* transforms MDbuf using message bytes X[0] through X[15]
*/
void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen);
/*
* puts bytes from strptr into X and pad out; appends length
* and finally, compresses the last block(s)
* note: length in bits == 8 * (lswlen + 2^32 mswlen).
* note: there are (lswlen mod 64) bytes left in strptr.
*/
#endif /* RMD160H */
/*********************** end of file rmd160.h ***********************/
lib/CPUs/MIPS/bsp/examples/rmd160_test.c
+95
View File
@@ -0,0 +1,95 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "libsys.h"
#include "rmd160.h"
#ifndef RMDsize
#define RMDsize 160
#endif
byte *RMD(byte *message)
/*
* returns RMD(message)
* message should be a string terminated by '\0'
*/
{
dword MDbuf[RMDsize/32]; /* contains (A, B, C, D(, E)) */
static byte hashcode[RMDsize/8]; /* for final hash-value */
dword X[16]; /* current 16-word chunk */
unsigned int i; /* counter */
dword length; /* length in bytes of message */
dword nbytes; /* # of bytes not yet processed */
/* initialize */
MDinit(MDbuf);
length = (dword)strlen((char *)message);
/* process message in 16-word chunks */
for (nbytes=length; nbytes > 63; nbytes-=64) {
for (i=0; i<16; i++) {
X[i] = BYTES_TO_DWORD(message);
message += 4;
}
compress(MDbuf, X);
} /* length mod 64 bytes left */
/* finish: */
MDfinish(MDbuf, message, length, 0);
for (i=0; i<RMDsize/8; i+=4) {
hashcode[i] = MDbuf[i>>2]; /* implicit cast to byte */
hashcode[i+1] = (MDbuf[i>>2] >> 8); /* extracts the 8 least */
hashcode[i+2] = (MDbuf[i>>2] >> 16); /* significant bits. */
hashcode[i+3] = (MDbuf[i>>2] >> 24);
}
return (byte *)hashcode;
}
#define MSG_SIZE 1024*1024 // Bit
int main (void)
{
int result, i, j, cnt;
byte *hashcode;
byte hashref[] = {0xFC,0x20,0x7B,0x84,0x40,0x1C,0x49,0x0B,0x8D,0x69,0x88,0xD2,0x49,0x20,0x01,0x90,0x41,0x77,0x72,0x59};
volatile int *pLED = (int*)sys_led_port;
char msg[MSG_SIZE/8];
char crlf[] = "\n";
UINT32 start, stop;
for (i=0; i < MSG_SIZE/8; i++)
msg[i] = 0x55;
msg[i] = 0;
setbuf(stdout, NULL);
cnt = 0;
start = clock();
stop = start + 1000;
while(1)
{
hashcode = RMD((byte *)msg);
start = clock();
if (memcmp(hashcode, hashref, sizeof(hashref)))
{
printf("Error RipeMD-160!\n");
return 1;
}
if (start >= stop)
{
for (i=0; i<RMDsize/8; i++)
printf("%2.2X", hashcode[i]);
printf("\n%d Hashes/s of %d Mbit message => %d Mbit/s\n\n", cnt, MSG_SIZE/(1024*1024), cnt*MSG_SIZE/(1024*1024));
start = clock();
stop = start + 1000;
cnt = 0;
}
cnt++;
}
return 0;
}
lib/CPUs/MIPS/bsp/examples/stanford.c
+1117
View File
File diff suppressed because it is too large Load Diff
lib/CPUs/MIPS/bsp/examples/startup.S
+15
View File
@@ -0,0 +1,15 @@
.file "startup.S"
.section .etext,"ax"
.extern _init
.align 2
.globl _start
_start:
.set noreorder
# jump init
la $8, _init
jr $8
nop
.set reorder
lib/CPUs/MIPS/bsp/examples/test_flash.c
+94
View File
@@ -0,0 +1,94 @@
/************************************************************************/
/* */
/* AMD CFI Enabled Flash Memory Drivers */
/* File name: CFIDRIVE.C */
/* Revision: 1.0 5/07/98 */
/* */
/* Copyright (c) 1998 ADVANCED MICRO DEVICES, INC. All Rights Reserved. */
/* This software is unpublished and contains the trade secrets and */
/* confidential proprietary information of AMD. Unless otherwise */
/* provided in the Software Agreement associated herewith, it is */
/* licensed in confidence "AS IS" and is not to be reproduced in whole */
/* or part by any means except for backup. Use, duplication, or */
/* disclosure by the Government is subject to the restrictions in */
/* paragraph (b) (3) (B) of the Rights in Technical Data and Computer */
/* Software clause in DFAR 52.227-7013 (a) (Oct 1988). */
/* Software owned by */
/* Advanced Micro Devices, Inc., */
/* One AMD Place, */
/* P.O. Box 3453 */
/* Sunnyvale, CA 94088-3453. */
/************************************************************************/
/* This software constitutes a basic shell of source code for */
/* programming all AMD Flash components. AMD */
/* will not be responsible for misuse or illegal use of this */
/* software for devices not supported herein. AMD is providing */
/* this source code "AS IS" and will not be responsible for */
/* issues arising from incorrect user implementation of the */
/* source code herein. It is the user's responsibility to */
/* properly design-in this source code. */
/* */
/************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include "cfiflash.h"
#include "libsys.h"
#define TEST_SIZE (1024*1024)
#define FLASH_OFFSET 0x700000
int main(void)
{
int i;
flash_t flash;
UINT8 *pFlash = (UINT8*)0xA4000000;
UINT32 result;
UINT8 *pBuf;
setbuf(stdout, NULL);
result = flash_find(&flash, 0xA4000000);
if (result < 0)
{
printf("flash_find() error!\n");
return 1;
}
printf("Found Flash at %8.8X\n", (UINT32)flash.pBase);
pBuf = (UINT8*)malloc(TEST_SIZE);
for (i=0; i < TEST_SIZE; i++)
pBuf[i] = i;
printf("Flash erase from %8.8X to %8.8X...", FLASH_OFFSET, FLASH_OFFSET+TEST_SIZE);
result = flash_erase(&flash, FLASH_OFFSET, TEST_SIZE);
if (result < 0)
{
printf("error!\n");
return 1;
}
printf("OK\n");
printf("Flash program from %8.8X to %8.8X...", FLASH_OFFSET, FLASH_OFFSET+TEST_SIZE);
result = flash_program(&flash, FLASH_OFFSET, pBuf, TEST_SIZE);
if (result < 0)
{
printf("error!\n");
return 1;
}
printf("OK\n");
printf("Flash verify from %8.8X to %8.8X...", FLASH_OFFSET, FLASH_OFFSET+TEST_SIZE);
result = flash_verify(&flash, FLASH_OFFSET, pBuf, TEST_SIZE);
if (result < 0)
{
printf("error!\n");
return 1;
}
printf("OK\n");
// PrintBuffer8((UINT8*)pFlash, 16, TEST_SIZE);
return 0;
}
lib/CPUs/MIPS/bsp/examples/test_irq.c
+124
View File
@@ -0,0 +1,124 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "irq.h"
#include "libsys.h"
char buffer[16384];
char * volatile pPtr_r;
char * volatile pPtr_w;
void handler0(void)
{
printf("Interrupt 0\n");
interrupt_clr(0);
}
void handler1(void)
{
printf("Interrupt 1\n");
interrupt_clr(1);
}
void handler2(void)
{
printf("Interrupt 2\n");
}
void handler3(void)
{
volatile char *pUART_stat = (char*)sys_uart_stat;
volatile char *pUART_data = (char*)sys_uart_data;
while((0x10 & *pUART_stat))
{
// sputs("w: "); print_word((int)pPtr_w); sputs("\n");
if (pPtr_w == &buffer[16383])
pPtr_w = buffer;
*(pPtr_w++) = *pUART_data;
}
}
void handler4(void)
{
printf("Interrupt 4\n");
}
void handler5(void)
{
printf("Interrupt 5\n");
}
void handler6(void)
{
printf("Interrupt 6\n");
}
void handler7(void)
{
printf("Interrupt 7\n");
}
int main(void)
{
printf("Hello\n");
memset(buffer, 0, sizeof(buffer));
pPtr_r = buffer;
pPtr_w = buffer;
interrupt_register(0, handler0);
interrupt_enable(0);
interrupt_register(1, handler1);
interrupt_enable(1);
interrupt_register(2, handler2);
interrupt_enable(2);
interrupt_register(3, handler3);
interrupt_enable(3);
interrupt_register(4, handler4);
// interrupt_enable(4);
interrupt_register(5, handler5);
interrupt_enable(5);
interrupt_register(6, handler6);
interrupt_enable(6);
interrupt_register(7, handler7);
interrupt_enable(7);
printf("Start:\n");
interrupt_set(0);
interrupt_set(1);
interrupt_set(2);
interrupt_set(3);
interrupt_set(4);
interrupt_set(5);
interrupt_set(6);
interrupt_set(7);
sputs("r: "); print_word((int)pPtr_r); sputs("\n");
sputs("w: "); print_word((int)pPtr_w); sputs("\n");
// Print Status register
sputs("Status : ");
print_word(CP0_SR_read());
sputs("\n");
while(1)
{
if(pPtr_w != pPtr_r)
{
// sputs("r: "); print_word((int)pPtr_r); sputs("\n");
if (pPtr_r == &buffer[16383])
pPtr_r = buffer;
writechar(*(pPtr_r++));
}
}
return 0;
}
lib/CPUs/MIPS/bsp/examples/testbench.c
+551
View File
@@ -0,0 +1,551 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include "libsys.h"
#define NO_ERROR 0x00000000
#define ERROR 0x80000000
#define IS_ERROR(e) ((e & ERROR) == ERROR)
#define TEST10_ERROR (ERROR | 0x10)
#define TEST11_ERROR (ERROR | 0x11)
#define TEST12_ERROR (ERROR | 0x12)
char buffer[16384];
int i;
extern int paranoia(int argc, char **argv);
void handler3(void)
{
volatile UINT32 *pUART_stat = (UINT32*)sys_uart_stat;
volatile UINT32 *pUART_data = (UINT32*)sys_uart_data;
while((0x10 & *pUART_stat))
{
buffer[i] = (char)*pUART_data;
i = (i+1)%sizeof(buffer);
}
}
int fibonacci(int f0, int f1, int *pDst, int len)
{
int i;
i = 0;
pDst[i++] = f0;
pDst[i++] = f1;
for (; i < len; i++)
{
pDst[i] = pDst[i-2] + pDst[i-1];
}
return i;
}
void PrintCPUinfo(void)
{
int result, rev_id;
char *cpu_type_str[7] = {"invalid", "R2000", "R3000", "R6000", "R4000", "reserved", "R6000A"};
// Print Status register
result = CP0_SR_read();
printf("Status : %8.8X\n", result);
// Print Revision
result = CP0_PRID_read();
rev_id = (result >> 8) & 0xFF;
printf("CPU type: ");
if ((rev_id > 0) && (rev_id < 0x07))
{
printf(cpu_type_str[rev_id]);
printf(" Rev.");
rev_id = result & 0xFF;
printf("%d", rev_id);
}
else
printf("Unknown");
printf("\n");
}
int Test10_LoadStore()
{
int *buf, i, result, data, err;
volatile int *pPtr;
buf = (int*)malloc(32*sizeof(int));
// sputs("buf = ");
// print_word((int)buf);
// sputs("\n");
while(1)
{
err = TEST10_ERROR;
// Basic Load/Store
pPtr = buf;
*pPtr++ = 0x00000000;
*pPtr++ = 0x55555555;
*pPtr++ = 0xAAAAAAAA;
*pPtr++ = 0xFFFFFFFF;
pPtr = buf;
if (*pPtr++ != 0x00000000)
break;
if (*pPtr++ != 0x55555555)
break;
if (*pPtr++ != 0xAAAAAAAA)
break;
if (*pPtr++ != 0xFFFFFFFF)
break;
// Filling from left
pPtr = buf;
data = 0x00000000;
for (i=0; i < 32; i++)
{
*pPtr++ = data;
data = data >> 1 | 0x80000000;
}
pPtr = buf;
data = 0x00000000;
for (i=0; i < 32; i++)
{
if (*pPtr++ != data)
break;
data = data >> 1 | 0x80000000;
}
if (i != 32)
break;
// Filling from right
pPtr = buf;
data = 0x00000000;
for (i=0; i < 32; i++)
{
*pPtr++ = data;
data = data << 1 | 1;
}
pPtr = buf;
data = 0x00000000;
for (i=0; i < 32; i++)
{
if (*pPtr++ != data)
break;
data = data << 1 | 1;
}
if (i != 32)
break;
// Walking ones
pPtr = buf;
data = 0x00000001;
for (i=0; i < 32; i++)
{
*pPtr++ = data;
data = data << 1;
}
pPtr = buf;
data = 0x00000001;
for (i=0; i < 32; i++)
{
if (*pPtr++ != data)
break;
data = data << 1;
}
if (i != 32)
break;
// Walking zeros
pPtr = buf;
data = 0xFFFFFFFE;
for (i=0; i < 32; i++)
{
*pPtr++ = data;
data = data << 1 | 1;
}
pPtr = buf;
data = 0xFFFFFFFE;
for (i=0; i < 32; i++)
{
if (*pPtr++ != data)
break;
data = data << 1 | 1;
}
if (i != 32)
break;
err = NO_ERROR;
break;
}
free(buf);
return err;
}
#define NUM_ELEMENTS 100000
#define NUM_RUNS 3
int Test11_AddSub()
{
int buf[NUM_ELEMENTS], result, i, j, diff, fill, num_right_elements, num_right_runs;
fill = 0xAAAAAAAA;
num_right_runs = 0;
for (i=0; i < NUM_RUNS; i++)
{
for (j=0; j < NUM_ELEMENTS; j++)
{
buf[j] = fill;
fill = ((fill ^ j) - 1) << 1;
}
num_right_elements = 2;
result = fibonacci(i, i+1, buf, NUM_ELEMENTS);
for (j=2; j < NUM_ELEMENTS; j++)
{
diff = buf[j] - buf[j-1];
if (diff == buf[j-2])
num_right_elements++;
}
if (num_right_elements == NUM_ELEMENTS)
num_right_runs++;
}
if (num_right_runs != NUM_RUNS)
return TEST11_ERROR;
return NO_ERROR;
}
int Test12_MulDiv()
{
int mix, i, j;
int s1, s2, sp, st;
div_t div_res;
srand(0x19701031);
for (i=0; i < 100; i++)
{
for (j=1; j < 100; j++)
{
mix = (int)rand();
mix = (mix << 8) ^ (mix << 16);
s1 = (int)rand() ^ mix;
mix = (int)rand();
mix = (mix << 8) ^ (mix << 16);
s2 = (int)rand() ^ mix;
div_res = div(s1, s2);
sp = s2*div_res.quot;
st = div_res.rem + sp;
if (st != s1)
return TEST12_ERROR;
}
}
return NO_ERROR;
}
#define PI_SCALE 10000
#define PI_MAXARR 2800
#define PI_ARRINIT 2000
int pi_calc()
{
int i, j;
int carry = 0;
int arr[PI_MAXARR+1];
// setbuf(stdout, NULL);
for (i = 0; i <= PI_MAXARR; ++i)
arr[i] = PI_ARRINIT;
for (i = PI_MAXARR; i; i -= 14)
{
int sum = 0;
for (j = i; j > 0; --j)
{
sum = sum*j + PI_SCALE*arr[j];
arr[j] = sum % (j*2-1);
sum /= (j*2-1);
}
printf("%04d", carry + sum/PI_SCALE);
carry = sum % PI_SCALE;
}
printf("\n");
return 0;
}
#define TEST_SIZE (32*1024*1024) // Bytes
#define SMALL_TEST_SIZE (8192) // Bytes
int main (void)
{
int result, i, j, cnt;
volatile UINT32 *pUART_baud = (UINT32*)sys_uart_baud;
volatile UINT32 *pReg = (UINT32*)sys_led_port;
volatile UINT32 *pReg_usec = (UINT32*)sys_timer_usec;
volatile UINT32 *pReg_sec = (UINT32*)sys_timer_sec;
volatile UINT32 *pSSRAM = (UINT32*)sys_ssram_io;
time_t curr_date;
struct tm *pDate, date;
UINT32 start, end;
char sel;
UINT8 *ram8 = NULL;
UINT16 *ram16 = NULL;
UINT32 *ram32 = NULL;
UINT32 *pSrc32, *pDst32;
// *pUART_baud = 1;
setbuf(stdout, NULL);
PrintCPUinfo();
i = 0;
memset(buffer, 0, sizeof(buffer));
interrupt_register(3, handler3);
// ----------------------------------------------------------
// Memtest BEGIN
/* printf("SSRAM Memory Test\r\n");
printf("Small data test\r\n");
printf("Write (32-Bit access)...");
start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=0; i < SMALL_TEST_SIZE/4; i++)
pSSRAM[i] = (UINT32)i;
end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
PrintBuffer8((UINT8*)pSSRAM, 16, 256);
printf("Verify (32-Bit access)...");
start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=SMALL_TEST_SIZE/4-1; i >= 0; i--)
if (pSSRAM[i] != (UINT32)i)
break;
end = clock();
i++;
if (i)
printf("failed\r\n");
else
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
*/
// ----------------------------------------------------------
// Memtest BEGIN
printf("SDRAM Memory Test\n");
printf("Test size %d kByte\n\n", TEST_SIZE/1024);
ram8 = (UINT8*)calloc(TEST_SIZE,sizeof(UINT8));
printf("Write (8-Bit access)...");
start = clock();
for (i=0; i < TEST_SIZE; i++)
ram8[i] = (UINT8)i;
end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
printf("Verify (8-Bit access)...");
start = clock();
for (i=TEST_SIZE-1; i >= 0; i--)
if (ram8[i] != (UINT8)i)
break;
end = clock();
i++;
if (i)
printf("failed\r\n");
else
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
free(ram8);
ram16 = (UINT16*)calloc(TEST_SIZE/2,sizeof(UINT16));
printf("Write (16-Bit access)...");
start = clock();
for (i=0; i < TEST_SIZE/2; i++)
ram16[i] = (UINT16)i;
end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
printf("Verify (16-Bit access)...");
start = clock();
for (i=TEST_SIZE/2-1; i >= 0; i--)
if (ram16[i] != (UINT16)i)
break;
end = clock();
i++;
if (i)
printf("failed\r\n");
else
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
free(ram16);
ram32 = (UINT32*)calloc(TEST_SIZE/4,sizeof(UINT32));
printf("Write (32-Bit access)...");
start = clock();
for (i=0; i < TEST_SIZE/4; i++)
ram32[i] = (UINT32)i;
end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
printf("Verify (32-Bit access)...");
start = clock();
for (i=TEST_SIZE/4-1; i >= 0; i--)
if (ram32[i] != (UINT32)i)
break;
end = clock();
i++;
if (i)
printf("failed\r\n");
else
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
free(ram32);
printf("Small data test\r\n");
printf("Test size %d kByte\n\n", SMALL_TEST_SIZE/1024);
printf("Write (32-Bit access)...");
ram32 = (UINT32*)calloc(SMALL_TEST_SIZE/4,sizeof(UINT32));
start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=0; i < SMALL_TEST_SIZE/4; i++)
ram32[i] = (UINT32)i;
end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
printf("Verify (32-Bit access)...");
start = clock();
for (j=0; j < TEST_SIZE/SMALL_TEST_SIZE; j++)
for (i=SMALL_TEST_SIZE/4-1; i >= 0; i--)
if (ram32[i] != (UINT32)i)
break;
end = clock();
i++;
if (i)
printf("failed\r\n");
else
printf("passed (%.2f MByte/s)\n", (double)TEST_SIZE/(1000*(end-start)));
free(ram32);
printf("Memcpy() Test \n");
pSrc32 = (UINT32*)calloc(TEST_SIZE/8,sizeof(UINT32));
pDst32 = (UINT32*)calloc(TEST_SIZE/8,sizeof(UINT32));
printf("Copying %d kBytes...", TEST_SIZE/(2*1024));
start = clock();
memcpy(pDst32, pSrc32, TEST_SIZE/2);
end = clock();
printf("done (%.2f MByte/s)\n", (double)TEST_SIZE/(2*1000*(end-start)));
free(pSrc32);
free(pDst32);
// Memtest END
// ----------------------------------------------------------
sputs("\r\n");
printf("Datum und Uhrzeit setzen? [j/N]: ");
scanf("%c", &sel);
if (toupper(sel) == 'J')
{
printf("Jahr : ");
scanf("%d", &date.tm_year);
printf("Monat : ");
scanf("%d", &date.tm_mon);
printf("Tag : ");
scanf("%d", &date.tm_mday);
printf("Wir haben heute den %d. %d. %d\n", date.tm_mday, date.tm_mon, date.tm_year);
}
interrupt_enable(3);
cnt = 0;
while (1)
{
*pReg = cnt & 0x3FFFFFFF;
printf("-------------------------------------------\n");
printf("-- LoadStore ------------------------------\n");
printf("-------------------------------------------\n");
result = Test10_LoadStore();
if (IS_ERROR(result))
break;
printf("passed\n\n");
printf("-------------------------------------------\n");
printf("-- AddSub ---------------------------------\n");
printf("-------------------------------------------\n");
result = Test11_AddSub();
if (IS_ERROR(result))
break;
printf("passed\n\n");
printf("-------------------------------------------\n");
printf("-- MulDiv ---------------------------------\n");
printf("-------------------------------------------\n");
result = Test12_MulDiv();
if (IS_ERROR(result))
break;
printf("passed\n\n");
printf("-------------------------------------------\n");
printf("-- Paranoia -------------------------------\n");
printf("-------------------------------------------\n");
paranoia(1, NULL);
printf("passed\n\n");
printf("-------------------------------------------\n");
printf("-- PI calc --------------------------------\n");
printf("-------------------------------------------\n");
pi_calc();
printf("passed\n\n");
printf("Iteration %d: Passed\n", cnt);
curr_date = time(NULL);
pDate = gmtime(&curr_date);
puts(asctime(pDate));
cnt++;
// printf("V=%.17e\n", pow((double)cnt-1, (double)cnt));
}
*pReg = 0x40000000 | cnt;
printf("Failed with error %8.8X\n", result);
return 1;
}
lib/CPUs/MIPS/bsp/examples/whet.c
+265
View File
@@ -0,0 +1,265 @@
/*
* @(#)whet.c 1.1
*/
/*
* Whetstone benchmark in C. This program is a translation of the
* original Algol version in "A Synthetic Benchmark" by H.J. Curnow
* and B.A. Wichman in Computer Journal, Vol 19 #1, February 1976.
*
* Used to test compiler optimization and floating point performance.
*/
/*
* Compile with -DMEASURE_TIME for time measurement.
*
* Compile with -DPOUT to print intermediate results.
* Running this benchmark without printing the intermediate results is
* contrary to the authors' intentions! But using serial I/O can draw back
* the performance extremely when low baud rate communication is used.
*/
#define MEASURE_TIME 1
//#define POUT 1
#define ITERATIONS 10 /* 10 Million Whetstone instructions */
#include <math.h>
#include <stdio.h>
#ifdef MEASURE_TIME
#include <time.h>
unsigned long Begin_Time,End_Time,Total_Time;
double whetstones;
#endif
#define Pout(n, j, k, x1, x2, x3, x4) pout(n, j, k, x1, x2, x3, x4);
double xx1, xx2, xx3, xx4, x, y, z, t, t1, t2;
double e1[4];
unsigned int i, j, k, l, n1, n2, n3, n4, n6, n7, n8, n9, n10, n11;
main()
{
printf("\nWhetstone Benchmark\n\n");
printf( "%d iterations\n", ITERATIONS );
#ifdef MEASURE_TIME
Begin_Time = clock();
#endif
/* initialize constants */
t = 0.499975;
t1 = 0.50025;
t2 = 2.0;
/* set values of module weights */
n1 = 0 * ITERATIONS;
n2 = 12 * ITERATIONS;
n3 = 14 * ITERATIONS;
n4 = 345 * ITERATIONS;
n6 = 210 * ITERATIONS;
n7 = 32 * ITERATIONS;
n8 = 899 * ITERATIONS;
n9 = 616 * ITERATIONS;
n10 = 0 * ITERATIONS;
n11 = 93 * ITERATIONS;
/* MODULE 1: simple identifiers */
xx1 = 1.0;
xx2 = xx3 = xx4 = -1.0;
for(i = 1; i <= n1; i += 1) {
xx1 = ( xx1 + xx2 + xx3 - xx4 ) * t;
xx2 = ( xx1 + xx2 - xx3 + xx4 ) * t;
xx3 = ( xx1 - xx2 + xx3 + xx4 ) * t;
xx4 = (-xx1 + xx2 + xx3 + xx4 ) * t;
}
#ifdef POUT
Pout(n1, n1, n1, xx1, xx2, xx3, xx4);
#endif
/* MODULE 2: array elements */
e1[0] = 1.0;
e1[1] = e1[2] = e1[3] = -1.0;
for (i = 1; i <= n2; i +=1) {
e1[0] = ( e1[0] + e1[1] + e1[2] - e1[3] ) * t;
e1[1] = ( e1[0] + e1[1] - e1[2] + e1[3] ) * t;
e1[2] = ( e1[0] - e1[1] + e1[2] + e1[3] ) * t;
e1[3] = (-e1[0] + e1[1] + e1[2] + e1[3] ) * t;
}
#ifdef POUT
Pout(n2, n3, n2, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE 3: array as parameter */
for (i = 1; i <= n3; i += 1)
pa(e1);
#ifdef POUT
Pout(n3, n2, n2, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE 4: conditional jumps */
j = 1;
for (i = 1; i <= n4; i += 1) {
if (j == 1)
j = 2;
else
j = 3;
if (j > 2)
j = 0;
else
j = 1;
if (j < 1 )
j = 1;
else
j = 0;
}
#ifdef POUT
Pout(n4, j, j, xx1, xx2, xx3, xx4);
#endif
/* MODULE 5: omitted */
/* MODULE 6: integer arithmetic */
j = 1;
k = 2;
l = 3;
for (i = 1; i <= n6; i += 1) {
j = j * (k - j) * (l -k);
k = l * k - (l - j) * k;
l = (l - k) * (k + j);
e1[l - 2] = j + k + l; /* C arrays are zero based */
e1[k - 2] = j * k * l;
}
#ifdef POUT
Pout(n6, j, k, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE 7: trig. functions */
x = y = 0.5;
for(i = 1; i <= n7; i +=1) {
x = t * atan(t2*sin(x)*cos(x)/(cos(x+y)+cos(x-y)-1.0));
y = t * atan(t2*sin(y)*cos(y)/(cos(x+y)+cos(x-y)-1.0));
}
#ifdef POUT
Pout(n7, j, k, x, x, y, y);
#endif
/* MODULE 8: procedure calls */
x = y = z = 1.0;
for (i = 1; i <= n8; i +=1)
p3(x, y, &z);
#ifdef POUT
Pout(n8, j, k, x, y, z, z);
#endif
/* MODULE9: array references */
j = 1;
k = 2;
l = 3;
e1[0] = 1.0;
e1[1] = 2.0;
e1[2] = 3.0;
for(i = 1; i <= n9; i += 1)
p0();
#ifdef POUT
Pout(n9, j, k, e1[0], e1[1], e1[2], e1[3]);
#endif
/* MODULE10: integer arithmetic */
j = 2;
k = 3;
for(i = 1; i <= n10; i +=1) {
j = j + k;
k = j + k;
j = k - j;
k = k - j - j;
}
#ifdef POUT
Pout(n10, j, k, xx1, xx2, xx3, xx4);
#endif
/* MODULE11: standard functions */
x = 0.75;
for(i = 1; i <= n11; i +=1)
x = sqrt( exp( log(x) / t1));
#ifdef POUT
Pout(n11, j, k, x, x, x, x);
#endif
#ifdef MEASURE_TIME
End_Time = clock();
Total_Time = End_Time - Begin_Time; /* in 1/ seconds */
whetstones = (1e5 * ITERATIONS * CLOCKS_PER_SEC) / Total_Time;
printf("\nWhetstone runs in %ld clock ticks (%d). %ld Kwhets/second\n",
Total_Time, CLOCKS_PER_SEC, (long) whetstones / 1000 );
#endif
}
pa(e)
double e[4];
{
register int j;
j = 0;
lab:
e[0] = ( e[0] + e[1] + e[2] - e[3] ) * t;
e[1] = ( e[0] + e[1] - e[2] + e[3] ) * t;
e[2] = ( e[0] - e[1] + e[2] + e[3] ) * t;
e[3] = ( -e[0] + e[1] + e[2] + e[3] ) / t2;
j += 1;
if (j < 6)
goto lab;
}
p3(x, y, z)
double x, y, *z;
{
x = t * (x + y);
y = t * (x + y);
*z = (x + y) /t2;
}
p0()
{
e1[j] = e1[k];
e1[k] = e1[l];
e1[l] = e1[j];
}
#ifdef POUT
pout(n, j, k, x1, x2, x3, x4)
unsigned int n, j, k;
double x1, x2, x3, x4;
{
printf("%5u %5u %5u %11.3e %11.3e %11.3e %11.3e\n",
n, j, k, x1, x2, x3, x4);
}
#endif
lib/CPUs/MIPS/bsp/examples/xcpt.c
+128
View File
@@ -0,0 +1,128 @@
#include <sys/times.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <errno.h>
#include <stdlib.h>
#include "libsys.h"
#include "xcpt.h"
#include "irq.h"
char *_xcpt_code_str[32] =
{
"Int", "Mod", "TLBL", "TLBS", "AdEL", "AdES", "IBE", "DBE",
"Sys", "Bp", "RI", "CpU", "Ov", "Tr", "NCD/VCEI", "MC/FPE",
"Res(16)", "Res(17)", "Res(18)", "Res(19)", "Res(20)", "Res(21)", "Res(22)", "WATCH",
"Res(24)", "Res(25)", "Res(26)", "Res(27)", "Res(28)", "Res(29)", "Res(30)", "VCED"
};
#define PRINT_REG(tag_str, reg) \
sputs(tag_str); \
print_word(reg); \
sputs("\n");
int _xcpt_default_dispatch(struct xcptcontext * xcp)
{
return 1;
}
int _xcpt_dispatch(struct xcptcontext * xcp)
{
int xcpt_code, result;
xcpt_code = ((0xFF & xcp->cr) >> 2);
switch(xcpt_code)
{
case Int:
result = _irq_dispatch(xcp);
break;
default:
result = _xcpt_default_dispatch(xcp);
break;
}
return result;
}
int _xcpt_deliver(struct xcptcontext * _xcp)
{
int exc_code;
volatile int *pInstr;
/* This function gets called by the low-level exception handler. */
if (_xcpt_dispatch(_xcp))
{
sputs("\n");
PRINT_REG("Status : ", _xcp->sr);
PRINT_REG("Cause : ", _xcp->cr);
PRINT_REG("EPC : ", _xcp->epc);
PRINT_REG("BadAddr : ", _xcp->baddr);
PRINT_REG("MDLO : ", _xcp->mdlo);
PRINT_REG("MDHI : ", _xcp->mdhi);
sputs("\n");
sputs("Registers:\n");
PRINT_REG(" 0 (zero) : ", _xcp->regs[0]);
PRINT_REG(" 1 (at) : ", _xcp->regs[1]);
PRINT_REG(" 2 (v0) : ", _xcp->regs[2]);
PRINT_REG(" 3 (v1) : ", _xcp->regs[3]);
PRINT_REG(" 4 (a0) : ", _xcp->regs[4]);
PRINT_REG(" 5 (a1) : ", _xcp->regs[5]);
PRINT_REG(" 6 (a2) : ", _xcp->regs[6]);
PRINT_REG(" 7 (a3) : ", _xcp->regs[7]);
PRINT_REG(" 8 (t0) : ", _xcp->regs[8]);
PRINT_REG(" 9 (t1) : ", _xcp->regs[9]);
PRINT_REG("10 (t2) : ", _xcp->regs[10]);
PRINT_REG("11 (t3) : ", _xcp->regs[11]);
PRINT_REG("12 (t4) : ", _xcp->regs[12]);
PRINT_REG("13 (t5) : ", _xcp->regs[13]);
PRINT_REG("14 (t6) : ", _xcp->regs[14]);
PRINT_REG("15 (t7) : ", _xcp->regs[15]);
PRINT_REG("16 (s0) : ", _xcp->regs[16]);
PRINT_REG("17 (s1) : ", _xcp->regs[17]);
PRINT_REG("18 (s2) : ", _xcp->regs[18]);
PRINT_REG("19 (s3) : ", _xcp->regs[19]);
PRINT_REG("20 (s4) : ", _xcp->regs[20]);
PRINT_REG("21 (s5) : ", _xcp->regs[21]);
PRINT_REG("22 (s6) : ", _xcp->regs[22]);
PRINT_REG("23 (s7) : ", _xcp->regs[23]);
PRINT_REG("24 (t8) : ", _xcp->regs[24]);
PRINT_REG("25 (t9) : ", _xcp->regs[25]);
PRINT_REG("26 (k0) : ", _xcp->regs[26]);
PRINT_REG("27 (k1) : ", _xcp->regs[27]);
PRINT_REG("28 (gp) : ", _xcp->regs[28]);
PRINT_REG("29 (sp) : ", _xcp->regs[29]);
PRINT_REG("30 (fp) : ", _xcp->regs[30]);
PRINT_REG("31 (ra) : ", _xcp->regs[31]);
sputs("\n");
exc_code = (_xcp->cr >> 2) & 0x1F;
sputs("Unhandled exception <");
sputs(_xcpt_code_str[exc_code]);
sputs("> at PC : ");
print_word(_xcp->epc);
sputs("\n");
if (_xcp->cr & 0x80000000)
{
pInstr = (int*)(_xcp->epc + 4);
}
else
{
pInstr = (int*)(_xcp->epc);
}
sputs("Instruction at exception address : ");
print_word(*pInstr);
sputs("\n");
sputs("Terminate.\n");
_exit(exc_code);
}
return 0;
}
lib/CPUs/MIPS/bsp/examples/xcpt.h
+34
View File
@@ -0,0 +1,34 @@
#ifndef XCPT_H
#define XCPT_H
typedef enum
{
Int = 0, Mod = 1, TLBL = 2, TLBS = 3, AdEL = 4, AdES = 5,
IBE = 6, DBE = 7, Syscall = 8, Bp = 9, RI = 10, CpU = 11,
Ov = 12, TRAP = 13, VCEI = 14, FPE = 15, C2E = 16, Watch = 23, VCED = 31
} EXCEPTION_CODE;
typedef unsigned int reg_t;
typedef struct xcptcontext
{
/* This is the exception context frame that is passed to the exception
handlers. It gets filled in by the low-level exception handler in
"machine.S". An assembler version of this structure can be found at the
bottom of "machine.H".*/
reg_t sr; /* Status Register */
reg_t cr; /* Cause Register */
reg_t epc; /* PC at time of exception. */
reg_t baddr;
reg_t regs[32]; /* Copy of all general purpose registers */
reg_t mdlo; /* HI/LO registers (used for memory management) */
reg_t mdhi;
reg_t count; /* Timer registers */
reg_t compare;
struct xcptcontext * prev; /* To link exceptions. (unused for now) */
unsigned xclass; /* Priority class of this exception. (unused for now). */
} EXCEPTION_CONTEXT;
#endif // XCPT_H
lib/CPUs/MIPS/bsp/examples/xcpt_asm.h
+67
View File
@@ -0,0 +1,67 @@
#ifndef XCPT_ASM_H
#define XCPT_ASM_H
/* LEAF - declare leaf routine */
#define LEAF(symbol) \
.globl symbol; \
.align 2; \
.type symbol, @function; \
.ent symbol, 0; \
symbol: .frame sp, 0, ra
/* END - mark end of function */
#define END(function) \
.end function; \
.size function, .-function
/* Exception stack size */
#define XCP_SIZE 1024
/* save location for registers */
#define XCP_SR 0
#define XCP_CR 4
#define XCP_EPC 8
#define XCP_BADDR 12
#define XCP_ZERO 16
#define XCP_AT 20
#define XCP_V0 24
#define XCP_V1 28
#define XCP_A0 32
#define XCP_A1 36
#define XCP_A2 40
#define XCP_A3 44
#define XCP_T0 48
#define XCP_T1 52
#define XCP_T2 56
#define XCP_T3 60
#define XCP_T4 64
#define XCP_T5 68
#define XCP_T6 72
#define XCP_T7 76
#define XCP_S0 80
#define XCP_S1 84
#define XCP_S2 88
#define XCP_S3 92
#define XCP_S4 96
#define XCP_S5 100
#define XCP_S6 104
#define XCP_S7 108
#define XCP_T8 112
#define XCP_T9 116
#define XCP_JP 116
#define XCP_K0 120
#define XCP_K1 124
#define XCP_GP 128
#define XCP_SP 132
#define XCP_S8 136
#define XCP_FP 136
#define XCP_RA 140
#define XCP_MDLO 144
#define XCP_MDHI 148
#define XCP_COUNT 152
#define XCP_COMPARE 156
#define XCP_PREV 160
#define XCP_CLASS 164
#endif /* XCPT_ASM_H */
lib/CPUs/MIPS/bsp/toolchain/howto_build.txt
+37
View File
@@ -0,0 +1,37 @@
# ---------------------------------------------------------------
# 1. Binutils bauen und installieren
# ---------------------------------------------------------------
> tar -xzf binutils-2.18.tar.gz
> mkdir binutils-2.18_build
> cd binutils-2.18_build
> ../binutils-2.18/configure --target=mipsel-elf --prefix=/usr/local
> make
> make install
# ---------------------------------------------------------------
# 2. GCC bauen und installieren
# ---------------------------------------------------------------
> tar -xzf gcc-4.3.0.tar.gz
> tar -xzf gcc-core-4.3.0.tar.gz
> mkdir gcc-4.3.0_build
> cd gcc-4.3.0_build
> ../gcc-4.3.0/configure --target=mipsel-elf --prefix=/usr/local --enable-languages=c,c++ --disable-shared --with-newlib --with-float=soft --disable-multilib --with-abi=eabi
> CFLAGS_FOR_TARGET="-G 0 -g -O2" make LANGUAGES="c c++"
> make install LANGUAGES="c c++"
# ---------------------------------------------------------------
# 3. Newlib bauen und installieren
# ---------------------------------------------------------------
> tar -xzf newlib-1.16.0.tar.gz
! Bug in newlib-1.16.0/newlib/libc/machine/mips/strlen.c.
Newlib von Hand patchen (32-bit MIPS targets):
"lbu $3,0($4)\n"
"nop\n" <= nop einfügen
"bnez $3,1b\n"
> mkdir newlib-1.16.0_build
> cd newlib-1.16.0_build
> ../newlib-1.16.0/configure --target=mipsel-elf --prefix=/usr/local --disable-multilib --with-float=soft --with-abi=eabi
> TARGET_CFLAGS="-G 0 -g -O2" make
> make install