blob: 9a3a16979c7154aedbae1b1259942ccfbe06c0e6 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
wdenk8bde7f72003-06-27 21:31:46 +00002/*
wdenk232c1502004-03-12 00:14:09 +00003 * (C) Copyright 2000-2004
wdenk8bde7f72003-06-27 21:31:46 +00004 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
wdenk8bde7f72003-06-27 21:31:46 +00005 */
6
7/*
8 * Serial up- and download support
9 */
10#include <common.h>
11#include <command.h>
Simon Glass24b852a2015-11-08 23:47:45 -070012#include <console.h>
Simon Glass1eb69ae2019-11-14 12:57:39 -070013#include <cpu_func.h>
Simon Glassc7694dd2019-08-01 09:46:46 -060014#include <env.h>
Simon Glass0ee482522019-12-28 10:44:40 -070015#include <flash.h>
Simon Glass8e8ccfe2019-12-28 10:45:03 -070016#include <image.h>
wdenk8bde7f72003-06-27 21:31:46 +000017#include <s_record.h>
18#include <net.h>
wdenk27b207f2003-07-24 23:38:38 +000019#include <exports.h>
Simon Glassb03e0512019-11-14 12:57:24 -070020#include <serial.h>
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +020021#include <xyzModem.h>
Simon Glass90526e92020-05-10 11:39:56 -060022#include <asm/cache.h>
Simon Glassc05ed002020-05-10 11:40:11 -060023#include <linux/delay.h>
wdenk8bde7f72003-06-27 21:31:46 +000024
Wolfgang Denkd87080b2006-03-31 18:32:53 +020025DECLARE_GLOBAL_DATA_PTR;
wdenk8bde7f72003-06-27 21:31:46 +000026
Jon Loeligerc76fe472007-07-08 18:02:23 -050027#if defined(CONFIG_CMD_LOADB)
Angus Ainslie6e66bd52013-06-26 16:54:24 -060028static ulong load_serial_ymodem(ulong offset, int mode);
Wolfgang Denk8546e232006-05-02 00:11:25 +020029#endif
30
Jon Loeligerc76fe472007-07-08 18:02:23 -050031#if defined(CONFIG_CMD_LOADS)
Kim Phillips088f1b12012-10-29 13:34:31 +000032static ulong load_serial(long offset);
33static int read_record(char *buf, ulong len);
Jon Loeligerc76fe472007-07-08 18:02:23 -050034# if defined(CONFIG_CMD_SAVES)
Kim Phillips088f1b12012-10-29 13:34:31 +000035static int save_serial(ulong offset, ulong size);
36static int write_record(char *buf);
Jon Loeliger90253172007-07-10 11:02:44 -050037#endif
wdenk8bde7f72003-06-27 21:31:46 +000038
39static int do_echo = 1;
Jon Loeliger90253172007-07-10 11:02:44 -050040#endif
wdenk8bde7f72003-06-27 21:31:46 +000041
42/* -------------------------------------------------------------------- */
43
Jon Loeligerc76fe472007-07-08 18:02:23 -050044#if defined(CONFIG_CMD_LOADS)
Simon Glass09140112020-05-10 11:40:03 -060045static int do_load_serial(struct cmd_tbl *cmdtp, int flag, int argc,
46 char *const argv[])
wdenk8bde7f72003-06-27 21:31:46 +000047{
Ricardo Ribalda Delgado2b22d602008-07-30 12:39:29 +020048 long offset = 0;
wdenk8bde7f72003-06-27 21:31:46 +000049 ulong addr;
50 int i;
51 char *env_echo;
52 int rcode = 0;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020053#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk8bde7f72003-06-27 21:31:46 +000054 int load_baudrate, current_baudrate;
55
56 load_baudrate = current_baudrate = gd->baudrate;
57#endif
58
Simon Glass00caae62017-08-03 12:22:12 -060059 env_echo = env_get("loads_echo");
60 if (env_echo && *env_echo == '1')
wdenk8bde7f72003-06-27 21:31:46 +000061 do_echo = 1;
Simon Glass00caae62017-08-03 12:22:12 -060062 else
wdenk8bde7f72003-06-27 21:31:46 +000063 do_echo = 0;
wdenk8bde7f72003-06-27 21:31:46 +000064
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020065#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk8bde7f72003-06-27 21:31:46 +000066 if (argc >= 2) {
Ricardo Ribalda Delgado2b22d602008-07-30 12:39:29 +020067 offset = simple_strtol(argv[1], NULL, 16);
wdenk8bde7f72003-06-27 21:31:46 +000068 }
69 if (argc == 3) {
70 load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);
71
72 /* default to current baudrate */
73 if (load_baudrate == 0)
74 load_baudrate = current_baudrate;
75 }
76 if (load_baudrate != current_baudrate) {
Kim Phillips088f1b12012-10-29 13:34:31 +000077 printf("## Switch baudrate to %d bps and press ENTER ...\n",
wdenk8bde7f72003-06-27 21:31:46 +000078 load_baudrate);
79 udelay(50000);
80 gd->baudrate = load_baudrate;
Kim Phillips088f1b12012-10-29 13:34:31 +000081 serial_setbrg();
wdenk8bde7f72003-06-27 21:31:46 +000082 udelay(50000);
83 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +020084 if (getchar() == '\r')
wdenk8bde7f72003-06-27 21:31:46 +000085 break;
86 }
87 }
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020088#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
wdenk8bde7f72003-06-27 21:31:46 +000089 if (argc == 2) {
Ricardo Ribalda Delgado2b22d602008-07-30 12:39:29 +020090 offset = simple_strtol(argv[1], NULL, 16);
wdenk8bde7f72003-06-27 21:31:46 +000091 }
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020092#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
wdenk8bde7f72003-06-27 21:31:46 +000093
Kim Phillips088f1b12012-10-29 13:34:31 +000094 printf("## Ready for S-Record download ...\n");
wdenk8bde7f72003-06-27 21:31:46 +000095
Kim Phillips088f1b12012-10-29 13:34:31 +000096 addr = load_serial(offset);
wdenk8bde7f72003-06-27 21:31:46 +000097
98 /*
99 * Gather any trailing characters (for instance, the ^D which
100 * is sent by 'cu' after sending a file), and give the
101 * box some time (100 * 1 ms)
102 */
103 for (i=0; i<100; ++i) {
wdenk232c1502004-03-12 00:14:09 +0000104 if (tstc()) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200105 getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000106 }
107 udelay(1000);
108 }
109
110 if (addr == ~0) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000111 printf("## S-Record download aborted\n");
wdenk8bde7f72003-06-27 21:31:46 +0000112 rcode = 1;
113 } else {
Kim Phillips088f1b12012-10-29 13:34:31 +0000114 printf("## Start Addr = 0x%08lX\n", addr);
Simon Glassbb872dd2019-12-28 10:45:02 -0700115 image_load_addr = addr;
wdenk8bde7f72003-06-27 21:31:46 +0000116 }
117
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200118#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk8bde7f72003-06-27 21:31:46 +0000119 if (load_baudrate != current_baudrate) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000120 printf("## Switch baudrate to %d bps and press ESC ...\n",
wdenk8bde7f72003-06-27 21:31:46 +0000121 current_baudrate);
Kim Phillips088f1b12012-10-29 13:34:31 +0000122 udelay(50000);
wdenk8bde7f72003-06-27 21:31:46 +0000123 gd->baudrate = current_baudrate;
Kim Phillips088f1b12012-10-29 13:34:31 +0000124 serial_setbrg();
125 udelay(50000);
wdenk8bde7f72003-06-27 21:31:46 +0000126 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200127 if (getchar() == 0x1B) /* ESC */
wdenk8bde7f72003-06-27 21:31:46 +0000128 break;
129 }
130 }
131#endif
132 return rcode;
133}
134
Kim Phillips088f1b12012-10-29 13:34:31 +0000135static ulong load_serial(long offset)
wdenk8bde7f72003-06-27 21:31:46 +0000136{
137 char record[SREC_MAXRECLEN + 1]; /* buffer for one S-Record */
138 char binbuf[SREC_MAXBINLEN]; /* buffer for binary data */
139 int binlen; /* no. of data bytes in S-Rec. */
140 int type; /* return code for record type */
141 ulong addr; /* load address from S-Record */
142 ulong size; /* number of bytes transferred */
wdenk8bde7f72003-06-27 21:31:46 +0000143 ulong store_addr;
144 ulong start_addr = ~0;
145 ulong end_addr = 0;
146 int line_count = 0;
147
148 while (read_record(record, SREC_MAXRECLEN + 1) >= 0) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000149 type = srec_decode(record, &binlen, &addr, binbuf);
wdenk8bde7f72003-06-27 21:31:46 +0000150
151 if (type < 0) {
152 return (~0); /* Invalid S-Record */
153 }
154
155 switch (type) {
156 case SREC_DATA2:
157 case SREC_DATA3:
158 case SREC_DATA4:
159 store_addr = addr + offset;
Masahiro Yamadae856bdc2017-02-11 22:43:54 +0900160#ifdef CONFIG_MTD_NOR_FLASH
wdenk8bde7f72003-06-27 21:31:46 +0000161 if (addr2info(store_addr)) {
162 int rc;
163
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200164 rc = flash_write((char *)binbuf,store_addr,binlen);
wdenk8bde7f72003-06-27 21:31:46 +0000165 if (rc != 0) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000166 flash_perror(rc);
wdenk8bde7f72003-06-27 21:31:46 +0000167 return (~0);
168 }
169 } else
170#endif
171 {
Kim Phillips088f1b12012-10-29 13:34:31 +0000172 memcpy((char *)(store_addr), binbuf, binlen);
wdenk8bde7f72003-06-27 21:31:46 +0000173 }
174 if ((store_addr) < start_addr)
175 start_addr = store_addr;
176 if ((store_addr + binlen - 1) > end_addr)
177 end_addr = store_addr + binlen - 1;
178 break;
179 case SREC_END2:
180 case SREC_END3:
181 case SREC_END4:
Kim Phillips088f1b12012-10-29 13:34:31 +0000182 udelay(10000);
wdenk8bde7f72003-06-27 21:31:46 +0000183 size = end_addr - start_addr + 1;
Kim Phillips088f1b12012-10-29 13:34:31 +0000184 printf("\n"
wdenk8bde7f72003-06-27 21:31:46 +0000185 "## First Load Addr = 0x%08lX\n"
186 "## Last Load Addr = 0x%08lX\n"
187 "## Total Size = 0x%08lX = %ld Bytes\n",
188 start_addr, end_addr, size, size
189 );
Kim Phillips088f1b12012-10-29 13:34:31 +0000190 flush_cache(start_addr, size);
Simon Glass018f5302017-08-03 12:22:10 -0600191 env_set_hex("filesize", size);
wdenk8bde7f72003-06-27 21:31:46 +0000192 return (addr);
193 case SREC_START:
194 break;
195 default:
196 break;
197 }
198 if (!do_echo) { /* print a '.' every 100 lines */
199 if ((++line_count % 100) == 0)
Kim Phillips088f1b12012-10-29 13:34:31 +0000200 putc('.');
wdenk8bde7f72003-06-27 21:31:46 +0000201 }
202 }
203
204 return (~0); /* Download aborted */
205}
206
Kim Phillips088f1b12012-10-29 13:34:31 +0000207static int read_record(char *buf, ulong len)
wdenk8bde7f72003-06-27 21:31:46 +0000208{
209 char *p;
210 char c;
211
212 --len; /* always leave room for terminating '\0' byte */
213
214 for (p=buf; p < buf+len; ++p) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200215 c = getchar(); /* read character */
wdenk8bde7f72003-06-27 21:31:46 +0000216 if (do_echo)
Kim Phillips088f1b12012-10-29 13:34:31 +0000217 putc(c); /* ... and echo it */
wdenk8bde7f72003-06-27 21:31:46 +0000218
219 switch (c) {
220 case '\r':
221 case '\n':
222 *p = '\0';
223 return (p - buf);
224 case '\0':
225 case 0x03: /* ^C - Control C */
226 return (-1);
227 default:
228 *p = c;
229 }
230
231 /* Check for the console hangup (if any different from serial) */
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200232 if (gd->jt->getc != getchar) {
wdenk8bde7f72003-06-27 21:31:46 +0000233 if (ctrlc()) {
234 return (-1);
235 }
236 }
wdenk8bde7f72003-06-27 21:31:46 +0000237 }
238
239 /* line too long - truncate */
240 *p = '\0';
241 return (p - buf);
242}
243
Jon Loeligerc76fe472007-07-08 18:02:23 -0500244#if defined(CONFIG_CMD_SAVES)
wdenk8bde7f72003-06-27 21:31:46 +0000245
Simon Glass09140112020-05-10 11:40:03 -0600246int do_save_serial(struct cmd_tbl *cmdtp, int flag, int argc,
247 char *const argv[])
wdenk8bde7f72003-06-27 21:31:46 +0000248{
249 ulong offset = 0;
250 ulong size = 0;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200251#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk8bde7f72003-06-27 21:31:46 +0000252 int save_baudrate, current_baudrate;
253
254 save_baudrate = current_baudrate = gd->baudrate;
255#endif
256
257 if (argc >= 2) {
258 offset = simple_strtoul(argv[1], NULL, 16);
259 }
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200260#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk8bde7f72003-06-27 21:31:46 +0000261 if (argc >= 3) {
262 size = simple_strtoul(argv[2], NULL, 16);
263 }
264 if (argc == 4) {
265 save_baudrate = (int)simple_strtoul(argv[3], NULL, 10);
266
267 /* default to current baudrate */
268 if (save_baudrate == 0)
269 save_baudrate = current_baudrate;
270 }
271 if (save_baudrate != current_baudrate) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000272 printf("## Switch baudrate to %d bps and press ENTER ...\n",
wdenk8bde7f72003-06-27 21:31:46 +0000273 save_baudrate);
274 udelay(50000);
275 gd->baudrate = save_baudrate;
Kim Phillips088f1b12012-10-29 13:34:31 +0000276 serial_setbrg();
wdenk8bde7f72003-06-27 21:31:46 +0000277 udelay(50000);
278 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200279 if (getchar() == '\r')
wdenk8bde7f72003-06-27 21:31:46 +0000280 break;
281 }
282 }
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200283#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
wdenk8bde7f72003-06-27 21:31:46 +0000284 if (argc == 3) {
285 size = simple_strtoul(argv[2], NULL, 16);
286 }
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200287#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
wdenk8bde7f72003-06-27 21:31:46 +0000288
Kim Phillips088f1b12012-10-29 13:34:31 +0000289 printf("## Ready for S-Record upload, press ENTER to proceed ...\n");
wdenk8bde7f72003-06-27 21:31:46 +0000290 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200291 if (getchar() == '\r')
wdenk8bde7f72003-06-27 21:31:46 +0000292 break;
293 }
Kim Phillips088f1b12012-10-29 13:34:31 +0000294 if (save_serial(offset, size)) {
295 printf("## S-Record upload aborted\n");
wdenk8bde7f72003-06-27 21:31:46 +0000296 } else {
Kim Phillips088f1b12012-10-29 13:34:31 +0000297 printf("## S-Record upload complete\n");
wdenk8bde7f72003-06-27 21:31:46 +0000298 }
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200299#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk8bde7f72003-06-27 21:31:46 +0000300 if (save_baudrate != current_baudrate) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000301 printf("## Switch baudrate to %d bps and press ESC ...\n",
wdenk8bde7f72003-06-27 21:31:46 +0000302 (int)current_baudrate);
Kim Phillips088f1b12012-10-29 13:34:31 +0000303 udelay(50000);
wdenk8bde7f72003-06-27 21:31:46 +0000304 gd->baudrate = current_baudrate;
Kim Phillips088f1b12012-10-29 13:34:31 +0000305 serial_setbrg();
306 udelay(50000);
wdenk8bde7f72003-06-27 21:31:46 +0000307 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200308 if (getchar() == 0x1B) /* ESC */
wdenk8bde7f72003-06-27 21:31:46 +0000309 break;
310 }
311 }
312#endif
313 return 0;
314}
315
316#define SREC3_START "S0030000FC\n"
317#define SREC3_FORMAT "S3%02X%08lX%s%02X\n"
318#define SREC3_END "S70500000000FA\n"
319#define SREC_BYTES_PER_RECORD 16
320
Kim Phillips088f1b12012-10-29 13:34:31 +0000321static int save_serial(ulong address, ulong count)
wdenk8bde7f72003-06-27 21:31:46 +0000322{
323 int i, c, reclen, checksum, length;
324 char *hex = "0123456789ABCDEF";
325 char record[2*SREC_BYTES_PER_RECORD+16]; /* buffer for one S-Record */
326 char data[2*SREC_BYTES_PER_RECORD+1]; /* buffer for hex data */
327
328 reclen = 0;
329 checksum = 0;
330
331 if(write_record(SREC3_START)) /* write the header */
332 return (-1);
333 do {
334 if(count) { /* collect hex data in the buffer */
335 c = *(volatile uchar*)(address + reclen); /* get one byte */
336 checksum += c; /* accumulate checksum */
337 data[2*reclen] = hex[(c>>4)&0x0f];
338 data[2*reclen+1] = hex[c & 0x0f];
339 data[2*reclen+2] = '\0';
340 ++reclen;
341 --count;
342 }
343 if(reclen == SREC_BYTES_PER_RECORD || count == 0) {
344 /* enough data collected for one record: dump it */
345 if(reclen) { /* build & write a data record: */
346 /* address + data + checksum */
347 length = 4 + reclen + 1;
348
349 /* accumulate length bytes into checksum */
350 for(i = 0; i < 2; i++)
351 checksum += (length >> (8*i)) & 0xff;
352
353 /* accumulate address bytes into checksum: */
354 for(i = 0; i < 4; i++)
355 checksum += (address >> (8*i)) & 0xff;
356
357 /* make proper checksum byte: */
358 checksum = ~checksum & 0xff;
359
360 /* output one record: */
361 sprintf(record, SREC3_FORMAT, length, address, data, checksum);
362 if(write_record(record))
363 return (-1);
364 }
365 address += reclen; /* increment address */
366 checksum = 0;
367 reclen = 0;
368 }
369 }
370 while(count);
371 if(write_record(SREC3_END)) /* write the final record */
372 return (-1);
373 return(0);
374}
375
Kim Phillips088f1b12012-10-29 13:34:31 +0000376static int write_record(char *buf)
wdenk8bde7f72003-06-27 21:31:46 +0000377{
378 char c;
379
380 while((c = *buf++))
wdenk232c1502004-03-12 00:14:09 +0000381 putc(c);
wdenk8bde7f72003-06-27 21:31:46 +0000382
383 /* Check for the console hangup (if any different from serial) */
384
385 if (ctrlc()) {
386 return (-1);
387 }
388 return (0);
389}
Jon Loeliger90253172007-07-10 11:02:44 -0500390# endif
wdenk8bde7f72003-06-27 21:31:46 +0000391
Jon Loeliger90253172007-07-10 11:02:44 -0500392#endif
wdenk8bde7f72003-06-27 21:31:46 +0000393
394
Jon Loeligerc76fe472007-07-08 18:02:23 -0500395#if defined(CONFIG_CMD_LOADB)
Jon Loeliger65c450b2007-06-11 19:01:54 -0500396/*
397 * loadb command (load binary) included
398 */
wdenk8bde7f72003-06-27 21:31:46 +0000399#define XON_CHAR 17
400#define XOFF_CHAR 19
401#define START_CHAR 0x01
402#define ETX_CHAR 0x03
403#define END_CHAR 0x0D
404#define SPACE 0x20
405#define K_ESCAPE 0x23
406#define SEND_TYPE 'S'
407#define DATA_TYPE 'D'
408#define ACK_TYPE 'Y'
409#define NACK_TYPE 'N'
410#define BREAK_TYPE 'B'
411#define tochar(x) ((char) (((x) + SPACE) & 0xff))
412#define untochar(x) ((int) (((x) - SPACE) & 0xff))
413
wdenk8bde7f72003-06-27 21:31:46 +0000414static void set_kerm_bin_mode(unsigned long *);
415static int k_recv(void);
Kim Phillips088f1b12012-10-29 13:34:31 +0000416static ulong load_serial_bin(ulong offset);
wdenk8bde7f72003-06-27 21:31:46 +0000417
418
Kim Phillips088f1b12012-10-29 13:34:31 +0000419static char his_eol; /* character he needs at end of packet */
420static int his_pad_count; /* number of pad chars he needs */
421static char his_pad_char; /* pad chars he needs */
422static char his_quote; /* quote chars he'll use */
wdenk8bde7f72003-06-27 21:31:46 +0000423
Simon Glass09140112020-05-10 11:40:03 -0600424static int do_load_serial_bin(struct cmd_tbl *cmdtp, int flag, int argc,
425 char *const argv[])
wdenk8bde7f72003-06-27 21:31:46 +0000426{
wdenk8bde7f72003-06-27 21:31:46 +0000427 ulong offset = 0;
428 ulong addr;
429 int load_baudrate, current_baudrate;
430 int rcode = 0;
431 char *s;
432
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200433 /* pre-set offset from CONFIG_SYS_LOAD_ADDR */
434 offset = CONFIG_SYS_LOAD_ADDR;
wdenk8bde7f72003-06-27 21:31:46 +0000435
436 /* pre-set offset from $loadaddr */
Simon Glass00caae62017-08-03 12:22:12 -0600437 s = env_get("loadaddr");
438 if (s)
wdenk8bde7f72003-06-27 21:31:46 +0000439 offset = simple_strtoul(s, NULL, 16);
wdenk8bde7f72003-06-27 21:31:46 +0000440
441 load_baudrate = current_baudrate = gd->baudrate;
442
443 if (argc >= 2) {
444 offset = simple_strtoul(argv[1], NULL, 16);
445 }
446 if (argc == 3) {
447 load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);
448
449 /* default to current baudrate */
450 if (load_baudrate == 0)
451 load_baudrate = current_baudrate;
452 }
453
454 if (load_baudrate != current_baudrate) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000455 printf("## Switch baudrate to %d bps and press ENTER ...\n",
wdenk8bde7f72003-06-27 21:31:46 +0000456 load_baudrate);
457 udelay(50000);
458 gd->baudrate = load_baudrate;
Kim Phillips088f1b12012-10-29 13:34:31 +0000459 serial_setbrg();
wdenk8bde7f72003-06-27 21:31:46 +0000460 udelay(50000);
461 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200462 if (getchar() == '\r')
wdenk8bde7f72003-06-27 21:31:46 +0000463 break;
464 }
465 }
466
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200467 if (strcmp(argv[0],"loady")==0) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000468 printf("## Ready for binary (ymodem) download "
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200469 "to 0x%08lX at %d bps...\n",
470 offset,
471 load_baudrate);
wdenk8bde7f72003-06-27 21:31:46 +0000472
Angus Ainslie6e66bd52013-06-26 16:54:24 -0600473 addr = load_serial_ymodem(offset, xyzModem_ymodem);
474
475 } else if (strcmp(argv[0],"loadx")==0) {
476 printf("## Ready for binary (xmodem) download "
477 "to 0x%08lX at %d bps...\n",
478 offset,
479 load_baudrate);
480
481 addr = load_serial_ymodem(offset, xyzModem_xmodem);
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200482
wdenk8bde7f72003-06-27 21:31:46 +0000483 } else {
wdenk8bde7f72003-06-27 21:31:46 +0000484
Kim Phillips088f1b12012-10-29 13:34:31 +0000485 printf("## Ready for binary (kermit) download "
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200486 "to 0x%08lX at %d bps...\n",
487 offset,
488 load_baudrate);
Kim Phillips088f1b12012-10-29 13:34:31 +0000489 addr = load_serial_bin(offset);
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200490
491 if (addr == ~0) {
Simon Glassbb872dd2019-12-28 10:45:02 -0700492 image_load_addr = 0;
Kim Phillips088f1b12012-10-29 13:34:31 +0000493 printf("## Binary (kermit) download aborted\n");
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200494 rcode = 1;
495 } else {
Kim Phillips088f1b12012-10-29 13:34:31 +0000496 printf("## Start Addr = 0x%08lX\n", addr);
Simon Glassbb872dd2019-12-28 10:45:02 -0700497 image_load_addr = addr;
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200498 }
499 }
wdenk8bde7f72003-06-27 21:31:46 +0000500 if (load_baudrate != current_baudrate) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000501 printf("## Switch baudrate to %d bps and press ESC ...\n",
wdenk8bde7f72003-06-27 21:31:46 +0000502 current_baudrate);
Kim Phillips088f1b12012-10-29 13:34:31 +0000503 udelay(50000);
wdenk8bde7f72003-06-27 21:31:46 +0000504 gd->baudrate = current_baudrate;
Kim Phillips088f1b12012-10-29 13:34:31 +0000505 serial_setbrg();
506 udelay(50000);
wdenk8bde7f72003-06-27 21:31:46 +0000507 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200508 if (getchar() == 0x1B) /* ESC */
wdenk8bde7f72003-06-27 21:31:46 +0000509 break;
510 }
511 }
512
wdenk8bde7f72003-06-27 21:31:46 +0000513 return rcode;
514}
515
516
Kim Phillips088f1b12012-10-29 13:34:31 +0000517static ulong load_serial_bin(ulong offset)
wdenk8bde7f72003-06-27 21:31:46 +0000518{
519 int size, i;
wdenk8bde7f72003-06-27 21:31:46 +0000520
Kim Phillips088f1b12012-10-29 13:34:31 +0000521 set_kerm_bin_mode((ulong *) offset);
522 size = k_recv();
wdenk8bde7f72003-06-27 21:31:46 +0000523
524 /*
525 * Gather any trailing characters (for instance, the ^D which
526 * is sent by 'cu' after sending a file), and give the
527 * box some time (100 * 1 ms)
528 */
529 for (i=0; i<100; ++i) {
wdenk232c1502004-03-12 00:14:09 +0000530 if (tstc()) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200531 getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000532 }
533 udelay(1000);
534 }
535
Kim Phillips088f1b12012-10-29 13:34:31 +0000536 flush_cache(offset, size);
wdenk8bde7f72003-06-27 21:31:46 +0000537
538 printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
Simon Glass018f5302017-08-03 12:22:10 -0600539 env_set_hex("filesize", size);
wdenk8bde7f72003-06-27 21:31:46 +0000540
541 return offset;
542}
543
Kim Phillips088f1b12012-10-29 13:34:31 +0000544static void send_pad(void)
wdenk8bde7f72003-06-27 21:31:46 +0000545{
546 int count = his_pad_count;
547
548 while (count-- > 0)
Kim Phillips088f1b12012-10-29 13:34:31 +0000549 putc(his_pad_char);
wdenk8bde7f72003-06-27 21:31:46 +0000550}
551
552/* converts escaped kermit char to binary char */
Kim Phillips088f1b12012-10-29 13:34:31 +0000553static char ktrans(char in)
wdenk8bde7f72003-06-27 21:31:46 +0000554{
555 if ((in & 0x60) == 0x40) {
556 return (char) (in & ~0x40);
557 } else if ((in & 0x7f) == 0x3f) {
558 return (char) (in | 0x40);
559 } else
560 return in;
561}
562
Kim Phillips088f1b12012-10-29 13:34:31 +0000563static int chk1(char *buffer)
wdenk8bde7f72003-06-27 21:31:46 +0000564{
565 int total = 0;
566
567 while (*buffer) {
568 total += *buffer++;
569 }
570 return (int) ((total + ((total >> 6) & 0x03)) & 0x3f);
571}
572
Kim Phillips088f1b12012-10-29 13:34:31 +0000573static void s1_sendpacket(char *packet)
wdenk8bde7f72003-06-27 21:31:46 +0000574{
Kim Phillips088f1b12012-10-29 13:34:31 +0000575 send_pad();
wdenk8bde7f72003-06-27 21:31:46 +0000576 while (*packet) {
Kim Phillips088f1b12012-10-29 13:34:31 +0000577 putc(*packet++);
wdenk8bde7f72003-06-27 21:31:46 +0000578 }
579}
580
581static char a_b[24];
Kim Phillips088f1b12012-10-29 13:34:31 +0000582static void send_ack(int n)
wdenk8bde7f72003-06-27 21:31:46 +0000583{
584 a_b[0] = START_CHAR;
Kim Phillips088f1b12012-10-29 13:34:31 +0000585 a_b[1] = tochar(3);
586 a_b[2] = tochar(n);
wdenk8bde7f72003-06-27 21:31:46 +0000587 a_b[3] = ACK_TYPE;
588 a_b[4] = '\0';
Kim Phillips088f1b12012-10-29 13:34:31 +0000589 a_b[4] = tochar(chk1(&a_b[1]));
wdenk8bde7f72003-06-27 21:31:46 +0000590 a_b[5] = his_eol;
591 a_b[6] = '\0';
Kim Phillips088f1b12012-10-29 13:34:31 +0000592 s1_sendpacket(a_b);
wdenk8bde7f72003-06-27 21:31:46 +0000593}
594
Kim Phillips088f1b12012-10-29 13:34:31 +0000595static void send_nack(int n)
wdenk8bde7f72003-06-27 21:31:46 +0000596{
597 a_b[0] = START_CHAR;
Kim Phillips088f1b12012-10-29 13:34:31 +0000598 a_b[1] = tochar(3);
599 a_b[2] = tochar(n);
wdenk8bde7f72003-06-27 21:31:46 +0000600 a_b[3] = NACK_TYPE;
601 a_b[4] = '\0';
Kim Phillips088f1b12012-10-29 13:34:31 +0000602 a_b[4] = tochar(chk1(&a_b[1]));
wdenk8bde7f72003-06-27 21:31:46 +0000603 a_b[5] = his_eol;
604 a_b[6] = '\0';
Kim Phillips088f1b12012-10-29 13:34:31 +0000605 s1_sendpacket(a_b);
wdenk8bde7f72003-06-27 21:31:46 +0000606}
607
608
Kim Phillips088f1b12012-10-29 13:34:31 +0000609static void (*os_data_init)(void);
610static void (*os_data_char)(char new_char);
wdenk8bde7f72003-06-27 21:31:46 +0000611static int os_data_state, os_data_state_saved;
wdenk8bde7f72003-06-27 21:31:46 +0000612static char *os_data_addr, *os_data_addr_saved;
613static char *bin_start_address;
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530614
Kim Phillips088f1b12012-10-29 13:34:31 +0000615static void bin_data_init(void)
wdenk8bde7f72003-06-27 21:31:46 +0000616{
617 os_data_state = 0;
wdenk8bde7f72003-06-27 21:31:46 +0000618 os_data_addr = bin_start_address;
619}
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530620
Kim Phillips088f1b12012-10-29 13:34:31 +0000621static void os_data_save(void)
wdenk8bde7f72003-06-27 21:31:46 +0000622{
623 os_data_state_saved = os_data_state;
wdenk8bde7f72003-06-27 21:31:46 +0000624 os_data_addr_saved = os_data_addr;
625}
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530626
Kim Phillips088f1b12012-10-29 13:34:31 +0000627static void os_data_restore(void)
wdenk8bde7f72003-06-27 21:31:46 +0000628{
629 os_data_state = os_data_state_saved;
wdenk8bde7f72003-06-27 21:31:46 +0000630 os_data_addr = os_data_addr_saved;
631}
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530632
Kim Phillips088f1b12012-10-29 13:34:31 +0000633static void bin_data_char(char new_char)
wdenk8bde7f72003-06-27 21:31:46 +0000634{
635 switch (os_data_state) {
636 case 0: /* data */
637 *os_data_addr++ = new_char;
wdenk8bde7f72003-06-27 21:31:46 +0000638 break;
639 }
640}
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530641
Kim Phillips088f1b12012-10-29 13:34:31 +0000642static void set_kerm_bin_mode(unsigned long *addr)
wdenk8bde7f72003-06-27 21:31:46 +0000643{
644 bin_start_address = (char *) addr;
645 os_data_init = bin_data_init;
646 os_data_char = bin_data_char;
647}
648
649
650/* k_data_* simply handles the kermit escape translations */
651static int k_data_escape, k_data_escape_saved;
Kim Phillips088f1b12012-10-29 13:34:31 +0000652static void k_data_init(void)
wdenk8bde7f72003-06-27 21:31:46 +0000653{
654 k_data_escape = 0;
Kim Phillips088f1b12012-10-29 13:34:31 +0000655 os_data_init();
wdenk8bde7f72003-06-27 21:31:46 +0000656}
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530657
Kim Phillips088f1b12012-10-29 13:34:31 +0000658static void k_data_save(void)
wdenk8bde7f72003-06-27 21:31:46 +0000659{
660 k_data_escape_saved = k_data_escape;
Kim Phillips088f1b12012-10-29 13:34:31 +0000661 os_data_save();
wdenk8bde7f72003-06-27 21:31:46 +0000662}
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530663
Kim Phillips088f1b12012-10-29 13:34:31 +0000664static void k_data_restore(void)
wdenk8bde7f72003-06-27 21:31:46 +0000665{
666 k_data_escape = k_data_escape_saved;
Kim Phillips088f1b12012-10-29 13:34:31 +0000667 os_data_restore();
wdenk8bde7f72003-06-27 21:31:46 +0000668}
Gururaja Hebbar K Ra9fe0c32008-08-07 13:13:27 +0530669
Kim Phillips088f1b12012-10-29 13:34:31 +0000670static void k_data_char(char new_char)
wdenk8bde7f72003-06-27 21:31:46 +0000671{
672 if (k_data_escape) {
673 /* last char was escape - translate this character */
Kim Phillips088f1b12012-10-29 13:34:31 +0000674 os_data_char(ktrans(new_char));
wdenk8bde7f72003-06-27 21:31:46 +0000675 k_data_escape = 0;
676 } else {
677 if (new_char == his_quote) {
678 /* this char is escape - remember */
679 k_data_escape = 1;
680 } else {
681 /* otherwise send this char as-is */
Kim Phillips088f1b12012-10-29 13:34:31 +0000682 os_data_char(new_char);
wdenk8bde7f72003-06-27 21:31:46 +0000683 }
684 }
685}
686
687#define SEND_DATA_SIZE 20
Kim Phillips088f1b12012-10-29 13:34:31 +0000688static char send_parms[SEND_DATA_SIZE];
689static char *send_ptr;
wdenk8bde7f72003-06-27 21:31:46 +0000690
691/* handle_send_packet interprits the protocol info and builds and
692 sends an appropriate ack for what we can do */
Kim Phillips088f1b12012-10-29 13:34:31 +0000693static void handle_send_packet(int n)
wdenk8bde7f72003-06-27 21:31:46 +0000694{
695 int length = 3;
696 int bytes;
697
698 /* initialize some protocol parameters */
699 his_eol = END_CHAR; /* default end of line character */
700 his_pad_count = 0;
701 his_pad_char = '\0';
702 his_quote = K_ESCAPE;
703
704 /* ignore last character if it filled the buffer */
705 if (send_ptr == &send_parms[SEND_DATA_SIZE - 1])
706 --send_ptr;
707 bytes = send_ptr - send_parms; /* how many bytes we'll process */
708 do {
709 if (bytes-- <= 0)
710 break;
711 /* handle MAXL - max length */
712 /* ignore what he says - most I'll take (here) is 94 */
Kim Phillips088f1b12012-10-29 13:34:31 +0000713 a_b[++length] = tochar(94);
wdenk8bde7f72003-06-27 21:31:46 +0000714 if (bytes-- <= 0)
715 break;
716 /* handle TIME - time you should wait for my packets */
717 /* ignore what he says - don't wait for my ack longer than 1 second */
Kim Phillips088f1b12012-10-29 13:34:31 +0000718 a_b[++length] = tochar(1);
wdenk8bde7f72003-06-27 21:31:46 +0000719 if (bytes-- <= 0)
720 break;
721 /* handle NPAD - number of pad chars I need */
722 /* remember what he says - I need none */
Kim Phillips088f1b12012-10-29 13:34:31 +0000723 his_pad_count = untochar(send_parms[2]);
724 a_b[++length] = tochar(0);
wdenk8bde7f72003-06-27 21:31:46 +0000725 if (bytes-- <= 0)
726 break;
727 /* handle PADC - pad chars I need */
728 /* remember what he says - I need none */
Kim Phillips088f1b12012-10-29 13:34:31 +0000729 his_pad_char = ktrans(send_parms[3]);
wdenk8bde7f72003-06-27 21:31:46 +0000730 a_b[++length] = 0x40; /* He should ignore this */
731 if (bytes-- <= 0)
732 break;
733 /* handle EOL - end of line he needs */
734 /* remember what he says - I need CR */
Kim Phillips088f1b12012-10-29 13:34:31 +0000735 his_eol = untochar(send_parms[4]);
736 a_b[++length] = tochar(END_CHAR);
wdenk8bde7f72003-06-27 21:31:46 +0000737 if (bytes-- <= 0)
738 break;
739 /* handle QCTL - quote control char he'll use */
740 /* remember what he says - I'll use '#' */
741 his_quote = send_parms[5];
742 a_b[++length] = '#';
743 if (bytes-- <= 0)
744 break;
745 /* handle QBIN - 8-th bit prefixing */
746 /* ignore what he says - I refuse */
747 a_b[++length] = 'N';
748 if (bytes-- <= 0)
749 break;
750 /* handle CHKT - the clock check type */
751 /* ignore what he says - I do type 1 (for now) */
752 a_b[++length] = '1';
753 if (bytes-- <= 0)
754 break;
755 /* handle REPT - the repeat prefix */
756 /* ignore what he says - I refuse (for now) */
757 a_b[++length] = 'N';
758 if (bytes-- <= 0)
759 break;
760 /* handle CAPAS - the capabilities mask */
761 /* ignore what he says - I only do long packets - I don't do windows */
Kim Phillips088f1b12012-10-29 13:34:31 +0000762 a_b[++length] = tochar(2); /* only long packets */
763 a_b[++length] = tochar(0); /* no windows */
764 a_b[++length] = tochar(94); /* large packet msb */
765 a_b[++length] = tochar(94); /* large packet lsb */
wdenk8bde7f72003-06-27 21:31:46 +0000766 } while (0);
767
768 a_b[0] = START_CHAR;
Kim Phillips088f1b12012-10-29 13:34:31 +0000769 a_b[1] = tochar(length);
770 a_b[2] = tochar(n);
wdenk8bde7f72003-06-27 21:31:46 +0000771 a_b[3] = ACK_TYPE;
772 a_b[++length] = '\0';
Kim Phillips088f1b12012-10-29 13:34:31 +0000773 a_b[length] = tochar(chk1(&a_b[1]));
wdenk8bde7f72003-06-27 21:31:46 +0000774 a_b[++length] = his_eol;
775 a_b[++length] = '\0';
Kim Phillips088f1b12012-10-29 13:34:31 +0000776 s1_sendpacket(a_b);
wdenk8bde7f72003-06-27 21:31:46 +0000777}
778
779/* k_recv receives a OS Open image file over kermit line */
Kim Phillips088f1b12012-10-29 13:34:31 +0000780static int k_recv(void)
wdenk8bde7f72003-06-27 21:31:46 +0000781{
782 char new_char;
783 char k_state, k_state_saved;
784 int sum;
785 int done;
786 int length;
787 int n, last_n;
wdenk8bde7f72003-06-27 21:31:46 +0000788 int len_lo, len_hi;
789
790 /* initialize some protocol parameters */
791 his_eol = END_CHAR; /* default end of line character */
792 his_pad_count = 0;
793 his_pad_char = '\0';
794 his_quote = K_ESCAPE;
795
796 /* initialize the k_recv and k_data state machine */
797 done = 0;
798 k_state = 0;
Kim Phillips088f1b12012-10-29 13:34:31 +0000799 k_data_init();
wdenk8bde7f72003-06-27 21:31:46 +0000800 k_state_saved = k_state;
Kim Phillips088f1b12012-10-29 13:34:31 +0000801 k_data_save();
wdenk8bde7f72003-06-27 21:31:46 +0000802 n = 0; /* just to get rid of a warning */
803 last_n = -1;
804
805 /* expect this "type" sequence (but don't check):
806 S: send initiate
807 F: file header
808 D: data (multiple)
809 Z: end of file
810 B: break transmission
811 */
812
813 /* enter main loop */
814 while (!done) {
815 /* set the send packet pointer to begining of send packet parms */
816 send_ptr = send_parms;
817
818 /* With each packet, start summing the bytes starting with the length.
819 Save the current sequence number.
820 Note the type of the packet.
821 If a character less than SPACE (0x20) is received - error.
822 */
823
824#if 0
825 /* OLD CODE, Prior to checking sequence numbers */
826 /* first have all state machines save current states */
827 k_state_saved = k_state;
828 k_data_save ();
829#endif
830
831 /* get a packet */
832 /* wait for the starting character or ^C */
833 for (;;) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200834 switch (getchar()) {
wdenk8bde7f72003-06-27 21:31:46 +0000835 case START_CHAR: /* start packet */
836 goto START;
837 case ETX_CHAR: /* ^C waiting for packet */
838 return (0);
839 default:
840 ;
841 }
842 }
843START:
844 /* get length of packet */
845 sum = 0;
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200846 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000847 if ((new_char & 0xE0) == 0)
848 goto packet_error;
849 sum += new_char & 0xff;
Kim Phillips088f1b12012-10-29 13:34:31 +0000850 length = untochar(new_char);
wdenk8bde7f72003-06-27 21:31:46 +0000851 /* get sequence number */
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200852 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000853 if ((new_char & 0xE0) == 0)
854 goto packet_error;
855 sum += new_char & 0xff;
Kim Phillips088f1b12012-10-29 13:34:31 +0000856 n = untochar(new_char);
wdenk8bde7f72003-06-27 21:31:46 +0000857 --length;
858
859 /* NEW CODE - check sequence numbers for retried packets */
860 /* Note - this new code assumes that the sequence number is correctly
861 * received. Handling an invalid sequence number adds another layer
862 * of complexity that may not be needed - yet! At this time, I'm hoping
863 * that I don't need to buffer the incoming data packets and can write
864 * the data into memory in real time.
865 */
866 if (n == last_n) {
867 /* same sequence number, restore the previous state */
868 k_state = k_state_saved;
Kim Phillips088f1b12012-10-29 13:34:31 +0000869 k_data_restore();
wdenk8bde7f72003-06-27 21:31:46 +0000870 } else {
871 /* new sequence number, checkpoint the download */
872 last_n = n;
873 k_state_saved = k_state;
Kim Phillips088f1b12012-10-29 13:34:31 +0000874 k_data_save();
wdenk8bde7f72003-06-27 21:31:46 +0000875 }
876 /* END NEW CODE */
877
878 /* get packet type */
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200879 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000880 if ((new_char & 0xE0) == 0)
881 goto packet_error;
882 sum += new_char & 0xff;
883 k_state = new_char;
884 --length;
885 /* check for extended length */
886 if (length == -2) {
887 /* (length byte was 0, decremented twice) */
888 /* get the two length bytes */
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200889 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000890 if ((new_char & 0xE0) == 0)
891 goto packet_error;
892 sum += new_char & 0xff;
Kim Phillips088f1b12012-10-29 13:34:31 +0000893 len_hi = untochar(new_char);
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200894 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000895 if ((new_char & 0xE0) == 0)
896 goto packet_error;
897 sum += new_char & 0xff;
Kim Phillips088f1b12012-10-29 13:34:31 +0000898 len_lo = untochar(new_char);
wdenk8bde7f72003-06-27 21:31:46 +0000899 length = len_hi * 95 + len_lo;
900 /* check header checksum */
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200901 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000902 if ((new_char & 0xE0) == 0)
903 goto packet_error;
Kim Phillips088f1b12012-10-29 13:34:31 +0000904 if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
wdenk8bde7f72003-06-27 21:31:46 +0000905 goto packet_error;
906 sum += new_char & 0xff;
907/* --length; */ /* new length includes only data and block check to come */
908 }
909 /* bring in rest of packet */
910 while (length > 1) {
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200911 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000912 if ((new_char & 0xE0) == 0)
913 goto packet_error;
914 sum += new_char & 0xff;
915 --length;
916 if (k_state == DATA_TYPE) {
917 /* pass on the data if this is a data packet */
918 k_data_char (new_char);
919 } else if (k_state == SEND_TYPE) {
920 /* save send pack in buffer as is */
921 *send_ptr++ = new_char;
922 /* if too much data, back off the pointer */
923 if (send_ptr >= &send_parms[SEND_DATA_SIZE])
924 --send_ptr;
925 }
926 }
927 /* get and validate checksum character */
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200928 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000929 if ((new_char & 0xE0) == 0)
930 goto packet_error;
Kim Phillips088f1b12012-10-29 13:34:31 +0000931 if (new_char != tochar((sum + ((sum >> 6) & 0x03)) & 0x3f))
wdenk8bde7f72003-06-27 21:31:46 +0000932 goto packet_error;
933 /* get END_CHAR */
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200934 new_char = getchar();
wdenk8bde7f72003-06-27 21:31:46 +0000935 if (new_char != END_CHAR) {
936 packet_error:
937 /* restore state machines */
938 k_state = k_state_saved;
Kim Phillips088f1b12012-10-29 13:34:31 +0000939 k_data_restore();
wdenk8bde7f72003-06-27 21:31:46 +0000940 /* send a negative acknowledge packet in */
Kim Phillips088f1b12012-10-29 13:34:31 +0000941 send_nack(n);
wdenk8bde7f72003-06-27 21:31:46 +0000942 } else if (k_state == SEND_TYPE) {
943 /* crack the protocol parms, build an appropriate ack packet */
Kim Phillips088f1b12012-10-29 13:34:31 +0000944 handle_send_packet(n);
wdenk8bde7f72003-06-27 21:31:46 +0000945 } else {
946 /* send simple acknowledge packet in */
Kim Phillips088f1b12012-10-29 13:34:31 +0000947 send_ack(n);
wdenk8bde7f72003-06-27 21:31:46 +0000948 /* quit if end of transmission */
949 if (k_state == BREAK_TYPE)
950 done = 1;
951 }
wdenk8bde7f72003-06-27 21:31:46 +0000952 }
953 return ((ulong) os_data_addr - (ulong) bin_start_address);
954}
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200955
956static int getcxmodem(void) {
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200957 if (tstc())
Heinrich Schuchardtc670aee2020-10-07 18:11:48 +0200958 return (getchar());
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200959 return -1;
960}
Angus Ainslie6e66bd52013-06-26 16:54:24 -0600961static ulong load_serial_ymodem(ulong offset, int mode)
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200962{
963 int size;
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200964 int err;
965 int res;
966 connection_info_t info;
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200967 char ymodemBuf[1024];
968 ulong store_addr = ~0;
969 ulong addr = 0;
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200970
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200971 size = 0;
Angus Ainslie6e66bd52013-06-26 16:54:24 -0600972 info.mode = mode;
Kim Phillips088f1b12012-10-29 13:34:31 +0000973 res = xyzModem_stream_open(&info, &err);
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200974 if (!res) {
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200975
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200976 while ((res =
Kim Phillips088f1b12012-10-29 13:34:31 +0000977 xyzModem_stream_read(ymodemBuf, 1024, &err)) > 0) {
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200978 store_addr = addr + offset;
979 size += res;
980 addr += res;
Masahiro Yamadae856bdc2017-02-11 22:43:54 +0900981#ifdef CONFIG_MTD_NOR_FLASH
Kim Phillips088f1b12012-10-29 13:34:31 +0000982 if (addr2info(store_addr)) {
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200983 int rc;
984
Kim Phillips088f1b12012-10-29 13:34:31 +0000985 rc = flash_write((char *) ymodemBuf,
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200986 store_addr, res);
987 if (rc != 0) {
Simon Glass0ee482522019-12-28 10:44:40 -0700988 flash_perror(rc);
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200989 return (~0);
990 }
991 } else
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +0200992#endif
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200993 {
Kim Phillips088f1b12012-10-29 13:34:31 +0000994 memcpy((char *)(store_addr), ymodemBuf,
Wolfgang Denkcf48eb92006-04-16 10:51:58 +0200995 res);
996 }
997
998 }
999 } else {
Kim Phillips088f1b12012-10-29 13:34:31 +00001000 printf("%s\n", xyzModem_error(err));
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001001 }
Wolfgang Denkcf48eb92006-04-16 10:51:58 +02001002
Kim Phillips088f1b12012-10-29 13:34:31 +00001003 xyzModem_stream_close(&err);
1004 xyzModem_stream_terminate(false, &getcxmodem);
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001005
1006
Chris Packham0a6036d2016-10-25 20:22:48 +13001007 flush_cache(offset, ALIGN(size, ARCH_DMA_MINALIGN));
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001008
Kim Phillips088f1b12012-10-29 13:34:31 +00001009 printf("## Total Size = 0x%08x = %d Bytes\n", size, size);
Simon Glass018f5302017-08-03 12:22:10 -06001010 env_set_hex("filesize", size);
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001011
1012 return offset;
1013}
1014
Jon Loeliger90253172007-07-10 11:02:44 -05001015#endif
wdenk8bde7f72003-06-27 21:31:46 +00001016
1017/* -------------------------------------------------------------------- */
1018
Jon Loeligerc76fe472007-07-08 18:02:23 -05001019#if defined(CONFIG_CMD_LOADS)
wdenk8bde7f72003-06-27 21:31:46 +00001020
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001021#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk0d498392003-07-01 21:06:45 +00001022U_BOOT_CMD(
1023 loads, 3, 0, do_load_serial,
Peter Tyser2fb26042009-01-27 18:03:12 -06001024 "load S-Record file over serial line",
wdenk8bde7f72003-06-27 21:31:46 +00001025 "[ off ] [ baud ]\n"
1026 " - load S-Record file over serial line"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001027 " with offset 'off' and baudrate 'baud'"
wdenk8bde7f72003-06-27 21:31:46 +00001028);
1029
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001030#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
wdenk0d498392003-07-01 21:06:45 +00001031U_BOOT_CMD(
1032 loads, 2, 0, do_load_serial,
Peter Tyser2fb26042009-01-27 18:03:12 -06001033 "load S-Record file over serial line",
wdenk8bde7f72003-06-27 21:31:46 +00001034 "[ off ]\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001035 " - load S-Record file over serial line with offset 'off'"
wdenk8bde7f72003-06-27 21:31:46 +00001036);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001037#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
wdenk8bde7f72003-06-27 21:31:46 +00001038
1039/*
1040 * SAVES always requires LOADS support, but not vice versa
1041 */
1042
1043
Jon Loeligerc76fe472007-07-08 18:02:23 -05001044#if defined(CONFIG_CMD_SAVES)
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001045#ifdef CONFIG_SYS_LOADS_BAUD_CHANGE
wdenk0d498392003-07-01 21:06:45 +00001046U_BOOT_CMD(
1047 saves, 4, 0, do_save_serial,
Peter Tyser2fb26042009-01-27 18:03:12 -06001048 "save S-Record file over serial line",
wdenk8bde7f72003-06-27 21:31:46 +00001049 "[ off ] [size] [ baud ]\n"
1050 " - save S-Record file over serial line"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001051 " with offset 'off', size 'size' and baudrate 'baud'"
wdenk8bde7f72003-06-27 21:31:46 +00001052);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001053#else /* ! CONFIG_SYS_LOADS_BAUD_CHANGE */
wdenk0d498392003-07-01 21:06:45 +00001054U_BOOT_CMD(
1055 saves, 3, 0, do_save_serial,
Peter Tyser2fb26042009-01-27 18:03:12 -06001056 "save S-Record file over serial line",
wdenk8bde7f72003-06-27 21:31:46 +00001057 "[ off ] [size]\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001058 " - save S-Record file over serial line with offset 'off' and size 'size'"
wdenk8bde7f72003-06-27 21:31:46 +00001059);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001060#endif /* CONFIG_SYS_LOADS_BAUD_CHANGE */
Robert P. J. Day70d7cb92013-02-03 05:46:13 +00001061#endif /* CONFIG_CMD_SAVES */
1062#endif /* CONFIG_CMD_LOADS */
wdenk8bde7f72003-06-27 21:31:46 +00001063
1064
Jon Loeligerc76fe472007-07-08 18:02:23 -05001065#if defined(CONFIG_CMD_LOADB)
wdenk0d498392003-07-01 21:06:45 +00001066U_BOOT_CMD(
1067 loadb, 3, 0, do_load_serial_bin,
Peter Tyser2fb26042009-01-27 18:03:12 -06001068 "load binary file over serial line (kermit mode)",
wdenk8bde7f72003-06-27 21:31:46 +00001069 "[ off ] [ baud ]\n"
1070 " - load binary file over serial line"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001071 " with offset 'off' and baudrate 'baud'"
wdenk8bde7f72003-06-27 21:31:46 +00001072);
1073
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001074U_BOOT_CMD(
Angus Ainslie6e66bd52013-06-26 16:54:24 -06001075 loadx, 3, 0, do_load_serial_bin,
1076 "load binary file over serial line (xmodem mode)",
1077 "[ off ] [ baud ]\n"
1078 " - load binary file over serial line"
1079 " with offset 'off' and baudrate 'baud'"
1080);
1081
1082U_BOOT_CMD(
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001083 loady, 3, 0, do_load_serial_bin,
Peter Tyser2fb26042009-01-27 18:03:12 -06001084 "load binary file over serial line (ymodem mode)",
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001085 "[ off ] [ baud ]\n"
1086 " - load binary file over serial line"
Wolfgang Denka89c33d2009-05-24 17:06:54 +02001087 " with offset 'off' and baudrate 'baud'"
Markus Klotzbuecherf2841d32006-03-30 13:40:55 +02001088);
1089
Robert P. J. Day70d7cb92013-02-03 05:46:13 +00001090#endif /* CONFIG_CMD_LOADB */