path: root/main/common/xmodem.c

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also obtain a copy of the License at:
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 **************************************************************************
 *
 * xmodem.c:
 *
 * Command to upload or download via XMODEM protocol.  Xmodem is quite
 * limited, but adequate for simple file up/down load.
 * This also supports XMODEM-1K and YMODEM.  YMODEM is an extension to XMODEM
 * that uses a 1K packet size, CRC and the first packet (seqno=0) contains
 * information about the file being downloaded (in partiuclar, the name).
 * YMODEM also supports BATCH downloads (multiple files downloaded in one
 * transaction).  This code supports incoming BATCH downloads (not tested
 * because I can't find any terminal emulators that do it), but not for 
 * uploads.

 * Minicom notes:
 * Minicom is the terminal emulation program that comes with Linux.
 * For some reason I had to make some adjustments to the xmodem.c 
 * to accommodate Minicom...
 * - Minicom sends an initial 0x1a (EOF). Not sure why, so I just absorb
 *   that now.
 * - Minicom doesn't like a fast nak-resend rate, so each additional
 *   'd' option on the xmodem command line now causes the delay
 *   between outgoing NAKs (used to start up the protocol in Xdown())
 *   to double.  As a result, when running with minicom, a file download
 *   may need "xmodem -ddd".  Not exactly sure why this is necessary but
 *   here's my hunch...
 *   To do an xmodem transfer to the target running uMon, the "xmodem -d"
 *   command is issued on the uMon command line.  This causes uMon to start
 *   generating periodic NAKs (part of the xmodem startup handshake).
 *   Then via CTRL-A Z, the minicom side of the transaction starts up.
 *   Apparently, minicom doesn't flush the input buffer when the xmodem
 *   transfer is started on its side.  As a result there may be several
 *   NAKs buffered up on the TTY.  The end result is that if too many
 *   NAKs have been queued up in the TTY's buffer, Minicom chokes on
 *   them at startup.
 *   Adding the ability to slow down the NAK send rate keeps uMon from 
 *   sending too many NAKs prior to Minicom actually starting up its
 *   side of the protocol; hence, Minicom doesn't choke and the transfer
 *   works ok.
 *
 *   By default, this code will disable the ethernet interface
 *   during the xmodem transaction.  This is done because in most
 *   cases the monitor runs with no flow control; and getchar polls
 *   the ethernet interface.  If the poll results in an incoming
 *   packet, then it may cause the serial port to lose characters.
 *   If this is not desireable (or if the uart has a large input fifo),
 *   then this can be changed with the DONT_DISABLE_ENET_IN_XMODEM
 *   #define set up in config.h
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include "config.h"
#include "genlib.h"
#include "stddefs.h"
#include "flash.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "cli.h"
#include "ether.h"
#include "timer.h"

#if INCLUDE_XMODEM

#define PUTCHAR putchar


/* struct xinfo:
 * Used to contain information pertaining to the current transaction.
 * The structure is built by the command Xmodem, then passed to the other
 * support functions (Xup, Xdown, etc..) for reference and update.
 */
struct xinfo {
	uchar	sno;			/* Sequence number. */
	uchar	pad;			/* Unused, padding. */
	int		xfertot;		/* Running total of transfer. */
	int		pktlen;			/* Length of packet (128 or 1024). */
	int		pktcnt;			/* Running tally of number of packets processed. */
	int		filcnt;			/* Number of files transferred by ymodem. */
	long	size;			/* Size of upload. */
	ulong	flags;			/* Storage for various runtime flags. */
	ulong	base;			/* Starting address for data transfer. */
	ulong	dataddr;		/* Running address for data transfer. */
	int		errcnt;			/* Keep track of errors (used in verify mode). */
	int		nakresend;		/* Time between each NAK sent at Xdown startup. */
	char	*firsterrat;	/* Pointer to location of error detected when */
							/* transfer is in verify mode. */
	char	fname[TFSNAMESIZE];
};

/* Runtime flags: */
#define	USECRC	(1<<0)
#define VERIFY	(1<<1)
#define YMODEM	(1<<2)

/* Current xmodem operation: */
#define XNULL	0
#define XUP		1
#define XDOWN	2

/* X/Ymodem protocol: */
#define SOH		0x01
#define STX		0x02
#define EOT		0x04
#define ACK		0x06
#define NAK		0x15
#define CAN		0x18
#define EOF		0x1a
#define ESC		0x1b

#define PKTLEN_128	128
#define PKTLEN_1K	1024

#define BYTE_TIMEOUT	1000

static int Xup(struct xinfo *);
static int Xdown(struct xinfo *);
static int getPacket(uchar *,struct xinfo *);
static int putPacket(uchar *,struct xinfo *);

char *XmodemHelp[] = {
	"Xmodem file transfer",
	"-[a:BcdF:f:i:ks:uvy]",
#if INCLUDE_VERBOSEHELP
	"Options:",
	" -a{##}     address (overrides default of APPRAMBASE)",
#if INCLUDE_FLASH
	" -B         boot sector reload",
#endif
	" -c         use crc (default = checksum)",
	" -d         download",
#if INCLUDE_TFS
	" -F{name}   filename",
	" -f{flags}  file flags (see tfs)",
	" -i{info}   file info (see tfs)",
#endif
	" -k         force packet length to 1K",
	" -s{##}     size (overrides computed size)",
	" -u         upload",
	" -v         verify only",
#if INCLUDE_TFS
	" -y         use Ymodem extensions",
#endif
	"Notes:",
	" * Either -d or -u must be specified (-B implies -d).",
	" * Each additional 'd' option cuts the nak-resend rate in half.",
	" * XMODEM forces a 128-byte modulo on file size.  The -s option",
	"   can be used to override this when transferring a file to TFS.",
	" * File upload requires no address or size (size will be mod 128).",
	" * When using -B, it should be the ONLY command line option,",
	"   it's purpose is to reprogram the boot sector, so be careful!",
#endif
	(char *)0,
};

int
Xmodem(int argc,char *argv[])
{
	int	opt, xop;
	struct	xinfo xi;
#if INCLUDE_TFS
	char	*info = (char *)0;
    char    *flags = (char *)0;
	TFILE	*tfp;
#endif
#if INCLUDE_FLASH
	int	newboot = 0;
#endif
#if INCLUDE_ETHERNET
	int eon;
#endif

	xop = XNULL;
	xi.fname[0] = 0;
	xi.size = 0;
	xi.flags = 0;
	xi.filcnt = 0;
	xi.nakresend = 2;
	xi.pktlen = PKTLEN_128;
	xi.base = xi.dataddr = getAppRamStart();
	while ((opt=getopt(argc,argv,"a:BcdF:f:i:ks:uvy")) != -1) {
		switch(opt) {
		case 'a':
			xi.dataddr = xi.base = strtoul(optarg,(char **)0,0);
			break;
		case 'B':
			xop = XDOWN;
#if INCLUDE_FLASH
			newboot = 1;
#endif
			break;
		case 'c':
			xi.flags |= USECRC;
			break;
		case 'd':
			xi.nakresend *= 2;		/* -ddd increases Xdown() resend delay */
			xop = XDOWN;
			break;
#if INCLUDE_TFS
		case 'F':
			strncpy(xi.fname,optarg,TFSNAMESIZE);
			break;
		case 'f':
			flags = optarg;
			break;
		case 'i':
			info = optarg;
			break;
#endif
		case 'k':
			xi.pktlen = PKTLEN_1K;
			break;
		case 's':
			xi.size = strtol(optarg,(char **)0,0);
			break;
		case 'u':
			xop = XUP;
			break;
		case 'v':
			xi.flags |= VERIFY;
			break;
#if INCLUDE_TFS
		case 'y':
			xi.flags |= (YMODEM | USECRC);
			xi.pktlen = PKTLEN_1K;
			break;
#endif
		default:
			return(CMD_PARAM_ERROR);
		}
	}

	/* There should be no arguments after the option list. */
	if (argc != optind)
		return(CMD_PARAM_ERROR);

	if (xop == XUP) {
		if ((xi.flags & YMODEM) && !(xi.fname[0]))
			printf("Ymodem upload needs filename\n");
		else {
			if (xi.fname[0]) {	/* Causes -a and -s options to be ignored. */
#if INCLUDE_TFS
				tfp = tfsstat(xi.fname);
				if (!tfp) {
					printf("%s: file not found\n",xi.fname);
					return(CMD_FAILURE);
				}
				xi.base = xi.dataddr = (ulong)TFS_BASE(tfp);
				xi.size = TFS_SIZE(tfp);
#endif
			}
#ifdef DONT_DISABLE_ENET_IN_XMODEM		/* See note at top of file */
			Xup(&xi);
#else
#if INCLUDE_ETHERNET
			eon = DisableEthernet();
#endif
			Xup(&xi);
#if INCLUDE_ETHERNET
			if (eon)
				EthernetStartup(0,0);
#endif
#endif
		}
	}
	else if (xop == XDOWN) {
		long	tmpsize;

		if ((xi.flags & YMODEM) && (xi.fname[0]))
			printf("Ymodem download gets name from protocol, '%s' ignored\n",
				xi.fname);

#ifdef DONT_DISABLE_ENET_IN_XMODEM		/* See note at top of file */
		tmpsize = (long)Xdown(&xi);
#else
#if INCLUDE_ETHERNET
		eon = DisableEthernet();
#endif
		tmpsize = (long)Xdown(&xi);
#if INCLUDE_ETHERNET
		if (eon)
			EthernetStartup(0,0);
#endif
#endif
		if (tmpsize == -1)
			return(CMD_FAILURE);
		if ((!xi.size) || (tmpsize < 0))
			xi.size = tmpsize;

#if INCLUDE_TFS
		if ((xi.fname[0]) && (xi.size > 0)) {
			int	err;

			printf("Writing to file '%s'...\n",xi.fname);
			err = tfsadd(xi.fname,info,flags,(uchar *)xi.base,xi.size);
			if (err != TFS_OKAY) {
				printf("%s: %s\n",xi.fname,(char *)tfsctrl(TFS_ERRMSG,err,0));
				return(CMD_FAILURE);
			}
		}
#if INCLUDE_FLASH
		else
#endif
#endif
#if INCLUDE_FLASH
		if ((newboot) && (xi.size > 0)) {
			extern	int FlashProtectWindow;
			int		rc;
			char	*bb;
			ulong	bootbase;

			bb = getenv("BOOTROMBASE");
			if (bb)
				bootbase = strtoul(bb,0,0);
			else
				bootbase = BOOTROM_BASE;
#ifdef TO_FLASH_ADDR
			/* The address the program is linked to is not necessarily the
			 * physical address where flash operations can be performed on.
			 * A typical use could be that the program is linked to run in
			 * a cacheable region but writing to the flash can only be done
			 * in an uncached region.
			 * "config.h" is a good place to define the TO_FLASH_ADDR macro.
			 */
			bootbase = (ulong)TO_FLASH_ADDR(bootbase);
#endif
			printf("Reprogramming boot @ 0x%lx from 0x%lx, %ld bytes.\n",
				bootbase,xi.base,xi.size);
			if (askuser("OK?")) {
				int first, last;

				/* If sector(s) need to be unlocked, do that now...
				 */
				if (addrtosector((uchar *)bootbase,&first,0,0) == -1)
					return(CMD_FAILURE);

				if (addrtosector((uchar *)bootbase+xi.size-1,&last,0,0) == -1)
					return(CMD_FAILURE);

				if (flashlock(first,FLASH_LOCKABLE) != -1) {
					FlashProtectWindow = 1;
					while(first < last)
						flashlock(first++,FLASH_UNLOCK);
				}

				FlashProtectWindow = 1;
				rc = flashewrite((uchar *)bootbase,(uchar *)xi.base,xi.size);
				if (rc == -1) {
					printf("failed\n");
					return(CMD_FAILURE);
				}
			}
		}
#endif
	}
	else
		return(CMD_PARAM_ERROR);
	shell_sprintf("XMODEMGET","%ld",xi.size);
	return(CMD_SUCCESS);
}

/* xgetchar():
 * Wrap getchar with a timer, so that after 5 seconds of waiting
 * we giveup...
 */
int
xgetchar(char *cp, int lno)
{
	struct	elapsed_tmr tmr;

	startElapsedTimer(&tmr,5000);
	while(!msecElapsed(&tmr) && !gotachar());
	if (!gotachar()) {
		Mtrace("Xgetchar tmt %d",lno);
		return(-1);
	}
	*cp = getchar();
	return(0);
}

/* putPacket():
 * Used by Xup to send packets.
 */
static int
putPacket(uchar *tmppkt, struct xinfo *xip)
{
	char	c;
	int		i;
	ushort	chksm;

	chksm = 0;
	
	if (xip->pktlen == PKTLEN_128)
		PUTCHAR(SOH);
	else
		PUTCHAR(STX);

	PUTCHAR((char)(xip->sno));
	PUTCHAR((char)~(xip->sno));

	if (xip->flags & USECRC) {
		for(i=0;i<xip->pktlen;i++) {
			PUTCHAR((char)*tmppkt);
			chksm = (chksm<<8)^xcrc16tab[(chksm>>8)^*tmppkt++];
		}
    	/* An "endian independent way to extract the CRC bytes. */
		PUTCHAR((char)(chksm >> 8));
		PUTCHAR((char)chksm);
	}
	else {
		for(i=0;i<xip->pktlen;i++) {
			PUTCHAR((char)*tmppkt);
			chksm = ((chksm+*tmppkt++)&0xff);
		}
		PUTCHAR((char)(chksm&0x00ff));
	}

	if (xgetchar(&c,__LINE__) == -1)			/* Wait for ack */
		return(-1);

	/* If pktcnt == -1, then this is the first packet sent by
	 * YMODEM (filename) and we must wait for one additional
	 * character in the response.
	 */
	if (xip->pktcnt == -1) {
		if (xgetchar(&c,__LINE__) == -1)
			return(-1);
	}
	return((int)c);
}

/* getPacket():
 * Used by Xdown to retrieve packets.
 */
static int
getPacket(uchar *tmppkt, struct xinfo *xip)
{
	char	*pkt;
	int		i,rcvd;
	uchar	seq[2];

	if ((rcvd = getbytes_t((char *)seq,2,BYTE_TIMEOUT)) != 2) {
		PUTCHAR(NAK);
		Mtrace("RCVD %d != 2",rcvd);
		return(0);
	}

	if (xip->flags & VERIFY) {
		rcvd = getbytes_t((char *)tmppkt,xip->pktlen,BYTE_TIMEOUT);
		if (rcvd != xip->pktlen) {
			PUTCHAR(NAK);
			Mtrace("RCVD %d != %d",rcvd,xip->pktlen);
			return(0);
		}
		for(i=0;i<xip->pktlen;i++) {
			if (tmppkt[i] != ((char *)xip->dataddr)[i]) {
				if (xip->errcnt++ == 0)
					xip->firsterrat = (char *)(xip->dataddr+i);
			}
		}
		pkt = (char *)tmppkt;
	}
	else {
		rcvd = getbytes_t((char *)xip->dataddr,xip->pktlen,BYTE_TIMEOUT);
		if (rcvd != xip->pktlen) {
			PUTCHAR(NAK);
			Mtrace("RCVD %d != %d",rcvd,xip->pktlen);
			return(0);
		}
		pkt = (char *)xip->dataddr;
	}

	if (xip->flags & USECRC) {
		char c;
		ushort	crc, xcrc;
		
    	/* An "endian independent way to combine the CRC bytes. */
		if (xgetchar(&c,__LINE__) == -1)
			return(0);
		crc = (ushort)c;
		crc <<= 8;
		if (xgetchar(&c,__LINE__) == -1)
			return(0);
	    crc += (ushort)c;
		xcrc = xcrc16((uchar *)pkt,(ulong)(xip->pktlen));
		if (crc != xcrc) {
			PUTCHAR(NAK);
			Mtrace("CRC %04x != %04x",crc,xcrc);
			return(0);
		}
	}
	else {
		uchar	csum, xcsum;

		if (xgetchar((char *)&xcsum,__LINE__) == -1)
			return(0);
		csum = 0;
		for(i=0;i<xip->pktlen;i++)
			csum += *pkt++;
		if (csum != xcsum) {
			PUTCHAR(NAK);
			Mtrace("CSUM %02x != %02x (%d)",csum,xcsum,xip->pktlen);
			return(0);
		}
		Mtrace("CSUM %02x (%d)",csum,xip->pktlen);
	}

	/* Test the sequence number compliment...
	 */
	if ((uchar)seq[0] != (uchar)~seq[1]) {
		PUTCHAR(NAK);
		Mtrace("SNOCMP %02x != %02x",(uchar)seq[0],(uchar)~(seq[1]));
		return(0);
	}

	/* Verify that the incoming sequence number is the expected value...
	 */
	if ((uchar)seq[0] !=  xip->sno) {
		/* If the incoming sequence number is one less than the expected
		 * sequence number, then we assume that the sender did not recieve
		 * our previous ACK, and they are resending the previously received
		 * packet.  In that case, we send  ACK and don't process the
		 * incoming packet...
	 	 */
		if ((uchar)seq[0] == xip->sno-1) {
			Mtrace("R_ACK");
			PUTCHAR(ACK);
			return(0);
		}

		/* Otherwise, something's messed up...
		 */
		PUTCHAR(CAN);
		Mtrace("SNO: %02x != %02x",seq[0],xip->sno);
		return(-1);
	}

	/* First packet of YMODEM contains information about the transfer:
	 * FILENAME SP FILESIZE SP MOD_DATE SP FILEMODE SP FILE_SNO
	 * Only the FILENAME is required and if others are present, then none
	 * can be skipped.
	 */
	if ((xip->flags & YMODEM) && (xip->pktcnt == 0)) {
		char *slash, *space, *fname;

		slash = strrchr((char *)(xip->dataddr),'/');
		space = strchr((char *)(xip->dataddr),' ');
		if (slash)
			fname = slash+1;
		else
			fname = (char *)(xip->dataddr);
		Mtrace("<fname=%s>",fname);
		if (space) {
			*space = 0;
			xip->size = atoi(space+1);
		}
		strcpy(xip->fname,fname);
		if (fname[0])
			xip->filcnt++;
	}
	else
		xip->dataddr += xip->pktlen;
	xip->sno++;
	xip->pktcnt++;
	xip->xfertot += xip->pktlen;
	Mtrace("ACK");
	PUTCHAR(ACK);
	if (xip->flags & YMODEM) {
		if (xip->fname[0] == 0) {
			printf("\nRcvd %d file%c\n",
				xip->filcnt,xip->filcnt > 1 ? 's' : ' ');
			return(1);
		}
	}
	return(0);
}

/* Xup():
 * Called when a transfer from target to host is being made (considered
 * an upload).
 */
static int
Xup(struct xinfo *xip)
{
	uchar	c, buf[PKTLEN_128];
	int		tmp, done, pktlen;

	Mtrace("Xup starting");

	if (xip->size & 0x7f) {
		xip->size += 128;
		xip->size &= 0xffffff80L;
	}

	printf("Upload %ld bytes from 0x%lx\n",xip->size,(ulong)xip->base);

	/* Startup synchronization... */
	/* Wait to receive a NAK or 'C' from receiver. */
	done = 0;
	while(!done) {
		if (xgetchar((char *)&c,__LINE__) == -1)
			return(0);
		switch(c) {
		case NAK:
			done = 1;
			Mtrace("CSM");
			break;
		case 'C':
			xip->flags |= USECRC;
			done = 1;
			Mtrace("CRC");
			break;
		case 'q':	/* ELS addition, not part of XMODEM spec. */
			return(0);
		default:
			break;
		}
	}

	rawon();

	if (xip->flags & YMODEM) {
		Mtrace("SNO_0");
		xip->sno = 0;
		xip->pktcnt = -1;
		memset((char *)buf,0,PKTLEN_128);
		sprintf((char *)buf,"%s",xip->fname);
		pktlen = xip->pktlen;
		xip->pktlen = PKTLEN_128;
		if (putPacket(buf,xip) == -1)
			return(0);
		xip->pktlen = pktlen;
	}

	done = 0;
	xip->sno = 1;
	xip->pktcnt = 0;
	while(!done) {
		if ((tmp = putPacket((uchar *)(xip->dataddr),xip)) == -1)
			return(0);
		c = (uchar)tmp;
		switch(c) {
		case ACK:
			xip->sno++;
			xip->pktcnt++;
			xip->size -= xip->pktlen;
			xip->dataddr += xip->pktlen;
			Mtrace("A");
			break;
		case NAK:
			Mtrace("N");
			break;
		case CAN:
			done = -1;
			Mtrace("C");
			break;
		case EOT:
			done = -1;
			Mtrace("E");
			break;
		default:
			done = -1;
			Mtrace("<%02x>",c);
			break;
		}
		if (xip->size <= 0) {
			char tmp;

			PUTCHAR(EOT);
			if (xgetchar(&tmp,__LINE__) == -1)	/* Flush the ACK */
				return(0);
			break;
		}
		Mtrace("!");
	}

	Mtrace("Xup_almost");
	if ((done != -1) && (xip->flags & YMODEM)) { 
		xip->sno = 0;
		memset((char *)buf,0,PKTLEN_128);
		pktlen = xip->pktlen;
		xip->pktlen = PKTLEN_128;
		if (putPacket(buf,xip) == -1)
			return(0);
		xip->pktlen = pktlen;
	}
	Mtrace("Xup_done.");
	rawoff();
	return(0);
}


/* Xdown():
 * Called when a transfer from host to target is being made (considered
 * an download).
 * Note that if we don't have INCLUDE_MALLOC set (in config.h), then
 * we allocate a 128-byte static buffer and only support the 128-byte
 * packet size here.
 */

static int
Xdown(struct xinfo *xip)
{
	struct	elapsed_tmr tmr;
	char	c, *tmppkt;
	int		i, done;
#if !INCLUDE_MALLOC
	static char pkt[PKTLEN_128];

	tmppkt = pkt;
#else
	tmppkt = malloc(PKTLEN_1K);
	if (!tmppkt) {
		Mtrace("malloc failed");
		return(-1);
	}
#endif

	rawon();

nextfile:
	if (xip->flags & YMODEM)
		xip->sno = 0x00;
	else
		xip->sno = 0x01;
	xip->pktcnt = 0;
	xip->errcnt = 0;
	xip->xfertot = 0;
	xip->firsterrat = 0;

	/* Startup synchronization... */
	/* Continuously send NAK or 'C' until sender responds. */
restart:
	Mtrace("Xdown");
	for(i=0;i<32;i++) {
		if (xip->flags & USECRC)
			PUTCHAR('C');
		else
			PUTCHAR(NAK);

		startElapsedTimer(&tmr,xip->nakresend * 1000);
		while(!msecElapsed(&tmr) && !gotachar());
		if (gotachar())
			break;
	}
	if (i == 32) {
		Mtrace("Giveup @ %d",__LINE__);
		return(-1);
	}

	done = 0;
	Mtrace("Got response");
	while(done == 0) {
		if (xgetchar(&c,__LINE__) == -1)
			return(-1);
		switch(c) {
		case SOH:				/* 128-byte incoming packet */
			Mtrace("O");
			xip->pktlen = 128;
			done = getPacket((uchar *)tmppkt,xip);
			if (done < 0)
				Mtrace("GP_%d",done);
			if (!done && (xip->pktcnt == 1) && (xip->flags & YMODEM))
				goto restart;
			break;
#if INCLUDE_MALLOC
		case STX:				/* 1024-byte incoming packet */
			Mtrace("T");
			xip->pktlen = 1024;
			done = getPacket((uchar *)tmppkt,xip);
			if (done < 0)
				Mtrace("GP_%d",done);
			if (!done && (xip->pktcnt == 1) && (xip->flags & YMODEM))
				goto restart;
			break;
#endif
		case CAN:
			Mtrace("C");
			done = -1;
			break;
		case EOT:
			Mtrace("E");
			PUTCHAR(ACK);
			if (xip->flags & YMODEM) {
#if INCLUDE_TFS
				if (!xip->size)
					xip->size = xip->pktcnt * xip->pktlen;
				if (xip->fname[0])
					tfsadd(xip->fname,0,0,(uchar *)xip->base,xip->size);
				xip->dataddr = xip->base;
#endif
				goto nextfile;
			}
			else {
				done = xip->xfertot;
				rawoff();
				printf("\nRcvd %d pkt%c (%d bytes)\n",xip->pktcnt,
						xip->pktcnt > 1 ? 's' : ' ',xip->xfertot);

		 		/* If the transfer is complete and no file add is to
				 * be done, then we flush d-cache and invalidate
				 * i-cache across the memory space that was just
				 * copied to.  This is necessary in case the
		 		 * binary data that was just transferred is code.
				 */
				flushDcache((char *)xip->base,xip->xfertot);
				invalidateIcache((char *)xip->base,xip->xfertot);
			}
			break;
		case ESC:		/* User-invoked abort */
			Mtrace("X");
			done = -1;
			break;
		case EOF:		/* 0x1a sent by MiniCom, just ignore it. */
			break;
		default:
			Mtrace("<%02x>",c);
			done = -1;
			break;
		}
		Mtrace("!");
	}
	rawoff();
	if (xip->flags & VERIFY) {
		if (xip->errcnt)
			printf("%d errors, first at 0x%lx\n",
				xip->errcnt,(ulong)(xip->firsterrat));
		else
			printf("verification passed\n");
	}
	free(tmppkt);
	return(done);
}


#endif