]> Git Repo - J-u-boot.git/blame - cmd/load.c
Dockerfile, CI: Update to latest "focal" tag
[J-u-boot.git] / cmd / load.c
CommitLineData
83d290c5 1// SPDX-License-Identifier: GPL-2.0+
8bde7f77 2/*
232c150a 3 * (C) Copyright 2000-2004
8bde7f77 4 * Wolfgang Denk, DENX Software Engineering, [email protected].
8bde7f77
WD
5 */
6
7/*
8 * Serial up- and download support
9 */
10#include <common.h>
11#include <command.h>
24b852a7 12#include <console.h>
1eb69ae4 13#include <cpu_func.h>
76b0a190 14#include <efi_loader.h>
c7694dd4 15#include <env.h>
76b0a190 16#include <exports.h>
0ee48252 17#include <flash.h>
8e8ccfe1 18#include <image.h>
c6855195 19#include <lmb.h>
76b0a190 20#include <mapmem.h>
8bde7f77 21#include <net.h>
76b0a190 22#include <s_record.h>
b03e0510 23#include <serial.h>
f2841d37 24#include <xyzModem.h>
90526e9f 25#include <asm/cache.h>
401d1c4f 26#include <asm/global_data.h>
c05ed00a 27#include <linux/delay.h>
8bde7f77 28
d87080b7 29DECLARE_GLOBAL_DATA_PTR;
8bde7f77 30
c76fe474 31#if defined(CONFIG_CMD_LOADB)
6e66bd55 32static ulong load_serial_ymodem(ulong offset, int mode);
8546e239
WD
33#endif
34
c76fe474 35#if defined(CONFIG_CMD_LOADS)
088f1b19
KP
36static ulong load_serial(long offset);
37static int read_record(char *buf, ulong len);
c76fe474 38# if defined(CONFIG_CMD_SAVES)
088f1b19
KP
39static int save_serial(ulong offset, ulong size);
40static int write_record(char *buf);
90253178 41#endif
8bde7f77
WD
42
43static int do_echo = 1;
90253178 44#endif
8bde7f77
WD
45
46/* -------------------------------------------------------------------- */
47
c76fe474 48#if defined(CONFIG_CMD_LOADS)
09140113
SG
49static int do_load_serial(struct cmd_tbl *cmdtp, int flag, int argc,
50 char *const argv[])
8bde7f77 51{
2b22d608 52 long offset = 0;
8bde7f77
WD
53 ulong addr;
54 int i;
55 char *env_echo;
56 int rcode = 0;
6d0f6bcf 57#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
8bde7f77
WD
58 int load_baudrate, current_baudrate;
59
60 load_baudrate = current_baudrate = gd->baudrate;
61#endif
62
00caae6d
SG
63 env_echo = env_get("loads_echo");
64 if (env_echo && *env_echo == '1')
8bde7f77 65 do_echo = 1;
00caae6d 66 else
8bde7f77 67 do_echo = 0;
8bde7f77 68
6d0f6bcf 69#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
8bde7f77 70 if (argc >= 2) {
2b22d608 71 offset = simple_strtol(argv[1], NULL, 16);
8bde7f77
WD
72 }
73 if (argc == 3) {
0b1284eb 74 load_baudrate = (int)dectoul(argv[2], NULL);
8bde7f77
WD
75
76 /* default to current baudrate */
77 if (load_baudrate == 0)
78 load_baudrate = current_baudrate;
79 }
80 if (load_baudrate != current_baudrate) {
088f1b19 81 printf("## Switch baudrate to %d bps and press ENTER ...\n",
8bde7f77
WD
82 load_baudrate);
83 udelay(50000);
84 gd->baudrate = load_baudrate;
088f1b19 85 serial_setbrg();
8bde7f77
WD
86 udelay(50000);
87 for (;;) {
c670aeee 88 if (getchar() == '\r')
8bde7f77
WD
89 break;
90 }
91 }
6d0f6bcf 92#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
8bde7f77 93 if (argc == 2) {
2b22d608 94 offset = simple_strtol(argv[1], NULL, 16);
8bde7f77 95 }
6d0f6bcf 96#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
8bde7f77 97
088f1b19 98 printf("## Ready for S-Record download ...\n");
8bde7f77 99
088f1b19 100 addr = load_serial(offset);
8bde7f77
WD
101
102 /*
103 * Gather any trailing characters (for instance, the ^D which
104 * is sent by 'cu' after sending a file), and give the
105 * box some time (100 * 1 ms)
106 */
107 for (i=0; i<100; ++i) {
232c150a 108 if (tstc()) {
c670aeee 109 getchar();
8bde7f77
WD
110 }
111 udelay(1000);
112 }
113
114 if (addr == ~0) {
088f1b19 115 printf("## S-Record download aborted\n");
8bde7f77
WD
116 rcode = 1;
117 } else {
088f1b19 118 printf("## Start Addr = 0x%08lX\n", addr);
bb872dd9 119 image_load_addr = addr;
8bde7f77
WD
120 }
121
6d0f6bcf 122#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
8bde7f77 123 if (load_baudrate != current_baudrate) {
088f1b19 124 printf("## Switch baudrate to %d bps and press ESC ...\n",
8bde7f77 125 current_baudrate);
088f1b19 126 udelay(50000);
8bde7f77 127 gd->baudrate = current_baudrate;
088f1b19
KP
128 serial_setbrg();
129 udelay(50000);
8bde7f77 130 for (;;) {
c670aeee 131 if (getchar() == 0x1B) /* ESC */
8bde7f77
WD
132 break;
133 }
134 }
135#endif
136 return rcode;
137}
138
088f1b19 139static ulong load_serial(long offset)
8bde7f77 140{
c6855195 141 struct lmb lmb;
8bde7f77
WD
142 char record[SREC_MAXRECLEN + 1]; /* buffer for one S-Record */
143 char binbuf[SREC_MAXBINLEN]; /* buffer for binary data */
144 int binlen; /* no. of data bytes in S-Rec. */
145 int type; /* return code for record type */
146 ulong addr; /* load address from S-Record */
147 ulong size; /* number of bytes transferred */
8bde7f77
WD
148 ulong store_addr;
149 ulong start_addr = ~0;
150 ulong end_addr = 0;
151 int line_count = 0;
c6855195
MV
152 long ret;
153
154 lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
8bde7f77
WD
155
156 while (read_record(record, SREC_MAXRECLEN + 1) >= 0) {
088f1b19 157 type = srec_decode(record, &binlen, &addr, binbuf);
8bde7f77
WD
158
159 if (type < 0) {
160 return (~0); /* Invalid S-Record */
161 }
162
163 switch (type) {
164 case SREC_DATA2:
165 case SREC_DATA3:
166 case SREC_DATA4:
167 store_addr = addr + offset;
e856bdcf 168#ifdef CONFIG_MTD_NOR_FLASH
8bde7f77
WD
169 if (addr2info(store_addr)) {
170 int rc;
171
77ddac94 172 rc = flash_write((char *)binbuf,store_addr,binlen);
8bde7f77 173 if (rc != 0) {
088f1b19 174 flash_perror(rc);
8bde7f77
WD
175 return (~0);
176 }
177 } else
178#endif
179 {
c6855195
MV
180 ret = lmb_reserve(&lmb, store_addr, binlen);
181 if (ret) {
182 printf("\nCannot overwrite reserved area (%08lx..%08lx)\n",
183 store_addr, store_addr + binlen);
184 return ret;
185 }
088f1b19 186 memcpy((char *)(store_addr), binbuf, binlen);
c6855195 187 lmb_free(&lmb, store_addr, binlen);
8bde7f77
WD
188 }
189 if ((store_addr) < start_addr)
190 start_addr = store_addr;
191 if ((store_addr + binlen - 1) > end_addr)
192 end_addr = store_addr + binlen - 1;
193 break;
194 case SREC_END2:
195 case SREC_END3:
196 case SREC_END4:
088f1b19 197 udelay(10000);
8bde7f77 198 size = end_addr - start_addr + 1;
088f1b19 199 printf("\n"
8bde7f77
WD
200 "## First Load Addr = 0x%08lX\n"
201 "## Last Load Addr = 0x%08lX\n"
202 "## Total Size = 0x%08lX = %ld Bytes\n",
203 start_addr, end_addr, size, size
204 );
088f1b19 205 flush_cache(start_addr, size);
018f5303 206 env_set_hex("filesize", size);
8bde7f77
WD
207 return (addr);
208 case SREC_START:
209 break;
210 default:
211 break;
212 }
213 if (!do_echo) { /* print a '.' every 100 lines */
214 if ((++line_count % 100) == 0)
088f1b19 215 putc('.');
8bde7f77
WD
216 }
217 }
218
219 return (~0); /* Download aborted */
220}
221
088f1b19 222static int read_record(char *buf, ulong len)
8bde7f77
WD
223{
224 char *p;
225 char c;
226
227 --len; /* always leave room for terminating '\0' byte */
228
229 for (p=buf; p < buf+len; ++p) {
c670aeee 230 c = getchar(); /* read character */
8bde7f77 231 if (do_echo)
088f1b19 232 putc(c); /* ... and echo it */
8bde7f77
WD
233
234 switch (c) {
235 case '\r':
236 case '\n':
237 *p = '\0';
238 return (p - buf);
239 case '\0':
240 case 0x03: /* ^C - Control C */
241 return (-1);
242 default:
243 *p = c;
244 }
245
e7fcfef4
MS
246 /* Check for the console hangup (if any different from serial) */
247 if (gd->jt->getc != getchar) {
248 if (ctrlc())
249 return (-1);
8bde7f77 250 }
8bde7f77
WD
251 }
252
253 /* line too long - truncate */
254 *p = '\0';
255 return (p - buf);
256}
257
c76fe474 258#if defined(CONFIG_CMD_SAVES)
8bde7f77 259
09140113
SG
260int do_save_serial(struct cmd_tbl *cmdtp, int flag, int argc,
261 char *const argv[])
8bde7f77
WD
262{
263 ulong offset = 0;
264 ulong size = 0;
6d0f6bcf 265#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
8bde7f77
WD
266 int save_baudrate, current_baudrate;
267
268 save_baudrate = current_baudrate = gd->baudrate;
269#endif
270
271 if (argc >= 2) {
7e5f460e 272 offset = hextoul(argv[1], NULL);
8bde7f77 273 }
6d0f6bcf 274#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
8bde7f77 275 if (argc >= 3) {
7e5f460e 276 size = hextoul(argv[2], NULL);
8bde7f77
WD
277 }
278 if (argc == 4) {
0b1284eb 279 save_baudrate = (int)dectoul(argv[3], NULL);
8bde7f77
WD
280
281 /* default to current baudrate */
282 if (save_baudrate == 0)
283 save_baudrate = current_baudrate;
284 }
285 if (save_baudrate != current_baudrate) {
088f1b19 286 printf("## Switch baudrate to %d bps and press ENTER ...\n",
8bde7f77
WD
287 save_baudrate);
288 udelay(50000);
289 gd->baudrate = save_baudrate;
088f1b19 290 serial_setbrg();
8bde7f77
WD
291 udelay(50000);
292 for (;;) {
c670aeee 293 if (getchar() == '\r')
8bde7f77
WD
294 break;
295 }
296 }
6d0f6bcf 297#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
8bde7f77 298 if (argc == 3) {
7e5f460e 299 size = hextoul(argv[2], NULL);
8bde7f77 300 }
6d0f6bcf 301#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
8bde7f77 302
088f1b19 303 printf("## Ready for S-Record upload, press ENTER to proceed ...\n");
8bde7f77 304 for (;;) {
c670aeee 305 if (getchar() == '\r')
8bde7f77
WD
306 break;
307 }
088f1b19
KP
308 if (save_serial(offset, size)) {
309 printf("## S-Record upload aborted\n");
8bde7f77 310 } else {
088f1b19 311 printf("## S-Record upload complete\n");
8bde7f77 312 }
6d0f6bcf 313#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
8bde7f77 314 if (save_baudrate != current_baudrate) {
088f1b19 315 printf("## Switch baudrate to %d bps and press ESC ...\n",
8bde7f77 316 (int)current_baudrate);
088f1b19 317 udelay(50000);
8bde7f77 318 gd->baudrate = current_baudrate;
088f1b19
KP
319 serial_setbrg();
320 udelay(50000);
8bde7f77 321 for (;;) {
c670aeee 322 if (getchar() == 0x1B) /* ESC */
8bde7f77
WD
323 break;
324 }
325 }
326#endif
327 return 0;
328}
329
330#define SREC3_START "S0030000FC\n"
331#define SREC3_FORMAT "S3%02X%08lX%s%02X\n"
332#define SREC3_END "S70500000000FA\n"
333#define SREC_BYTES_PER_RECORD 16
334
088f1b19 335static int save_serial(ulong address, ulong count)
8bde7f77
WD
336{
337 int i, c, reclen, checksum, length;
338 char *hex = "0123456789ABCDEF";
339 char record[2*SREC_BYTES_PER_RECORD+16]; /* buffer for one S-Record */
340 char data[2*SREC_BYTES_PER_RECORD+1]; /* buffer for hex data */
341
342 reclen = 0;
343 checksum = 0;
344
345 if(write_record(SREC3_START)) /* write the header */
346 return (-1);
347 do {
348 if(count) { /* collect hex data in the buffer */
349 c = *(volatile uchar*)(address + reclen); /* get one byte */
350 checksum += c; /* accumulate checksum */
351 data[2*reclen] = hex[(c>>4)&0x0f];
352 data[2*reclen+1] = hex[c & 0x0f];
353 data[2*reclen+2] = '\0';
354 ++reclen;
355 --count;
356 }
357 if(reclen == SREC_BYTES_PER_RECORD || count == 0) {
358 /* enough data collected for one record: dump it */
359 if(reclen) { /* build & write a data record: */
360 /* address + data + checksum */
361 length = 4 + reclen + 1;
362
363 /* accumulate length bytes into checksum */
364 for(i = 0; i < 2; i++)
365 checksum += (length >> (8*i)) & 0xff;
366
367 /* accumulate address bytes into checksum: */
368 for(i = 0; i < 4; i++)
369 checksum += (address >> (8*i)) & 0xff;
370
371 /* make proper checksum byte: */
372 checksum = ~checksum & 0xff;
373
374 /* output one record: */
375 sprintf(record, SREC3_FORMAT, length, address, data, checksum);
376 if(write_record(record))
377 return (-1);
378 }
379 address += reclen; /* increment address */
380 checksum = 0;
381 reclen = 0;
382 }
383 }
384 while(count);
385 if(write_record(SREC3_END)) /* write the final record */
386 return (-1);
387 return(0);
388}
389
088f1b19 390static int write_record(char *buf)
8bde7f77
WD
391{
392 char c;
393
394 while((c = *buf++))
232c150a 395 putc(c);
8bde7f77
WD
396
397 /* Check for the console hangup (if any different from serial) */
398
399 if (ctrlc()) {
400 return (-1);
401 }
402 return (0);
403}
90253178 404# endif
8bde7f77 405
90253178 406#endif
8bde7f77
WD
407
408
c76fe474 409#if defined(CONFIG_CMD_LOADB)
65c450b4
JL
410/*
411 * loadb command (load binary) included
412 */
8bde7f77
WD
413#define XON_CHAR 17
414#define XOFF_CHAR 19
415#define START_CHAR 0x01
416#define ETX_CHAR 0x03
417#define END_CHAR 0x0D
418#define SPACE 0x20
419#define K_ESCAPE 0x23
420#define SEND_TYPE 'S'
421#define DATA_TYPE 'D'
422#define ACK_TYPE 'Y'
423#define NACK_TYPE 'N'
424#define BREAK_TYPE 'B'
425#define tochar(x) ((char) (((x) + SPACE) & 0xff))
426#define untochar(x) ((int) (((x) - SPACE) & 0xff))
427
8bde7f77
WD
428static void set_kerm_bin_mode(unsigned long *);
429static int k_recv(void);
088f1b19 430static ulong load_serial_bin(ulong offset);
8bde7f77
WD
431
432
088f1b19
KP
433static char his_eol; /* character he needs at end of packet */
434static int his_pad_count; /* number of pad chars he needs */
435static char his_pad_char; /* pad chars he needs */
436static char his_quote; /* quote chars he'll use */
8bde7f77 437
09140113
SG
438static int do_load_serial_bin(struct cmd_tbl *cmdtp, int flag, int argc,
439 char *const argv[])
8bde7f77 440{
8bde7f77
WD
441 ulong offset = 0;
442 ulong addr;
443 int load_baudrate, current_baudrate;
444 int rcode = 0;
445 char *s;
446
6d0f6bcf
JCPV
447 /* pre-set offset from CONFIG_SYS_LOAD_ADDR */
448 offset = CONFIG_SYS_LOAD_ADDR;
8bde7f77
WD
449
450 /* pre-set offset from $loadaddr */
00caae6d
SG
451 s = env_get("loadaddr");
452 if (s)
7e5f460e 453 offset = hextoul(s, NULL);
8bde7f77
WD
454
455 load_baudrate = current_baudrate = gd->baudrate;
456
457 if (argc >= 2) {
7e5f460e 458 offset = hextoul(argv[1], NULL);
8bde7f77
WD
459 }
460 if (argc == 3) {
0b1284eb 461 load_baudrate = (int)dectoul(argv[2], NULL);
8bde7f77
WD
462
463 /* default to current baudrate */
464 if (load_baudrate == 0)
465 load_baudrate = current_baudrate;
466 }
467
468 if (load_baudrate != current_baudrate) {
088f1b19 469 printf("## Switch baudrate to %d bps and press ENTER ...\n",
8bde7f77
WD
470 load_baudrate);
471 udelay(50000);
472 gd->baudrate = load_baudrate;
088f1b19 473 serial_setbrg();
8bde7f77
WD
474 udelay(50000);
475 for (;;) {
c670aeee 476 if (getchar() == '\r')
8bde7f77
WD
477 break;
478 }
479 }
480
f2841d37 481 if (strcmp(argv[0],"loady")==0) {
088f1b19 482 printf("## Ready for binary (ymodem) download "
f2841d37
MK
483 "to 0x%08lX at %d bps...\n",
484 offset,
485 load_baudrate);
486
6e66bd55
AA
487 addr = load_serial_ymodem(offset, xyzModem_ymodem);
488
c97b2557
T
489 if (addr == ~0) {
490 image_load_addr = 0;
491 printf("## Binary (ymodem) download aborted\n");
492 rcode = 1;
493 } else {
494 printf("## Start Addr = 0x%08lX\n", addr);
495 image_load_addr = addr;
496 }
6e66bd55
AA
497 } else if (strcmp(argv[0],"loadx")==0) {
498 printf("## Ready for binary (xmodem) download "
499 "to 0x%08lX at %d bps...\n",
500 offset,
501 load_baudrate);
502
503 addr = load_serial_ymodem(offset, xyzModem_xmodem);
8bde7f77 504
c97b2557
T
505 if (addr == ~0) {
506 image_load_addr = 0;
507 printf("## Binary (xmodem) download aborted\n");
508 rcode = 1;
509 } else {
510 printf("## Start Addr = 0x%08lX\n", addr);
511 image_load_addr = addr;
512 }
8bde7f77 513 } else {
8bde7f77 514
088f1b19 515 printf("## Ready for binary (kermit) download "
f2841d37
MK
516 "to 0x%08lX at %d bps...\n",
517 offset,
518 load_baudrate);
088f1b19 519 addr = load_serial_bin(offset);
f2841d37
MK
520
521 if (addr == ~0) {
bb872dd9 522 image_load_addr = 0;
088f1b19 523 printf("## Binary (kermit) download aborted\n");
f2841d37
MK
524 rcode = 1;
525 } else {
088f1b19 526 printf("## Start Addr = 0x%08lX\n", addr);
bb872dd9 527 image_load_addr = addr;
f2841d37
MK
528 }
529 }
8bde7f77 530 if (load_baudrate != current_baudrate) {
088f1b19 531 printf("## Switch baudrate to %d bps and press ESC ...\n",
8bde7f77 532 current_baudrate);
088f1b19 533 udelay(50000);
8bde7f77 534 gd->baudrate = current_baudrate;
088f1b19
KP
535 serial_setbrg();
536 udelay(50000);
8bde7f77 537 for (;;) {
c670aeee 538 if (getchar() == 0x1B) /* ESC */
8bde7f77
WD
539 break;
540 }
541 }
542
8bde7f77
WD
543 return rcode;
544}
545
546
088f1b19 547static ulong load_serial_bin(ulong offset)
8bde7f77
WD
548{
549 int size, i;
8bde7f77 550
088f1b19
KP
551 set_kerm_bin_mode((ulong *) offset);
552 size = k_recv();
8bde7f77
WD
553
554 /*
555 * Gather any trailing characters (for instance, the ^D which
556 * is sent by 'cu' after sending a file), and give the
557 * box some time (100 * 1 ms)
558 */
559 for (i=0; i<100; ++i) {
232c150a 560 if (tstc()) {
c670aeee 561 getchar();
8bde7f77
WD
562 }
563 udelay(1000);
564 }
565
51538141
T
566 if (size == 0)
567 return ~0; /* Download aborted */
568
088f1b19 569 flush_cache(offset, size);
8bde7f77
WD
570
571 printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
018f5303 572 env_set_hex("filesize", size);
8bde7f77
WD
573
574 return offset;
575}
576
088f1b19 577static void send_pad(void)
8bde7f77
WD
578{
579 int count = his_pad_count;
580
581 while (count-- > 0)
088f1b19 582 putc(his_pad_char);
8bde7f77
WD
583}
584
585/* converts escaped kermit char to binary char */
088f1b19 586static char ktrans(char in)
8bde7f77
WD
587{
588 if ((in & 0x60) == 0x40) {
589 return (char) (in & ~0x40);
590 } else if ((in & 0x7f) == 0x3f) {
591 return (char) (in | 0x40);
592 } else
593 return in;
594}
595
088f1b19 596static int chk1(char *buffer)
8bde7f77
WD
597{
598 int total = 0;
599
600 while (*buffer) {
601 total += *buffer++;
602 }
603 return (int) ((total + ((total >> 6) & 0x03)) & 0x3f);
604}
605
088f1b19 606static void s1_sendpacket(char *packet)
8bde7f77 607{
088f1b19 608 send_pad();
8bde7f77 609 while (*packet) {
088f1b19 610 putc(*packet++);
8bde7f77
WD
611 }
612}
613
614static char a_b[24];
088f1b19 615static void send_ack(int n)
8bde7f77
WD
616{
617 a_b[0] = START_CHAR;
088f1b19
KP
618 a_b[1] = tochar(3);
619 a_b[2] = tochar(n);
8bde7f77
WD
620 a_b[3] = ACK_TYPE;
621 a_b[4] = '\0';
088f1b19 622 a_b[4] = tochar(chk1(&a_b[1]));
8bde7f77
WD
623 a_b[5] = his_eol;
624 a_b[6] = '\0';
088f1b19 625 s1_sendpacket(a_b);
8bde7f77
WD
626}
627
088f1b19 628static void send_nack(int n)
8bde7f77
WD
629{
630 a_b[0] = START_CHAR;
088f1b19
KP
631 a_b[1] = tochar(3);
632 a_b[2] = tochar(n);
8bde7f77
WD
633 a_b[3] = NACK_TYPE;
634 a_b[4] = '\0';
088f1b19 635 a_b[4] = tochar(chk1(&a_b[1]));
8bde7f77
WD
636 a_b[5] = his_eol;
637 a_b[6] = '\0';
088f1b19 638 s1_sendpacket(a_b);
8bde7f77
WD
639}
640
641
088f1b19
KP
642static void (*os_data_init)(void);
643static void (*os_data_char)(char new_char);
8bde7f77 644static int os_data_state, os_data_state_saved;
8bde7f77
WD
645static char *os_data_addr, *os_data_addr_saved;
646static char *bin_start_address;
a9fe0c3e 647
088f1b19 648static void bin_data_init(void)
8bde7f77
WD
649{
650 os_data_state = 0;
8bde7f77
WD
651 os_data_addr = bin_start_address;
652}
a9fe0c3e 653
088f1b19 654static void os_data_save(void)
8bde7f77
WD
655{
656 os_data_state_saved = os_data_state;
8bde7f77
WD
657 os_data_addr_saved = os_data_addr;
658}
a9fe0c3e 659
088f1b19 660static void os_data_restore(void)
8bde7f77
WD
661{
662 os_data_state = os_data_state_saved;
8bde7f77
WD
663 os_data_addr = os_data_addr_saved;
664}
a9fe0c3e 665
088f1b19 666static void bin_data_char(char new_char)
8bde7f77
WD
667{
668 switch (os_data_state) {
669 case 0: /* data */
670 *os_data_addr++ = new_char;
8bde7f77
WD
671 break;
672 }
673}
a9fe0c3e 674
088f1b19 675static void set_kerm_bin_mode(unsigned long *addr)
8bde7f77
WD
676{
677 bin_start_address = (char *) addr;
678 os_data_init = bin_data_init;
679 os_data_char = bin_data_char;
680}
681
682
683/* k_data_* simply handles the kermit escape translations */
684static int k_data_escape, k_data_escape_saved;
088f1b19 685static void k_data_init(void)
8bde7f77
WD
686{
687 k_data_escape = 0;
088f1b19 688 os_data_init();
8bde7f77 689}
a9fe0c3e 690
088f1b19 691static void k_data_save(void)
8bde7f77
WD
692{
693 k_data_escape_saved = k_data_escape;
088f1b19 694 os_data_save();
8bde7f77 695}
a9fe0c3e 696
088f1b19 697static void k_data_restore(void)
8bde7f77
WD
698{
699 k_data_escape = k_data_escape_saved;
088f1b19 700 os_data_restore();
8bde7f77 701}
a9fe0c3e 702
088f1b19 703static void k_data_char(char new_char)
8bde7f77
WD
704{
705 if (k_data_escape) {
706 /* last char was escape - translate this character */
088f1b19 707 os_data_char(ktrans(new_char));
8bde7f77
WD
708 k_data_escape = 0;
709 } else {
710 if (new_char == his_quote) {
711 /* this char is escape - remember */
712 k_data_escape = 1;
713 } else {
714 /* otherwise send this char as-is */
088f1b19 715 os_data_char(new_char);
8bde7f77
WD
716 }
717 }
718}
719
720#define SEND_DATA_SIZE 20
088f1b19
KP
721static char send_parms[SEND_DATA_SIZE];
722static char *send_ptr;
8bde7f77
WD
723
724/* handle_send_packet interprits the protocol info and builds and
725 sends an appropriate ack for what we can do */
088f1b19 726static void handle_send_packet(int n)
8bde7f77
WD
727{
728 int length = 3;
729 int bytes;
730
731 /* initialize some protocol parameters */
732 his_eol = END_CHAR; /* default end of line character */
733 his_pad_count = 0;
734 his_pad_char = '\0';
735 his_quote = K_ESCAPE;
736
737 /* ignore last character if it filled the buffer */
738 if (send_ptr == &send_parms[SEND_DATA_SIZE - 1])
739 --send_ptr;
740 bytes = send_ptr - send_parms; /* how many bytes we'll process */
741 do {
742 if (bytes-- <= 0)
743 break;
744 /* handle MAXL - max length */
745 /* ignore what he says - most I'll take (here) is 94 */
088f1b19 746 a_b[++length] = tochar(94);
8bde7f77
WD
747 if (bytes-- <= 0)
748 break;
749 /* handle TIME - time you should wait for my packets */
750 /* ignore what he says - don't wait for my ack longer than 1 second */
088f1b19 751 a_b[++length] = tochar(1);
8bde7f77
WD
752 if (bytes-- <= 0)
753 break;
754 /* handle NPAD - number of pad chars I need */
755 /* remember what he says - I need none */
088f1b19
KP
756 his_pad_count = untochar(send_parms[2]);
757 a_b[++length] = tochar(0);
8bde7f77
WD
758 if (bytes-- <= 0)
759 break;
760 /* handle PADC - pad chars I need */
761 /* remember what he says - I need none */
088f1b19 762 his_pad_char = ktrans(send_parms[3]);
8bde7f77
WD
763 a_b[++length] = 0x40; /* He should ignore this */
764 if (bytes-- <= 0)
765 break;
766 /* handle EOL - end of line he needs */
767 /* remember what he says - I need CR */
088f1b19
KP
768 his_eol = untochar(send_parms[4]);
769 a_b[++length] = tochar(END_CHAR);
8bde7f77
WD
770 if (bytes-- <= 0)
771 break;
772 /* handle QCTL - quote control char he'll use */
773 /* remember what he says - I'll use '#' */
774 his_quote = send_parms[5];
775 a_b[++length] = '#';
776 if (bytes-- <= 0)
777 break;
778 /* handle QBIN - 8-th bit prefixing */
779 /* ignore what he says - I refuse */
780 a_b[++length] = 'N';
781 if (bytes-- <= 0)
782 break;
783 /* handle CHKT - the clock check type */
784 /* ignore what he says - I do type 1 (for now) */
785 a_b[++length] = '1';
786 if (bytes-- <= 0)
787 break;
788 /* handle REPT - the repeat prefix */
789 /* ignore what he says - I refuse (for now) */
790 a_b[++length] = 'N';
791 if (bytes-- <= 0)
792 break;
793 /* handle CAPAS - the capabilities mask */
794 /* ignore what he says - I only do long packets - I don't do windows */
088f1b19
KP
795 a_b[++length] = tochar(2); /* only long packets */
796 a_b[++length] = tochar(0); /* no windows */
797 a_b[++length] = tochar(94); /* large packet msb */
798 a_b[++length] = tochar(94); /* large packet lsb */
8bde7f77
WD
799 } while (0);
800
801 a_b[0] = START_CHAR;
088f1b19
KP
802 a_b[1] = tochar(length);
803 a_b[2] = tochar(n);
8bde7f77
WD
804 a_b[3] = ACK_TYPE;
805 a_b[++length] = '\0';
088f1b19 806 a_b[length] = tochar(chk1(&a_b[1]));
8bde7f77
WD
807 a_b[++length] = his_eol;
808 a_b[++length] = '\0';
088f1b19 809 s1_sendpacket(a_b);
8bde7f77
WD
810}
811
812/* k_recv receives a OS Open image file over kermit line */
088f1b19 813static int k_recv(void)
8bde7f77
WD
814{
815 char new_char;
816 char k_state, k_state_saved;
817 int sum;
818 int done;
819 int length;
820 int n, last_n;
8bde7f77
WD
821 int len_lo, len_hi;
822
823 /* initialize some protocol parameters */
824 his_eol = END_CHAR; /* default end of line character */
825 his_pad_count = 0;
826 his_pad_char = '\0';
827 his_quote = K_ESCAPE;
828
829 /* initialize the k_recv and k_data state machine */
830 done = 0;
831 k_state = 0;
088f1b19 832 k_data_init();
8bde7f77 833 k_state_saved = k_state;
088f1b19 834 k_data_save();
8bde7f77
WD
835 n = 0; /* just to get rid of a warning */
836 last_n = -1;
837
838 /* expect this "type" sequence (but don't check):
839 S: send initiate
840 F: file header
841 D: data (multiple)
842 Z: end of file
843 B: break transmission
844 */
845
846 /* enter main loop */
847 while (!done) {
848 /* set the send packet pointer to begining of send packet parms */
849 send_ptr = send_parms;
850
851 /* With each packet, start summing the bytes starting with the length.
852 Save the current sequence number.
853 Note the type of the packet.
854 If a character less than SPACE (0x20) is received - error.
855 */
856
857#if 0
858 /* OLD CODE, Prior to checking sequence numbers */
859 /* first have all state machines save current states */
860 k_state_saved = k_state;
861 k_data_save ();
862#endif
863
864 /* get a packet */
865 /* wait for the starting character or ^C */
866 for (;;) {
c670aeee 867 switch (getchar()) {
8bde7f77
WD
868 case START_CHAR: /* start packet */
869 goto START;
870 case ETX_CHAR: /* ^C waiting for packet */
871 return (0);
872 default:
873 ;
874 }
875 }
876START:
877 /* get length of packet */
878 sum = 0;
c670aeee 879 new_char = getchar();
8bde7f77
WD
880 if ((new_char & 0xE0) == 0)
881 goto packet_error;
882 sum += new_char & 0xff;
088f1b19 883 length = untochar(new_char);
8bde7f77 884 /* get sequence number */
c670aeee 885 new_char = getchar();
8bde7f77
WD
886 if ((new_char & 0xE0) == 0)
887 goto packet_error;
888 sum += new_char & 0xff;
088f1b19 889 n = untochar(new_char);
8bde7f77
WD
890 --length;
891
892 /* NEW CODE - check sequence numbers for retried packets */
893 /* Note - this new code assumes that the sequence number is correctly
894 * received. Handling an invalid sequence number adds another layer
895 * of complexity that may not be needed - yet! At this time, I'm hoping
896 * that I don't need to buffer the incoming data packets and can write
897 * the data into memory in real time.
898 */
899 if (n == last_n) {
900 /* same sequence number, restore the previous state */
901 k_state = k_state_saved;
088f1b19 902 k_data_restore();
8bde7f77
WD
903 } else {
904 /* new sequence number, checkpoint the download */
905 last_n = n;
906 k_state_saved = k_state;
088f1b19 907 k_data_save();
8bde7f77
WD
908 }
909 /* END NEW CODE */
910
911 /* get packet type */
c670aeee 912 new_char = getchar();
8bde7f77
WD
913 if ((new_char & 0xE0) == 0)
914 goto packet_error;
915 sum += new_char & 0xff;
916 k_state = new_char;
917 --length;
918 /* check for extended length */
919 if (length == -2) {
920 /* (length byte was 0, decremented twice) */
921 /* get the two length bytes */
c670aeee 922 new_char = getchar();
8bde7f77
WD
923 if ((new_char & 0xE0) == 0)
924 goto packet_error;
925 sum += new_char & 0xff;
088f1b19 926 len_hi = untochar(new_char);
c670aeee 927 new_char = getchar();
8bde7f77
WD
928 if ((new_char & 0xE0) == 0)
929 goto packet_error;
930 sum += new_char & 0xff;
088f1b19 931 len_lo = untochar(new_char);
8bde7f77
WD
932 length = len_hi * 95 + len_lo;
933 /* check header checksum */
c670aeee 934 new_char = getchar();
8bde7f77
WD
935 if ((new_char & 0xE0) == 0)
936 goto packet_error;
088f1b19 937 if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
8bde7f77
WD
938 goto packet_error;
939 sum += new_char & 0xff;
940/* --length; */ /* new length includes only data and block check to come */
941 }
942 /* bring in rest of packet */
943 while (length > 1) {
c670aeee 944 new_char = getchar();
8bde7f77
WD
945 if ((new_char & 0xE0) == 0)
946 goto packet_error;
947 sum += new_char & 0xff;
948 --length;
949 if (k_state == DATA_TYPE) {
950 /* pass on the data if this is a data packet */
951 k_data_char (new_char);
952 } else if (k_state == SEND_TYPE) {
953 /* save send pack in buffer as is */
954 *send_ptr++ = new_char;
955 /* if too much data, back off the pointer */
956 if (send_ptr >= &send_parms[SEND_DATA_SIZE])
957 --send_ptr;
958 }
959 }
960 /* get and validate checksum character */
c670aeee 961 new_char = getchar();
8bde7f77
WD
962 if ((new_char & 0xE0) == 0)
963 goto packet_error;
088f1b19 964 if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
8bde7f77
WD
965 goto packet_error;
966 /* get END_CHAR */
c670aeee 967 new_char = getchar();
8bde7f77
WD
968 if (new_char != END_CHAR) {
969 packet_error:
970 /* restore state machines */
971 k_state = k_state_saved;
088f1b19 972 k_data_restore();
8bde7f77 973 /* send a negative acknowledge packet in */
088f1b19 974 send_nack(n);
8bde7f77
WD
975 } else if (k_state == SEND_TYPE) {
976 /* crack the protocol parms, build an appropriate ack packet */
088f1b19 977 handle_send_packet(n);
8bde7f77
WD
978 } else {
979 /* send simple acknowledge packet in */
088f1b19 980 send_ack(n);
8bde7f77
WD
981 /* quit if end of transmission */
982 if (k_state == BREAK_TYPE)
983 done = 1;
984 }
8bde7f77
WD
985 }
986 return ((ulong) os_data_addr - (ulong) bin_start_address);
987}
f2841d37
MK
988
989static int getcxmodem(void) {
cf48eb9a 990 if (tstc())
c670aeee 991 return (getchar());
f2841d37
MK
992 return -1;
993}
6e66bd55 994static ulong load_serial_ymodem(ulong offset, int mode)
f2841d37
MK
995{
996 int size;
f2841d37
MK
997 int err;
998 int res;
999 connection_info_t info;
cf48eb9a
WD
1000 char ymodemBuf[1024];
1001 ulong store_addr = ~0;
1002 ulong addr = 0;
f2841d37 1003
cf48eb9a 1004 size = 0;
6e66bd55 1005 info.mode = mode;
088f1b19 1006 res = xyzModem_stream_open(&info, &err);
f2841d37 1007 if (!res) {
f2841d37 1008
081bd249 1009 err = 0;
cf48eb9a 1010 while ((res =
088f1b19 1011 xyzModem_stream_read(ymodemBuf, 1024, &err)) > 0) {
cf48eb9a
WD
1012 store_addr = addr + offset;
1013 size += res;
1014 addr += res;
e856bdcf 1015#ifdef CONFIG_MTD_NOR_FLASH
088f1b19 1016 if (addr2info(store_addr)) {
cf48eb9a
WD
1017 int rc;
1018
088f1b19 1019 rc = flash_write((char *) ymodemBuf,
cf48eb9a
WD
1020 store_addr, res);
1021 if (rc != 0) {
081bd249
T
1022 xyzModem_stream_terminate(true, &getcxmodem);
1023 xyzModem_stream_close(&err);
1024 printf("\n");
0ee48252 1025 flash_perror(rc);
cf48eb9a
WD
1026 return (~0);
1027 }
1028 } else
f2841d37 1029#endif
cf48eb9a 1030 {
088f1b19 1031 memcpy((char *)(store_addr), ymodemBuf,
cf48eb9a
WD
1032 res);
1033 }
1034
1035 }
081bd249
T
1036 if (err) {
1037 xyzModem_stream_terminate((err == xyzModem_cancel) ? false : true, &getcxmodem);
1038 xyzModem_stream_close(&err);
1039 printf("\n%s\n", xyzModem_error(err));
1040 return (~0); /* Download aborted */
1041 }
1042
76b0a190
HS
1043 if (IS_ENABLED(CONFIG_CMD_BOOTEFI))
1044 efi_set_bootdev("Uart", "", "",
1045 map_sysmem(offset, 0), size);
1046
cf48eb9a 1047 } else {
081bd249
T
1048 printf("\n%s\n", xyzModem_error(err));
1049 return (~0); /* Download aborted */
f2841d37 1050 }
cf48eb9a 1051
088f1b19 1052 xyzModem_stream_terminate(false, &getcxmodem);
1f26c49e 1053 xyzModem_stream_close(&err);
f2841d37
MK
1054
1055
0a6036da 1056 flush_cache(offset, ALIGN(size, ARCH_DMA_MINALIGN));
f2841d37 1057
088f1b19 1058 printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
018f5303 1059 env_set_hex("filesize", size);
f2841d37
MK
1060
1061 return offset;
1062}
1063
90253178 1064#endif
8bde7f77
WD
1065
1066/* -------------------------------------------------------------------- */
1067
c76fe474 1068#if defined(CONFIG_CMD_LOADS)
8bde7f77 1069
6d0f6bcf 1070#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
0d498393
WD
1071U_BOOT_CMD(
1072 loads, 3, 0, do_load_serial,
2fb2604d 1073 "load S-Record file over serial line",
8bde7f77
WD
1074 "[ off ] [ baud ]\n"
1075 " - load S-Record file over serial line"
a89c33db 1076 " with offset 'off' and baudrate 'baud'"
8bde7f77
WD
1077);
1078
6d0f6bcf 1079#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
0d498393
WD
1080U_BOOT_CMD(
1081 loads, 2, 0, do_load_serial,
2fb2604d 1082 "load S-Record file over serial line",
8bde7f77 1083 "[ off ]\n"
a89c33db 1084 " - load S-Record file over serial line with offset 'off'"
8bde7f77 1085);
6d0f6bcf 1086#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
8bde7f77
WD
1087
1088/*
1089 * SAVES always requires LOADS support, but not vice versa
1090 */
1091
1092
c76fe474 1093#if defined(CONFIG_CMD_SAVES)
6d0f6bcf 1094#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
0d498393
WD
1095U_BOOT_CMD(
1096 saves, 4, 0, do_save_serial,
2fb2604d 1097 "save S-Record file over serial line",
8bde7f77
WD
1098 "[ off ] [size] [ baud ]\n"
1099 " - save S-Record file over serial line"
a89c33db 1100 " with offset 'off', size 'size' and baudrate 'baud'"
8bde7f77 1101);
6d0f6bcf 1102#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
0d498393
WD
1103U_BOOT_CMD(
1104 saves, 3, 0, do_save_serial,
2fb2604d 1105 "save S-Record file over serial line",
8bde7f77 1106 "[ off ] [size]\n"
a89c33db 1107 " - save S-Record file over serial line with offset 'off' and size 'size'"
8bde7f77 1108);
6d0f6bcf 1109#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
70d7cb92
RD
1110#endif /* CONFIG_CMD_SAVES */
1111#endif /* CONFIG_CMD_LOADS */
8bde7f77
WD
1112
1113
c76fe474 1114#if defined(CONFIG_CMD_LOADB)
0d498393
WD
1115U_BOOT_CMD(
1116 loadb, 3, 0, do_load_serial_bin,
2fb2604d 1117 "load binary file over serial line (kermit mode)",
b911208f 1118 "[ addr [ baud ] ]\n"
8bde7f77 1119 " - load binary file over serial line"
b911208f 1120 " at address 'addr' with baudrate 'baud'"
6e66bd55
AA
1121);
1122
1123U_BOOT_CMD(
1124 loadx, 3, 0, do_load_serial_bin,
1125 "load binary file over serial line (xmodem mode)",
b911208f 1126 "[ addr [ baud ] ]\n"
6e66bd55 1127 " - load binary file over serial line"
b911208f 1128 " at address 'addr' with baudrate 'baud'"
8bde7f77
WD
1129);
1130
f2841d37
MK
1131U_BOOT_CMD(
1132 loady, 3, 0, do_load_serial_bin,
2fb2604d 1133 "load binary file over serial line (ymodem mode)",
b911208f 1134 "[ addr [ baud ] ]\n"
f2841d37 1135 " - load binary file over serial line"
b911208f 1136 " at address 'addr' with baudrate 'baud'"
f2841d37
MK
1137);
1138
70d7cb92 1139#endif /* CONFIG_CMD_LOADB */
This page took 0.722498 seconds and 4 git commands to generate.