]> Git Repo - J-u-boot.git/blame - tools/kwboot.c
projects / J-u-boot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
tools: kwboot: Disable non-blocking mode
[J-u-boot.git] / tools / kwboot.c
CommitLineData
d131ad68 1/*
84899e2d
SR		 2 * Boot a Marvell SoC, with Xmodem over UART0.
3 * supports Kirkwood, Dove, Armada 370, Armada XP
d131ad68
LP		 4 *
5 * (c) 2012 Daniel Stodden <[email protected]>
6 *
7 * References: marvell.com, "88F6180, 88F6190, 88F6192, and 88F6281
8 * Integrated Controller: Functional Specifications" December 2,
9 * 2008. Chapter 24.2 "BootROM Firmware".
10 */
11
f4db6c97
SR		 12#include "kwbimage.h"
13#include "mkimage.h"
a050a862 14#include "version.h"
f4db6c97 15
d131ad68
LP		 16#include <stdlib.h>
17#include <stdio.h>
18#include <string.h>
19#include <stdarg.h>
f4db6c97 20#include <image.h>
d131ad68
LP		 21#include <libgen.h>
22#include <fcntl.h>
23#include <errno.h>
24#include <unistd.h>
25#include <stdint.h>
12df7b79 26#include <time.h>
d131ad68
LP		 27#include <sys/stat.h>
28
93b55636
T		 29#ifdef __linux__
30#include "termios_linux.h"
31#else
32#include <termios.h>
33#endif
34
d131ad68
LP		 35/*
36 * Marvell BootROM UART Sensing
37 */
38
39static unsigned char kwboot_msg_boot[] = {
40 0xBB, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
41};
42
84899e2d
SR		 43static unsigned char kwboot_msg_debug[] = {
44 0xDD, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
45};
46
47/* Defines known to work on Kirkwood */
d131ad68
LP		 48#define KWBOOT_MSG_REQ_DELAY 10 /* ms */
49#define KWBOOT_MSG_RSP_TIMEO 50 /* ms */
50
84899e2d
SR		 51/* Defines known to work on Armada XP */
52#define KWBOOT_MSG_REQ_DELAY_AXP 1000 /* ms */
53#define KWBOOT_MSG_RSP_TIMEO_AXP 1000 /* ms */
54
d131ad68
LP		 55/*
56 * Xmodem Transfers
57 */
58
59#define SOH 1 /* sender start of block header */
60#define EOT 4 /* sender end of block transfer */
61#define ACK 6 /* target block ack */
62#define NAK 21 /* target block negative ack */
63#define CAN 24 /* target/sender transfer cancellation */
64
2ef87f75
T		 65#define KWBOOT_XM_BLKSZ 128 /* xmodem block size */
66
d131ad68
LP		 67struct kwboot_block {
68 uint8_t soh;
69 uint8_t pnum;
70 uint8_t _pnum;
2ef87f75 71 uint8_t data[KWBOOT_XM_BLKSZ];
d131ad68 72 uint8_t csum;
a107c61b 73} __packed;
d131ad68
LP		 74
75#define KWBOOT_BLK_RSP_TIMEO 1000 /* ms */
12df7b79 76#define KWBOOT_HDR_RSP_TIMEO 10000 /* ms */
d131ad68 77
ca272041
T		 78/* ARM code making baudrate changing function return to original exec address */
79static unsigned char kwboot_pre_baud_code[] = {
80 /* exec_addr: */
81 0x00, 0x00, 0x00, 0x00, /* .word 0 */
82 0x0c, 0xe0, 0x1f, 0xe5, /* ldr lr, exec_addr */
83};
84
85/* ARM code for binary header injection to change baudrate */
86static unsigned char kwboot_baud_code[] = {
87 /* ; #define UART_BASE 0xd0012000 */
88 /* ; #define THR 0x00 */
89 /* ; #define DLL 0x00 */
90 /* ; #define DLH 0x04 */
91 /* ; #define LCR 0x0c */
92 /* ; #define DLAB 0x80 */
93 /* ; #define LSR 0x14 */
94 /* ; #define THRE 0x20 */
95 /* ; #define TEMT 0x40 */
96 /* ; #define DIV_ROUND(a, b) ((a + b/2) / b) */
97 /* ; */
98 /* ; u32 set_baudrate(u32 old_b, u32 new_b) { */
99 /* ; const u8 *str = "$baudratechange"; */
100 /* ; u8 c; */
101 /* ; do { */
102 /* ; c = *str++; */
103 /* ; writel(UART_BASE + THR, c); */
104 /* ; } while (c); */
105 /* ; while */
106 /* ; (!(readl(UART_BASE + LSR) & TEMT)); */
107 /* ; u32 lcr = readl(UART_BASE + LCR); */
108 /* ; writel(UART_BASE + LCR, lcr | DLAB); */
109 /* ; u8 old_dll = readl(UART_BASE + DLL); */
110 /* ; u8 old_dlh = readl(UART_BASE + DLH); */
111 /* ; u16 old_dl = old_dll | (old_dlh << 8); */
112 /* ; u32 clk = old_b * old_dl; */
113 /* ; u16 new_dl = DIV_ROUND(clk, new_b); */
114 /* ; u8 new_dll = new_dl & 0xff; */
115 /* ; u8 new_dlh = (new_dl >> 8) & 0xff; */
116 /* ; writel(UART_BASE + DLL, new_dll); */
117 /* ; writel(UART_BASE + DLH, new_dlh); */
118 /* ; writel(UART_BASE + LCR, lcr & ~DLAB); */
119 /* ; msleep(1); */
120 /* ; return 0; */
121 /* ; } */
122
123 0xfe, 0x5f, 0x2d, 0xe9, /* push { r1 - r12, lr } */
124
125 /* ; r0 = UART_BASE */
126 0x02, 0x0a, 0xa0, 0xe3, /* mov r0, #0x2000 */
127 0x01, 0x00, 0x4d, 0xe3, /* movt r0, #0xd001 */
128
129 /* ; r2 = address of preamble string */
130 0xd0, 0x20, 0x8f, 0xe2, /* adr r2, preamble */
131
132 /* ; Send preamble string over UART */
133 /* .Lloop_preamble: */
134 /* */
135 /* ; Wait until Transmitter Holding is Empty */
136 /* .Lloop_thre: */
137 /* ; r1 = UART_BASE[LSR] & THRE */
138 0x14, 0x10, 0x90, 0xe5, /* ldr r1, [r0, #0x14] */
139 0x20, 0x00, 0x11, 0xe3, /* tst r1, #0x20 */
140 0xfc, 0xff, 0xff, 0x0a, /* beq .Lloop_thre */
141
142 /* ; Put character into Transmitter FIFO */
143 /* ; r1 = *r2++ */
144 0x01, 0x10, 0xd2, 0xe4, /* ldrb r1, [r2], #1 */
145 /* ; UART_BASE[THR] = r1 */
146 0x00, 0x10, 0x80, 0xe5, /* str r1, [r0, #0x0] */
147
148 /* ; Loop until end of preamble string */
149 0x00, 0x00, 0x51, 0xe3, /* cmp r1, #0 */
150 0xf8, 0xff, 0xff, 0x1a, /* bne .Lloop_preamble */
151
152 /* ; Wait until Transmitter FIFO is Empty */
153 /* .Lloop_txempty: */
154 /* ; r1 = UART_BASE[LSR] & TEMT */
155 0x14, 0x10, 0x90, 0xe5, /* ldr r1, [r0, #0x14] */
156 0x40, 0x00, 0x11, 0xe3, /* tst r1, #0x40 */
157 0xfc, 0xff, 0xff, 0x0a, /* beq .Lloop_txempty */
158
159 /* ; Set Divisor Latch Access Bit */
160 /* ; UART_BASE[LCR] |= DLAB */
161 0x0c, 0x10, 0x90, 0xe5, /* ldr r1, [r0, #0x0c] */
162 0x80, 0x10, 0x81, 0xe3, /* orr r1, r1, #0x80 */
163 0x0c, 0x10, 0x80, 0xe5, /* str r1, [r0, #0x0c] */
164
165 /* ; Read current Divisor Latch */
166 /* ; r1 = UART_BASE[DLH]<<8 | UART_BASE[DLL] */
167 0x00, 0x10, 0x90, 0xe5, /* ldr r1, [r0, #0x00] */
168 0xff, 0x10, 0x01, 0xe2, /* and r1, r1, #0xff */
169 0x01, 0x20, 0xa0, 0xe1, /* mov r2, r1 */
170 0x04, 0x10, 0x90, 0xe5, /* ldr r1, [r0, #0x04] */
171 0xff, 0x10, 0x01, 0xe2, /* and r1, r1, #0xff */
172 0x41, 0x14, 0xa0, 0xe1, /* asr r1, r1, #8 */
173 0x02, 0x10, 0x81, 0xe1, /* orr r1, r1, r2 */
174
175 /* ; Read old baudrate value */
176 /* ; r2 = old_baudrate */
177 0x8c, 0x20, 0x9f, 0xe5, /* ldr r2, old_baudrate */
178
179 /* ; Calculate base clock */
180 /* ; r1 = r2 * r1 */
181 0x92, 0x01, 0x01, 0xe0, /* mul r1, r2, r1 */
182
183 /* ; Read new baudrate value */
184 /* ; r2 = baudrate */
185 0x88, 0x20, 0x9f, 0xe5, /* ldr r2, baudrate */
186
187 /* ; Calculate new Divisor Latch */
188 /* ; r1 = DIV_ROUND(r1, r2) = */
189 /* ; = (r1 + r2/2) / r2 */
190 0xa2, 0x10, 0x81, 0xe0, /* add r1, r1, r2, lsr #1 */
191 0x02, 0x40, 0xa0, 0xe1, /* mov r4, r2 */
192 0xa1, 0x00, 0x54, 0xe1, /* cmp r4, r1, lsr #1 */
193 /* .Lloop_div1: */
194 0x84, 0x40, 0xa0, 0x91, /* movls r4, r4, lsl #1 */
195 0xa1, 0x00, 0x54, 0xe1, /* cmp r4, r1, lsr #1 */
196 0xfc, 0xff, 0xff, 0x9a, /* bls .Lloop_div1 */
197 0x00, 0x30, 0xa0, 0xe3, /* mov r3, #0 */
198 /* .Lloop_div2: */
199 0x04, 0x00, 0x51, 0xe1, /* cmp r1, r4 */
200 0x04, 0x10, 0x41, 0x20, /* subhs r1, r1, r4 */
201 0x03, 0x30, 0xa3, 0xe0, /* adc r3, r3, r3 */
202 0xa4, 0x40, 0xa0, 0xe1, /* mov r4, r4, lsr #1 */
203 0x02, 0x00, 0x54, 0xe1, /* cmp r4, r2 */
204 0xf9, 0xff, 0xff, 0x2a, /* bhs .Lloop_div2 */
205 0x03, 0x10, 0xa0, 0xe1, /* mov r1, r3 */
206
207 /* ; Set new Divisor Latch Low */
208 /* ; UART_BASE[DLL] = r1 & 0xff */
209 0x01, 0x20, 0xa0, 0xe1, /* mov r2, r1 */
210 0xff, 0x20, 0x02, 0xe2, /* and r2, r2, #0xff */
211 0x00, 0x20, 0x80, 0xe5, /* str r2, [r0, #0x00] */
212
213 /* ; Set new Divisor Latch High */
214 /* ; UART_BASE[DLH] = r1>>8 & 0xff */
215 0x41, 0x24, 0xa0, 0xe1, /* asr r2, r1, #8 */
216 0xff, 0x20, 0x02, 0xe2, /* and r2, r2, #0xff */
217 0x04, 0x20, 0x80, 0xe5, /* str r2, [r0, #0x04] */
218
219 /* ; Clear Divisor Latch Access Bit */
220 /* ; UART_BASE[LCR] &= ~DLAB */
221 0x0c, 0x10, 0x90, 0xe5, /* ldr r1, [r0, #0x0c] */
222 0x80, 0x10, 0xc1, 0xe3, /* bic r1, r1, #0x80 */
223 0x0c, 0x10, 0x80, 0xe5, /* str r1, [r0, #0x0c] */
224
225 /* ; Sleep 1ms ~~ 600000 cycles at 1200 MHz */
226 /* ; r1 = 600000 */
227 0x9f, 0x1d, 0xa0, 0xe3, /* mov r1, #0x27c0 */
228 0x09, 0x10, 0x40, 0xe3, /* movt r1, #0x0009 */
229 /* .Lloop_sleep: */
230 0x01, 0x10, 0x41, 0xe2, /* sub r1, r1, #1 */
231 0x00, 0x00, 0x51, 0xe3, /* cmp r1, #0 */
232 0xfc, 0xff, 0xff, 0x1a, /* bne .Lloop_sleep */
233
234 /* ; Return 0 - no error */
235 0x00, 0x00, 0xa0, 0xe3, /* mov r0, #0 */
236 0xfe, 0x9f, 0xbd, 0xe8, /* pop { r1 - r12, pc } */
237
238 /* ; Preamble string */
239 /* preamble: */
240 0x24, 0x62, 0x61, 0x75, /* .asciz "$baudratechange" */
241 0x64, 0x72, 0x61, 0x74,
242 0x65, 0x63, 0x68, 0x61,
243 0x6e, 0x67, 0x65, 0x00,
244
245 /* ; Placeholder for old baudrate value */
246 /* old_baudrate: */
247 0x00, 0x00, 0x00, 0x00, /* .word 0 */
248
249 /* ; Placeholder for new baudrate value */
250 /* new_baudrate: */
251 0x00, 0x00, 0x00, 0x00, /* .word 0 */
252};
253
254#define KWBOOT_BAUDRATE_BIN_HEADER_SZ (sizeof(kwboot_baud_code) + \
255 sizeof(struct opt_hdr_v1) + 8)
256
257static const char kwb_baud_magic[16] = "$baudratechange";
258
d131ad68
LP		 259static int kwboot_verbose;
260
84899e2d
SR		 261static int msg_req_delay = KWBOOT_MSG_REQ_DELAY;
262static int msg_rsp_timeo = KWBOOT_MSG_RSP_TIMEO;
7497a6a1 263static int blk_rsp_timeo = KWBOOT_BLK_RSP_TIMEO;
84899e2d 264
e453bb42
MB		 265static ssize_t
266kwboot_write(int fd, const char *buf, size_t len)
267{
268 size_t tot = 0;
269
270 while (tot < len) {
271 ssize_t wr = write(fd, buf + tot, len - tot);
272
273 if (wr < 0)
274 return -1;
275
276 tot += wr;
277 }
278
279 return tot;
280}
281
d131ad68
LP		 282static void
283kwboot_printv(const char *fmt, ...)
284{
285 va_list ap;
286
287 if (kwboot_verbose) {
288 va_start(ap, fmt);
289 vprintf(fmt, ap);
290 va_end(ap);
291 fflush(stdout);
292 }
293}
294
295static void
296__spinner(void)
297{
298 const char seq[] = { '-', '\\', '|', '/' };
299 const int div = 8;
300 static int state, bs;
301
302 if (state % div == 0) {
303 fputc(bs, stdout);
304 fputc(seq[state / div % sizeof(seq)], stdout);
305 fflush(stdout);
306 }
307
308 bs = '\b';
309 state++;
310}
311
312static void
313kwboot_spinner(void)
314{
315 if (kwboot_verbose)
316 __spinner();
317}
318
319static void
320__progress(int pct, char c)
321{
322 const int width = 70;
323 static const char *nl = "";
324 static int pos;
325
326 if (pos % width == 0)
327 printf("%s%3d %% [", nl, pct);
328
329 fputc(c, stdout);
330
331 nl = "]\n";
5a1f8cbe 332 pos = (pos + 1) % width;
d131ad68
LP		 333
334 if (pct == 100) {
5a1f8cbe 335 while (pos && pos++ < width)
d131ad68
LP		 336 fputc(' ', stdout);
337 fputs(nl, stdout);
5a1f8cbe
T		 338 nl = "";
339 pos = 0;
d131ad68
LP		 340 }
341
342 fflush(stdout);
343
344}
345
346static void
347kwboot_progress(int _pct, char c)
348{
349 static int pct;
350
351 if (_pct != -1)
352 pct = _pct;
353
354 if (kwboot_verbose)
355 __progress(pct, c);
5a1f8cbe
T		 356
357 if (pct == 100)
358 pct = 0;
d131ad68
LP		 359}
360
361static int
362kwboot_tty_recv(int fd, void *buf, size_t len, int timeo)
363{
364 int rc, nfds;
365 fd_set rfds;
366 struct timeval tv;
367 ssize_t n;
368
369 rc = -1;
370
371 FD_ZERO(&rfds);
372 FD_SET(fd, &rfds);
373
374 tv.tv_sec = 0;
375 tv.tv_usec = timeo * 1000;
376 if (tv.tv_usec > 1000000) {
377 tv.tv_sec += tv.tv_usec / 1000000;
378 tv.tv_usec %= 1000000;
379 }
380
381 do {
382 nfds = select(fd + 1, &rfds, NULL, NULL, &tv);
383 if (nfds < 0)
384 goto out;
385 if (!nfds) {
386 errno = ETIMEDOUT;
387 goto out;
388 }
389
390 n = read(fd, buf, len);
4469bd7b 391 if (n <= 0)
d131ad68
LP		 392 goto out;
393
394 buf = (char *)buf + n;
395 len -= n;
396 } while (len > 0);
397
398 rc = 0;
399out:
400 return rc;
401}
402
403static int
404kwboot_tty_send(int fd, const void *buf, size_t len)
405{
84899e2d
SR		 406 if (!buf)
407 return 0;
408
e453bb42
MB		 409 if (kwboot_write(fd, buf, len) < 0)
410 return -1;
d131ad68 411
e453bb42 412 return tcdrain(fd);
d131ad68
LP		 413}
414
415static int
416kwboot_tty_send_char(int fd, unsigned char c)
417{
418 return kwboot_tty_send(fd, &c, 1);
419}
420
421static speed_t
ca272041 422kwboot_tty_baudrate_to_speed(int baudrate)
d131ad68
LP		 423{
424 switch (baudrate) {
ca272041
T		 425#ifdef B4000000
426 case 4000000:
427 return B4000000;
428#endif
429#ifdef B3500000
430 case 3500000:
431 return B3500000;
432#endif
433#ifdef B3000000
434 case 3000000:
435 return B3000000;
436#endif
437#ifdef B2500000
438 case 2500000:
439 return B2500000;
440#endif
441#ifdef B2000000
442 case 2000000:
443 return B2000000;
444#endif
445#ifdef B1500000
446 case 1500000:
447 return B1500000;
448#endif
449#ifdef B1152000
450 case 1152000:
451 return B1152000;
452#endif
453#ifdef B1000000
454 case 1000000:
455 return B1000000;
456#endif
457#ifdef B921600
458 case 921600:
459 return B921600;
460#endif
461#ifdef B614400
462 case 614400:
463 return B614400;
464#endif
465#ifdef B576000
466 case 576000:
467 return B576000;
468#endif
469#ifdef B500000
470 case 500000:
471 return B500000;
472#endif
473#ifdef B460800
474 case 460800:
475 return B460800;
476#endif
477#ifdef B307200
478 case 307200:
479 return B307200;
480#endif
481#ifdef B230400
482 case 230400:
483 return B230400;
484#endif
485#ifdef B153600
486 case 153600:
487 return B153600;
488#endif
489#ifdef B115200
d131ad68
LP		 490 case 115200:
491 return B115200;
ca272041
T		 492#endif
493#ifdef B76800
494 case 76800:
495 return B76800;
496#endif
497#ifdef B57600
d131ad68
LP		 498 case 57600:
499 return B57600;
ca272041
T		 500#endif
501#ifdef B38400
d131ad68
LP		 502 case 38400:
503 return B38400;
ca272041
T		 504#endif
505#ifdef B19200
d131ad68
LP		 506 case 19200:
507 return B19200;
ca272041
T		 508#endif
509#ifdef B9600
d131ad68
LP		 510 case 9600:
511 return B9600;
ca272041
T		 512#endif
513#ifdef B4800
514 case 4800:
515 return B4800;
516#endif
517#ifdef B2400
518 case 2400:
519 return B2400;
520#endif
521#ifdef B1800
522 case 1800:
523 return B1800;
524#endif
525#ifdef B1200
526 case 1200:
527 return B1200;
528#endif
529#ifdef B600
530 case 600:
531 return B600;
532#endif
533#ifdef B300
534 case 300:
535 return B300;
536#endif
537#ifdef B200
538 case 200:
539 return B200;
540#endif
541#ifdef B150
542 case 150:
543 return B150;
544#endif
545#ifdef B134
546 case 134:
547 return B134;
548#endif
549#ifdef B110
550 case 110:
551 return B110;
552#endif
553#ifdef B75
554 case 75:
555 return B75;
556#endif
557#ifdef B50
558 case 50:
559 return B50;
560#endif
561 default:
93b55636
T		 562#ifdef BOTHER
563 return BOTHER;
564#else
ca272041 565 return B0;
93b55636 566#endif
ca272041
T		 567 }
568}
569
99a3d023
MB		 570static int
571_is_within_tolerance(int value, int reference, int tolerance)
572{
573 return 100 * value >= reference * (100 - tolerance) &&
574 100 * value <= reference * (100 + tolerance);
575}
576
ca272041
T		 577static int
578kwboot_tty_change_baudrate(int fd, int baudrate)
579{
580 struct termios tio;
581 speed_t speed;
582 int rc;
583
584 rc = tcgetattr(fd, &tio);
585 if (rc)
586 return rc;
587
588 speed = kwboot_tty_baudrate_to_speed(baudrate);
589 if (speed == B0) {
590 errno = EINVAL;
591 return -1;
d131ad68
LP		 592 }
593
93b55636
T		 594#ifdef BOTHER
595 if (speed == BOTHER)
596 tio.c_ospeed = tio.c_ispeed = baudrate;
597#endif
598
ca272041
T		 599 rc = cfsetospeed(&tio, speed);
600 if (rc)
601 return rc;
602
603 rc = cfsetispeed(&tio, speed);
604 if (rc)
605 return rc;
606
607 rc = tcsetattr(fd, TCSANOW, &tio);
608 if (rc)
609 return rc;
610
99a3d023
MB		 611 rc = tcgetattr(fd, &tio);
612 if (rc)
613 return rc;
614
615 if (cfgetospeed(&tio) != speed || cfgetispeed(&tio) != speed)
616 goto baud_fail;
617
618#ifdef BOTHER
619 /*
620 * Check whether set baudrate is within 3% tolerance.
621 * If BOTHER is defined, Linux always fills out c_ospeed / c_ispeed
622 * with real values.
623 */
624 if (!_is_within_tolerance(tio.c_ospeed, baudrate, 3))
625 goto baud_fail;
626
627 if (!_is_within_tolerance(tio.c_ispeed, baudrate, 3))
628 goto baud_fail;
629#endif
630
ca272041 631 return 0;
99a3d023
MB		 632
633baud_fail:
634 fprintf(stderr, "Could not set baudrate to requested value\n");
635 errno = EINVAL;
636 return -1;
d131ad68
LP		 637}
638
639static int
ca272041 640kwboot_open_tty(const char *path, int baudrate)
d131ad68 641{
911515b3 642 int rc, fd, flags;
d131ad68
LP		 643 struct termios tio;
644
645 rc = -1;
646
647 fd = open(path, O_RDWR|O_NOCTTY|O_NDELAY);
648 if (fd < 0)
649 goto out;
650
c704e0e1
T		 651 rc = tcgetattr(fd, &tio);
652 if (rc)
653 goto out;
d131ad68 654
c704e0e1
T		 655 cfmakeraw(&tio);
656 tio.c_cflag |= CREAD|CLOCAL;
d131ad68 657 tio.c_cc[VMIN] = 1;
24a471bc 658 tio.c_cc[VTIME] = 0;
d131ad68 659
d131ad68
LP		 660 rc = tcsetattr(fd, TCSANOW, &tio);
661 if (rc)
662 goto out;
663
911515b3
T		 664 flags = fcntl(fd, F_GETFL);
665 if (flags < 0)
666 goto out;
667
668 rc = fcntl(fd, F_SETFL, flags & ~O_NDELAY);
669 if (rc)
670 goto out;
671
ca272041
T		 672 rc = kwboot_tty_change_baudrate(fd, baudrate);
673 if (rc)
674 goto out;
675
d131ad68
LP		 676 rc = fd;
677out:
678 if (rc < 0) {
679 if (fd >= 0)
680 close(fd);
681 }
682
683 return rc;
684}
685
686static int
687kwboot_bootmsg(int tty, void *msg)
688{
689 int rc;
690 char c;
9ca6fae9 691 int count;
d131ad68 692
84899e2d
SR		 693 if (msg == NULL)
694 kwboot_printv("Please reboot the target into UART boot mode...");
695 else
696 kwboot_printv("Sending boot message. Please reboot the target...");
d131ad68
LP		 697
698 do {
699 rc = tcflush(tty, TCIOFLUSH);
700 if (rc)
701 break;
702
9ca6fae9
JN		 703 for (count = 0; count < 128; count++) {
704 rc = kwboot_tty_send(tty, msg, 8);
705 if (rc) {
706 usleep(msg_req_delay * 1000);
707 continue;
708 }
d131ad68
LP		 709 }
710
84899e2d 711 rc = kwboot_tty_recv(tty, &c, 1, msg_rsp_timeo);
d131ad68
LP		 712
713 kwboot_spinner();
714
715 } while (rc || c != NAK);
716
717 kwboot_printv("\n");
718
719 return rc;
720}
721
84899e2d
SR		 722static int
723kwboot_debugmsg(int tty, void *msg)
724{
725 int rc;
726
727 kwboot_printv("Sending debug message. Please reboot the target...");
728
729 do {
730 char buf[16];
731
732 rc = tcflush(tty, TCIOFLUSH);
733 if (rc)
734 break;
735
736 rc = kwboot_tty_send(tty, msg, 8);
737 if (rc) {
738 usleep(msg_req_delay * 1000);
739 continue;
740 }
741
742 rc = kwboot_tty_recv(tty, buf, 16, msg_rsp_timeo);
743
744 kwboot_spinner();
745
746 } while (rc);
747
748 kwboot_printv("\n");
749
750 return rc;
751}
752
c5d666aa 753static size_t
d131ad68
LP		 754kwboot_xm_makeblock(struct kwboot_block *block, const void *data,
755 size_t size, int pnum)
756{
d8cc851d 757 size_t i, n;
d131ad68 758
84899e2d 759 block->soh = SOH;
d131ad68
LP		 760 block->pnum = pnum;
761 block->_pnum = ~block->pnum;
762
2ef87f75 763 n = size < KWBOOT_XM_BLKSZ ? size : KWBOOT_XM_BLKSZ;
d131ad68 764 memcpy(&block->data[0], data, n);
2ef87f75 765 memset(&block->data[n], 0, KWBOOT_XM_BLKSZ - n);
d131ad68
LP		 766
767 block->csum = 0;
768 for (i = 0; i < n; i++)
769 block->csum += block->data[i];
770
771 return n;
772}
773
12df7b79
MB		 774static uint64_t
775_now(void)
776{
777 struct timespec ts;
778
779 if (clock_gettime(CLOCK_MONOTONIC, &ts)) {
780 static int err_print;
781
782 if (!err_print) {
783 perror("clock_gettime() does not work");
784 err_print = 1;
785 }
786
787 /* this will just make the timeout not work */
788 return -1ULL;
789 }
790
791 return ts.tv_sec * 1000ULL + (ts.tv_nsec + 500000) / 1000000;
792}
793
408ea613
MB		 794static int
795_is_xm_reply(char c)
796{
797 return c == ACK || c == NAK || c == CAN;
798}
799
9cdc264e
T		 800static int
801_xm_reply_to_error(int c)
802{
803 int rc = -1;
804
805 switch (c) {
806 case ACK:
807 rc = 0;
808 break;
809 case NAK:
810 errno = EBADMSG;
811 break;
812 case CAN:
813 errno = ECANCELED;
814 break;
815 default:
816 errno = EPROTO;
817 break;
818 }
819
820 return rc;
821}
822
d131ad68 823static int
ca272041
T		 824kwboot_baud_magic_handle(int fd, char c, int baudrate)
825{
826 static size_t rcv_len;
827
828 if (rcv_len < sizeof(kwb_baud_magic)) {
829 /* try to recognize whole magic word */
830 if (c == kwb_baud_magic[rcv_len]) {
831 rcv_len++;
832 } else {
833 printf("%.*s%c", (int)rcv_len, kwb_baud_magic, c);
834 fflush(stdout);
835 rcv_len = 0;
836 }
837 }
838
839 if (rcv_len == sizeof(kwb_baud_magic)) {
840 /* magic word received */
841 kwboot_printv("\nChanging baudrate to %d Bd\n", baudrate);
842
843 return kwboot_tty_change_baudrate(fd, baudrate) ? : 1;
844 } else {
845 return 0;
846 }
847}
848
849static int
850kwboot_xm_recv_reply(int fd, char *c, int allow_non_xm, int *non_xm_print,
851 int baudrate, int *baud_changed)
48b3ea66 852{
12df7b79 853 int timeout = allow_non_xm ? KWBOOT_HDR_RSP_TIMEO : blk_rsp_timeo;
819cd328 854 uint64_t recv_until = _now() + timeout;
48b3ea66
T		 855 int rc;
856
819cd328
MB		 857 if (non_xm_print)
858 *non_xm_print = 0;
ca272041
T		 859 if (baud_changed)
860 *baud_changed = 0;
2e81b3ab 861
48b3ea66 862 while (1) {
12df7b79 863 rc = kwboot_tty_recv(fd, c, 1, timeout);
48b3ea66
T		 864 if (rc) {
865 if (errno != ETIMEDOUT)
866 return rc;
819cd328 867 else if (allow_non_xm && *non_xm_print)
12df7b79
MB		 868 return -1;
869 else
870 *c = NAK;
48b3ea66
T		 871 }
872
873 /* If received xmodem reply, end. */
874 if (_is_xm_reply(*c))
875 break;
876
877 /*
ca272041
T		 878 * If receiving/printing non-xmodem text output is allowed and
879 * such a byte was received, we want to increase receiving time
880 * and either:
881 * - print the byte, if it is not part of baudrate change magic
882 * sequence while baudrate change was requested (-B option)
883 * - change baudrate
819cd328 884 * Otherwise decrease timeout by time elapsed.
48b3ea66
T		 885 */
886 if (allow_non_xm) {
12df7b79 887 recv_until = _now() + timeout;
ca272041
T		 888
889 if (baudrate && !*baud_changed) {
890 rc = kwboot_baud_magic_handle(fd, *c, baudrate);
891 if (rc == 1)
892 *baud_changed = 1;
893 else if (!rc)
894 *non_xm_print = 1;
895 else
896 return rc;
897 } else if (!baudrate || !*baud_changed) {
898 putchar(*c);
899 fflush(stdout);
900 *non_xm_print = 1;
901 }
819cd328
MB		 902 } else {
903 timeout = recv_until - _now();
904 if (timeout < 0) {
905 errno = ETIMEDOUT;
906 return -1;
907 }
48b3ea66
T		 908 }
909 }
910
911 return 0;
912}
913
914static int
915kwboot_xm_sendblock(int fd, struct kwboot_block *block, int allow_non_xm,
ca272041 916 int *done_print, int baudrate)
d131ad68 917{
ca272041
T		 918 int non_xm_print, baud_changed;
919 int rc, err, retries;
d131ad68
LP		 920 char c;
921
48b3ea66
T		 922 *done_print = 0;
923
d131ad68
LP		 924 retries = 16;
925 do {
926 rc = kwboot_tty_send(fd, block, sizeof(*block));
927 if (rc)
00a1deed 928 return rc;
d131ad68 929
48b3ea66
T		 930 if (allow_non_xm && !*done_print) {
931 kwboot_progress(100, '.');
932 kwboot_printv("Done\n");
933 *done_print = 1;
934 }
84899e2d 935
ca272041
T		 936 rc = kwboot_xm_recv_reply(fd, &c, allow_non_xm, &non_xm_print,
937 baudrate, &baud_changed);
48b3ea66 938 if (rc)
ca272041 939 goto can;
d131ad68 940
48b3ea66 941 if (!allow_non_xm && c != ACK)
d131ad68 942 kwboot_progress(-1, '+');
d131ad68
LP		 943 } while (c == NAK && retries-- > 0);
944
2e81b3ab
MB		 945 if (non_xm_print)
946 kwboot_printv("\n");
947
ca272041
T		 948 if (allow_non_xm && baudrate && !baud_changed) {
949 fprintf(stderr, "Baudrate was not changed\n");
950 rc = -1;
951 errno = EPROTO;
952 goto can;
953 }
954
9cdc264e 955 return _xm_reply_to_error(c);
ca272041
T		 956can:
957 err = errno;
958 kwboot_tty_send_char(fd, CAN);
959 kwboot_printv("\n");
960 errno = err;
961 return rc;
9cdc264e 962}
d131ad68 963
9cdc264e
T		 964static int
965kwboot_xm_finish(int fd)
966{
967 int rc, retries;
968 char c;
d131ad68 969
9cdc264e
T		 970 kwboot_printv("Finishing transfer\n");
971
972 retries = 16;
973 do {
974 rc = kwboot_tty_send_char(fd, EOT);
975 if (rc)
976 return rc;
977
ca272041 978 rc = kwboot_xm_recv_reply(fd, &c, 0, NULL, 0, NULL);
9cdc264e
T		 979 if (rc)
980 return rc;
981 } while (c == NAK && retries-- > 0);
982
983 return _xm_reply_to_error(c);
d131ad68
LP		 984}
985
986static int
2ef87f75 987kwboot_xmodem_one(int tty, int *pnum, int header, const uint8_t *data,
ca272041 988 size_t size, int baudrate)
d131ad68 989{
48b3ea66 990 int done_print = 0;
2ef87f75
T		 991 size_t sent, left;
992 int rc;
d131ad68 993
2ef87f75
T		 994 kwboot_printv("Sending boot image %s (%zu bytes)...\n",
995 header ? "header" : "data", size);
d131ad68 996
2ef87f75
T		 997 left = size;
998 sent = 0;
d131ad68 999
2ef87f75 1000 while (sent < size) {
d131ad68 1001 struct kwboot_block block;
48b3ea66 1002 int last_block;
2ef87f75 1003 size_t blksz;
d131ad68 1004
2ef87f75
T		 1005 blksz = kwboot_xm_makeblock(&block, data, left, (*pnum)++);
1006 data += blksz;
d131ad68 1007
48b3ea66
T		 1008 last_block = (left <= blksz);
1009
1010 rc = kwboot_xm_sendblock(tty, &block, header && last_block,
ca272041 1011 &done_print, baudrate);
d131ad68
LP		 1012 if (rc)
1013 goto out;
1014
2ef87f75
T		 1015 sent += blksz;
1016 left -= blksz;
1017
48b3ea66
T		 1018 if (!done_print)
1019 kwboot_progress(sent * 100 / size, '.');
2ef87f75 1020 }
d131ad68 1021
48b3ea66
T		 1022 if (!done_print)
1023 kwboot_printv("Done\n");
d131ad68 1024
2ef87f75 1025 return 0;
d131ad68 1026out:
d5ba8dbd 1027 kwboot_printv("\n");
d131ad68 1028 return rc;
2ef87f75
T		 1029}
1030
1031static int
ca272041 1032kwboot_xmodem(int tty, const void *_img, size_t size, int baudrate)
2ef87f75
T		 1033{
1034 const uint8_t *img = _img;
1035 int rc, pnum;
1036 size_t hdrsz;
1037
fe2fd73d 1038 hdrsz = kwbheader_size(img);
2ef87f75
T		 1039
1040 kwboot_printv("Waiting 2s and flushing tty\n");
1041 sleep(2); /* flush isn't effective without it */
1042 tcflush(tty, TCIOFLUSH);
1043
1044 pnum = 1;
1045
ca272041 1046 rc = kwboot_xmodem_one(tty, &pnum, 1, img, hdrsz, baudrate);
2ef87f75
T		 1047 if (rc)
1048 return rc;
1049
1050 img += hdrsz;
1051 size -= hdrsz;
1052
ca272041
T		 1053 rc = kwboot_xmodem_one(tty, &pnum, 0, img, size, 0);
1054 if (rc)
1055 return rc;
1056
1057 rc = kwboot_xm_finish(tty);
2ef87f75
T		 1058 if (rc)
1059 return rc;
d131ad68 1060
ca272041
T		 1061 if (baudrate) {
1062 char buf[sizeof(kwb_baud_magic)];
1063
1064 /* Wait 1s for baudrate change magic */
1065 rc = kwboot_tty_recv(tty, buf, sizeof(buf), 1000);
1066 if (rc)
1067 return rc;
1068
1069 if (memcmp(buf, kwb_baud_magic, sizeof(buf))) {
1070 errno = EPROTO;
1071 return -1;
1072 }
1073
1074 kwboot_printv("\nChanging baudrate back to 115200 Bd\n\n");
1075 rc = kwboot_tty_change_baudrate(tty, 115200);
1076 if (rc)
1077 return rc;
1078 }
1079
1080 return 0;
d131ad68
LP		 1081}
1082
1083static int
46237e63 1084kwboot_term_pipe(int in, int out, const char *quit, int *s)
d131ad68 1085{
e453bb42 1086 ssize_t nin;
d131ad68
LP		 1087 char _buf[128], *buf = _buf;
1088
43fef8d4 1089 nin = read(in, buf, sizeof(_buf));
4469bd7b 1090 if (nin <= 0)
d131ad68
LP		 1091 return -1;
1092
1093 if (quit) {
1094 int i;
1095
1096 for (i = 0; i < nin; i++) {
1097 if (*buf == quit[*s]) {
1098 (*s)++;
1099 if (!quit[*s])
1100 return 0;
1101 buf++;
1102 nin--;
b943eee9 1103 } else {
e453bb42
MB		 1104 if (kwboot_write(out, quit, *s) < 0)
1105 return -1;
1106 *s = 0;
b943eee9 1107 }
d131ad68
LP		 1108 }
1109 }
1110
e453bb42
MB		 1111 if (kwboot_write(out, buf, nin) < 0)
1112 return -1;
d131ad68
LP		 1113
1114 return 0;
1115}
1116
1117static int
1118kwboot_terminal(int tty)
1119{
1120 int rc, in, s;
46237e63 1121 const char *quit = "\34c";
d131ad68
LP		 1122 struct termios otio, tio;
1123
1124 rc = -1;
1125
1126 in = STDIN_FILENO;
1127 if (isatty(in)) {
1128 rc = tcgetattr(in, &otio);
1129 if (!rc) {
1130 tio = otio;
1131 cfmakeraw(&tio);
1132 rc = tcsetattr(in, TCSANOW, &tio);
1133 }
1134 if (rc) {
1135 perror("tcsetattr");
1136 goto out;
1137 }
1138
1139 kwboot_printv("[Type Ctrl-%c + %c to quit]\r\n",
1140 quit[0]|0100, quit[1]);
1141 } else
1142 in = -1;
1143
1144 rc = 0;
1145 s = 0;
1146
1147 do {
1148 fd_set rfds;
1149 int nfds = 0;
1150
1151 FD_SET(tty, &rfds);
1152 nfds = nfds < tty ? tty : nfds;
1153
1154 if (in >= 0) {
1155 FD_SET(in, &rfds);
1156 nfds = nfds < in ? in : nfds;
1157 }
1158
1159 nfds = select(nfds + 1, &rfds, NULL, NULL, NULL);
1160 if (nfds < 0)
1161 break;
1162
1163 if (FD_ISSET(tty, &rfds)) {
1164 rc = kwboot_term_pipe(tty, STDOUT_FILENO, NULL, NULL);
1165 if (rc)
1166 break;
1167 }
1168
f30cb0d3 1169 if (in >= 0 && FD_ISSET(in, &rfds)) {
d131ad68
LP		 1170 rc = kwboot_term_pipe(in, tty, quit, &s);
1171 if (rc)
1172 break;
1173 }
1174 } while (quit[s] != 0);
1175
ec0fe5b8
T		 1176 if (in >= 0)
1177 tcsetattr(in, TCSANOW, &otio);
49a0a3b8 1178 printf("\n");
d131ad68
LP		 1179out:
1180 return rc;
1181}
1182
1183static void *
04ced029 1184kwboot_read_image(const char *path, size_t *size, size_t reserve)
d131ad68 1185{
ddc04fac 1186 int rc, fd;
d131ad68
LP		 1187 struct stat st;
1188 void *img;
04ced029 1189 off_t tot;
d131ad68
LP		 1190
1191 rc = -1;
d131ad68
LP		 1192 img = NULL;
1193
1194 fd = open(path, O_RDONLY);
1195 if (fd < 0)
1196 goto out;
1197
1198 rc = fstat(fd, &st);
1199 if (rc)
1200 goto out;
1201
04ced029
T		 1202 img = malloc(st.st_size + reserve);
1203 if (!img)
d131ad68 1204 goto out;
04ced029
T		 1205
1206 tot = 0;
1207 while (tot < st.st_size) {
1208 ssize_t rd = read(fd, img + tot, st.st_size - tot);
1209
1210 if (rd < 0)
1211 goto out;
1212
1213 tot += rd;
1214
1215 if (!rd && tot < st.st_size) {
1216 errno = EIO;
1217 goto out;
1218 }
d131ad68
LP		 1219 }
1220
1221 rc = 0;
1222 *size = st.st_size;
1223out:
1224 if (rc && img) {
04ced029 1225 free(img);
d131ad68
LP		 1226 img = NULL;
1227 }
1228 if (fd >= 0)
1229 close(fd);
1230
1231 return img;
1232}
1233
1234static uint8_t
fe2fd73d 1235kwboot_hdr_csum8(const void *hdr)
d131ad68 1236{
fe2fd73d
MB		 1237 const uint8_t *data = hdr;
1238 uint8_t csum;
1239 size_t size;
1240
1241 size = kwbheader_size_for_csum(hdr);
d131ad68
LP		 1242
1243 for (csum = 0; size-- > 0; data++)
1244 csum += *data;
1245
1246 return csum;
1247}
1248
550c9308
T		 1249static int
1250kwboot_img_is_secure(void *img)
1251{
1252 struct opt_hdr_v1 *ohdr;
1253
1254 for_each_opt_hdr_v1 (ohdr, img)
1255 if (ohdr->headertype == OPT_HDR_V1_SECURE_TYPE)
1256 return 1;
1257
1258 return 0;
1259}
1260
ca272041
T		 1261static void *
1262kwboot_img_grow_data_left(void *img, size_t *size, size_t grow)
1263{
1264 uint32_t hdrsz, datasz, srcaddr;
1265 struct main_hdr_v1 *hdr = img;
1266 uint8_t *data;
1267
1268 srcaddr = le32_to_cpu(hdr->srcaddr);
1269
1270 hdrsz = kwbheader_size(hdr);
1271 data = (uint8_t *)img + srcaddr;
1272 datasz = *size - srcaddr;
1273
1274 /* only move data if there is not enough space */
1275 if (hdrsz + grow > srcaddr) {
1276 size_t need = hdrsz + grow - srcaddr;
1277
1278 /* move data by enough bytes */
1279 memmove(data + need, data, datasz);
1280 *size += need;
1281 srcaddr += need;
1282 }
1283
1284 srcaddr -= grow;
1285 hdr->srcaddr = cpu_to_le32(srcaddr);
1286 hdr->destaddr = cpu_to_le32(le32_to_cpu(hdr->destaddr) - grow);
1287 hdr->blocksize = cpu_to_le32(le32_to_cpu(hdr->blocksize) + grow);
1288
1289 return (uint8_t *)img + srcaddr;
1290}
1291
04ced029
T		 1292static void
1293kwboot_img_grow_hdr(void *img, size_t *size, size_t grow)
1294{
1295 uint32_t hdrsz, datasz, srcaddr;
1296 struct main_hdr_v1 *hdr = img;
1297 uint8_t *data;
1298
1299 srcaddr = le32_to_cpu(hdr->srcaddr);
1300
1301 hdrsz = kwbheader_size(img);
1302 data = (uint8_t *)img + srcaddr;
1303 datasz = *size - srcaddr;
1304
1305 /* only move data if there is not enough space */
1306 if (hdrsz + grow > srcaddr) {
1307 size_t need = hdrsz + grow - srcaddr;
1308
1309 /* move data by enough bytes */
1310 memmove(data + need, data, datasz);
1311
1312 hdr->srcaddr = cpu_to_le32(srcaddr + need);
1313 *size += need;
1314 }
1315
1316 if (kwbimage_version(img) == 1) {
1317 hdrsz += grow;
1318 hdr->headersz_msb = hdrsz >> 16;
1319 hdr->headersz_lsb = cpu_to_le16(hdrsz & 0xffff);
1320 }
1321}
1322
ca272041
T		 1323static void *
1324kwboot_add_bin_ohdr_v1(void *img, size_t *size, uint32_t binsz)
1325{
1326 struct main_hdr_v1 *hdr = img;
1327 struct opt_hdr_v1 *ohdr;
1328 uint32_t ohdrsz;
1329
1330 ohdrsz = binsz + 8 + sizeof(*ohdr);
1331 kwboot_img_grow_hdr(img, size, ohdrsz);
1332
1333 if (hdr->ext & 0x1) {
1334 for_each_opt_hdr_v1 (ohdr, img)
1335 if (opt_hdr_v1_next(ohdr) == NULL)
1336 break;
1337
1338 *opt_hdr_v1_ext(ohdr) |= 1;
1339 ohdr = opt_hdr_v1_next(ohdr);
1340 } else {
1341 hdr->ext |= 1;
1342 ohdr = (void *)(hdr + 1);
1343 }
1344
1345 ohdr->headertype = OPT_HDR_V1_BINARY_TYPE;
1346 ohdr->headersz_msb = ohdrsz >> 16;
1347 ohdr->headersz_lsb = cpu_to_le16(ohdrsz & 0xffff);
1348
1349 memset(&ohdr->data[0], 0, ohdrsz - sizeof(*ohdr));
1350
1351 return &ohdr->data[4];
1352}
1353
1354static void
1355_copy_baudrate_change_code(struct main_hdr_v1 *hdr, void *dst, int pre,
1356 int old_baud, int new_baud)
1357{
1358 size_t codesz = sizeof(kwboot_baud_code);
1359 uint8_t *code = dst;
1360
1361 if (pre) {
1362 size_t presz = sizeof(kwboot_pre_baud_code);
1363
1364 /*
1365 * We need to prepend code that loads lr register with original
1366 * value of hdr->execaddr. We do this by putting the original
1367 * exec address before the code that loads it relatively from
1368 * it's beginning.
1369 * Afterwards we change the exec address to this code (which is
1370 * at offset 4, because the first 4 bytes contain the original
1371 * exec address).
1372 */
1373 memcpy(code, kwboot_pre_baud_code, presz);
1374 *(uint32_t *)code = hdr->execaddr;
1375
1376 hdr->execaddr = cpu_to_le32(le32_to_cpu(hdr->destaddr) + 4);
1377
1378 code += presz;
1379 }
1380
1381 memcpy(code, kwboot_baud_code, codesz - 8);
1382 *(uint32_t *)(code + codesz - 8) = cpu_to_le32(old_baud);
1383 *(uint32_t *)(code + codesz - 4) = cpu_to_le32(new_baud);
1384}
1385
d131ad68 1386static int
ca272041 1387kwboot_img_patch(void *img, size_t *size, int baudrate)
d131ad68
LP		 1388{
1389 int rc;
e29f1db3 1390 struct main_hdr_v1 *hdr;
792e4235 1391 uint32_t srcaddr;
d131ad68 1392 uint8_t csum;
5c8f812c 1393 size_t hdrsz;
e29f1db3 1394 int image_ver;
550c9308 1395 int is_secure;
d131ad68
LP		 1396
1397 rc = -1;
1398 hdr = img;
1399
5c8f812c 1400 if (*size < sizeof(struct main_hdr_v1)) {
d131ad68
LP		 1401 errno = EINVAL;
1402 goto out;
1403 }
1404
acb0b38d 1405 image_ver = kwbimage_version(img);
5029d7bf 1406 if (image_ver != 0 && image_ver != 1) {
e29f1db3
SR		 1407 fprintf(stderr, "Invalid image header version\n");
1408 errno = EINVAL;
1409 goto out;
1410 }
1411
fe2fd73d 1412 hdrsz = kwbheader_size(hdr);
e29f1db3 1413
04ced029 1414 if (*size < hdrsz) {
825a2ca0
T		 1415 errno = EINVAL;
1416 goto out;
1417 }
1418
fe2fd73d 1419 csum = kwboot_hdr_csum8(hdr) - hdr->checksum;
e29f1db3 1420 if (csum != hdr->checksum) {
d131ad68
LP		 1421 errno = EINVAL;
1422 goto out;
1423 }
1424
792e4235
T		 1425 if (image_ver == 0) {
1426 struct main_hdr_v0 *hdr_v0 = img;
1427
1428 hdr_v0->nandeccmode = IBR_HDR_ECC_DISABLED;
1429 hdr_v0->nandpagesize = 0;
1430 }
1431
1432 srcaddr = le32_to_cpu(hdr->srcaddr);
1433
1434 switch (hdr->blockid) {
1435 case IBR_HDR_SATA_ID:
1436 if (srcaddr < 1) {
1437 errno = EINVAL;
1438 goto out;
1439 }
1440 hdr->srcaddr = cpu_to_le32((srcaddr - 1) * 512);
1441 break;
1442
1443 case IBR_HDR_SDIO_ID:
1444 hdr->srcaddr = cpu_to_le32(srcaddr * 512);
1445 break;
1446
1447 case IBR_HDR_PEX_ID:
1448 if (srcaddr == 0xFFFFFFFF)
1449 hdr->srcaddr = cpu_to_le32(hdrsz);
1450 break;
f2c644e0
T		 1451
1452 case IBR_HDR_SPI_ID:
1453 if (hdr->destaddr == cpu_to_le32(0xFFFFFFFF)) {
1454 kwboot_printv("Patching destination and execution addresses from SPI/NOR XIP area to DDR area 0x00800000\n");
1455 hdr->destaddr = cpu_to_le32(0x00800000);
1456 hdr->execaddr = cpu_to_le32(0x00800000);
1457 }
1458 break;
792e4235
T		 1459 }
1460
04ced029
T		 1461 if (hdrsz > le32_to_cpu(hdr->srcaddr) ||
1462 *size < le32_to_cpu(hdr->srcaddr) + le32_to_cpu(hdr->blocksize)) {
1463 errno = EINVAL;
1464 goto out;
1465 }
1466
550c9308 1467 is_secure = kwboot_img_is_secure(img);
d131ad68 1468
550c9308
T		 1469 if (hdr->blockid != IBR_HDR_UART_ID) {
1470 if (is_secure) {
1471 fprintf(stderr,
1472 "Image has secure header with signature for non-UART booting\n");
1473 errno = EINVAL;
1474 goto out;
1475 }
1476
1477 kwboot_printv("Patching image boot signature to UART\n");
1478 hdr->blockid = IBR_HDR_UART_ID;
1479 }
d131ad68 1480
ca272041
T		 1481 if (baudrate) {
1482 uint32_t codesz = sizeof(kwboot_baud_code);
1483 void *code;
1484
1485 if (image_ver == 0) {
1486 fprintf(stderr,
1487 "Cannot inject code for changing baudrate into v0 image header\n");
1488 errno = EINVAL;
1489 goto out;
1490 }
1491
1492 if (is_secure) {
1493 fprintf(stderr,
1494 "Cannot inject code for changing baudrate into image with secure header\n");
1495 errno = EINVAL;
1496 goto out;
1497 }
1498
1499 /*
1500 * First inject code that changes the baudrate from the default
1501 * value of 115200 Bd to requested value. This code is inserted
1502 * as a new opt hdr, so it is executed by BootROM after the
1503 * header part is received.
1504 */
1505 kwboot_printv("Injecting binary header code for changing baudrate to %d Bd\n",
1506 baudrate);
1507
1508 code = kwboot_add_bin_ohdr_v1(img, size, codesz);
1509 _copy_baudrate_change_code(hdr, code, 0, 115200, baudrate);
1510
1511 /*
1512 * Now inject code that changes the baudrate back to 115200 Bd.
1513 * This code is prepended to the data part of the image, so it
1514 * is executed before U-Boot proper.
1515 */
1516 kwboot_printv("Injecting code for changing baudrate back\n");
1517
1518 codesz += sizeof(kwboot_pre_baud_code);
1519 code = kwboot_img_grow_data_left(img, size, codesz);
1520 _copy_baudrate_change_code(hdr, code, 1, baudrate, 115200);
1521
1522 /* recompute header size */
1523 hdrsz = kwbheader_size(hdr);
1524 }
1525
04ced029
T		 1526 if (hdrsz % KWBOOT_XM_BLKSZ) {
1527 size_t offset = (KWBOOT_XM_BLKSZ - hdrsz % KWBOOT_XM_BLKSZ) %
1528 KWBOOT_XM_BLKSZ;
1529
1530 if (is_secure) {
1531 fprintf(stderr, "Cannot align image with secure header\n");
1532 errno = EINVAL;
1533 goto out;
1534 }
1535
1536 kwboot_printv("Aligning image header to Xmodem block size\n");
1537 kwboot_img_grow_hdr(img, size, offset);
1538 }
1539
fe2fd73d 1540 hdr->checksum = kwboot_hdr_csum8(hdr) - csum;
d131ad68 1541
04ced029 1542 *size = le32_to_cpu(hdr->srcaddr) + le32_to_cpu(hdr->blocksize);
d131ad68
LP		 1543 rc = 0;
1544out:
1545 return rc;
1546}
1547
1548static void
1549kwboot_usage(FILE *stream, char *progname)
1550{
a050a862 1551 fprintf(stream, "kwboot version %s\n", PLAIN_VERSION);
d131ad68 1552 fprintf(stream,
8669dacf 1553 "Usage: %s [OPTIONS] [-b <image> | -D <image> ] [-B <baud> ] <TTY>\n",
84899e2d 1554 progname);
d131ad68 1555 fprintf(stream, "\n");
84899e2d
SR		 1556 fprintf(stream,
1557 " -b <image>: boot <image> with preamble (Kirkwood, Armada 370/XP)\n");
84899e2d
SR		 1558 fprintf(stream,
1559 " -D <image>: boot <image> without preamble (Dove)\n");
1560 fprintf(stream, " -d: enter debug mode\n");
1561 fprintf(stream, " -a: use timings for Armada XP\n");
1c0df9ef
SR		 1562 fprintf(stream, " -q <req-delay>: use specific request-delay\n");
1563 fprintf(stream, " -s <resp-timeo>: use specific response-timeout\n");
7497a6a1
KS		 1564 fprintf(stream,
1565 " -o <block-timeo>: use specific xmodem block timeout\n");
d131ad68
LP		 1566 fprintf(stream, "\n");
1567 fprintf(stream, " -t: mini terminal\n");
1568 fprintf(stream, "\n");
1569 fprintf(stream, " -B <baud>: set baud rate\n");
1570 fprintf(stream, "\n");
1571}
1572
1573int
1574main(int argc, char **argv)
1575{
1576 const char *ttypath, *imgpath;
ddc04fac 1577 int rv, rc, tty, term;
d131ad68 1578 void *bootmsg;
84899e2d 1579 void *debugmsg;
d131ad68
LP		 1580 void *img;
1581 size_t size;
ca272041
T		 1582 size_t after_img_rsv;
1583 int baudrate;
d131ad68
LP		 1584
1585 rv = 1;
1586 tty = -1;
1587 bootmsg = NULL;
84899e2d 1588 debugmsg = NULL;
d131ad68
LP		 1589 imgpath = NULL;
1590 img = NULL;
1591 term = 0;
d131ad68 1592 size = 0;
ca272041
T		 1593 after_img_rsv = KWBOOT_XM_BLKSZ;
1594 baudrate = 115200;
d131ad68
LP		 1595
1596 kwboot_verbose = isatty(STDOUT_FILENO);
1597
1598 do {
7497a6a1 1599 int c = getopt(argc, argv, "hb:ptaB:dD:q:s:o:");
d131ad68
LP		 1600 if (c < 0)
1601 break;
1602
1603 switch (c) {
1604 case 'b':
1605 bootmsg = kwboot_msg_boot;
1606 imgpath = optarg;
1607 break;
1608
84899e2d
SR		 1609 case 'D':
1610 bootmsg = NULL;
1611 imgpath = optarg;
1612 break;
1613
1614 case 'd':
1615 debugmsg = kwboot_msg_debug;
1616 break;
1617
d131ad68 1618 case 'p':
ddc04fac 1619 /* nop, for backward compatibility */
d131ad68
LP		 1620 break;
1621
1622 case 't':
1623 term = 1;
1624 break;
1625
84899e2d
SR		 1626 case 'a':
1627 msg_req_delay = KWBOOT_MSG_REQ_DELAY_AXP;
1628 msg_rsp_timeo = KWBOOT_MSG_RSP_TIMEO_AXP;
1629 break;
1630
1c0df9ef
SR		 1631 case 'q':
1632 msg_req_delay = atoi(optarg);
1633 break;
1634
1635 case 's':
1636 msg_rsp_timeo = atoi(optarg);
1637 break;
1638
7497a6a1
KS		 1639 case 'o':
1640 blk_rsp_timeo = atoi(optarg);
1641 break;
1642
d131ad68 1643 case 'B':
ca272041 1644 baudrate = atoi(optarg);
d131ad68
LP		 1645 break;
1646
1647 case 'h':
1648 rv = 0;
1649 default:
1650 goto usage;
1651 }
1652 } while (1);
1653
84899e2d 1654 if (!bootmsg && !term && !debugmsg)
d131ad68
LP		 1655 goto usage;
1656
d131ad68
LP		 1657 if (argc - optind < 1)
1658 goto usage;
1659
1660 ttypath = argv[optind++];
1661
ca272041 1662 tty = kwboot_open_tty(ttypath, imgpath ? 115200 : baudrate);
d131ad68
LP		 1663 if (tty < 0) {
1664 perror(ttypath);
1665 goto out;
1666 }
1667
ca272041
T		 1668 if (baudrate == 115200)
1669 /* do not change baudrate during Xmodem to the same value */
1670 baudrate = 0;
1671 else
1672 /* ensure we have enough space for baudrate change code */
1673 after_img_rsv += KWBOOT_BAUDRATE_BIN_HEADER_SZ +
1674 sizeof(kwboot_pre_baud_code) +
1675 sizeof(kwboot_baud_code);
1676
d131ad68 1677 if (imgpath) {
ca272041 1678 img = kwboot_read_image(imgpath, &size, after_img_rsv);
d131ad68
LP		 1679 if (!img) {
1680 perror(imgpath);
1681 goto out;
1682 }
d131ad68 1683
ca272041 1684 rc = kwboot_img_patch(img, &size, baudrate);
d131ad68
LP		 1685 if (rc) {
1686 fprintf(stderr, "%s: Invalid image.\n", imgpath);
1687 goto out;
1688 }
1689 }
1690
84899e2d
SR		 1691 if (debugmsg) {
1692 rc = kwboot_debugmsg(tty, debugmsg);
1693 if (rc) {
1694 perror("debugmsg");
1695 goto out;
1696 }
3475a71d 1697 } else if (bootmsg) {
d131ad68
LP		 1698 rc = kwboot_bootmsg(tty, bootmsg);
1699 if (rc) {
1700 perror("bootmsg");
1701 goto out;
1702 }
1703 }
1704
1705 if (img) {
ca272041 1706 rc = kwboot_xmodem(tty, img, size, baudrate);
d131ad68
LP		 1707 if (rc) {
1708 perror("xmodem");
1709 goto out;
1710 }
1711 }
1712
1713 if (term) {
1714 rc = kwboot_terminal(tty);
1715 if (rc && !(errno == EINTR)) {
1716 perror("terminal");
1717 goto out;
1718 }
1719 }
1720
1721 rv = 0;
1722out:
1723 if (tty >= 0)
1724 close(tty);
1725
1726 if (img)
04ced029 1727 free(img);
d131ad68
LP		 1728
1729 return rv;
1730
1731usage:
1732 kwboot_usage(rv ? stderr : stdout, basename(argv[0]));
1733 goto out;
1734}
Empty description
This page took 0.626942 seconds and 4 git commands to generate.