OpenCores
URL https://opencores.org/ocsvn/amber/amber/trunk

Subversion Repositories amber

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /amber/trunk
    from Rev 66 to Rev 67
    ↔ Reverse comparison
  •

Rev 66 → Rev 67

/sw/tools/amber-pkt2mem.c
42,7 → 42,7
 
#include <stdio.h>
#include <stdlib.h>
#include "../boot-loader/boot-loader.h"
#include "../boot-loader-serial/boot-loader.h"
 
/* Function prototypes */
int fsize(FILE *f);
/sw/tools/amber-bin2mem.c
42,7 → 42,7
 
#include <stdio.h>
#include <stdlib.h>
#include "../boot-loader/boot-loader.h"
#include "../boot-loader-serial/boot-loader.h"
 
/* Function prototypes */
int fsize(FILE *f);
/sw/boot-loader-serial/boot-loader.c File deleted
/sw/boot-loader-serial/boot-loader-serial.c
0,0 → 1,430
/*----------------------------------------------------------------
// //
// boot-loader.c //
// //
// This file is part of the Amber project //
// http://www.opencores.org/project,amber //
// //
// Description //
// The main functions for the boot loader application. This //
// application is embedded in the FPGA's SRAM and is used //
// to load larger applications into the DDR3 memory on //
// the development board. //
// //
// Author(s): //
// - Conor Santifort, csantifort.amber@gmail.com //
// //
//////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2010 Authors and OPENCORES.ORG //
// //
// This source file may be used and distributed without //
// restriction provided that this copyright statement is not //
// removed from the file and that any derivative work contains //
// the original copyright notice and the associated disclaimer. //
// //
// This source file is free software; you can redistribute it //
// and/or modify it under the terms of the GNU Lesser General //
// Public License as published by the Free Software Foundation; //
// either version 2.1 of the License, or (at your option) any //
// later version. //
// //
// This source is distributed in the hope that it will be //
// useful, but WITHOUT ANY WARRANTY; without even the implied //
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR //
// PURPOSE. See the GNU Lesser General Public License for more //
// details. //
// //
// You should have received a copy of the GNU Lesser General //
// Public License along with this source; if not, download it //
// from http://www.opencores.org/lgpl.shtml //
// //
----------------------------------------------------------------*/
 
