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