xmodem.c

Tornado的源代码资源包

/*
 * vivi/deriver/serialxmodem.c:
 *     - an implementation of the xmodem protocol from the spec.
 *
 * Based on bootldr/xmodem.c (C) 2000 Compaq Computer Coporation.
 *
 * Copyright (C) 2001 MIZI Research, Inc.
 *
 *
 * 1999-01-xx: Edwin Foo <[e-mail]>
 *    - Initial code
 *
 * 2001-10-04: Janghoon Lyu <[e-mail]>
 *    - Modified a little bit.
 *
 * 2002-07-04: Janghoon Lyu <[e-mail]>
 *    - get_param_value() 

   2006-05: jkuang BUPT
     some bugs are killed & code optimized

   UART related are changed by jkuang. 2006-05

   Buffer copy is canceled by jkuang, so this program can works very good with fast speed
   Windows terminal. 2006-05
 */

#include "stdio.h"
#include "string.h"
#include "vxworks.h"
#include "tylib.h"
/*
#include "def.h"
#include "option.h"
#include "s3c2410.h"
#include "2410slib.h"
#include "xmodem.h"
#include "uart.h"
*/
/* XMODEM parameters */
#define BLOCK_SIZE_1	128	/* size of transmit blocks , SOH=0x01时的block大小*/
#define BLOCK_SIZE_2	1024	/* size of transmit blocks , SOH=0x02时的block大小*/
#define BLOCK_SIZE block_size
#define RETRIES		20	/* maximum number of RETRIES */

static int block_size = BLOCK_SIZE_1;

typedef int __u32;

/* Line control codes */
#define SOH_1	0x01	/* start of header */
#define SOH_2	0x02	/* 1K xmodem start of header */
#define ACK		0x06	/* Acknowledge */
#define NAK		0x15	/* Negative acknowledge */
#define CAN		0x18	/* Cancel */
#define EOT		0x04	/* end of text */

#define GET_BYTE_TIMEOUT 250000  /* 1000000 */
/* #define GET_BYTE_TIMEOUT (1000 * 5)	//秒 */


/* global error variable */
char *xmodem_errtxt = NULL;

/* prototypes of helper functions */
static int get_record(char* bufptr);
static int do_getc( unsigned long timeout, char *cp);
static int get_byte(char * cp);

enum
{
	SAC_SEND_NAK = 0,
	SAC_SENT_NAK = 1,
	SAC_PAST_START_NAK = 2
};

static unsigned long xmodem_timeout = GET_BYTE_TIMEOUT;
static volatile int seen_a_char = SAC_SEND_NAK;
static int one_nak = 0;

#ifdef XMODEM_DEBUG
char debugbuf[DEBUGBUF_SIZE];
int db_idx = 0;

/*-------------------------------------------------------------------*/
void bufputs(char *s)
{
	size_t len = strlen(s) + 1;

	if (len + db_idx > sizeof(debugbuf))
		len = sizeof(debugbuf) - db_idx;

	if (len) {
		memcpy(&debugbuf[db_idx], s, len);
		db_idx += len;
	}
}

/*-------------------------------------------------------------------*/
void reset_debugbuf(void)
{
	memset(debugbuf, 0x0, sizeof(debugbuf));
	db_idx = 0;
}
#endif

/*-------------------------------------------------------------------*/
__u32 xmodem_receive(char *dldaddr)
{
	char ochr;
	int r, rx_block_num, error_count;
	__u32 foffset = 0;
	
	serial_init();
	
    do{
		taskDelay(60);
		if (!sio_ischar())
			Uart_SendKey(NAK);
    } while(!sio_ischar());

	xmodem_errtxt = NULL;
	seen_a_char = 0;

	/* one_nak = get_param_value("xmodem_one_nak", &ret);*/
	one_nak = 0;
	
	xmodem_timeout = GET_BYTE_TIMEOUT/2;

	rx_block_num = 1;
	error_count = RETRIES;

  do{
      if ((r = get_record((char*)(dldaddr+foffset))) == (rx_block_num & 255)) 
      {
        printf("xmodem_receive: Get a packet... Block Num %d\n",r);
        error_count = RETRIES;
        /* xmodem_errtxt = "RX PACKET";*/
        rx_block_num++;
        foffset += BLOCK_SIZE;
        Uart_SendKey(ACK);   /* jkuang*/
        printf("xmodem_receive: An ACK Sent continue...\n");
        continue;
      }

      /* EOT or CAN*/
      if((r == -4)||(r == -5))
      {
        printf("xmodem_receive: EOT or CAN... Block Num %d\n",r);
        /* xmodem_errtxt = "DONE";*/
        {
          /* some terminal prog send more chars after 'EOT'*/
          printf("xmodem_receive: An ACK Sent.\n");
          Uart_SendKey(ACK);
          Uart_SendKey(ACK);
        }
        break;
      }

      switch (r) 
      {
        case -1: /* TIMEOUT */
            printf("xmodem_receive: TIMEOUT \n");
            xmodem_errtxt = "TIMEOUT";
            ochr = NAK;
            break;
        case -2: /* Bad block */
            printf("xmodem_receive: Bad block  \n"); 
            xmodem_errtxt = "BAD BLOCK#";
            /* eat teh rest of the block */
            while (get_byte(&ochr) != -1);
            ochr = NAK;
            break;
        case -3: /* Bad checksum */
            printf("xmodem_receive: Bad checksum \n");  
            xmodem_errtxt = "BAD CHKSUM";
            ochr = NAK;
            break;
        default: /* Block out of sequence */
            printf("xmodem_receive: Block out of sequence  \n");     
            xmodem_errtxt = "WRONG BLK";
            ochr = NAK;
      }
      error_count--;
      Uart_SendKey(ochr);
    } while ((r > -3) && error_count);

	if  ((!error_count) || (r != -4)) {
        printf("x-modem error: %s\n", xmodem_errtxt);              
        return 0;	/* indicate failure to caller */
		/*printk("x-modem error: %s\n", xmodem_errtxt); */
	}

	return foffset;
}