#include "amber_registers.h"
#include "stdio.h"
#include "boot-loader.h"
#include "fpga-version.h"
 
 
int main ( void ) {
int c, esc = 0;
char buf [20]; /* current line */
char lbuf [20]; /* last line */
int i = 0;
int li = 0;
int j;
 
/* Enable the UART FIFO */
*(unsigned int *) ADR_AMBER_UART0_LCRH = 0x10;
printf("%cAmber Boot Loader v%s\n", 0xc, AMBER_FPGA_VERSION ); /* 0xc == new page */
 
/* When ADR_AMBER_TEST_SIM_CTRL is non-zero, its a Verilog simulation.
The ADR_AMBER_TEST_SIM_CTRL register is always 0 in the real fpga
The register is in vlog/system/test_module.v
*/
if ( *(unsigned int *) ADR_AMBER_TEST_SIM_CTRL ) {
load_run(*(unsigned int *) ADR_AMBER_TEST_SIM_CTRL, 0);
}
 
/* Print the instructions */
print_help();
printf("Ready\n> ");
/* Loop forever on user input */
while (1) {
if ((c = _inbyte (DLY_1S)) >= 0) {
/* Escape Sequence ? */
if (c == 0x1b) esc = 1;
else if (esc == 1 && c == 0x5b) esc = 2;
else if (esc == 2) {
esc = 0;
if (c == 'A') {
/* Erase current line using backspaces */
for (j=0;j<i;j++) _outbyte(0x08);
/* print last line and
make current line equal to last line */
for (j=0;j<li;j++) _outbyte(buf[j] = lbuf[j]);
i = li;
}
continue;
}
else esc = 0;
/* Character not part of escape sequence so print it
and add it to the buffer
*/
if (!esc) {
_outbyte (c);
/* Backspace ? */
if (c == 8 && i > 0) { i--; }
else { buf[i++] = c; }
}
/* End of line ? */
if (c == '\r' || i >= 19) {
if (i>1) {
/* Copy current line buffer to last line buffer */
for (j=0;j<20;j++) lbuf[j] = buf[j];
li = i-1;
}
buf[i] = 0; i = 0;
/* Process line */
printf("\n");
parse( buf );
printf("> ");
}
}
}
}
 
 
/* Parse a command line passed from main and execute the command */
void parse ( char * buf )
{
unsigned int found, address, data, i, length, bytes, rdata;
int file_size;
char byte;
unsigned int lcount;
char bad_command_msg[] = "Invalid command";
/* Ignore returns with no trext on the line */
if (!buf[1]) return;
/* Check if its a single character instruction */
if (buf[1] == '\r') {
switch (buf[0]) {
case 'h': /* Help */
print_help();
break;
case 'l': /* Load */
load_run(1,0);
break;
 
case 's': /* Status */
_core_status();
/* Flush out the uart with spaces */
print_spaces(16);
printf ("\n");
break;
default:
printf ("%s\n", bad_command_msg);
break;
}
return;
}
 
 
/* Check for invalid instruction format for multi-word instructions */
else if (buf[1] != 0x20) {
printf ("%s\n", bad_command_msg);
return;
}
 
 
switch (buf[0]) {
case 'd': /* Dump block of memory */
/* Dump memory contents <start address> <number of bytes in hex> */
if (get_address_data ( buf, &address, &bytes )) {
for (i=address;i<address+bytes;i+=4) {
printm (i);
}
}
break;
 
case 'j': /* Jump to <address> */
if (get_hex ( buf, 2, &address, &length )) {
load_run(0, address);
}
break;
 
 
case 'p': /* Print String */
/* Recover the address from the string - the address is written in hex */
if (get_hex ( buf, 2, &address, &length )) {
length = 0;
lcount = 0;
byte = * (char *)address++;
while ( byte < 128 && length < 0x1000 ) {
if ( byte != 0 ) _outbyte( byte );
if ( byte == '\r' ) printf("\n"); lcount = 0;
if ( lcount == 79 ) printf("\n"); lcount = 0;
byte = * (char *)address++;
lcount++;
length++;
}
}
break;
 
case 'r': /* Read address */
/* Recover the address from the string - the address is written in hex */
if (get_hex ( buf, 2, &address, &length )) {
printm (address);
}
break;
 
case 'b': /* Load binary file into address */
/* Recover the address from the string - the address is written in hex */
if (get_hex ( buf, 2, &address, &length )) {
load_run (5, address);
}
break;
 
case 'w': /* Write address */
/* Get the address */
if (get_address_data ( buf, &address, &data )) {
/* Write to memory */
* (unsigned int*) address = data;
/* read back */
printm (address);
}
break;
default:
printf ("%s\n", bad_command_msg);
break;
}
}
 
 
/* Load a binary file into memory via the UART
If its an elf file, copy it into the correct memory areas
and execute it.
*/
void load_run( int type, unsigned int address )
{
int file_size;
char * message = "Send file w/ 1K Xmodem protocol from terminal emulator now...";
switch (type) {
case 1: /* Load a binary file to FILE_LOAD_BASE */
/* Load a file using the xmodem protocol */
printf ("%s\n", message);
 
/* Destination, Destination Size */
file_size = xmodemReceive((char *) FILE_LOAD_BASE, FILE_MAX_SIZE);
if (file_size < 0 || file_size > FILE_MAX_SIZE) {
printf ("Xmodem error file size 0x%x \n", file_size);
return;
}
printf("\nelf split\n");
elfsplitter(FILE_LOAD_BASE, file_size);
break;
 
case 2: /* testing the boot loader itself in simulation */
print_help();
_core_status();
print_spaces(16);
_testpass();
break;
 
 
case 3: /* vmlinux in simulation */
printf("j 0x%08x\n", LINUX_JUMP_ADR);
/* Flush the uart tx buffer with spaces */
print_spaces(16);
printf("\n");
/* pc jump */
_jump_to_program(LINUX_JUMP_ADR);
_testpass();
break;
 
 
case 4: /* programs starting at 0x8000 in simulation */
printf("j 0x%08x\n", APP_JUMP_ADR);
/* Flush the uart tx buffer with spaces */
print_spaces(16);
printf("\n");
/* pc jump */
_jump_to_program(APP_JUMP_ADR);
_testpass();
break;
 
case 5: /* Load a binary file into memory, to 'address' */
/* Load a file using the xmodem protocol */
printf ("%s\n", message);
/* Destination, Destination Size */
file_size = xmodemReceive((char *) address, FILE_MAX_SIZE);
if (file_size < 0 || file_size > FILE_MAX_SIZE) {
printf ("Xmodem error file size 0x%x \n", file_size);
return;
}
break;
 
 
default: /* Run the program */
printf("j 0x%08x\n", address);
/* Flush the uart tx buffer with spaces */
print_spaces(16);
printf("\n");
/* pc jump */
_jump_to_program(address);
_testpass();
break;
}
}
 
 
/* Print a memory location */
void printm ( unsigned int address )
{
printf ("mem 0x%08x = 0x%08x\n", address, * (unsigned int *)address);
}
 
 
void print_help ( void )
 
