2 * (C) Copyright 2000-2004
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
5 * SPDX-License-Identifier: GPL-2.0+
9 * Serial up- and download support
18 DECLARE_GLOBAL_DATA_PTR;
20 #if defined(CONFIG_CMD_LOADB)
21 static ulong load_serial_ymodem(ulong offset, int mode);
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);
32 static int do_echo = 1;
35 /* -------------------------------------------------------------------- */
37 #if defined(CONFIG_CMD_LOADS)
38 static int do_load_serial(cmd_tbl_t *cmdtp, int flag, int argc,
46 #ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
47 int load_baudrate, current_baudrate;
49 load_baudrate = current_baudrate = gd->baudrate;
52 if (((env_echo = getenv("loads_echo")) != NULL) && (*env_echo == '1')) {
58 #ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
60 offset = simple_strtol(argv[1], NULL, 16);
63 load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);
65 /* default to current baudrate */
66 if (load_baudrate == 0)
67 load_baudrate = current_baudrate;
69 if (load_baudrate != current_baudrate) {
70 printf("## Switch baudrate to %d bps and press ENTER ...\n",
73 gd->baudrate = load_baudrate;
81 #else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
83 offset = simple_strtol(argv[1], NULL, 16);
85 #endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
87 printf("## Ready for S-Record download ...\n");
89 addr = load_serial(offset);
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)
96 for (i=0; i<100; ++i) {
104 printf("## S-Record download aborted\n");
107 printf("## Start Addr = 0x%08lX\n", addr);
111 #ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
112 if (load_baudrate != current_baudrate) {
113 printf("## Switch baudrate to %d bps and press ESC ...\n",
116 gd->baudrate = current_baudrate;
120 if (getc() == 0x1B) /* ESC */
128 static ulong load_serial(long offset)
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 */
137 ulong start_addr = ~0;
141 while (read_record(record, SREC_MAXRECLEN + 1) >= 0) {
142 type = srec_decode(record, &binlen, &addr, binbuf);
145 return (~0); /* Invalid S-Record */
152 store_addr = addr + offset;
153 #ifndef CONFIG_SYS_NO_FLASH
154 if (addr2info(store_addr)) {
157 rc = flash_write((char *)binbuf,store_addr,binlen);
165 memcpy((char *)(store_addr), binbuf, binlen);
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;
176 size = end_addr - start_addr + 1;
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
183 flush_cache(start_addr, size);
184 setenv_hex("filesize", size);
191 if (!do_echo) { /* print a '.' every 100 lines */
192 if ((++line_count % 100) == 0)
197 return (~0); /* Download aborted */
200 static int read_record(char *buf, ulong len)
205 --len; /* always leave room for terminating '\0' byte */
207 for (p=buf; p < buf+len; ++p) {
208 c = getc(); /* read character */
210 putc(c); /* ... and echo it */
218 case 0x03: /* ^C - Control C */
224 /* Check for the console hangup (if any different from serial) */
225 if (gd->jt->getc != getc) {
232 /* line too long - truncate */
237 #if defined(CONFIG_CMD_SAVES)
239 int do_save_serial (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
243 #ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
244 int save_baudrate, current_baudrate;
246 save_baudrate = current_baudrate = gd->baudrate;
250 offset = simple_strtoul(argv[1], NULL, 16);
252 #ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
254 size = simple_strtoul(argv[2], NULL, 16);
257 save_baudrate = (int)simple_strtoul(argv[3], NULL, 10);
259 /* default to current baudrate */
260 if (save_baudrate == 0)
261 save_baudrate = current_baudrate;
263 if (save_baudrate != current_baudrate) {
264 printf("## Switch baudrate to %d bps and press ENTER ...\n",
267 gd->baudrate = save_baudrate;
275 #else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
277 size = simple_strtoul(argv[2], NULL, 16);
279 #endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
281 printf("## Ready for S-Record upload, press ENTER to proceed ...\n");
286 if (save_serial(offset, size)) {
287 printf("## S-Record upload aborted\n");
289 printf("## S-Record upload complete\n");
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);
296 gd->baudrate = current_baudrate;
300 if (getc() == 0x1B) /* ESC */
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
313 static int save_serial(ulong address, ulong count)
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 */
323 if(write_record(SREC3_START)) /* write the header */
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';
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;
341 /* accumulate length bytes into checksum */
342 for(i = 0; i < 2; i++)
343 checksum += (length >> (8*i)) & 0xff;
345 /* accumulate address bytes into checksum: */
346 for(i = 0; i < 4; i++)
347 checksum += (address >> (8*i)) & 0xff;
349 /* make proper checksum byte: */
350 checksum = ~checksum & 0xff;
352 /* output one record: */
353 sprintf(record, SREC3_FORMAT, length, address, data, checksum);
354 if(write_record(record))
357 address += reclen; /* increment address */
363 if(write_record(SREC3_END)) /* write the final record */
368 static int write_record(char *buf)
375 /* Check for the console hangup (if any different from serial) */
387 #if defined(CONFIG_CMD_LOADB)
389 * loadb command (load binary) included
393 #define START_CHAR 0x01
394 #define ETX_CHAR 0x03
395 #define END_CHAR 0x0D
397 #define K_ESCAPE 0x23
398 #define SEND_TYPE 'S'
399 #define DATA_TYPE 'D'
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))
406 static void set_kerm_bin_mode(unsigned long *);
407 static int k_recv(void);
408 static ulong load_serial_bin(ulong offset);
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 */
416 static int do_load_serial_bin(cmd_tbl_t *cmdtp, int flag, int argc,
421 int load_baudrate, current_baudrate;
425 /* pre-set offset from CONFIG_SYS_LOAD_ADDR */
426 offset = CONFIG_SYS_LOAD_ADDR;
428 /* pre-set offset from $loadaddr */
429 if ((s = getenv("loadaddr")) != NULL) {
430 offset = simple_strtoul(s, NULL, 16);
433 load_baudrate = current_baudrate = gd->baudrate;
436 offset = simple_strtoul(argv[1], NULL, 16);
439 load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);
441 /* default to current baudrate */
442 if (load_baudrate == 0)
443 load_baudrate = current_baudrate;
446 if (load_baudrate != current_baudrate) {
447 printf("## Switch baudrate to %d bps and press ENTER ...\n",
450 gd->baudrate = load_baudrate;
459 if (strcmp(argv[0],"loady")==0) {
460 printf("## Ready for binary (ymodem) download "
461 "to 0x%08lX at %d bps...\n",
465 addr = load_serial_ymodem(offset, xyzModem_ymodem);
467 } else if (strcmp(argv[0],"loadx")==0) {
468 printf("## Ready for binary (xmodem) download "
469 "to 0x%08lX at %d bps...\n",
473 addr = load_serial_ymodem(offset, xyzModem_xmodem);
477 printf("## Ready for binary (kermit) download "
478 "to 0x%08lX at %d bps...\n",
481 addr = load_serial_bin(offset);
485 printf("## Binary (kermit) download aborted\n");
488 printf("## Start Addr = 0x%08lX\n", addr);
492 if (load_baudrate != current_baudrate) {
493 printf("## Switch baudrate to %d bps and press ESC ...\n",
496 gd->baudrate = current_baudrate;
500 if (getc() == 0x1B) /* ESC */
509 static ulong load_serial_bin(ulong offset)
513 set_kerm_bin_mode((ulong *) offset);
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)
521 for (i=0; i<100; ++i) {
528 flush_cache(offset, size);
530 printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
531 setenv_hex("filesize", size);
536 static void send_pad(void)
538 int count = his_pad_count;
544 /* converts escaped kermit char to binary char */
545 static char ktrans(char in)
547 if ((in & 0x60) == 0x40) {
548 return (char) (in & ~0x40);
549 } else if ((in & 0x7f) == 0x3f) {
550 return (char) (in | 0x40);
555 static int chk1(char *buffer)
562 return (int) ((total + ((total >> 6) & 0x03)) & 0x3f);
565 static void s1_sendpacket(char *packet)
574 static void send_ack(int n)
581 a_b[4] = tochar(chk1(&a_b[1]));
587 static void send_nack(int n)
594 a_b[4] = tochar(chk1(&a_b[1]));
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;
607 static void bin_data_init(void)
610 os_data_addr = bin_start_address;
613 static void os_data_save(void)
615 os_data_state_saved = os_data_state;
616 os_data_addr_saved = os_data_addr;
619 static void os_data_restore(void)
621 os_data_state = os_data_state_saved;
622 os_data_addr = os_data_addr_saved;
625 static void bin_data_char(char new_char)
627 switch (os_data_state) {
629 *os_data_addr++ = new_char;
634 static void set_kerm_bin_mode(unsigned long *addr)
636 bin_start_address = (char *) addr;
637 os_data_init = bin_data_init;
638 os_data_char = bin_data_char;
642 /* k_data_* simply handles the kermit escape translations */
643 static int k_data_escape, k_data_escape_saved;
644 static void k_data_init(void)
650 static void k_data_save(void)
652 k_data_escape_saved = k_data_escape;
656 static void k_data_restore(void)
658 k_data_escape = k_data_escape_saved;
662 static void k_data_char(char new_char)
665 /* last char was escape - translate this character */
666 os_data_char(ktrans(new_char));
669 if (new_char == his_quote) {
670 /* this char is escape - remember */
673 /* otherwise send this char as-is */
674 os_data_char(new_char);
679 #define SEND_DATA_SIZE 20
680 static char send_parms[SEND_DATA_SIZE];
681 static char *send_ptr;
683 /* handle_send_packet interprits the protocol info and builds and
684 sends an appropriate ack for what we can do */
685 static void handle_send_packet(int n)
690 /* initialize some protocol parameters */
691 his_eol = END_CHAR; /* default end of line character */
694 his_quote = K_ESCAPE;
696 /* ignore last character if it filled the buffer */
697 if (send_ptr == &send_parms[SEND_DATA_SIZE - 1])
699 bytes = send_ptr - send_parms; /* how many bytes we'll process */
703 /* handle MAXL - max length */
704 /* ignore what he says - most I'll take (here) is 94 */
705 a_b[++length] = tochar(94);
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);
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);
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 */
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);
731 /* handle QCTL - quote control char he'll use */
732 /* remember what he says - I'll use '#' */
733 his_quote = send_parms[5];
737 /* handle QBIN - 8-th bit prefixing */
738 /* ignore what he says - I refuse */
742 /* handle CHKT - the clock check type */
743 /* ignore what he says - I do type 1 (for now) */
747 /* handle REPT - the repeat prefix */
748 /* ignore what he says - I refuse (for now) */
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 */
761 a_b[1] = tochar(length);
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';
771 /* k_recv receives a OS Open image file over kermit line */
772 static int k_recv(void)
775 char k_state, k_state_saved;
782 /* initialize some protocol parameters */
783 his_eol = END_CHAR; /* default end of line character */
786 his_quote = K_ESCAPE;
788 /* initialize the k_recv and k_data state machine */
792 k_state_saved = k_state;
794 n = 0; /* just to get rid of a warning */
797 /* expect this "type" sequence (but don't check):
802 B: break transmission
805 /* enter main loop */
807 /* set the send packet pointer to begining of send packet parms */
808 send_ptr = send_parms;
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.
817 /* OLD CODE, Prior to checking sequence numbers */
818 /* first have all state machines save current states */
819 k_state_saved = k_state;
824 /* wait for the starting character or ^C */
827 case START_CHAR: /* start packet */
829 case ETX_CHAR: /* ^C waiting for packet */
836 /* get length of packet */
839 if ((new_char & 0xE0) == 0)
841 sum += new_char & 0xff;
842 length = untochar(new_char);
843 /* get sequence number */
845 if ((new_char & 0xE0) == 0)
847 sum += new_char & 0xff;
848 n = untochar(new_char);
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.
859 /* same sequence number, restore the previous state */
860 k_state = k_state_saved;
863 /* new sequence number, checkpoint the download */
865 k_state_saved = k_state;
870 /* get packet type */
872 if ((new_char & 0xE0) == 0)
874 sum += new_char & 0xff;
877 /* check for extended length */
879 /* (length byte was 0, decremented twice) */
880 /* get the two length bytes */
882 if ((new_char & 0xE0) == 0)
884 sum += new_char & 0xff;
885 len_hi = untochar(new_char);
887 if ((new_char & 0xE0) == 0)
889 sum += new_char & 0xff;
890 len_lo = untochar(new_char);
891 length = len_hi * 95 + len_lo;
892 /* check header checksum */
894 if ((new_char & 0xE0) == 0)
896 if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
898 sum += new_char & 0xff;
899 /* --length; */ /* new length includes only data and block check to come */
901 /* bring in rest of packet */
904 if ((new_char & 0xE0) == 0)
906 sum += new_char & 0xff;
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])
919 /* get and validate checksum character */
921 if ((new_char & 0xE0) == 0)
923 if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
927 if (new_char != END_CHAR) {
929 /* restore state machines */
930 k_state = k_state_saved;
932 /* send a negative acknowledge packet in */
934 } else if (k_state == SEND_TYPE) {
935 /* crack the protocol parms, build an appropriate ack packet */
936 handle_send_packet(n);
938 /* send simple acknowledge packet in */
940 /* quit if end of transmission */
941 if (k_state == BREAK_TYPE)
945 return ((ulong) os_data_addr - (ulong) bin_start_address);
948 static int getcxmodem(void) {
953 static ulong load_serial_ymodem(ulong offset, int mode)
958 connection_info_t info;
959 char ymodemBuf[1024];
960 ulong store_addr = ~0;
965 res = xyzModem_stream_open(&info, &err);
969 xyzModem_stream_read(ymodemBuf, 1024, &err)) > 0) {
970 store_addr = addr + offset;
973 #ifndef CONFIG_SYS_NO_FLASH
974 if (addr2info(store_addr)) {
977 rc = flash_write((char *) ymodemBuf,
986 memcpy((char *)(store_addr), ymodemBuf,
992 printf("%s\n", xyzModem_error(err));
995 xyzModem_stream_close(&err);
996 xyzModem_stream_terminate(false, &getcxmodem);
999 flush_cache(offset, size);
1001 printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
1002 setenv_hex("filesize", size);
1009 /* -------------------------------------------------------------------- */
1011 #if defined(CONFIG_CMD_LOADS)
1013 #ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
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'"
1022 #else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
1024 loads, 2, 0, do_load_serial,
1025 "load S-Record file over serial line",
1027 " - load S-Record file over serial line with offset 'off'"
1029 #endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
1032 * SAVES always requires LOADS support, but not vice versa
1036 #if defined(CONFIG_CMD_SAVES)
1037 #ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
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'"
1045 #else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
1047 saves, 3, 0, do_save_serial,
1048 "save S-Record file over serial line",
1050 " - save S-Record file over serial line with offset 'off' and size 'size'"
1052 #endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
1053 #endif /* CONFIG_CMD_SAVES */
1054 #endif /* CONFIG_CMD_LOADS */
1057 #if defined(CONFIG_CMD_LOADB)
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'"
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'"
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'"
1082 #endif /* CONFIG_CMD_LOADB */
1084 /* -------------------------------------------------------------------- */
1086 #if defined(CONFIG_CMD_HWFLOW)
1087 int do_hwflow(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1089 extern int hwflow_onoff(int);
1092 if (strcmp(argv[1], "off") == 0)
1095 if (strcmp(argv[1], "on") == 0)
1098 return CMD_RET_USAGE;
1100 printf("RTS/CTS hardware flow control: %s\n", hwflow_onoff(0) ? "on" : "off");
1104 /* -------------------------------------------------------------------- */
1107 hwflow, 2, 0, do_hwflow,
1108 "turn RTS/CTS hardware flow control in serial line on/off",
1112 #endif /* CONFIG_CMD_HWFLOW */