Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-11-08 22:24:32 +00:00
Code Issues Projects Releases Packages Wiki Activity
u-boot/cmd/load.c
Tom Rini 83d290c56f SPDX: Convert all of our single license tags to Linux Kernel style 
When U-Boot started using SPDX tags we were among the early adopters and
there weren't a lot of other examples to borrow from.  So we picked the
area of the file that usually had a full license text and replaced it
with an appropriate SPDX-License-Identifier: entry.  Since then, the
Linux Kernel has adopted SPDX tags and they place it as the very first
line in a file (except where shebangs are used, then it's second line)
and with slightly different comment styles than us.

In part due to community overlap, in part due to better tag visibility
and in part for other minor reasons, switch over to that style.

This commit changes all instances where we have a single declared
license in the tag as both the before and after are identical in tag
contents.  There's also a few places where I found we did not have a tag
and have introduced one.

Signed-off-by: Tom Rini <trini@konsulko.com>
2018-05-07 09:34:12 -04:00

1082 lines
25 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0+
/*
* (C) Copyright 2000-2004
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*/
/*
* Serial up- and download support
*/
#include <common.h>
#include <command.h>
#include <console.h>
#include <s_record.h>
#include <net.h>
#include <exports.h>
#include <xyzModem.h>
DECLARE_GLOBAL_DATA_PTR;
#if defined(CONFIG_CMD_LOADB)
static ulong load_serial_ymodem(ulong offset, int mode);
#endif
#if defined(CONFIG_CMD_LOADS)
static ulong load_serial(long offset);
static int read_record(char *buf, ulong len);
# if defined(CONFIG_CMD_SAVES)
static int save_serial(ulong offset, ulong size);
static int write_record(char *buf);
#endif
static int do_echo = 1;
#endif
/* -------------------------------------------------------------------- */
#if defined(CONFIG_CMD_LOADS)
static int do_load_serial(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
long offset = 0;
ulong addr;
int i;
char *env_echo;
int rcode = 0;
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
int load_baudrate, current_baudrate;
load_baudrate = current_baudrate = gd->baudrate;
#endif
env_echo = env_get("loads_echo");
if (env_echo && *env_echo == '1')
do_echo = 1;
else
do_echo = 0;
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
if (argc >= 2) {
offset = simple_strtol(argv[1], NULL, 16);
}
if (argc == 3) {
load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);
/* default to current baudrate */
if (load_baudrate == 0)
load_baudrate = current_baudrate;
}
if (load_baudrate != current_baudrate) {
printf("## Switch baudrate to %d bps and press ENTER ...\n",
load_baudrate);
udelay(50000);
gd->baudrate = load_baudrate;
serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == '\r')
break;
}
}
#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
if (argc == 2) {
offset = simple_strtol(argv[1], NULL, 16);
}
#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
printf("## Ready for S-Record download ...\n");
addr = load_serial(offset);
/*
* Gather any trailing characters (for instance, the ^D which
* is sent by 'cu' after sending a file), and give the
* box some time (100 * 1 ms)
*/
for (i=0; i<100; ++i) {
if (tstc()) {
(void) getc();
}
udelay(1000);
}
if (addr == ~0) {
printf("## S-Record download aborted\n");
rcode = 1;
} else {
printf("## Start Addr = 0x%08lX\n", addr);
load_addr = addr;
}
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
if (load_baudrate != current_baudrate) {
printf("## Switch baudrate to %d bps and press ESC ...\n",
current_baudrate);
udelay(50000);
gd->baudrate = current_baudrate;
serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == 0x1B) /* ESC */
break;
}
}
#endif
return rcode;
}
static ulong load_serial(long offset)
{
char record[SREC_MAXRECLEN + 1]; /* buffer for one S-Record */
char binbuf[SREC_MAXBINLEN]; /* buffer for binary data */
int binlen; /* no. of data bytes in S-Rec. */
int type; /* return code for record type */
ulong addr; /* load address from S-Record */
ulong size; /* number of bytes transferred */
ulong store_addr;
ulong start_addr = ~0;
ulong end_addr = 0;
int line_count = 0;
while (read_record(record, SREC_MAXRECLEN + 1) >= 0) {
type = srec_decode(record, &binlen, &addr, binbuf);
if (type < 0) {
return (~0); /* Invalid S-Record */
}
switch (type) {
case SREC_DATA2:
case SREC_DATA3:
case SREC_DATA4:
store_addr = addr + offset;
#ifdef CONFIG_MTD_NOR_FLASH
if (addr2info(store_addr)) {
int rc;
rc = flash_write((char *)binbuf,store_addr,binlen);
if (rc != 0) {
flash_perror(rc);
return (~0);
}
} else
#endif
{
memcpy((char *)(store_addr), binbuf, binlen);
}
if ((store_addr) < start_addr)
start_addr = store_addr;
if ((store_addr + binlen - 1) > end_addr)
end_addr = store_addr + binlen - 1;
break;
case SREC_END2:
case SREC_END3:
case SREC_END4:
udelay(10000);
size = end_addr - start_addr + 1;
printf("\n"
"## First Load Addr = 0x%08lX\n"
"## Last Load Addr = 0x%08lX\n"
"## Total Size = 0x%08lX = %ld Bytes\n",
start_addr, end_addr, size, size
);
flush_cache(start_addr, size);
env_set_hex("filesize", size);
return (addr);
case SREC_START:
break;
default:
break;
}
if (!do_echo) { /* print a '.' every 100 lines */
if ((++line_count % 100) == 0)
putc('.');
}
}
return (~0); /* Download aborted */
}
static int read_record(char *buf, ulong len)
{
char *p;
char c;
--len; /* always leave room for terminating '\0' byte */
for (p=buf; p < buf+len; ++p) {
c = getc(); /* read character */
if (do_echo)
putc(c); /* ... and echo it */
switch (c) {
case '\r':
case '\n':
*p = '\0';
return (p - buf);
case '\0':
case 0x03: /* ^C - Control C */
return (-1);
default:
*p = c;
}
/* Check for the console hangup (if any different from serial) */
if (gd->jt->getc != getc) {
if (ctrlc()) {
return (-1);
}
}
}
/* line too long - truncate */
*p = '\0';
return (p - buf);
}
#if defined(CONFIG_CMD_SAVES)
int do_save_serial (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
ulong offset = 0;
ulong size = 0;
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
int save_baudrate, current_baudrate;
save_baudrate = current_baudrate = gd->baudrate;
#endif
if (argc >= 2) {
offset = simple_strtoul(argv[1], NULL, 16);
}
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
if (argc >= 3) {
size = simple_strtoul(argv[2], NULL, 16);
}
if (argc == 4) {
save_baudrate = (int)simple_strtoul(argv[3], NULL, 10);
/* default to current baudrate */
if (save_baudrate == 0)
save_baudrate = current_baudrate;
}
if (save_baudrate != current_baudrate) {
printf("## Switch baudrate to %d bps and press ENTER ...\n",
save_baudrate);
udelay(50000);
gd->baudrate = save_baudrate;
serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == '\r')
break;
}
}
#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
if (argc == 3) {
size = simple_strtoul(argv[2], NULL, 16);
}
#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
printf("## Ready for S-Record upload, press ENTER to proceed ...\n");
for (;;) {
if (getc() == '\r')
break;
}
if (save_serial(offset, size)) {
printf("## S-Record upload aborted\n");
} else {
printf("## S-Record upload complete\n");
}
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
if (save_baudrate != current_baudrate) {
printf("## Switch baudrate to %d bps and press ESC ...\n",
(int)current_baudrate);
udelay(50000);
gd->baudrate = current_baudrate;
serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == 0x1B) /* ESC */
break;
}
}
#endif
return 0;
}
#define SREC3_START "S0030000FC\n"
#define SREC3_FORMAT "S3%02X%08lX%s%02X\n"
#define SREC3_END "S70500000000FA\n"
#define SREC_BYTES_PER_RECORD 16
static int save_serial(ulong address, ulong count)
{
int i, c, reclen, checksum, length;
char *hex = "0123456789ABCDEF";
char record[2*SREC_BYTES_PER_RECORD+16]; /* buffer for one S-Record */
char data[2*SREC_BYTES_PER_RECORD+1]; /* buffer for hex data */
reclen = 0;
checksum = 0;
if(write_record(SREC3_START)) /* write the header */
return (-1);
do {
if(count) { /* collect hex data in the buffer */
c = *(volatile uchar*)(address + reclen); /* get one byte */
checksum += c; /* accumulate checksum */
data[2*reclen] = hex[(c>>4)&0x0f];
data[2*reclen+1] = hex[c & 0x0f];
data[2*reclen+2] = '\0';
++reclen;
--count;
}
if(reclen == SREC_BYTES_PER_RECORD || count == 0) {
/* enough data collected for one record: dump it */
if(reclen) { /* build & write a data record: */
/* address + data + checksum */
length = 4 + reclen + 1;
/* accumulate length bytes into checksum */
for(i = 0; i < 2; i++)
checksum += (length >> (8*i)) & 0xff;
/* accumulate address bytes into checksum: */
for(i = 0; i < 4; i++)
checksum += (address >> (8*i)) & 0xff;
/* make proper checksum byte: */
checksum = ~checksum & 0xff;
/* output one record: */
sprintf(record, SREC3_FORMAT, length, address, data, checksum);
if(write_record(record))
return (-1);
}
address += reclen; /* increment address */
checksum = 0;
reclen = 0;
}
}
while(count);
if(write_record(SREC3_END)) /* write the final record */
return (-1);
return(0);
}
static int write_record(char *buf)
{
char c;
while((c = *buf++))
putc(c);
/* Check for the console hangup (if any different from serial) */
if (ctrlc()) {
return (-1);
}
return (0);
}
# endif
#endif
#if defined(CONFIG_CMD_LOADB)
/*
* loadb command (load binary) included
*/
#define XON_CHAR 17
#define XOFF_CHAR 19
#define START_CHAR 0x01
#define ETX_CHAR 0x03
#define END_CHAR 0x0D
#define SPACE 0x20
#define K_ESCAPE 0x23
#define SEND_TYPE 'S'
#define DATA_TYPE 'D'
#define ACK_TYPE 'Y'
#define NACK_TYPE 'N'
#define BREAK_TYPE 'B'
#define tochar(x) ((char) (((x) + SPACE) & 0xff))
#define untochar(x) ((int) (((x) - SPACE) & 0xff))
static void set_kerm_bin_mode(unsigned long *);
static int k_recv(void);
static ulong load_serial_bin(ulong offset);
static char his_eol; /* character he needs at end of packet */
static int his_pad_count; /* number of pad chars he needs */
static char his_pad_char; /* pad chars he needs */
static char his_quote; /* quote chars he'll use */
static int do_load_serial_bin(cmd_tbl_t *cmdtp, int flag, int argc,
char * const argv[])
{
ulong offset = 0;
ulong addr;
int load_baudrate, current_baudrate;
int rcode = 0;
char *s;
/* pre-set offset from CONFIG_SYS_LOAD_ADDR */
offset = CONFIG_SYS_LOAD_ADDR;
/* pre-set offset from $loadaddr */
s = env_get("loadaddr");
if (s)
offset = simple_strtoul(s, NULL, 16);
load_baudrate = current_baudrate = gd->baudrate;
if (argc >= 2) {
offset = simple_strtoul(argv[1], NULL, 16);
}
if (argc == 3) {
load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);
/* default to current baudrate */
if (load_baudrate == 0)
load_baudrate = current_baudrate;
}
if (load_baudrate != current_baudrate) {
printf("## Switch baudrate to %d bps and press ENTER ...\n",
load_baudrate);
udelay(50000);
gd->baudrate = load_baudrate;
serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == '\r')
break;
}
}
if (strcmp(argv[0],"loady")==0) {
printf("## Ready for binary (ymodem) download "
"to 0x%08lX at %d bps...\n",
offset,
load_baudrate);
addr = load_serial_ymodem(offset, xyzModem_ymodem);
} else if (strcmp(argv[0],"loadx")==0) {
printf("## Ready for binary (xmodem) download "
"to 0x%08lX at %d bps...\n",
offset,
load_baudrate);
addr = load_serial_ymodem(offset, xyzModem_xmodem);
} else {
printf("## Ready for binary (kermit) download "
"to 0x%08lX at %d bps...\n",
offset,
load_baudrate);
addr = load_serial_bin(offset);
if (addr == ~0) {
load_addr = 0;
printf("## Binary (kermit) download aborted\n");
rcode = 1;
} else {
printf("## Start Addr = 0x%08lX\n", addr);
load_addr = addr;
}
}
if (load_baudrate != current_baudrate) {
printf("## Switch baudrate to %d bps and press ESC ...\n",
current_baudrate);
udelay(50000);
gd->baudrate = current_baudrate;
serial_setbrg();
udelay(50000);
for (;;) {
if (getc() == 0x1B) /* ESC */
break;
}
}
return rcode;
}
static ulong load_serial_bin(ulong offset)
{
int size, i;
set_kerm_bin_mode((ulong *) offset);
size = k_recv();
/*
* Gather any trailing characters (for instance, the ^D which
* is sent by 'cu' after sending a file), and give the
* box some time (100 * 1 ms)
*/
for (i=0; i<100; ++i) {
if (tstc()) {
(void) getc();
}
udelay(1000);
}
flush_cache(offset, size);
printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
env_set_hex("filesize", size);
return offset;
}
static void send_pad(void)
{
int count = his_pad_count;
while (count-- > 0)
putc(his_pad_char);
}
/* converts escaped kermit char to binary char */
static char ktrans(char in)
{
if ((in & 0x60) == 0x40) {
return (char) (in & ~0x40);
} else if ((in & 0x7f) == 0x3f) {
return (char) (in | 0x40);
} else
return in;
}
static int chk1(char *buffer)
{
int total = 0;
while (*buffer) {
total += *buffer++;
}
return (int) ((total + ((total >> 6) & 0x03)) & 0x3f);
}
static void s1_sendpacket(char *packet)
{
send_pad();
while (*packet) {
putc(*packet++);
}
}
static char a_b[24];
static void send_ack(int n)
{
a_b[0] = START_CHAR;
a_b[1] = tochar(3);
a_b[2] = tochar(n);
a_b[3] = ACK_TYPE;
a_b[4] = '\0';
a_b[4] = tochar(chk1(&a_b[1]));
a_b[5] = his_eol;
a_b[6] = '\0';
s1_sendpacket(a_b);
}
static void send_nack(int n)
{
a_b[0] = START_CHAR;
a_b[1] = tochar(3);
a_b[2] = tochar(n);
a_b[3] = NACK_TYPE;
a_b[4] = '\0';
a_b[4] = tochar(chk1(&a_b[1]));
a_b[5] = his_eol;
a_b[6] = '\0';
s1_sendpacket(a_b);
}
static void (*os_data_init)(void);
static void (*os_data_char)(char new_char);
static int os_data_state, os_data_state_saved;
static char *os_data_addr, *os_data_addr_saved;
static char *bin_start_address;
static void bin_data_init(void)
{
os_data_state = 0;
os_data_addr = bin_start_address;
}
static void os_data_save(void)
{
os_data_state_saved = os_data_state;
os_data_addr_saved = os_data_addr;
}
static void os_data_restore(void)
{
os_data_state = os_data_state_saved;
os_data_addr = os_data_addr_saved;
}
static void bin_data_char(char new_char)
{
switch (os_data_state) {
case 0: /* data */
*os_data_addr++ = new_char;
break;
}
}
static void set_kerm_bin_mode(unsigned long *addr)
{
bin_start_address = (char *) addr;
os_data_init = bin_data_init;
os_data_char = bin_data_char;
}
/* k_data_* simply handles the kermit escape translations */
static int k_data_escape, k_data_escape_saved;
static void k_data_init(void)
{
k_data_escape = 0;
os_data_init();
}
static void k_data_save(void)
{
k_data_escape_saved = k_data_escape;
os_data_save();
}
static void k_data_restore(void)
{
k_data_escape = k_data_escape_saved;
os_data_restore();
}
static void k_data_char(char new_char)
{
if (k_data_escape) {
/* last char was escape - translate this character */
os_data_char(ktrans(new_char));
k_data_escape = 0;
} else {
if (new_char == his_quote) {
/* this char is escape - remember */
k_data_escape = 1;
} else {
/* otherwise send this char as-is */
os_data_char(new_char);
}
}
}
#define SEND_DATA_SIZE 20
static char send_parms[SEND_DATA_SIZE];
static char *send_ptr;
/* handle_send_packet interprits the protocol info and builds and
sends an appropriate ack for what we can do */
static void handle_send_packet(int n)
{
int length = 3;
int bytes;
/* initialize some protocol parameters */
his_eol = END_CHAR; /* default end of line character */
his_pad_count = 0;
his_pad_char = '\0';
his_quote = K_ESCAPE;
/* ignore last character if it filled the buffer */
if (send_ptr == &send_parms[SEND_DATA_SIZE - 1])
--send_ptr;
bytes = send_ptr - send_parms; /* how many bytes we'll process */
do {
if (bytes-- <= 0)
break;
/* handle MAXL - max length */
/* ignore what he says - most I'll take (here) is 94 */
a_b[++length] = tochar(94);
if (bytes-- <= 0)
break;
/* handle TIME - time you should wait for my packets */
/* ignore what he says - don't wait for my ack longer than 1 second */
a_b[++length] = tochar(1);
if (bytes-- <= 0)
break;
/* handle NPAD - number of pad chars I need */
/* remember what he says - I need none */
his_pad_count = untochar(send_parms[2]);
a_b[++length] = tochar(0);
if (bytes-- <= 0)
break;
/* handle PADC - pad chars I need */
/* remember what he says - I need none */
his_pad_char = ktrans(send_parms[3]);
a_b[++length] = 0x40; /* He should ignore this */
if (bytes-- <= 0)
break;
/* handle EOL - end of line he needs */
/* remember what he says - I need CR */
his_eol = untochar(send_parms[4]);
a_b[++length] = tochar(END_CHAR);
if (bytes-- <= 0)
break;
/* handle QCTL - quote control char he'll use */
/* remember what he says - I'll use '#' */
his_quote = send_parms[5];
a_b[++length] = '#';
if (bytes-- <= 0)
break;
/* handle QBIN - 8-th bit prefixing */
/* ignore what he says - I refuse */
a_b[++length] = 'N';
if (bytes-- <= 0)
break;
/* handle CHKT - the clock check type */
/* ignore what he says - I do type 1 (for now) */
a_b[++length] = '1';
if (bytes-- <= 0)
break;
/* handle REPT - the repeat prefix */
/* ignore what he says - I refuse (for now) */
a_b[++length] = 'N';
if (bytes-- <= 0)
break;
/* handle CAPAS - the capabilities mask */
/* ignore what he says - I only do long packets - I don't do windows */
a_b[++length] = tochar(2); /* only long packets */
a_b[++length] = tochar(0); /* no windows */
a_b[++length] = tochar(94); /* large packet msb */
a_b[++length] = tochar(94); /* large packet lsb */
} while (0);
a_b[0] = START_CHAR;
a_b[1] = tochar(length);
a_b[2] = tochar(n);
a_b[3] = ACK_TYPE;
a_b[++length] = '\0';
a_b[length] = tochar(chk1(&a_b[1]));
a_b[++length] = his_eol;
a_b[++length] = '\0';
s1_sendpacket(a_b);
}
/* k_recv receives a OS Open image file over kermit line */
static int k_recv(void)
{
char new_char;
char k_state, k_state_saved;
int sum;
int done;
int length;
int n, last_n;
int len_lo, len_hi;
/* initialize some protocol parameters */
his_eol = END_CHAR; /* default end of line character */
his_pad_count = 0;
his_pad_char = '\0';
his_quote = K_ESCAPE;
/* initialize the k_recv and k_data state machine */
done = 0;
k_state = 0;
k_data_init();
k_state_saved = k_state;
k_data_save();
n = 0; /* just to get rid of a warning */
last_n = -1;
/* expect this "type" sequence (but don't check):
S: send initiate
F: file header
D: data (multiple)
Z: end of file
B: break transmission
*/
/* enter main loop */
while (!done) {
/* set the send packet pointer to begining of send packet parms */
send_ptr = send_parms;
/* With each packet, start summing the bytes starting with the length.
Save the current sequence number.
Note the type of the packet.
If a character less than SPACE (0x20) is received - error.
*/
#if 0
/* OLD CODE, Prior to checking sequence numbers */
/* first have all state machines save current states */
k_state_saved = k_state;
k_data_save ();
#endif
/* get a packet */
/* wait for the starting character or ^C */
for (;;) {
switch (getc ()) {
case START_CHAR: /* start packet */
goto START;
case ETX_CHAR: /* ^C waiting for packet */
return (0);
default:
;
}
}
START:
/* get length of packet */
sum = 0;
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
length = untochar(new_char);
/* get sequence number */
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
n = untochar(new_char);
--length;
/* NEW CODE - check sequence numbers for retried packets */
/* Note - this new code assumes that the sequence number is correctly
* received. Handling an invalid sequence number adds another layer
* of complexity that may not be needed - yet! At this time, I'm hoping
* that I don't need to buffer the incoming data packets and can write
* the data into memory in real time.
*/
if (n == last_n) {
/* same sequence number, restore the previous state */
k_state = k_state_saved;
k_data_restore();
} else {
/* new sequence number, checkpoint the download */
last_n = n;
k_state_saved = k_state;
k_data_save();
}
/* END NEW CODE */
/* get packet type */
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
k_state = new_char;
--length;
/* check for extended length */
if (length == -2) {
/* (length byte was 0, decremented twice) */
/* get the two length bytes */
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
len_hi = untochar(new_char);
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
len_lo = untochar(new_char);
length = len_hi * 95 + len_lo;
/* check header checksum */
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
goto packet_error;
sum += new_char & 0xff;
/* --length; */ /* new length includes only data and block check to come */
}
/* bring in rest of packet */
while (length > 1) {
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
sum += new_char & 0xff;
--length;
if (k_state == DATA_TYPE) {
/* pass on the data if this is a data packet */
k_data_char (new_char);
} else if (k_state == SEND_TYPE) {
/* save send pack in buffer as is */
*send_ptr++ = new_char;
/* if too much data, back off the pointer */
if (send_ptr >= &send_parms[SEND_DATA_SIZE])
--send_ptr;
}
}
/* get and validate checksum character */
new_char = getc();
if ((new_char & 0xE0) == 0)
goto packet_error;
if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
goto packet_error;
/* get END_CHAR */
new_char = getc();
if (new_char != END_CHAR) {
packet_error:
/* restore state machines */
k_state = k_state_saved;
k_data_restore();
/* send a negative acknowledge packet in */
send_nack(n);
} else if (k_state == SEND_TYPE) {
/* crack the protocol parms, build an appropriate ack packet */
handle_send_packet(n);
} else {
/* send simple acknowledge packet in */
send_ack(n);
/* quit if end of transmission */
if (k_state == BREAK_TYPE)
done = 1;
}
}
return ((ulong) os_data_addr - (ulong) bin_start_address);
}
static int getcxmodem(void) {
if (tstc())
return (getc());
return -1;
}
static ulong load_serial_ymodem(ulong offset, int mode)
{
int size;
int err;
int res;
connection_info_t info;
char ymodemBuf[1024];
ulong store_addr = ~0;
ulong addr = 0;
size = 0;
info.mode = mode;
res = xyzModem_stream_open(&info, &err);
if (!res) {
while ((res =
xyzModem_stream_read(ymodemBuf, 1024, &err)) > 0) {
store_addr = addr + offset;
size += res;
addr += res;
#ifdef CONFIG_MTD_NOR_FLASH
if (addr2info(store_addr)) {
int rc;
rc = flash_write((char *) ymodemBuf,
store_addr, res);
if (rc != 0) {
flash_perror (rc);
return (~0);
}
} else
#endif
{
memcpy((char *)(store_addr), ymodemBuf,
res);
}
}
} else {
printf("%s\n", xyzModem_error(err));
}
xyzModem_stream_close(&err);
xyzModem_stream_terminate(false, &getcxmodem);
flush_cache(offset, ALIGN(size, ARCH_DMA_MINALIGN));
printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
env_set_hex("filesize", size);
return offset;
}
#endif
/* -------------------------------------------------------------------- */
#if defined(CONFIG_CMD_LOADS)
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
U_BOOT_CMD(
loads, 3, 0, do_load_serial,
"load S-Record file over serial line",
"[ off ] [ baud ]\n"
" - load S-Record file over serial line"
" with offset 'off' and baudrate 'baud'"
);
#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
U_BOOT_CMD(
loads, 2, 0, do_load_serial,
"load S-Record file over serial line",
"[ off ]\n"
" - load S-Record file over serial line with offset 'off'"
);
#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
/*
* SAVES always requires LOADS support, but not vice versa
*/
#if defined(CONFIG_CMD_SAVES)
#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
U_BOOT_CMD(
saves, 4, 0, do_save_serial,
"save S-Record file over serial line",
"[ off ] [size] [ baud ]\n"
" - save S-Record file over serial line"
" with offset 'off', size 'size' and baudrate 'baud'"
);
#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
U_BOOT_CMD(
saves, 3, 0, do_save_serial,
"save S-Record file over serial line",
"[ off ] [size]\n"
" - save S-Record file over serial line with offset 'off' and size 'size'"
);
#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
#endif /* CONFIG_CMD_SAVES */
#endif /* CONFIG_CMD_LOADS */
#if defined(CONFIG_CMD_LOADB)
U_BOOT_CMD(
loadb, 3, 0, do_load_serial_bin,
"load binary file over serial line (kermit mode)",
"[ off ] [ baud ]\n"
" - load binary file over serial line"
" with offset 'off' and baudrate 'baud'"
);
U_BOOT_CMD(
loadx, 3, 0, do_load_serial_bin,
"load binary file over serial line (xmodem mode)",
"[ off ] [ baud ]\n"
" - load binary file over serial line"
" with offset 'off' and baudrate 'baud'"
);
U_BOOT_CMD(
loady, 3, 0, do_load_serial_bin,
"load binary file over serial line (ymodem mode)",
"[ off ] [ baud ]\n"
" - load binary file over serial line"
" with offset 'off' and baudrate 'baud'"
);
#endif /* CONFIG_CMD_LOADB */
Reference in a new issue View git blame Copy permalink