/*
|
/*
|
* Copyright 1994, 1995, 2000 Neil Russell.
|
* Copyright 1994, 1995, 2000 Neil Russell.
|
* (See License)
|
* (See License)
|
* Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de
|
* Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de
|
*/
|
*/
|
|
|
#include "common.h"
|
#include "common.h"
|
#include "support.h"
|
#include "support.h"
|
#include "net.h"
|
#include "net.h"
|
#include "tftp.h"
|
#include "tftp.h"
|
#include "bootp.h"
|
#include "bootp.h"
|
|
|
|
|
#define WELL_KNOWN_PORT 69 /* Well known TFTP port # */
|
#define WELL_KNOWN_PORT 69 /* Well known TFTP port # */
|
#define TIMEOUT 2 /* Seconds to timeout for a lost pkt */
|
#define TIMEOUT 2 /* Seconds to timeout for a lost pkt */
|
#define TIMEOUT_COUNT 10 /* # of timeouts before giving up */
|
#define TIMEOUT_COUNT 10 /* # of timeouts before giving up */
|
/* (for checking the image size) */
|
/* (for checking the image size) */
|
#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
|
#define HASHES_PER_LINE 65 /* Number of "loading" hashes per line */
|
|
|
/*
|
/*
|
* TFTP operations.
|
* TFTP operations.
|
*/
|
*/
|
#define TFTP_RRQ 1
|
#define TFTP_RRQ 1
|
#define TFTP_WRQ 2
|
#define TFTP_WRQ 2
|
#define TFTP_DATA 3
|
#define TFTP_DATA 3
|
#define TFTP_ACK 4
|
#define TFTP_ACK 4
|
#define TFTP_ERROR 5
|
#define TFTP_ERROR 5
|
|
|
|
|
static int TftpServerPort; /* The UDP port at their end */
|
static int TftpServerPort; /* The UDP port at their end */
|
static int TftpOurPort; /* The UDP port at our end */
|
static int TftpOurPort; /* The UDP port at our end */
|
static int TftpTimeoutCount;
|
static int TftpTimeoutCount;
|
static unsigned TftpBlock;
|
static unsigned TftpBlock;
|
static unsigned TftpLastBlock;
|
static unsigned TftpLastBlock;
|
static int TftpState;
|
static int TftpState;
|
#define STATE_RRQ 1
|
#define STATE_RRQ 1
|
#define STATE_DATA 2
|
#define STATE_DATA 2
|
#define STATE_TOO_LARGE 3
|
#define STATE_TOO_LARGE 3
|
#define STATE_BAD_MAGIC 4
|
#define STATE_BAD_MAGIC 4
|
|
|
char *tftp_filename;
|
char *tftp_filename;
|
|
|
|
|
// running TFTP CRC value
|
// running TFTP CRC value
|
unsigned long TFTP_CHKSUM;
|
unsigned long TFTP_CHKSUM;
|
|
|
#ifdef CFG_DIRECT_FLASH_TFTP
|
#ifdef CFG_DIRECT_FLASH_TFTP
|
extern flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
|
extern flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
|
#endif
|
#endif
|
|
|
static __inline__ void
|
static __inline__ void
|
store_block (unsigned block, unsigned char * src, unsigned len)
|
store_block(unsigned block, unsigned char *src, unsigned len)
|
{
|
{
|
unsigned long offset = block * 512, newsize = offset + len;
|
unsigned long offset = block * 512, newsize = offset + len;
|
#ifdef CFG_DIRECT_FLASH_TFTP
|
#ifdef CFG_DIRECT_FLASH_TFTP
|
int i, rc = 0;
|
int i, rc = 0;
|
|
|
for (i=0; i<CFG_MAX_FLASH_BANKS; i++) {
|
for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) {
|
/* start address in flash? */
|
/* start address in flash? */
|
if (global.src_addr + offset >= flash_info[i].start[0]) {
|
if (global.src_addr + offset >= flash_info[i].start[0]) {
|
rc = 1;
|
rc = 1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (rc) { /* Flash is destination for this packet */
|
if (rc) { /* Flash is destination for this packet */
|
rc = flash_write ((unsigned char *)src, (unsigned long)(global.src_addr+offset), len);
|
rc = flash_write((unsigned char *)src,
|
|
(unsigned long)(global.src_addr + offset),
|
|
len);
|
switch (rc) {
|
switch (rc) {
|
case 0: /* OK */
|
case 0: /* OK */
|
break;
|
break;
|
case 1: printf ("Timeout writing to Flash\n");
|
case 1:
|
|
printf("Timeout writing to Flash\n");
|
break;
|
break;
|
case 2: printf ("Flash not Erased\n");
|
case 2:
|
|
printf("Flash not Erased\n");
|
break;
|
break;
|
case 4: printf ("Can't write to protected Flash sectors\n");
|
case 4:
|
|
printf("Can't write to protected Flash sectors\n");
|
break;
|
break;
|
case 8: printf ("Outside available Flash\n");
|
case 8:
|
|
printf("Outside available Flash\n");
|
break;
|
break;
|
case 16:printf ("Size must be aligned (multiple of 8?)\n");
|
case 16:
|
|
printf("Size must be aligned (multiple of 8?)\n");
|
break;
|
break;
|
default:
|
default:
|
printf ("%s[%d] FIXME: rc=%d\n",__FILE__,__LINE__,rc);
|
printf("%s[%d] FIXME: rc=%d\n", __FILE__, __LINE__, rc);
|
break;
|
break;
|
}
|
}
|
if (rc) {
|
if (rc) {
|
NetState = NETLOOP_FAIL;
|
NetState = NETLOOP_FAIL;
|
return;
|
return;
|
}
|
}
|
}
|
} else
|
else
|
|
#endif /* CFG_DIRECT_FLASH_TFTP */
|
#endif /* CFG_DIRECT_FLASH_TFTP */
|
|
|
//#define QUICK_ETHPACKET_COPY
|
//#define QUICK_ETHPACKET_COPY
|
#ifdef QUICK_ETHPACKET_COPY
|
#ifdef QUICK_ETHPACKET_COPY
|
{
|
{
|
unsigned char * dst = (unsigned char*)(global.src_addr + offset);
|
unsigned char *dst =
|
|
(unsigned char *)(global.src_addr + offset);
|
//printf("quick ethpacket copy: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
//printf("quick ethpacket copy: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
// First, align the destination address so we can copy words
|
// First, align the destination address so we can copy words
|
// If either src or dst are not word aligned, then we will never
|
// If either src or dst are not word aligned, then we will never
|
// be able to do word copies
|
// be able to do word copies
|
while((len) && ((((unsigned long)dst) & 0x3) || (((unsigned long)src) & 0x3)))
|
while ((len)
|
{
|
&& ((((unsigned long)dst) & 0x3)
|
|
|| (((unsigned long)src) & 0x3))) {
|
// printf("bc: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
// printf("bc: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
dst[0] = src[0];
|
dst[0] = src[0];
|
len--;
|
len--;
|
dst++;
|
dst++;
|
src++;
|
src++;
|
|
|
}
|
}
|
unsigned long *wdst, *wsrc;
|
unsigned long *wdst, *wsrc;
|
wdst = (unsigned long*) dst;
|
wdst = (unsigned long *)dst;
|
wsrc = (unsigned long*) src;
|
wsrc = (unsigned long*) src;
|
while(len >= 4)
|
while (len >= 4) {
|
{
|
|
//printf("wc: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
//printf("wc: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
wdst[0] = wsrc[0];
|
wdst[0] = wsrc[0];
|
wdst++; wsrc++;
|
wdst++;
|
|
wsrc++;
|
len -= 4;
|
len -= 4;
|
dst+=4;
|
dst += 4;
|
src+=4;
|
src += 4;
|
|
|
}
|
}
|
while (len)
|
while (len) {
|
{
|
|
//printf("cu: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
//printf("cu: src: 0x%x dst: 0x%x, len: %d\n",(unsigned long)src, (unsigned long)dst, len);
|
dst[0] = src[0];
|
dst[0] = src[0];
|
len--;
|
len--;
|
dst++;
|
dst++;
|
src++;
|
src++;
|
}
|
}
|
}
|
}
|
#else
|
#else
|
|
|
#ifdef TFTP_CALC_CRC
|
#ifdef TFTP_CALC_CRC
|
// Call special memcpy that calculates CRC for us:
|
// Call special memcpy that calculates CRC for us:
|
TFTP_CHKSUM += memcpy_crc((void *)(global.src_addr + offset), src, len);
|
TFTP_CHKSUM +=
|
|
memcpy_crc((void *)(global.src_addr + offset), src, len);
|
#else
|
#else
|
// Standard memcpy:
|
// Standard memcpy:
|
(void)memcpy((void *)(global.src_addr + offset), src, len);
|
(void)memcpy((void *)(global.src_addr + offset), src, len);
|
#endif
|
#endif
|
|
|
|
|
#endif
|
#endif
|
|
|
if (NetBootFileXferSize < newsize)
|
if (NetBootFileXferSize < newsize)
|
NetBootFileXferSize = newsize;
|
NetBootFileXferSize = newsize;
|
}
|
}
|
|
|
static void TftpSend (void);
|
static void TftpSend(void);
|
static void TftpTimeout (void);
|
static void TftpTimeout(void);
|
|
|
/**********************************************************************/
|
/**********************************************************************/
|
|
|
static void
|
static void TftpSend(void)
|
TftpSend (void)
|
|
{
|
{
|
volatile unsigned char * pkt;
|
volatile unsigned char *pkt;
|
volatile unsigned char * xp;
|
volatile unsigned char *xp;
|
int len = 0;
|
int len = 0;
|
|
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("TftpSend: %d\n", TftpState);
|
printf("TftpSend: %d\n", TftpState);
|
#endif
|
#endif
|
|
|
|
|
/*
|
/*
|
* We will always be sending some sort of packet, so
|
* We will always be sending some sort of packet, so
|
* cobble together the packet headers now.
|
* cobble together the packet headers now.
|
*/
|
*/
|
pkt = NetTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE;
|
pkt = NetTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE;
|
|
|
switch (TftpState) {
|
switch (TftpState) {
|
|
|
case STATE_RRQ:
|
case STATE_RRQ:
|
xp = pkt;
|
xp = pkt;
|
(*((unsigned short *)pkt)) = SWAP16c(TFTP_RRQ);
|
(*((unsigned short *)pkt)) = SWAP16c(TFTP_RRQ);
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
strcpy ((char *)pkt, tftp_filename);
|
strcpy((char *)pkt, tftp_filename);
|
pkt += strlen(tftp_filename) + 1;
|
pkt += strlen(tftp_filename) + 1;
|
strcpy ((char *)pkt, "octet");
|
strcpy((char *)pkt, "octet");
|
pkt += 5 /*strlen("octet")*/ + 1;
|
pkt += 5 /*strlen("octet") */ + 1;
|
len = pkt - xp;
|
len = pkt - xp;
|
|
|
break;
|
break;
|
|
|
case STATE_DATA:
|
case STATE_DATA:
|
xp = pkt;
|
xp = pkt;
|
*((unsigned short *)pkt) = SWAP16c(TFTP_ACK);
|
*((unsigned short *)pkt) = SWAP16c(TFTP_ACK);
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
*((unsigned short *)pkt) = SWAP16(TftpBlock);
|
*((unsigned short *)pkt) = SWAP16(TftpBlock);
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
len = pkt - xp;
|
len = pkt - xp;
|
break;
|
break;
|
|
|
case STATE_TOO_LARGE:
|
case STATE_TOO_LARGE:
|
xp = pkt;
|
xp = pkt;
|
*((unsigned short *)pkt) = SWAP16c(TFTP_ERROR);
|
*((unsigned short *)pkt) = SWAP16c(TFTP_ERROR);
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
*((unsigned short *)pkt) = SWAP16(3);
|
*((unsigned short *)pkt) = SWAP16(3);
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
strcpy ((char *)pkt, "File too large");
|
strcpy((char *)pkt, "File too large");
|
pkt += 14 /*strlen("File too large")*/ + 1;
|
pkt += 14 /*strlen("File too large") */ + 1;
|
len = pkt - xp;
|
len = pkt - xp;
|
break;
|
break;
|
|
|
case STATE_BAD_MAGIC:
|
case STATE_BAD_MAGIC:
|
xp = pkt;
|
xp = pkt;
|
*((unsigned short *)pkt) = SWAP16c(TFTP_ERROR);
|
*((unsigned short *)pkt) = SWAP16c(TFTP_ERROR);
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
*((unsigned short *)pkt) = SWAP16(2);
|
*((unsigned short *)pkt) = SWAP16(2);
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
strcpy ((char *)pkt, "File has bad magic");
|
strcpy((char *)pkt, "File has bad magic");
|
pkt += 18 /*strlen("File has bad magic")*/ + 1;
|
pkt += 18 /*strlen("File has bad magic") */ + 1;
|
len = pkt - xp;
|
len = pkt - xp;
|
break;
|
break;
|
}
|
}
|
|
|
NetSetEther (NetTxPacket, NetServerEther, PROT_IP);
|
NetSetEther(NetTxPacket, NetServerEther, PROT_IP);
|
NetSetIP (NetTxPacket + ETHER_HDR_SIZE, NetServerIP,
|
NetSetIP(NetTxPacket + ETHER_HDR_SIZE, NetServerIP,
|
TftpServerPort, TftpOurPort, len);
|
TftpServerPort, TftpOurPort, len);
|
NetSendPacket (NetTxPacket, ETHER_HDR_SIZE + IP_HDR_SIZE + len);
|
NetSendPacket(NetTxPacket, ETHER_HDR_SIZE + IP_HDR_SIZE + len);
|
|
|
}
|
}
|
|
|
|
|
static void
|
static void
|
TftpHandler (unsigned char * pkt, unsigned dest, unsigned src, unsigned len)
|
TftpHandler(unsigned char *pkt, unsigned dest, unsigned src, unsigned len)
|
{
|
{
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
// printf("TftpHandler\n");
|
// printf("TftpHandler\n");
|
#endif
|
#endif
|
if (dest != TftpOurPort) {
|
if (dest != TftpOurPort) {
|
return;
|
return;
|
}
|
}
|
if (TftpState != STATE_RRQ && src != TftpServerPort) {
|
if (TftpState != STATE_RRQ && src != TftpServerPort) {
|
return;
|
return;
|
}
|
}
|
|
|
if (len < 2) {
|
if (len < 2) {
|
return;
|
return;
|
}
|
}
|
len -= 2;
|
len -= 2;
|
switch (SWAP16(*((unsigned short *)pkt))) {
|
switch (SWAP16(*((unsigned short *)pkt))) {
|
|
|
case TFTP_RRQ:
|
case TFTP_RRQ:
|
case TFTP_WRQ:
|
case TFTP_WRQ:
|
case TFTP_ACK:
|
case TFTP_ACK:
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
|
|
case TFTP_DATA:
|
case TFTP_DATA:
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
if (len < 2)
|
if (len < 2)
|
return;
|
return;
|
len -= 2;
|
len -= 2;
|
TftpBlock = SWAP16(*(unsigned short *)pkt);
|
TftpBlock = SWAP16(*(unsigned short *)pkt);
|
if (((TftpBlock - 1) % 10) == 0) {
|
if (((TftpBlock - 1) % 10) == 0) {
|
putc ('#');
|
putc('#');
|
TftpTimeoutCount = 0;
|
TftpTimeoutCount = 0;
|
} else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) {
|
} else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) {
|
printf ("\n\t ");
|
printf("\n\t ");
|
}
|
}
|
|
|
if (TftpState == STATE_RRQ) {
|
if (TftpState == STATE_RRQ) {
|
TftpState = STATE_DATA;
|
TftpState = STATE_DATA;
|
TftpServerPort = src;
|
TftpServerPort = src;
|
TftpLastBlock = 0;
|
TftpLastBlock = 0;
|
|
|
|
|
if (TftpBlock != 1) { /* Assertion */
|
if (TftpBlock != 1) { /* Assertion */
|
printf ("\nTFTP error: "
|
printf("\nTFTP error: "
|
"First block is not block 1 (%d)\n"
|
"First block is not block 1 (%d)\n"
|
"Starting again\n\n",
|
"Starting again\n\n", TftpBlock);
|
TftpBlock);
|
|
NetStartAgain ();
|
NetStartAgain ();
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
if (TftpBlock == TftpLastBlock) {
|
if (TftpBlock == TftpLastBlock) {
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("block %d - repeated\n",TftpLastBlock);
|
printf("block %d - repeated\n", TftpLastBlock);
|
#endif
|
#endif
|
/*
|
/*
|
* Same block again; resend ack (maybe got lost last time)
|
* Same block again; resend ack (maybe got lost last time)
|
*/
|
*/
|
TftpSend ();
|
TftpSend();
|
break;
|
break;
|
}
|
} else {
|
else
|
|
{
|
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf("block %d - OK\n",TftpLastBlock);
|
printf("block %d - OK\n", TftpLastBlock);
|
#endif
|
#endif
|
TftpLastBlock = TftpBlock;
|
TftpLastBlock = TftpBlock;
|
NetSetTimeout (TIMEOUT * TICKS_PER_SEC, TftpTimeout);
|
NetSetTimeout(TIMEOUT * TICKS_PER_SEC, TftpTimeout);
|
|
|
store_block (TftpBlock - 1, pkt + 2, len);
|
store_block(TftpBlock - 1, pkt + 2, len);
|
}
|
}
|
|
|
/*
|
/*
|
* Acknoledge the block just received, which will prompt
|
* Acknoledge the block just received, which will prompt
|
* the server for the next one.
|
* the server for the next one.
|
*/
|
*/
|
TftpSend ();
|
TftpSend();
|
|
|
if (len < 512) {
|
if (len < 512) {
|
/*
|
/*
|
* We received the whole thing. Try to
|
* We received the whole thing. Try to
|
* run it.
|
* run it.
|
*/
|
*/
|
printf ("\ndone\n");
|
printf("\ndone\n");
|
NetState = NETLOOP_SUCCESS;
|
NetState = NETLOOP_SUCCESS;
|
}
|
}
|
break;
|
break;
|
|
|
case TFTP_ERROR:
|
case TFTP_ERROR:
|
pkt += sizeof(short);
|
pkt += sizeof(short);
|
printf ("\nTFTP error: '%s' (%d)\n",
|
printf("\nTFTP error: '%s' (%d)\n",
|
pkt + 2, SWAP16(*(unsigned short *)pkt));
|
pkt + 2, SWAP16(*(unsigned short *)pkt));
|
printf ("Starting again\n\n");
|
printf("Starting again\n\n");
|
NetStartAgain ();
|
NetStartAgain();
|
break;
|
break;
|
}
|
}
|
|
|
}
|
}
|
|
|
|
static void TftpTimeout(void)
|
static void
|
|
TftpTimeout (void)
|
|
{
|
{
|
if (++TftpTimeoutCount >= TIMEOUT_COUNT) {
|
if (++TftpTimeoutCount >= TIMEOUT_COUNT) {
|
printf ("\nRetry count exceeded; starting again\n");
|
printf("\nRetry count exceeded; starting again\n");
|
NetStartAgain ();
|
NetStartAgain();
|
} else {
|
} else {
|
printf ("T ");
|
printf("T ");
|
NetSetTimeout (TIMEOUT * TICKS_PER_SEC, TftpTimeout);
|
NetSetTimeout(TIMEOUT * TICKS_PER_SEC, TftpTimeout);
|
TftpSend ();
|
TftpSend();
|
}
|
}
|
}
|
}
|
|
|
|
void TftpStart(void)
|
void
|
|
TftpStart (void)
|
|
{
|
{
|
#ifdef ET_DEBUG
|
#ifdef ET_DEBUG
|
printf ("\nServer ethernet address %02x:%02x:%02x:%02x:%02x:%02x\n",
|
printf("\nServer ethernet address %02x:%02x:%02x:%02x:%02x:%02x\n",
|
NetServerEther[0],
|
NetServerEther[0],
|
NetServerEther[1],
|
NetServerEther[1],
|
NetServerEther[2],
|
NetServerEther[2],
|
NetServerEther[3],
|
NetServerEther[3], NetServerEther[4], NetServerEther[5]
|
NetServerEther[4],
|
|
NetServerEther[5]
|
|
);
|
);
|
#endif /* DEBUG */
|
#endif /* DEBUG */
|
|
|
TFTP_CHKSUM = 0; // Reset checksum
|
TFTP_CHKSUM = 0; // Reset checksum
|
|
|
printf ("TFTP from server "); print_IPaddr (NetServerIP);
|
printf("TFTP from server ");
|
printf ("; our IP address is "); print_IPaddr (NetOurIP);
|
print_IPaddr(NetServerIP);
|
|
printf("; our IP address is ");
|
|
print_IPaddr(NetOurIP);
|
|
|
// Check if we need to send across this subnet
|
// Check if we need to send across this subnet
|
if (NetOurGatewayIP && NetOurSubnetMask) {
|
if (NetOurGatewayIP && NetOurSubnetMask) {
|
IPaddr_t OurNet = NetOurIP & NetOurSubnetMask;
|
IPaddr_t OurNet = NetOurIP & NetOurSubnetMask;
|
IPaddr_t ServerNet = NetServerIP & NetOurSubnetMask;
|
IPaddr_t ServerNet = NetServerIP & NetOurSubnetMask;
|
|
|
if (OurNet != ServerNet) {
|
if (OurNet != ServerNet) {
|
printf ("; sending through gateway ");
|
printf("; sending through gateway ");
|
print_IPaddr (NetOurGatewayIP) ;
|
print_IPaddr(NetOurGatewayIP);
|
}
|
}
|
}
|
}
|
putc ('\n');
|
putc('\n');
|
|
|
printf ("Filename '%s'.", tftp_filename);
|
printf("Filename '%s'.", tftp_filename);
|
|
|
if (NetBootFileSize) {
|
if (NetBootFileSize) {
|
printf (" Size is %d%s kB => %x Bytes",
|
printf(" Size is %d%s kB => %x Bytes",
|
NetBootFileSize/2,
|
NetBootFileSize/2,
|
(NetBootFileSize%2) ? ".5" : "",
|
(NetBootFileSize % 2) ? ".5" : "", NetBootFileSize << 9);
|
NetBootFileSize<<9);
|
|
}
|
}
|
|
|
putc ('\n');
|
putc('\n');
|
|
|
printf ("Load address: 0x%lx\n", global.src_addr);
|
printf("Load address: 0x%lx\n", global.src_addr);
|
|
|
printf ("Loading: *\b");
|
printf("Loading: *\b");
|
|
|
NetSetTimeout (TIMEOUT * TICKS_PER_SEC, TftpTimeout);
|
NetSetTimeout(TIMEOUT * TICKS_PER_SEC, TftpTimeout);
|
NetSetHandler (TftpHandler);
|
NetSetHandler(TftpHandler);
|
|
|
TftpServerPort = WELL_KNOWN_PORT;
|
TftpServerPort = WELL_KNOWN_PORT;
|
TftpTimeoutCount = 0;
|
TftpTimeoutCount = 0;
|
TftpState = STATE_RRQ;
|
TftpState = STATE_RRQ;
|
TftpOurPort = 1024 + (get_timer(0) % 3072);
|
TftpOurPort = 1024 + (get_timer(0) % 3072);
|
|
|
TftpSend ();
|
TftpSend();
|
}
|
}
|
|
|
|
|
No newline at end of file
|
No newline at end of file
|