{
printf("Commands\n");
printf("l");
print_spaces(29);
printf(": Load elf file\n");
 
printf("b <address>");
print_spaces(19);
printf(": Load binary file to <address>\n");
 
printf("d <start address> <num bytes> : Dump mem\n");
 
printf("h");
print_spaces(29);
printf(": Print help message\n");
 
printf("j <address>");
print_spaces(19);
printf(": Execute loaded elf, jumping to <address>\n");
 
printf("p <address>");
print_spaces(19);
printf(": Print ascii mem until first 0\n");
printf("r <address>");
print_spaces(19);
printf(": Read mem\n");
 
printf("s");
print_spaces(29);
printf(": Core status\n");
printf("w <address> <value>");
print_spaces(11);
printf(": Write mem\n");
}
 
 
/* Print a number of spaces */
void print_spaces ( int num )
{
while(num--) printf(" ");
}
 
 
/* Return a number recovered from a string of hex digits */
int get_hex ( char * buf, int start_position,
unsigned int *address,
unsigned int *length)
{
int cpos = 0, done = 0;
 
cpos = start_position; done = 0; *address = 0;
 
while (done == 0) {
if ( buf[cpos] >= '0' && buf[cpos] <= '9' ) {
*address = *address<<4;
*address = *address + buf[cpos] - '0';
}
else if ( buf[cpos] >= 'A' && buf[cpos] <= 'F' ) {
*address = *address<<4;
*address = *address + buf[cpos] - 'A' + 10;
}
else if ( buf[cpos] >= 'a' && buf[cpos] <= 'f' ) {
*address = *address<<4;
*address = *address + buf[cpos] - 'a' + 10;
}
else {
done = 1;
*length = cpos - start_position;
}
if ( cpos >= 8+start_position ) {
done = 1;
*length = 8;
}
cpos++;
}
/* Return the length of the hexadecimal string */
if (cpos > start_position+1) return 1; else return 0;
}
 
 
/* Parse a string for an address and data in hex */
int get_address_data ( char * buf, unsigned int *address, unsigned int *data )
{
int found, length;
 
found = get_hex ( buf, 2, address, &length );
if (found) {
/* Get the data */
found = get_hex ( buf, 3+length, data, &length );
}
return found;
}
 
/sw/boot-loader-serial/Makefile
40,9 → 40,9
# ----------------------------------------------------------------
# Assembly source files
 
SRC = boot-loader.c start.S crc16.c xmodem.c elfsplitter.c
SRC = boot-loader-serial.c start.S crc16.c xmodem.c elfsplitter.c
DEP = boot-loader.h fpga-version.h
TGT = boot-loader.elf
TGT = boot-loader-serial.elf
LDS = sections.lds
 
USE_MINI_LIBC = 1
/hw/isim/run.sh
201,12 → 201,12
 
elif [ $TEST_TYPE == 3 ] || [ $TEST_TYPE == 4 ]; then
# sw test using boot loader
pushd ../../sw/boot-loader > /dev/null
pushd ../../sw/boot-loader-serial > /dev/null
make
MAKE_STATUS=$?
popd > /dev/null
if [ $MAKE_STATUS != 0 ]; then
echo "Error compiling boot-loader"
echo "Error compiling boot-loader-serial"
exit 1
fi
217,11 → 217,11
MAKE_STATUS=$?
popd > /dev/null
BOOT_MEM_FILE="../../sw/boot-loader/boot-loader.mem"
BOOT_MEM_FILE="../../sw/boot-loader-serial/boot-loader-serial.mem"
if [ $SET_5 == 1 ]; then
BOOT_MEM_PARAMS_FILE="../../sw/boot-loader/boot-loader_memparams128.v"
BOOT_MEM_PARAMS_FILE="../../sw/boot-loader-serial/boot-loader-serial_memparams128.v"
else
BOOT_MEM_PARAMS_FILE="../../sw/boot-loader/boot-loader_memparams32.v"
BOOT_MEM_PARAMS_FILE="../../sw/boot-loader-serial/boot-loader-serial_memparams32.v"
fi
MAIN_MEM_FILE="../../sw/${AMBER_TEST_NAME}/${AMBER_TEST_NAME}.mem"
AMBER_LOAD_MAIN_MEM="-d AMBER_LOAD_MAIN_MEM"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.