1 /* 2 * Copyright 1994, 1995, 2000 Neil Russell. 3 * (See License) 4 * Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de 5 * Copyright 2011 Comelit Group SpA, 6 * Luca Ceresoli <luca.ceresoli@comelit.it> 7 */ 8 9 #include <common.h> 10 #include <command.h> 11 #include <efi_loader.h> 12 #include <mapmem.h> 13 #include <net.h> 14 #include <net/tftp.h> 15 #include "bootp.h" 16 #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP 17 #include <flash.h> 18 #endif 19 20 DECLARE_GLOBAL_DATA_PTR; 21 22 /* Well known TFTP port # */ 23 #define WELL_KNOWN_PORT 69 24 /* Millisecs to timeout for lost pkt */ 25 #define TIMEOUT 5000UL 26 #ifndef CONFIG_NET_RETRY_COUNT 27 /* # of timeouts before giving up */ 28 # define TIMEOUT_COUNT 10 29 #else 30 # define TIMEOUT_COUNT (CONFIG_NET_RETRY_COUNT * 2) 31 #endif 32 /* Number of "loading" hashes per line (for checking the image size) */ 33 #define HASHES_PER_LINE 65 34 35 /* 36 * TFTP operations. 37 */ 38 #define TFTP_RRQ 1 39 #define TFTP_WRQ 2 40 #define TFTP_DATA 3 41 #define TFTP_ACK 4 42 #define TFTP_ERROR 5 43 #define TFTP_OACK 6 44 45 static ulong timeout_ms = TIMEOUT; 46 static int timeout_count_max = TIMEOUT_COUNT; 47 static ulong time_start; /* Record time we started tftp */ 48 49 /* 50 * These globals govern the timeout behavior when attempting a connection to a 51 * TFTP server. tftp_timeout_ms specifies the number of milliseconds to 52 * wait for the server to respond to initial connection. Second global, 53 * tftp_timeout_count_max, gives the number of such connection retries. 54 * tftp_timeout_count_max must be non-negative and tftp_timeout_ms must be 55 * positive. The globals are meant to be set (and restored) by code needing 56 * non-standard timeout behavior when initiating a TFTP transfer. 57 */ 58 ulong tftp_timeout_ms = TIMEOUT; 59 int tftp_timeout_count_max = TIMEOUT_COUNT; 60 61 enum { 62 TFTP_ERR_UNDEFINED = 0, 63 TFTP_ERR_FILE_NOT_FOUND = 1, 64 TFTP_ERR_ACCESS_DENIED = 2, 65 TFTP_ERR_DISK_FULL = 3, 66 TFTP_ERR_UNEXPECTED_OPCODE = 4, 67 TFTP_ERR_UNKNOWN_TRANSFER_ID = 5, 68 TFTP_ERR_FILE_ALREADY_EXISTS = 6, 69 }; 70 71 static struct in_addr tftp_remote_ip; 72 /* The UDP port at their end */ 73 static int tftp_remote_port; 74 /* The UDP port at our end */ 75 static int tftp_our_port; 76 static int timeout_count; 77 /* packet sequence number */ 78 static ulong tftp_cur_block; 79 /* last packet sequence number received */ 80 static ulong tftp_prev_block; 81 /* count of sequence number wraparounds */ 82 static ulong tftp_block_wrap; 83 /* memory offset due to wrapping */ 84 static ulong tftp_block_wrap_offset; 85 static int tftp_state; 86 static ulong tftp_load_addr; 87 #ifdef CONFIG_LMB 88 static ulong tftp_load_size; 89 #endif 90 #ifdef CONFIG_TFTP_TSIZE 91 /* The file size reported by the server */ 92 static int tftp_tsize; 93 /* The number of hashes we printed */ 94 static short tftp_tsize_num_hash; 95 #endif 96 #ifdef CONFIG_CMD_TFTPPUT 97 /* 1 if writing, else 0 */ 98 static int tftp_put_active; 99 /* 1 if we have sent the last block */ 100 static int tftp_put_final_block_sent; 101 #else 102 #define tftp_put_active 0 103 #endif 104 105 #define STATE_SEND_RRQ 1 106 #define STATE_DATA 2 107 #define STATE_TOO_LARGE 3 108 #define STATE_BAD_MAGIC 4 109 #define STATE_OACK 5 110 #define STATE_RECV_WRQ 6 111 #define STATE_SEND_WRQ 7 112 113 /* default TFTP block size */ 114 #define TFTP_BLOCK_SIZE 512 115 /* sequence number is 16 bit */ 116 #define TFTP_SEQUENCE_SIZE ((ulong)(1<<16)) 117 118 #define DEFAULT_NAME_LEN (8 + 4 + 1) 119 static char default_filename[DEFAULT_NAME_LEN]; 120 121 #ifndef CONFIG_TFTP_FILE_NAME_MAX_LEN 122 #define MAX_LEN 128 123 #else 124 #define MAX_LEN CONFIG_TFTP_FILE_NAME_MAX_LEN 125 #endif 126 127 static char tftp_filename[MAX_LEN]; 128 129 /* 512 is poor choice for ethernet, MTU is typically 1500. 130 * Minus eth.hdrs thats 1468. Can get 2x better throughput with 131 * almost-MTU block sizes. At least try... fall back to 512 if need be. 132 * (but those using CONFIG_IP_DEFRAG may want to set a larger block in cfg file) 133 */ 134 #ifdef CONFIG_TFTP_BLOCKSIZE 135 #define TFTP_MTU_BLOCKSIZE CONFIG_TFTP_BLOCKSIZE 136 #else 137 #define TFTP_MTU_BLOCKSIZE 1468 138 #endif 139 140 static unsigned short tftp_block_size = TFTP_BLOCK_SIZE; 141 static unsigned short tftp_block_size_option = TFTP_MTU_BLOCKSIZE; 142 143 static inline int store_block(int block, uchar *src, unsigned int len) 144 { 145 ulong offset = block * tftp_block_size + tftp_block_wrap_offset; 146 ulong newsize = offset + len; 147 ulong store_addr = tftp_load_addr + offset; 148 #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP 149 int i, rc = 0; 150 151 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) { 152 /* start address in flash? */ 153 if (flash_info[i].flash_id == FLASH_UNKNOWN) 154 continue; 155 if (store_addr >= flash_info[i].start[0]) { 156 rc = 1; 157 break; 158 } 159 } 160 161 if (rc) { /* Flash is destination for this packet */ 162 rc = flash_write((char *)src, store_addr, len); 163 if (rc) { 164 flash_perror(rc); 165 return rc; 166 } 167 } else 168 #endif /* CONFIG_SYS_DIRECT_FLASH_TFTP */ 169 { 170 void *ptr; 171 172 #ifdef CONFIG_LMB 173 if (store_addr < tftp_load_addr || 174 store_addr + len > tftp_load_addr + tftp_load_size) { 175 puts("\nTFTP error: "); 176 puts("trying to overwrite reserved memory...\n"); 177 return -1; 178 } 179 #endif 180 ptr = map_sysmem(store_addr, len); 181 memcpy(ptr, src, len); 182 unmap_sysmem(ptr); 183 } 184 185 if (net_boot_file_size < newsize) 186 net_boot_file_size = newsize; 187 188 return 0; 189 } 190 191 /* Clear our state ready for a new transfer */ 192 static void new_transfer(void) 193 { 194 tftp_prev_block = 0; 195 tftp_block_wrap = 0; 196 tftp_block_wrap_offset = 0; 197 #ifdef CONFIG_CMD_TFTPPUT 198 tftp_put_final_block_sent = 0; 199 #endif 200 } 201 202 #ifdef CONFIG_CMD_TFTPPUT 203 /** 204 * Load the next block from memory to be sent over tftp. 205 * 206 * @param block Block number to send 207 * @param dst Destination buffer for data 208 * @param len Number of bytes in block (this one and every other) 209 * @return number of bytes loaded 210 */ 211 static int load_block(unsigned block, uchar *dst, unsigned len) 212 { 213 /* We may want to get the final block from the previous set */ 214 ulong offset = ((int)block - 1) * len + tftp_block_wrap_offset; 215 ulong tosend = len; 216 217 tosend = min(net_boot_file_size - offset, tosend); 218 (void)memcpy(dst, (void *)(save_addr + offset), tosend); 219 debug("%s: block=%d, offset=%ld, len=%d, tosend=%ld\n", __func__, 220 block, offset, len, tosend); 221 return tosend; 222 } 223 #endif 224 225 static void tftp_send(void); 226 static void tftp_timeout_handler(void); 227 228 /**********************************************************************/ 229 230 static void show_block_marker(void) 231 { 232 #ifdef CONFIG_TFTP_TSIZE 233 if (tftp_tsize) { 234 ulong pos = tftp_cur_block * tftp_block_size + 235 tftp_block_wrap_offset; 236 if (pos > tftp_tsize) 237 pos = tftp_tsize; 238 239 while (tftp_tsize_num_hash < pos * 50 / tftp_tsize) { 240 putc('#'); 241 tftp_tsize_num_hash++; 242 } 243 } else 244 #endif 245 { 246 if (((tftp_cur_block - 1) % 10) == 0) 247 putc('#'); 248 else if ((tftp_cur_block % (10 * HASHES_PER_LINE)) == 0) 249 puts("\n\t "); 250 } 251 } 252 253 /** 254 * restart the current transfer due to an error 255 * 256 * @param msg Message to print for user 257 */ 258 static void restart(const char *msg) 259 { 260 printf("\n%s; starting again\n", msg); 261 net_start_again(); 262 } 263 264 /* 265 * Check if the block number has wrapped, and update progress 266 * 267 * TODO: The egregious use of global variables in this file should be tidied. 268 */ 269 static void update_block_number(void) 270 { 271 /* 272 * RFC1350 specifies that the first data packet will 273 * have sequence number 1. If we receive a sequence 274 * number of 0 this means that there was a wrap 275 * around of the (16 bit) counter. 276 */ 277 if (tftp_cur_block == 0 && tftp_prev_block != 0) { 278 tftp_block_wrap++; 279 tftp_block_wrap_offset += tftp_block_size * TFTP_SEQUENCE_SIZE; 280 timeout_count = 0; /* we've done well, reset the timeout */ 281 } else { 282 show_block_marker(); 283 } 284 } 285 286 /* The TFTP get or put is complete */ 287 static void tftp_complete(void) 288 { 289 #ifdef CONFIG_TFTP_TSIZE 290 /* Print hash marks for the last packet received */ 291 while (tftp_tsize && tftp_tsize_num_hash < 49) { 292 putc('#'); 293 tftp_tsize_num_hash++; 294 } 295 puts(" "); 296 print_size(tftp_tsize, ""); 297 #endif 298 time_start = get_timer(time_start); 299 if (time_start > 0) { 300 puts("\n\t "); /* Line up with "Loading: " */ 301 print_size(net_boot_file_size / 302 time_start * 1000, "/s"); 303 } 304 puts("\ndone\n"); 305 net_set_state(NETLOOP_SUCCESS); 306 } 307 308 static void tftp_send(void) 309 { 310 uchar *pkt; 311 uchar *xp; 312 int len = 0; 313 ushort *s; 314 315 /* 316 * We will always be sending some sort of packet, so 317 * cobble together the packet headers now. 318 */ 319 pkt = net_tx_packet + net_eth_hdr_size() + IP_UDP_HDR_SIZE; 320 321 switch (tftp_state) { 322 case STATE_SEND_RRQ: 323 case STATE_SEND_WRQ: 324 xp = pkt; 325 s = (ushort *)pkt; 326 #ifdef CONFIG_CMD_TFTPPUT 327 *s++ = htons(tftp_state == STATE_SEND_RRQ ? TFTP_RRQ : 328 TFTP_WRQ); 329 #else 330 *s++ = htons(TFTP_RRQ); 331 #endif 332 pkt = (uchar *)s; 333 strcpy((char *)pkt, tftp_filename); 334 pkt += strlen(tftp_filename) + 1; 335 strcpy((char *)pkt, "octet"); 336 pkt += 5 /*strlen("octet")*/ + 1; 337 strcpy((char *)pkt, "timeout"); 338 pkt += 7 /*strlen("timeout")*/ + 1; 339 sprintf((char *)pkt, "%lu", timeout_ms / 1000); 340 debug("send option \"timeout %s\"\n", (char *)pkt); 341 pkt += strlen((char *)pkt) + 1; 342 #ifdef CONFIG_TFTP_TSIZE 343 pkt += sprintf((char *)pkt, "tsize%c%u%c", 344 0, net_boot_file_size, 0); 345 #endif 346 /* try for more effic. blk size */ 347 pkt += sprintf((char *)pkt, "blksize%c%d%c", 348 0, tftp_block_size_option, 0); 349 len = pkt - xp; 350 break; 351 352 case STATE_OACK: 353 354 case STATE_RECV_WRQ: 355 case STATE_DATA: 356 xp = pkt; 357 s = (ushort *)pkt; 358 s[0] = htons(TFTP_ACK); 359 s[1] = htons(tftp_cur_block); 360 pkt = (uchar *)(s + 2); 361 #ifdef CONFIG_CMD_TFTPPUT 362 if (tftp_put_active) { 363 int toload = tftp_block_size; 364 int loaded = load_block(tftp_cur_block, pkt, toload); 365 366 s[0] = htons(TFTP_DATA); 367 pkt += loaded; 368 tftp_put_final_block_sent = (loaded < toload); 369 } 370 #endif 371 len = pkt - xp; 372 break; 373 374 case STATE_TOO_LARGE: 375 xp = pkt; 376 s = (ushort *)pkt; 377 *s++ = htons(TFTP_ERROR); 378 *s++ = htons(3); 379 380 pkt = (uchar *)s; 381 strcpy((char *)pkt, "File too large"); 382 pkt += 14 /*strlen("File too large")*/ + 1; 383 len = pkt - xp; 384 break; 385 386 case STATE_BAD_MAGIC: 387 xp = pkt; 388 s = (ushort *)pkt; 389 *s++ = htons(TFTP_ERROR); 390 *s++ = htons(2); 391 pkt = (uchar *)s; 392 strcpy((char *)pkt, "File has bad magic"); 393 pkt += 18 /*strlen("File has bad magic")*/ + 1; 394 len = pkt - xp; 395 break; 396 } 397 398 net_send_udp_packet(net_server_ethaddr, tftp_remote_ip, 399 tftp_remote_port, tftp_our_port, len); 400 } 401 402 #ifdef CONFIG_CMD_TFTPPUT 403 static void icmp_handler(unsigned type, unsigned code, unsigned dest, 404 struct in_addr sip, unsigned src, uchar *pkt, 405 unsigned len) 406 { 407 if (type == ICMP_NOT_REACH && code == ICMP_NOT_REACH_PORT) { 408 /* Oh dear the other end has gone away */ 409 restart("TFTP server died"); 410 } 411 } 412 #endif 413 414 static void tftp_handler(uchar *pkt, unsigned dest, struct in_addr sip, 415 unsigned src, unsigned len) 416 { 417 __be16 proto; 418 __be16 *s; 419 int i; 420 421 if (dest != tftp_our_port) { 422 return; 423 } 424 if (tftp_state != STATE_SEND_RRQ && src != tftp_remote_port && 425 tftp_state != STATE_RECV_WRQ && tftp_state != STATE_SEND_WRQ) 426 return; 427 428 if (len < 2) 429 return; 430 len -= 2; 431 /* warning: don't use increment (++) in ntohs() macros!! */ 432 s = (__be16 *)pkt; 433 proto = *s++; 434 pkt = (uchar *)s; 435 switch (ntohs(proto)) { 436 case TFTP_RRQ: 437 break; 438 439 case TFTP_ACK: 440 #ifdef CONFIG_CMD_TFTPPUT 441 if (tftp_put_active) { 442 if (tftp_put_final_block_sent) { 443 tftp_complete(); 444 } else { 445 /* 446 * Move to the next block. We want our block 447 * count to wrap just like the other end! 448 */ 449 int block = ntohs(*s); 450 int ack_ok = (tftp_cur_block == block); 451 452 tftp_cur_block = (unsigned short)(block + 1); 453 update_block_number(); 454 if (ack_ok) 455 tftp_send(); /* Send next data block */ 456 } 457 } 458 #endif 459 break; 460 461 default: 462 break; 463 464 #ifdef CONFIG_CMD_TFTPSRV 465 case TFTP_WRQ: 466 debug("Got WRQ\n"); 467 tftp_remote_ip = sip; 468 tftp_remote_port = src; 469 tftp_our_port = 1024 + (get_timer(0) % 3072); 470 new_transfer(); 471 tftp_send(); /* Send ACK(0) */ 472 break; 473 #endif 474 475 case TFTP_OACK: 476 debug("Got OACK: %s %s\n", 477 pkt, pkt + strlen((char *)pkt) + 1); 478 tftp_state = STATE_OACK; 479 tftp_remote_port = src; 480 /* 481 * Check for 'blksize' option. 482 * Careful: "i" is signed, "len" is unsigned, thus 483 * something like "len-8" may give a *huge* number 484 */ 485 for (i = 0; i+8 < len; i++) { 486 if (strcmp((char *)pkt + i, "blksize") == 0) { 487 tftp_block_size = (unsigned short) 488 simple_strtoul((char *)pkt + i + 8, 489 NULL, 10); 490 debug("Blocksize ack: %s, %d\n", 491 (char *)pkt + i + 8, tftp_block_size); 492 } 493 #ifdef CONFIG_TFTP_TSIZE 494 if (strcmp((char *)pkt+i, "tsize") == 0) { 495 tftp_tsize = simple_strtoul((char *)pkt + i + 6, 496 NULL, 10); 497 debug("size = %s, %d\n", 498 (char *)pkt + i + 6, tftp_tsize); 499 } 500 #endif 501 } 502 #ifdef CONFIG_CMD_TFTPPUT 503 if (tftp_put_active) { 504 /* Get ready to send the first block */ 505 tftp_state = STATE_DATA; 506 tftp_cur_block++; 507 } 508 #endif 509 tftp_send(); /* Send ACK or first data block */ 510 break; 511 case TFTP_DATA: 512 if (len < 2) 513 return; 514 len -= 2; 515 tftp_cur_block = ntohs(*(__be16 *)pkt); 516 517 update_block_number(); 518 519 if (tftp_state == STATE_SEND_RRQ) 520 debug("Server did not acknowledge timeout option!\n"); 521 522 if (tftp_state == STATE_SEND_RRQ || tftp_state == STATE_OACK || 523 tftp_state == STATE_RECV_WRQ) { 524 /* first block received */ 525 tftp_state = STATE_DATA; 526 tftp_remote_port = src; 527 new_transfer(); 528 529 if (tftp_cur_block != 1) { /* Assertion */ 530 puts("\nTFTP error: "); 531 printf("First block is not block 1 (%ld)\n", 532 tftp_cur_block); 533 puts("Starting again\n\n"); 534 net_start_again(); 535 break; 536 } 537 } 538 539 if (tftp_cur_block == tftp_prev_block) { 540 /* Same block again; ignore it. */ 541 break; 542 } 543 544 tftp_prev_block = tftp_cur_block; 545 timeout_count_max = tftp_timeout_count_max; 546 net_set_timeout_handler(timeout_ms, tftp_timeout_handler); 547 548 if (store_block(tftp_cur_block - 1, pkt + 2, len)) { 549 eth_halt(); 550 net_set_state(NETLOOP_FAIL); 551 break; 552 } 553 554 /* 555 * Acknowledge the block just received, which will prompt 556 * the remote for the next one. 557 */ 558 tftp_send(); 559 560 if (len < tftp_block_size) 561 tftp_complete(); 562 break; 563 564 case TFTP_ERROR: 565 printf("\nTFTP error: '%s' (%d)\n", 566 pkt + 2, ntohs(*(__be16 *)pkt)); 567 568 switch (ntohs(*(__be16 *)pkt)) { 569 case TFTP_ERR_FILE_NOT_FOUND: 570 case TFTP_ERR_ACCESS_DENIED: 571 puts("Not retrying...\n"); 572 eth_halt(); 573 net_set_state(NETLOOP_FAIL); 574 break; 575 case TFTP_ERR_UNDEFINED: 576 case TFTP_ERR_DISK_FULL: 577 case TFTP_ERR_UNEXPECTED_OPCODE: 578 case TFTP_ERR_UNKNOWN_TRANSFER_ID: 579 case TFTP_ERR_FILE_ALREADY_EXISTS: 580 default: 581 puts("Starting again\n\n"); 582 net_start_again(); 583 break; 584 } 585 break; 586 } 587 } 588 589 590 static void tftp_timeout_handler(void) 591 { 592 if (++timeout_count > timeout_count_max) { 593 restart("Retry count exceeded"); 594 } else { 595 puts("T "); 596 net_set_timeout_handler(timeout_ms, tftp_timeout_handler); 597 if (tftp_state != STATE_RECV_WRQ) 598 tftp_send(); 599 } 600 } 601 602 /* Initialize tftp_load_addr and tftp_load_size from load_addr and lmb */ 603 static int tftp_init_load_addr(void) 604 { 605 #ifdef CONFIG_LMB 606 struct lmb lmb; 607 phys_size_t max_size; 608 609 lmb_init_and_reserve(&lmb, gd->bd->bi_dram[0].start, 610 gd->bd->bi_dram[0].size, (void *)gd->fdt_blob); 611 612 max_size = lmb_get_unreserved_size(&lmb, load_addr); 613 if (!max_size) 614 return -1; 615 616 tftp_load_size = max_size; 617 #endif 618 tftp_load_addr = load_addr; 619 return 0; 620 } 621 622 void tftp_start(enum proto_t protocol) 623 { 624 #if CONFIG_NET_TFTP_VARS 625 char *ep; /* Environment pointer */ 626 627 /* 628 * Allow the user to choose TFTP blocksize and timeout. 629 * TFTP protocol has a minimal timeout of 1 second. 630 */ 631 632 ep = env_get("tftpblocksize"); 633 if (ep != NULL) 634 tftp_block_size_option = simple_strtol(ep, NULL, 10); 635 636 ep = env_get("tftptimeout"); 637 if (ep != NULL) 638 timeout_ms = simple_strtol(ep, NULL, 10); 639 640 if (timeout_ms < 1000) { 641 printf("TFTP timeout (%ld ms) too low, set min = 1000 ms\n", 642 timeout_ms); 643 timeout_ms = 1000; 644 } 645 646 ep = env_get("tftptimeoutcountmax"); 647 if (ep != NULL) 648 tftp_timeout_count_max = simple_strtol(ep, NULL, 10); 649 650 if (tftp_timeout_count_max < 0) { 651 printf("TFTP timeout count max (%d ms) negative, set to 0\n", 652 tftp_timeout_count_max); 653 tftp_timeout_count_max = 0; 654 } 655 #endif 656 657 debug("TFTP blocksize = %i, timeout = %ld ms\n", 658 tftp_block_size_option, timeout_ms); 659 660 tftp_remote_ip = net_server_ip; 661 if (!net_parse_bootfile(&tftp_remote_ip, tftp_filename, MAX_LEN)) { 662 sprintf(default_filename, "%02X%02X%02X%02X.img", 663 net_ip.s_addr & 0xFF, 664 (net_ip.s_addr >> 8) & 0xFF, 665 (net_ip.s_addr >> 16) & 0xFF, 666 (net_ip.s_addr >> 24) & 0xFF); 667 668 strncpy(tftp_filename, default_filename, DEFAULT_NAME_LEN); 669 tftp_filename[DEFAULT_NAME_LEN - 1] = 0; 670 671 printf("*** Warning: no boot file name; using '%s'\n", 672 tftp_filename); 673 } 674 675 printf("Using %s device\n", eth_get_name()); 676 printf("TFTP %s server %pI4; our IP address is %pI4", 677 #ifdef CONFIG_CMD_TFTPPUT 678 protocol == TFTPPUT ? "to" : "from", 679 #else 680 "from", 681 #endif 682 &tftp_remote_ip, &net_ip); 683 684 /* Check if we need to send across this subnet */ 685 if (net_gateway.s_addr && net_netmask.s_addr) { 686 struct in_addr our_net; 687 struct in_addr remote_net; 688 689 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr; 690 remote_net.s_addr = tftp_remote_ip.s_addr & net_netmask.s_addr; 691 if (our_net.s_addr != remote_net.s_addr) 692 printf("; sending through gateway %pI4", &net_gateway); 693 } 694 putc('\n'); 695 696 printf("Filename '%s'.", tftp_filename); 697 698 if (net_boot_file_expected_size_in_blocks) { 699 printf(" Size is 0x%x Bytes = ", 700 net_boot_file_expected_size_in_blocks << 9); 701 print_size(net_boot_file_expected_size_in_blocks << 9, ""); 702 } 703 704 putc('\n'); 705 #ifdef CONFIG_CMD_TFTPPUT 706 tftp_put_active = (protocol == TFTPPUT); 707 if (tftp_put_active) { 708 printf("Save address: 0x%lx\n", save_addr); 709 printf("Save size: 0x%lx\n", save_size); 710 net_boot_file_size = save_size; 711 puts("Saving: *\b"); 712 tftp_state = STATE_SEND_WRQ; 713 new_transfer(); 714 } else 715 #endif 716 { 717 if (tftp_init_load_addr()) { 718 eth_halt(); 719 net_set_state(NETLOOP_FAIL); 720 puts("\nTFTP error: "); 721 puts("trying to overwrite reserved memory...\n"); 722 return; 723 } 724 printf("Load address: 0x%lx\n", tftp_load_addr); 725 puts("Loading: *\b"); 726 tftp_state = STATE_SEND_RRQ; 727 #ifdef CONFIG_CMD_BOOTEFI 728 efi_set_bootdev("Net", "", tftp_filename); 729 #endif 730 } 731 732 time_start = get_timer(0); 733 timeout_count_max = tftp_timeout_count_max; 734 735 net_set_timeout_handler(timeout_ms, tftp_timeout_handler); 736 net_set_udp_handler(tftp_handler); 737 #ifdef CONFIG_CMD_TFTPPUT 738 net_set_icmp_handler(icmp_handler); 739 #endif 740 tftp_remote_port = WELL_KNOWN_PORT; 741 timeout_count = 0; 742 /* Use a pseudo-random port unless a specific port is set */ 743 tftp_our_port = 1024 + (get_timer(0) % 3072); 744 745 #ifdef CONFIG_TFTP_PORT 746 ep = env_get("tftpdstp"); 747 if (ep != NULL) 748 tftp_remote_port = simple_strtol(ep, NULL, 10); 749 ep = env_get("tftpsrcp"); 750 if (ep != NULL) 751 tftp_our_port = simple_strtol(ep, NULL, 10); 752 #endif 753 tftp_cur_block = 0; 754 755 /* zero out server ether in case the server ip has changed */ 756 memset(net_server_ethaddr, 0, 6); 757 /* Revert tftp_block_size to dflt */ 758 tftp_block_size = TFTP_BLOCK_SIZE; 759 #ifdef CONFIG_TFTP_TSIZE 760 tftp_tsize = 0; 761 tftp_tsize_num_hash = 0; 762 #endif 763 764 tftp_send(); 765 } 766 767 #ifdef CONFIG_CMD_TFTPSRV 768 void tftp_start_server(void) 769 { 770 tftp_filename[0] = 0; 771 772 if (tftp_init_load_addr()) { 773 eth_halt(); 774 net_set_state(NETLOOP_FAIL); 775 puts("\nTFTP error: trying to overwrite reserved memory...\n"); 776 return; 777 } 778 printf("Using %s device\n", eth_get_name()); 779 printf("Listening for TFTP transfer on %pI4\n", &net_ip); 780 printf("Load address: 0x%lx\n", tftp_load_addr); 781 782 puts("Loading: *\b"); 783 784 timeout_count_max = tftp_timeout_count_max; 785 timeout_count = 0; 786 timeout_ms = TIMEOUT; 787 net_set_timeout_handler(timeout_ms, tftp_timeout_handler); 788 789 /* Revert tftp_block_size to dflt */ 790 tftp_block_size = TFTP_BLOCK_SIZE; 791 tftp_cur_block = 0; 792 tftp_our_port = WELL_KNOWN_PORT; 793 794 #ifdef CONFIG_TFTP_TSIZE 795 tftp_tsize = 0; 796 tftp_tsize_num_hash = 0; 797 #endif 798 799 tftp_state = STATE_RECV_WRQ; 800 net_set_udp_handler(tftp_handler); 801 802 /* zero out server ether in case the server ip has changed */ 803 memset(net_server_ethaddr, 0, 6); 804 } 805 #endif /* CONFIG_CMD_TFTPSRV */ 806 807