nes-proj/cpu/mc1322x/tests/flasher.c

255 lines
6.4 KiB
C
Raw Normal View History

/*
* Copyright (c) 2010, Mariano Alvira <mar@devl.org> and other contributors
* to the MC1322x project (http://mc1322x.devl.org)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This file is part of libmc1322x: see http://mc1322x.devl.org
* for details.
*
*
*/
2010-02-26 19:51:01 +00:00
#include <mc1322x.h>
#include <board.h>
2009-05-08 16:32:14 +00:00
2010-02-26 19:51:01 +00:00
#include "tests.h"
#include "config.h"
2009-05-09 19:30:54 +00:00
#define DEBUG 1
#if DEBUG
#define dbg_putchr(...) putchr(__VA_ARGS__)
#define dbg_putstr(...) putstr(__VA_ARGS__)
2009-05-09 18:55:48 +00:00
#define dbg_put_hex(...) put_hex(__VA_ARGS__)
#define dbg_put_hex16(...) put_hex16(__VA_ARGS__)
#define dbg_put_hex32(...) put_hex32(__VA_ARGS__)
#else
#define dbg_putchr(...)
#define dbg_putstr(...)
2009-05-09 18:55:48 +00:00
#define dbg_put_hex(...)
#define dbg_put_hex16(...)
#define dbg_put_hex32(...)
#endif
2010-03-09 23:23:40 +00:00
uint8_t getc(void)
{
volatile uint8_t c;
while(*UART1_URXCON == 0);
c = *UART1_UDATA;
return c;
}
void flushrx(void);
2010-02-26 19:51:01 +00:00
uint32_t to_u32(volatile uint32_t *c);
enum parse_states {
SCAN_X,
READ_CHARS,
PROCESS,
MAX_STATE,
};
2009-05-08 16:32:14 +00:00
void main(void) {
nvmType_t type=0;
nvmErr_t err;
2009-05-08 21:27:24 +00:00
volatile uint8_t c;
volatile uint32_t i;
2010-02-26 19:51:01 +00:00
volatile uint32_t buf[4];
2009-05-08 21:27:24 +00:00
volatile uint32_t len=0;
volatile uint32_t state = SCAN_X;
volatile uint32_t addr,data;
2009-05-08 16:32:14 +00:00
2012-10-24 01:50:32 +00:00
uart_init(UART1, 115200);
2009-05-08 16:32:14 +00:00
2010-03-09 23:23:40 +00:00
disable_irq(UART1);
2009-05-08 16:32:14 +00:00
vreg_init();
dbg_putstr("Detecting internal nvm\n\r");
2009-05-08 16:32:14 +00:00
err = nvm_detect(gNvmInternalInterface_c, &type);
dbg_putstr("nvm_detect returned: 0x");
2009-05-09 19:30:54 +00:00
dbg_put_hex(err);
dbg_putstr(" type is: 0x");
2009-05-09 19:30:54 +00:00
dbg_put_hex32(type);
dbg_putstr("\n\r");
2009-05-08 16:32:14 +00:00
/* erase the flash */
err = nvm_erase(gNvmInternalInterface_c, type, 0x7fffffff);
2009-05-09 19:30:54 +00:00
dbg_putstr("nvm_erase returned: 0x");
2009-05-09 19:30:54 +00:00
dbg_put_hex(err);
dbg_putstr("\n\r");
2009-05-08 21:27:24 +00:00
dbg_putstr(" type is: 0x");
2009-05-09 19:30:54 +00:00
dbg_put_hex32(type);
dbg_putstr("\n\r");
2009-05-08 16:32:14 +00:00
/* say we are ready */
len = 0;
putstr("ready");
2009-05-08 21:27:24 +00:00
flushrx();
2009-05-08 16:32:14 +00:00
/* read the length */
for(i=0; i<4; i++) {
2010-03-09 23:23:40 +00:00
c = uart1_getc();
2009-05-08 16:32:14 +00:00
/* bail if the first byte of the length is zero */
2009-05-08 21:27:24 +00:00
len += (c<<(i*8));
2009-05-08 16:32:14 +00:00
}
dbg_putstr("len: ");
2009-05-09 19:30:54 +00:00
dbg_put_hex32(len);
dbg_putstr("\n\r");
2009-05-08 21:27:24 +00:00
2009-05-08 16:32:14 +00:00
/* write the OKOK magic */
2009-05-09 19:30:54 +00:00
#if BOOT_OK
((uint8_t *)buf)[0] = 'O'; ((uint8_t *)buf)[1] = 'K'; ((uint8_t *)buf)[2] = 'O'; ((uint8_t *)buf)[3] = 'K';
#elif BOOT_SECURE
((uint8_t *)buf)[0] = 'S'; ((uint8_t *)buf)[1] = 'E'; ((uint8_t *)buf)[2] = 'C'; ((uint8_t *)buf)[3] = 'U';
#else
((uint8_t *)buf)[0] = 'N'; ((uint8_t *)buf)[1] = 'O'; ((uint8_t *)buf)[2] = 'N'; ((uint8_t *)buf)[3] = 'O';
#endif
dbg_putstr(" type is: 0x");
2009-05-09 19:30:54 +00:00
dbg_put_hex32(type);
dbg_putstr("\n\r");
2009-05-09 19:30:54 +00:00
/* don't make a valid boot image if the received length is zero */
if(len == 0) {
((uint8_t *)buf)[0] = 'N';
((uint8_t *)buf)[1] = 'O';
((uint8_t *)buf)[2] = 'N';
((uint8_t *)buf)[3] = 'O';
}
2009-05-09 19:30:54 +00:00
err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)buf, 0, 4);
dbg_putstr("nvm_write returned: 0x");
2009-05-09 19:30:54 +00:00
dbg_put_hex(err);
dbg_putstr("\n\r");
2009-05-08 21:27:24 +00:00
/* write the length */
2009-05-09 19:30:54 +00:00
err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)&len, 4, 4);
2009-05-08 16:32:14 +00:00
/* read a byte, write a byte */
for(i=0; i<len; i++) {
c = getc();
2010-02-26 19:51:01 +00:00
err = nvm_write(gNvmInternalInterface_c, type, (uint8_t *)&c, 8+i, 1);
2009-05-08 16:32:14 +00:00
}
putstr("flasher done\n\r");
2009-05-08 16:32:14 +00:00
state = SCAN_X; addr=0;
while((c=getc())) {
if(state == SCAN_X) {
/* read until we see an 'x' */
if(c==0) { break; }
if(c!='x'){ continue; }
/* go to read_chars once we have an 'x' */
state = READ_CHARS;
i = 0;
}
if(state == READ_CHARS) {
/* read all the chars up to a ',' */
((uint8_t *)buf)[i++] = c;
/* after reading a ',' */
/* goto PROCESS state */
if((c == ',') || (c == 0)) { state = PROCESS; }
}
if(state == PROCESS) {
if(addr==0) {
/*interpret the string as the starting address */
2010-02-26 19:51:01 +00:00
addr = to_u32(buf);
} else {
/* string is data to write */
2010-02-26 19:51:01 +00:00
data = to_u32(buf);
putstr("writing addr ");
put_hex32(addr);
putstr(" data ");
put_hex32(data);
putstr("\n\r");
err = nvm_write(gNvmInternalInterface_c, 1, (uint8_t *)&data, addr, 4);
addr += 4;
}
/* look for the next 'x' */
state=SCAN_X;
}
}
2009-05-08 16:32:14 +00:00
while(1) {continue;};
}
void flushrx(void)
2009-05-08 16:32:14 +00:00
{
2009-05-08 21:27:24 +00:00
volatile uint8_t c;
2010-03-09 23:23:40 +00:00
while(*UART1_URXCON !=0) {
c = *UART1_UDATA;
2009-05-08 16:32:14 +00:00
}
}
/* Convert from ASCII hex. Returns
the value, or 16 if it was space/newline, or
32 if some other character. */
uint8_t from_hex(uint8_t ch)
{
if(ch==' ' || ch=='\r' || ch=='\n')
return 16;
if(ch < '0')
goto bad;
if(ch <= '9')
return ch - '0';
ch |= 0x20;
if(ch < 'a')
goto bad;
if(ch <= 'f')
return ch - 'a' + 10;
bad:
return 32;
}
2010-02-26 19:51:01 +00:00
uint32_t to_u32(volatile uint32_t *c)
{
volatile uint32_t ret=0;
volatile uint32_t i,val;
/* c should be /x\d+,/ */
i=1; /* skip x */
2010-02-26 19:51:01 +00:00
while(((uint8_t *)c)[i] != ',') {
ret = ret<<4;
2010-02-26 19:51:01 +00:00
val = from_hex(((uint8_t *)c)[i++]);
ret += val;
}
return ret;
}
2010-03-09 23:23:40 +00:00
2009-05-08 21:27:24 +00:00