/*-------------------------------------------------------------------*/
/*
 * Read a record in the XMODEM protocol, return the block number
 * (0-255) if successful, or one of the following return codes:
 * 	-1 = Bad byte
 * 	-2 = Bad block number
 * 	-3 = Bad block checksum
 * 	-4 = End of file
 * 	-5 = Canceled by remote
 */

static int get_record(char* bufptr)
{
    char c;
	int block_num;
	int i;
	__u32 check_sum;

    /* 1st byte */
    if  (!get_byte(&c)) 
    {
        printf("get_record: First byte Error.\n");
        return -1;
    }       

    switch (c) 
    {
      case SOH_1:	/* Receive packet */
        BLOCK_SIZE = BLOCK_SIZE_1;
        printf("get_record: Block Size 1 \n");
        break;
      case SOH_2:	/* Receive packet */
        BLOCK_SIZE = BLOCK_SIZE_2;
        printf("get_record: Block Size 2 \n");
        break;
      case EOT:	/* end of file encountered */
        printf("get_record: End of Transmit. \n");   
        return -4;
      case CAN:	/* cancel protocol */
      default:
              printf("get_record: Cancelled or error. \n");
        return -5;
	}

    /* 2nd byte */
    if  (!get_byte(&c)) 
    {
        printf("get_record: Second byte error.\n");
        return -1;
    }       
    block_num = c;

    /* 3rd byte */
    if  (!get_byte(&c)) 
    {
        printf("get_record: Third block erroe.\n");
        return -1;
    }
           
    /* from 4th -> byte before last */
    printf("get_record: Start recieving data part.\n");
    check_sum = 0;
    for(i=0; i<BLOCK_SIZE; i++)
    {
      /* if  (!get_byte(&c))	
      {
          printf("get_record: Data byte recieving error.\n");
          return -1;
      }*/
      /* printf("get_record: Get a data byte %c \n",c);*/
      get_byte(&c);
      *bufptr = c;
      check_sum += c;
      bufptr++;
    }

    /* last byte */
    get_byte(&c);
    /* if  (!get_byte(&c)) 
    {
        printf("get_record: Last byte error.\n");
        return -1;
    }*/
    if  ((check_sum & 0xff) == c)
    {
        printf("get_record: check is OK.Return the check_sum.\n");
        return block_num;
    }
    printf("get_record: Checksum error.\n");
    return -3;
}


/*-------------------------------------------------------------------*/
static int do_getc(unsigned long timeout, char * cp)
{
  int rxstat;

  while((rxstat = Uart_GetKey( cp )) == -1)
  {
    printf("do_getc: Get -1 waiting for timeout.\n");
    if  (!(timeout--))
    {
        printf("do_getc: Getting char timeout.\n");
        break;
    }
    /* if(idler) idler();*/
  }
  /* printf("do_getc: get char integer %d \n" ,rxstat);*/
  return rxstat;
}


/*-------------------------------------------------------------------*/
static int get_byte(char *cp)
{
  int rc;
  
again:
/*
 * Reads and returns a character from the serial port
 *   - Times out after delay iterations checking for presence of character
 *   - Sets *error_p to UART error bits or - on timeout
 *   - On timeout, sets *error_p to -1 and returns 0
 */
    rc = do_getc( xmodem_timeout, cp);
    /* printf("get_byte: get char integer %d  %c \n",rc,(char)rc);*/
    
	if (rc)
	{
	  /* printf("get_byte: Return a char integer.\n"); */
      seen_a_char = SAC_PAST_START_NAK;
	  return rc;
	}
    else 
	{
	  /* printf("get_byte: get a zero char  integer.\n"); */
      if (seen_a_char == SAC_SEND_NAK || !one_nak) 
	  {
		/* bufputs("timeout nak");*/
		Uart_SendKey(NAK);   /* jkuang*/
	  }

   	  if (seen_a_char < SAC_PAST_START_NAK) 
	  {
		seen_a_char = SAC_SENT_NAK;
		xmodem_timeout = GET_BYTE_TIMEOUT;
		goto again;
 	  }
	}
	return (rc);
}

void gt()
{

    char text[80000];
	int i;
	int st;

    printf ("Prepare your terminal emulator to receive data now...\n");
    
	st = xmodem_receive(text);
	
	for (i = strlen(text)-2; i> 0; i--)
		if (text[i] == 26)
			text[i] = 0; 
	if (st < 0) {
		printf ("Xmodem transmit error: status: %d\n", st);
	}
	else  {
		printf ("Xmodem successfully transmitted %d bytes\n", st);
	}
	printf("The context of the file is : \n\n");
	printf("%s\n",text);
	
	return 0;

}