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, (void *)gd->fdt_blob); 610 611 max_size = lmb_get_free_size(&lmb, load_addr); 612 if (!max_size) 613 return -1; 614 615 tftp_load_size = max_size; 616 #endif 617 tftp_load_addr = load_addr; 618 return 0; 619 } 620 621 void tftp_start(enum proto_t protocol) 622 { 623 #if CONFIG_NET_TFTP_VARS 624 char *ep; /* Environment pointer */ 625 626 /* 627 * Allow the user to choose TFTP blocksize and timeout. 628 * TFTP protocol has a minimal timeout of 1 second. 629 */ 630 631 ep = env_get("tftpblocksize"); 632 if (ep != NULL) 633 tftp_block_size_option = simple_strtol(ep, NULL, 10); 634 635 ep = env_get("tftptimeout"); 636 if (ep != NULL) 637 timeout_ms = simple_strtol(ep, NULL, 10); 638 639 if (timeout_ms < 1000) { 640 printf("TFTP timeout (%ld ms) too low, set min = 1000 ms\n", 641 timeout_ms); 642 timeout_ms = 1000; 643 } 644 645 ep = env_get("tftptimeoutcountmax"); 646 if (ep != NULL) 647 tftp_timeout_count_max = simple_strtol(ep, NULL, 10); 648 649 if (tftp_timeout_count_max < 0) { 650 printf("TFTP timeout count max (%d ms) negative, set to 0\n", 651 tftp_timeout_count_max); 652 tftp_timeout_count_max = 0; 653 } 654 #endif 655 656 debug("TFTP blocksize = %i, timeout = %ld ms\n", 657 tftp_block_size_option, timeout_ms); 658 659 tftp_remote_ip = net_server_ip; 660 if (!net_parse_bootfile(&tftp_remote_ip, tftp_filename, MAX_LEN)) { 661 sprintf(default_filename, "%02X%02X%02X%02X.img", 662 net_ip.s_addr & 0xFF, 663 (net_ip.s_addr >> 8) & 0xFF, 664 (net_ip.s_addr >> 16) & 0xFF, 665 (net_ip.s_addr >> 24) & 0xFF); 666 667 strncpy(tftp_filename, default_filename, DEFAULT_NAME_LEN); 668 tftp_filename[DEFAULT_NAME_LEN - 1] = 0; 669 670 printf("*** Warning: no boot file name; using '%s'\n", 671 tftp_filename); 672 } 673 674 printf("Using %s device\n", eth_get_name()); 675 printf("TFTP %s server %pI4; our IP address is %pI4", 676 #ifdef CONFIG_CMD_TFTPPUT 677 protocol == TFTPPUT ? "to" : "from", 678 #else 679 "from", 680 #endif 681 &tftp_remote_ip, &net_ip); 682 683 /* Check if we need to send across this subnet */ 684 if (net_gateway.s_addr && net_netmask.s_addr) { 685 struct in_addr our_net; 686 struct in_addr remote_net; 687 688 our_net.s_addr = net_ip.s_addr & net_netmask.s_addr; 689 remote_net.s_addr = tftp_remote_ip.s_addr & net_netmask.s_addr; 690 if (our_net.s_addr != remote_net.s_addr) 691 printf("; sending through gateway %pI4", &net_gateway); 692 } 693 putc('\n'); 694 695 printf("Filename '%s'.", tftp_filename); 696 697 if (net_boot_file_expected_size_in_blocks) { 698 printf(" Size is 0x%x Bytes = ", 699 net_boot_file_expected_size_in_blocks << 9); 700 print_size(net_boot_file_expected_size_in_blocks << 9, ""); 701 } 702 703 putc('\n'); 704 #ifdef CONFIG_CMD_TFTPPUT 705 tftp_put_active = (protocol == TFTPPUT); 706 if (tftp_put_active) { 707 printf("Save address: 0x%lx\n", save_addr); 708 printf("Save size: 0x%lx\n", save_size); 709 net_boot_file_size = save_size; 710 puts("Saving: *\b"); 711 tftp_state = STATE_SEND_WRQ; 712 new_transfer(); 713 } else 714 #endif 715 { 716 if (tftp_init_load_addr()) { 717 eth_halt(); 718 net_set_state(NETLOOP_FAIL); 719 puts("\nTFTP error: "); 720 puts("trying to overwrite reserved memory...\n"); 721 return; 722 } 723 printf("Load address: 0x%lx\n", tftp_load_addr); 724 puts("Loading: *\b"); 725 tftp_state = STATE_SEND_RRQ; 726 #ifdef CONFIG_CMD_BOOTEFI 727 efi_set_bootdev("Net", "", tftp_filename); 728 #endif 729 } 730 731 time_start = get_timer(0); 732 timeout_count_max = tftp_timeout_count_max; 733 734 net_set_timeout_handler(timeout_ms, tftp_timeout_handler); 735 net_set_udp_handler(tftp_handler); 736 #ifdef CONFIG_CMD_TFTPPUT 737 net_set_icmp_handler(icmp_handler); 738 #endif 739 tftp_remote_port = WELL_KNOWN_PORT; 740 timeout_count = 0; 741 /* Use a pseudo-random port unless a specific port is set */ 742 tftp_our_port = 1024 + (get_timer(0) % 3072); 743 744 #ifdef CONFIG_TFTP_PORT 745 ep = env_get("tftpdstp"); 746 if (ep != NULL) 747 tftp_remote_port = simple_strtol(ep, NULL, 10); 748 ep = env_get("tftpsrcp"); 749 if (ep != NULL) 750 tftp_our_port = simple_strtol(ep, NULL, 10); 751 #endif 752 tftp_cur_block = 0; 753 754 /* zero out server ether in case the server ip has changed */ 755 memset(net_server_ethaddr, 0, 6); 756 /* Revert tftp_block_size to dflt */ 757 tftp_block_size = TFTP_BLOCK_SIZE; 758 #ifdef CONFIG_TFTP_TSIZE 759 tftp_tsize = 0; 760 tftp_tsize_num_hash = 0; 761 #endif 762 763 tftp_send(); 764 } 765 766 #ifdef CONFIG_CMD_TFTPSRV 767 void tftp_start_server(void) 768 { 769 tftp_filename[0] = 0; 770 771 if (tftp_init_load_addr()) { 772 eth_halt(); 773 net_set_state(NETLOOP_FAIL); 774 puts("\nTFTP error: trying to overwrite reserved memory...\n"); 775 return; 776 } 777 printf("Using %s device\n", eth_get_name()); 778 printf("Listening for TFTP transfer on %pI4\n", &net_ip); 779 printf("Load address: 0x%lx\n", tftp_load_addr); 780 781 puts("Loading: *\b"); 782 783 timeout_count_max = tftp_timeout_count_max; 784 timeout_count = 0; 785 timeout_ms = TIMEOUT; 786 net_set_timeout_handler(timeout_ms, tftp_timeout_handler); 787 788 /* Revert tftp_block_size to dflt */ 789 tftp_block_size = TFTP_BLOCK_SIZE; 790 tftp_cur_block = 0; 791 tftp_our_port = WELL_KNOWN_PORT; 792 793 #ifdef CONFIG_TFTP_TSIZE 794 tftp_tsize = 0; 795 tftp_tsize_num_hash = 0; 796 #endif 797 798 tftp_state = STATE_RECV_WRQ; 799 net_set_udp_handler(tftp_handler); 800 801 /* zero out server ether in case the server ip has changed */ 802 memset(net_server_ethaddr, 0, 6); 803 } 804 #endif /* CONFIG_CMD_TFTPSRV */ 805 806