683 lines
14 KiB
C
683 lines
14 KiB
C
/*
|
|
* cmd.c
|
|
*
|
|
* Copyright (C) 2005 Erik Gilling, all rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation, version 2.
|
|
*
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include "samba.h"
|
|
#include "cmd.h"
|
|
|
|
#include "loader128_data.h"
|
|
#include "loader256_data.h"
|
|
|
|
#define MANUAL_FLASH
|
|
|
|
static int cmd_help( int argc, char *argv[] );
|
|
static int cmd_version( int argc, char *argv[] );
|
|
static int cmd_write_mem( int argc, char *argv[] );
|
|
static int cmd_read_mem( int argc, char *argv[] );
|
|
static int cmd_send_file( int argc, char *argv[] );
|
|
static int cmd_set_clock( int argc, char *argv[] );
|
|
static int cmd_locked_regions( int argc, char *argv[] );
|
|
static int cmd_unlock_regions( int argc, char *argv[] );
|
|
static int cmd_boot_from_flash( int argc, char *argv[] );
|
|
static int cmd_flash( int argc, char *argv[] );
|
|
static int cmd_read( int argc, char *argv[] );
|
|
static int cmd_manual_flash( int argc, char *argv[] );
|
|
static int cmd_manual_read( int argc, char *argv[] );
|
|
|
|
static cmd_t cmds[] = {
|
|
{cmd_write_mem, "wb",
|
|
"wb <addr> <byte>", "write <byte> to <addr>"},
|
|
|
|
{cmd_read_mem, "rb",
|
|
"rb <addr>", "read byte from <addr>"},
|
|
|
|
{cmd_write_mem, "ws",
|
|
"ws <addr> <short>", "write <short> to <addr>"},
|
|
|
|
{cmd_read_mem, "rs",
|
|
"rs <addr>", "read short from <addr>"},
|
|
|
|
{cmd_write_mem, "ww",
|
|
"ww <addr> <word>", "write <word> to <addr>"},
|
|
|
|
{cmd_read_mem, "rw",
|
|
"rw <addr>", "read word from <addr>"},
|
|
|
|
{cmd_send_file, "sf",
|
|
"sf <addr> <file> <offset> <len>",
|
|
"send len bytes of file starting at offset"},
|
|
|
|
{cmd_set_clock, "set_clock",
|
|
"set_clock", "set clock as SAM-BA does"},
|
|
{cmd_locked_regions, "locked_regions",
|
|
"locked_regions", "display locked regions"},
|
|
{cmd_unlock_regions, "unlock_regions",
|
|
"unlock_regions", "unlock all lock regions"},
|
|
{cmd_boot_from_flash, "boot_from_flash",
|
|
"boot_from_flash", "set the SAM7X to boot from flash"},
|
|
{cmd_flash, "flash",
|
|
"flash <file>", "upload <file> to flash using the loader"},
|
|
{cmd_read, "read",
|
|
"read <file> <addr> <len>", "read <len> bytes at <addr> to <file> using R commands"},
|
|
{cmd_manual_flash, "manual_flash",
|
|
"manual_flash <file>", "upload <file> to flash using ww commands"},
|
|
{cmd_manual_read, "manual_read",
|
|
"manual_read <file> <addr> <len>", "write <len> bytes at <addr> to <file> using rw commands"},
|
|
{cmd_version, "version",
|
|
"version", "get boot program version"},
|
|
{cmd_help, "help",
|
|
"help", "display help screen"}
|
|
};
|
|
|
|
cmd_t *cmd_find( char *name )
|
|
{
|
|
int i;
|
|
for( i=0 ; i<(sizeof(cmds)/
|
|
sizeof(*cmds)); i++ ) {
|
|
if( !strcmp( name, cmds[i].name ) ) {
|
|
return &cmds[i];
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static int cmd_help( int argc, char *argv[] )
|
|
{
|
|
int i;
|
|
for( i=0 ; i<(sizeof(cmds)/
|
|
sizeof(*cmds)); i++ ) {
|
|
printf( "%-30s%s\n", cmds[i].invo, cmds[i].help );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int cmd_write_mem( int argc, char *argv[] )
|
|
{
|
|
unsigned long int addr;
|
|
unsigned long int val;
|
|
char *endp;
|
|
|
|
if( argc != 3 ) {
|
|
return CMD_E_WRONG_NUM_ARGS;
|
|
}
|
|
|
|
addr = strtoul( argv[1], &endp, 0 );
|
|
if( endp == argv[1] ||
|
|
*endp != '\0' ) {
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
val = strtoul( argv[2], &endp, 0 );
|
|
if( endp == argv[1] ||
|
|
*endp != '\0' ) {
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
|
|
switch( argv[0][1] ) {
|
|
case 'b':
|
|
if( samba_write_byte( addr, (uint8_t) val ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
break;
|
|
case 's':
|
|
if( samba_write_half_word( addr, (uint16_t) val ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
break;
|
|
case 'w':
|
|
if( samba_write_word( addr, (uint32_t) val ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return CMD_E_OK;
|
|
}
|
|
|
|
static int cmd_read_mem( int argc, char *argv[] )
|
|
{
|
|
unsigned long int addr;
|
|
char *endp;
|
|
|
|
if( argc != 2 ) {
|
|
return CMD_E_WRONG_NUM_ARGS;
|
|
}
|
|
|
|
addr = strtoul( argv[1], &endp, 0 );
|
|
if( endp == argv[1] ||
|
|
*endp != '\0' ) {
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
switch( argv[0][1] ) {
|
|
case 'b':
|
|
{
|
|
uint8_t val;
|
|
if( samba_read_byte( addr, &val ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
printf( "%02X\n", val );
|
|
}
|
|
break;
|
|
case 's':
|
|
{
|
|
uint16_t val;
|
|
|
|
if( samba_read_half_word( addr, &val ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
printf( "%04X\n", val );
|
|
}
|
|
break;
|
|
case 'w':
|
|
{
|
|
uint32_t val;
|
|
if( samba_read_word( addr, &val ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
printf( "%08X\n", (unsigned int) val );
|
|
}
|
|
break;
|
|
}
|
|
|
|
return CMD_E_OK;
|
|
}
|
|
|
|
static int cmd_send_file( int argc, char *argv[] )
|
|
{
|
|
unsigned long int offset;
|
|
unsigned long int len;
|
|
unsigned long int addr;
|
|
char *endp;
|
|
uint8_t *data;
|
|
int fd;
|
|
|
|
if( argc != 5 ) {
|
|
return CMD_E_WRONG_NUM_ARGS;
|
|
}
|
|
|
|
addr = strtoul( argv[1], &endp, 0 );
|
|
if( endp == argv[1] ||
|
|
*endp != '\0' ) {
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
offset = strtoul( argv[3], &endp, 0 );
|
|
if( endp == argv[1] ||
|
|
*endp != '\0' ) {
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
len = strtoul( argv[4], &endp, 0 );
|
|
if( endp == argv[1] ||
|
|
*endp != '\0' ) {
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
if( (data = (uint8_t *) malloc( len )) == NULL ) {
|
|
printf( "can't allocate %d bytes\n", (int)len );
|
|
return CMD_E_NO_MEM;
|
|
}
|
|
|
|
if( (fd = open( argv[2], O_RDONLY )) < 0 ) {
|
|
printf( "can't open file \"%s\": %s\n", argv[2],
|
|
strerror( errno ) );
|
|
return CMD_E_BAD_FILE;
|
|
}
|
|
|
|
lseek( fd, offset, SEEK_SET );
|
|
len = read( fd, data, len );
|
|
|
|
if( samba_send_file( 0x202000, data, len ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
|
|
return CMD_E_OK;
|
|
}
|
|
|
|
static int cmd_version( int argc, char *argv[] )
|
|
{
|
|
char buff[256];
|
|
|
|
if( samba_get_version( buff, 256 ) < 0 ) {
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
|
|
printf( "%s\n", buff );
|
|
|
|
return CMD_E_OK;
|
|
}
|
|
|
|
static int cmd_set_clock( int argc, char *argv[] )
|
|
{
|
|
uint32_t val;
|
|
uint8_t val8;
|
|
|
|
/* set clock to main clock / 2 */
|
|
if( samba_write_word( 0xFFFFFC30, 0x5 ) < 0 ) {
|
|
return -1;
|
|
}
|
|
|
|
do {
|
|
if( samba_read_word( 0xFFFFFC68, &val ) < 0 ) {
|
|
return -1;
|
|
}
|
|
} while( val != 0xD );
|
|
|
|
/* set clock to pll clock / 2 */
|
|
if( samba_write_word( 0xFFFFFC30, 0x7 ) < 0 ) {
|
|
return -1;
|
|
}
|
|
|
|
do {
|
|
if( samba_read_word( 0xFFFFFC68, &val ) < 0 ) {
|
|
return -1;
|
|
}
|
|
} while( val != 0xD );
|
|
|
|
|
|
/* read 0x200000 two times because SAM-BA does it */
|
|
if( samba_read_byte( 0x00200000, &val8 ) < 0 ) {
|
|
return -1;
|
|
}
|
|
if( val8 != 0x13 ) {
|
|
printf( "warning: magic read 0x00200000 != 0x13\n" );
|
|
}
|
|
|
|
if( samba_read_byte( 0x00200000, &val8 ) < 0 ) {
|
|
return -1;
|
|
}
|
|
if( val8 != 0x13 ) {
|
|
printf( "warning: magic read 0x00200000 != 0x13\n" );
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int cmd_locked_regions( int argc, char *argv[] )
|
|
{
|
|
uint32_t val;
|
|
int i;
|
|
|
|
if( samba_read_word( 0xffffff68, &val ) < 0 ) {
|
|
return -1;
|
|
}
|
|
|
|
|
|
printf( "Locked Regions:" );
|
|
|
|
for( i=0 ; i<16 ; i++ ) {
|
|
if( val & 0x00010000 ) {
|
|
printf( " %i", i );
|
|
}
|
|
val >>= 1;
|
|
}
|
|
|
|
printf( "\n" );
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int cmd_unlock_regions( int argc, char *argv[] )
|
|
{
|
|
uint32_t val;
|
|
int i;
|
|
|
|
if( samba_read_word( 0xffffff68, &val ) < 0 ) {
|
|
return -1;
|
|
}
|
|
|
|
|
|
if( val & 0xffff0000 ) {
|
|
/* set up MCLKS to some odd value... hey SAM-BA does it */
|
|
if( samba_write_word( 0xffffff60, 0x00050100 ) < 0 ) {
|
|
return -1;
|
|
}
|
|
|
|
for( i=0 ; i<samba_chip_info.lock_bits; i++ ) {
|
|
if( val & 0x00010000 ) {
|
|
int page = (samba_chip_info.nvpsiz / samba_chip_info.page_size /
|
|
samba_chip_info.lock_bits) * i;
|
|
|
|
printf( "unlocking region %i:", i );
|
|
|
|
|
|
if( samba_write_word( 0xffffff64,
|
|
0x5a000004 | (page << 8) ) < 0 ) {
|
|
return -1;
|
|
}
|
|
|
|
printf( " done\n" );
|
|
}
|
|
val >>= 1;
|
|
}
|
|
|
|
|
|
/* set up MCLKS back to a sane value */
|
|
if( samba_write_word( 0xffffff60, 0x00480100 ) < 0 ) {
|
|
return -1;
|
|
}
|
|
}
|
|
printf( "\n" );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* contributed by Liam Staskawicz */
|
|
static int cmd_boot_from_flash( int argc, char *argv[] )
|
|
{
|
|
/*
|
|
* word: 5A is key to send any message,
|
|
* 02 is GPNVM2 to boot from Flash,
|
|
* 0B is "set this bit"
|
|
*/
|
|
uint32_t val;
|
|
|
|
|
|
do {
|
|
if( samba_read_word( 0xffffff68, &val ) < 0 ) {
|
|
return -1;
|
|
}
|
|
} while( !val & 0x1 );
|
|
|
|
if( samba_write_word( 0xFFFFFF64, 0x5A00020B ) < 0 ) {
|
|
printf( "Couldn't flip the bit to boot from Flash.\n" );
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int cmd_flash( int argc, char *argv[] )
|
|
{
|
|
struct stat stbuf;
|
|
size_t loader_len;
|
|
size_t file_len;
|
|
size_t i;
|
|
uint8_t *buff;
|
|
int file_fd;
|
|
int read_len;
|
|
int ps = samba_chip_info.page_size;
|
|
uint8_t *loader_data;
|
|
|
|
if( argc != 2 ) {
|
|
return CMD_E_WRONG_NUM_ARGS;
|
|
}
|
|
|
|
if( ps == 128 ) {
|
|
loader_data = loader128_data;
|
|
loader_len = sizeof( loader128_data );
|
|
} else if( ps == 256 ) {
|
|
loader_data = loader256_data;
|
|
loader_len = sizeof( loader256_data );
|
|
} else {
|
|
printf( "no loader for %d byte pages\n", ps );
|
|
return -1;
|
|
}
|
|
|
|
if( stat( argv[1], &stbuf ) < 0 ) {
|
|
printf( "%s not found\n", argv[1] );
|
|
return -1;
|
|
}
|
|
|
|
file_len = stbuf.st_size;
|
|
|
|
if( (buff = (uint8_t *) malloc( ps ) ) == NULL ) {
|
|
printf( "can't alocate buffer of size 0x%x\n", ps );
|
|
goto error0;
|
|
}
|
|
|
|
if( samba_send_file( 0x00201600, loader_data, loader_len ) < 0 ) {
|
|
printf( "could not upload samba.bin\n" );
|
|
goto error1;
|
|
}
|
|
|
|
if( (file_fd = open( argv[1], O_RDONLY )) < 0 ) {
|
|
printf( "can't open %s\n", argv[1] );
|
|
return -1;
|
|
}
|
|
|
|
for( i=0 ; i<file_len ; i+=ps ) {
|
|
/* set page # */
|
|
if( samba_write_word( 0x00201400+ps, i/ps ) < 0 ) {
|
|
printf( "could not write page %d address\n", (int) i/ps );
|
|
goto error2;
|
|
}
|
|
|
|
read_len = (file_len-i < ps)?file_len-i:ps;
|
|
/* XXX need to implement safe read */
|
|
if( read( file_fd, buff, read_len ) < read_len ) {
|
|
printf( "could not read 0x%x bytes from file\n", read_len );
|
|
goto error2;
|
|
}
|
|
|
|
if( samba_send_file( 0x00201400, buff, ps ) < 0 ) {
|
|
printf( "could not send page %d\n", (int) i/ps );
|
|
goto error2;
|
|
}
|
|
|
|
if( samba_go( 0x00201600 ) < 0 ) {
|
|
printf( "could not send go command for page %d\n", (int) i/ps );
|
|
goto error2;
|
|
}
|
|
|
|
}
|
|
|
|
free( buff );
|
|
close( file_fd );
|
|
|
|
return 0;
|
|
|
|
error2:
|
|
close( file_fd );
|
|
|
|
error1:
|
|
free( buff );
|
|
|
|
error0:
|
|
return -1;
|
|
}
|
|
|
|
static int cmd_manual_flash( int argc, char *argv[] )
|
|
{
|
|
struct stat stbuf;
|
|
size_t file_len;
|
|
size_t i,j;
|
|
char *buff;
|
|
int file_fd;
|
|
int read_len;
|
|
uint32_t val;
|
|
int ps = samba_chip_info.page_size;
|
|
|
|
if( argc != 2 ) {
|
|
return CMD_E_WRONG_NUM_ARGS;
|
|
}
|
|
|
|
if( stat( argv[1], &stbuf ) < 0 ) {
|
|
printf( "%s not found\n", argv[1] );
|
|
return -1;
|
|
}
|
|
file_len = stbuf.st_size;
|
|
|
|
|
|
if( (buff = (char *) malloc( ps )) == NULL ) {
|
|
printf( "can't alocate buffer of size 128\n" );
|
|
return -1;
|
|
}
|
|
|
|
|
|
if( (file_fd = open( argv[1], O_RDONLY )) < 0 ) {
|
|
printf( "can't open %s\n", argv[1] );
|
|
goto error0;
|
|
}
|
|
|
|
for( i=0 ; i<file_len ; i+=ps ) {
|
|
/* wait for flash to become ready */
|
|
do {
|
|
if( samba_read_word( 0xffffff68, &val ) < 0 ) {
|
|
goto error1;
|
|
}
|
|
} while( !val & 0x1 );
|
|
|
|
read_len = (file_len-i < ps)?file_len-i:ps;
|
|
/* XXX need to implement safe read */
|
|
if( read( file_fd, buff, read_len ) < read_len ) {
|
|
printf( "could not read 0x%x bytes from file\n", read_len );
|
|
goto error1;
|
|
}
|
|
|
|
for( j=0 ; j<ps ; j+=4 ) {
|
|
if( samba_write_word( 0x00100000 + i + j, *((uint32_t*)(buff+j))) < 0 ) {
|
|
printf( "could not write byte 0x%x\n", (unsigned int)( 0x00100000 + i + j) );
|
|
}
|
|
}
|
|
|
|
/* send write command */
|
|
if( samba_write_word( 0xFFFFFF64, 0x5A000001 | ((i/ps) << 8) ) < 0 ) {
|
|
printf( "could not send write command for page %d\n", (int) i/ps );
|
|
goto error1;
|
|
}
|
|
|
|
}
|
|
|
|
free( buff );
|
|
close( file_fd );
|
|
|
|
return 0;
|
|
|
|
error1:
|
|
close( file_fd );
|
|
|
|
error0:
|
|
free( buff );
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int cmd_manual_read( int argc, char *argv[] )
|
|
{
|
|
unsigned long int addr;
|
|
unsigned long int len;
|
|
int fd;
|
|
int i;
|
|
uint32_t val;
|
|
char *endp;
|
|
|
|
if( argc != 4 ) {
|
|
printf( "wrong number of args\n" );
|
|
return CMD_E_WRONG_NUM_ARGS;
|
|
}
|
|
|
|
addr = strtoul( argv[2], &endp, 0 );
|
|
if( endp == argv[2] ||
|
|
*endp != '\0' ) {
|
|
printf("%s not a vaild number\n", argv[2]);
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
len = strtoul( argv[3], &endp, 0 );
|
|
if( endp == argv[3] ||
|
|
*endp != '\0' ) {
|
|
printf("%s not a vaild number\n", argv[3]);
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
if( (fd = open( argv[1], O_RDWR | O_CREAT, 0666 )) < 0 ) {
|
|
printf( "can't open file \"%s\": %s\n", argv[1],
|
|
strerror( errno ) );
|
|
return CMD_E_BAD_FILE;
|
|
}
|
|
|
|
for( i=0; i<len ; i+=4 ) {
|
|
if( samba_read_word( addr + i, &val ) < 0 ) {
|
|
printf( "io error\n" );
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
|
|
if( write( fd, &val, 4 ) < 4 ) {
|
|
printf("write error\n" );
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
}
|
|
|
|
close( fd );
|
|
|
|
return CMD_E_OK;
|
|
}
|
|
|
|
static int cmd_read( int argc, char *argv[] )
|
|
{
|
|
unsigned long int addr;
|
|
unsigned long int len;
|
|
int fd;
|
|
int i;
|
|
char *endp;
|
|
int read_len;
|
|
uint8_t buff[0x80];
|
|
|
|
if( argc != 4 ) {
|
|
printf( "wrong number of args\n");
|
|
return CMD_E_WRONG_NUM_ARGS;
|
|
}
|
|
|
|
addr = strtoul( argv[2], &endp, 0 );
|
|
if( endp == argv[2] ||
|
|
*endp != '\0' ) {
|
|
printf("%s not a vaild number\n", argv[2]);
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
len = strtoul( argv[3], &endp, 0 );
|
|
if( endp == argv[3] ||
|
|
*endp != '\0' ) {
|
|
printf("%s not a vaild number\n", argv[3]);
|
|
return CMD_E_INVAL_ARG;
|
|
}
|
|
|
|
if( (fd = open( argv[1], O_RDWR | O_CREAT, 0666 )) < 0 ) {
|
|
printf( "can't open file \"%s\": %s\n", argv[1],
|
|
strerror( errno ) );
|
|
return CMD_E_BAD_FILE;
|
|
}
|
|
|
|
for( i=0; i<len ; i+=0x80 ) {
|
|
read_len = len-i < 0x80 ? len-i : 0x80;
|
|
if( samba_recv_file( addr + i, buff, read_len ) < 0 ) {
|
|
printf( "io error\n" );
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
|
|
if( write( fd, buff, read_len ) < read_len ) {
|
|
printf("write error\n" );
|
|
return CMD_E_IO_FAILURE;
|
|
}
|
|
}
|
|
|
|
close( fd );
|
|
|
|
return CMD_E_OK;
|
|
}
|
|
|
|
|