zmport.c

本source code 為s3c4510的bootloader

   Print("\nSelect port UART0/UART1 [0/1/Q]");
   ch = get_upper(); 
   if(ch == 'Q')
    {
     return(0);
    }
   else 
   if(ch >= '0' && ch <= '1')
    {
     ZmUartData = ch - '0';
     break;
    } 
  }


//
 Print("\n");
 if(ZmUartData == 0)
  {
   ZmUartConsole = 1;
   ZmVerbose     = 0;			// verbose off 
   ZmDoLogging   = 0; 			// logging off
  }
 else
  {
   ZmUartConsole = 0;
   ZmVerbose     = 1;			// verbose on 
   ZmDoLogging   = 1; 			// logging on 
  }

// input memory base address
 Print("\nInput base address (0x%08x) ", ZmMemoryBase);
 addr = get_number(16, 8);
 if(addr != 0)
  {
   ZmMemoryBase = (void *) addr;
  }

// set ZModem data port speed //////////////////////////////////////////////////

 speed = UARTGetSpeed(ZmUartData);
 while(1)
  {
   U8 ch;
   Print("\nSelect Speed 38400/57600/115200 [3/5/1/Q]");
   ch = get_upper();

        if(ch == '3') { UARTSetSpeed(ZmUartData, 38400); break; } //
   else if(ch == '5') { UARTSetSpeed(ZmUartData, 57600); break; } //
   else if(ch == '1') { UARTSetSpeed(ZmUartData,115200); break; } //
   else if(ch == 'Q') { return(0); }
  }  

// print parametes
 Print("\nZmRx UART%d", ZmUartData);		
 Print("\nSpeed %d", UARTGetSpeed(ZmUartData));	
 Print("\nBase address 0x%08x\n",ZmMemoryBase);

// 
#ifdef  ZM_IO_INT
 UARTTxIntOn(0);			// UART0 Tx Int on 
 UARTRxIntOn(0);			// UART0 Rx Int on 
 UARTTxIntOn(1);			// UART1 Tx Int on 
 UARTRxIntOn(1);			// UART1 Rx Int on 
#endif

// TIMER 1 Initialized for mesuring the test time //////////////////////////////

 TimerReset(0);					// reset timer 0
 TimerInit(0,(ONE_SECOND/TICKS_PER_SECOND));	// init timer  0
 TimerStart(0);					// start timer 0

 Enable_Int(nGLOBAL_INT);

/* 2. Call ZmRInit() to begin protocol. */
 done = ZmRInit(& zmInfo);

/* 3 Read characters from remote end and pass them to
  ZmRcv() until ZmRcv() returns ZmDone or an error.
*/

 if(done == 0)
  {
   done = ZmDoIO(& zmInfo);
  }

 TimerStop(0);				// stop timer 0  
#ifdef  ZM_IO_INT
 UARTTxIntOff(0);			// UART0 Tx Int off 
 UARTRxIntOff(0);			// UART0 Rx Int off 
 UARTTxIntOff(1);			// UART1 Tx Int off 
 UARTRxIntOff(1);			// UART1 Rx Int off
#endif
 Disable_Int(nGLOBAL_INT);		// disable global int 
	
 if(done != ZmDone) 
  {
// error ///////////////////////////////////////////////////////////////////////
   Print("\r\nconnect failed [%d]\r\n", done);

//
   UARTSetSpeed(ZmUartData, speed);	// restore data port speed 
   return(0);
  }

//
 Print("\nFile %s loaded", ZmFileName);		   // print file name 
 Print("\nStart address : 0x%08x", ZmMemoryBase);  // Memory Base Addrees
 Print("\nFile size     : %d", ZmMemoryPos);       // file size 	
//
 UARTSetSpeed(ZmUartData, speed);	// restore data port speed
 return(1);
}

// 

int ZmTest(void)
{
 while(1)
  {
   char it;						// selected item
   Print("\n\nProgram Download & Run");
   Print("\n[R] ZMODEM load & Run.");
   Print("\n[S] ZMODEM send.");
   Print("\n[G] Run User Program (loaded by command [R]).");
   Print("\n[F] Write flash & Reset.");
   Print("\n[X] Reset.");
   Print("\n[Q] Quit.");

// Select test item ////////////////////////////////////////////////////////////

   Print("\nSelect Test Item: ");
   it = get_upper();			// read character from console

   switch(it)
    {
     case 'R' : 
// ZMODEM receive //////////////////////////////////////////////////////////////
      if(ZmMemRx() == 1)		// receive file
       {
        ZmStartProgramm();      	// start download programm  	
       }
      break;

     case 'S' : 
// ZMODEM send /////////////////////////////////////////////////////////////////
      ZmMemTx();			// send memory dump 
      break;

     case 'G' : 
// start download programm /////////////////////////////////////////////////////
      ZmStartProgramm();      
      break;

     case 'F' :
// write flash & reset /////////////////////////////////////////////////////////
      ZmFlash();
      break;

     case 'X' :
      ZmReset(); 
      break;

     case 'Q' : return(1);  
     default  : 
      Print("\nNo Test Item Selected"); 
      break ;
    }

   Print("\nPress Any Key to Continue"); 
   it = get_byte();
   if(it == 'q' || it == 'Q')
    {
     return(1);
    }  
  }

 return(1);
}


/* Transmit a buffer.  Return 0 on success, ZmErrSys on error. */

int ZXmitStr(u_char *buffer, int len, ZModem *info)
{
 int pos;
 for(pos = 0; pos < len; ++pos)
  {
   if(ZM_PUTC(ZmUartData, *(buffer + pos)) == 0)
    {
// transmit character error ////////////////////////////////////////////////////
     return(ZmErrSys);
    } 
  }

 return(0);
}

/* Flush all unread input on receive channel.  Do nothing if this is 
not possible. */

void ZIFlush(ZModem *info)
{
}

/* Flush all buffered but not-yet-transmitted output
on transmit channel.  Do nothing if this is not possible. */

void ZOFlush(ZModem *info)
{
}


static void ZStatusMessage(char * s0, int * j, char * s1)
{
 if(s0 != 0)
  {
// s0 string defined => print s0 to console ////////////////////////////////////
   ZM_PUTS(ZmUartConsole, s0);
  }

 if(j != 0)
  {
// not null j pointer //////////////////////////////////////////////////////////  
   if(*j == 0)
    {
// *j == 0 /////////////////////////////////////////////////////////////////////  
     ZM_PUTS(ZmUartConsole, "0");
    }
   else
    {
// not zero *j /////////////////////////////////////////////////////////////////
     U8 jbuf[24];
     int pos;
     int val;

     val = *j;				
     pos = 0;				// start position in jbuf
     while(val != 0 && pos < 24)
      {
       jbuf[pos++] = '0' + (val % 10);
       val /= 10;
      }

     while(pos > 0)
      {
       pos--;
       ZM_PUTC(ZmUartConsole, jbuf[pos]);
      }     
    } 
  }

 if(s1 != 0)
  {
// print s1 string to console //////////////////////////////////////////////////
   ZM_PUTS(ZmUartConsole, s1);
  }
}

void ZStatus(int type, int j, char *str)
{
 switch(type) 
  {
   case RcvByteCount:
// received bytes count ////////////////////////////////////////////////////////
    if(ZmVerbose)
     {
      ZStatusMessage("received:", &j,"\r\n");
     }
    break;

   case SndByteCount:
// sended bytes count //////////////////////////////////////////////////////////
    if(ZmVerbose)
     {
      ZStatusMessage("sent:", &j,"\r\n");
     }
    break ;

   case RcvTimeout:
// receiver timeouts ///////////////////////////////////////////////////////////
    if(ZmVerbose)
     {
      ZStatusMessage("receiver timeouts:", &j,"\r\n");
     }
    break;

   case SndTimeout:
// sender timeouts /////////////////////////////////////////////////////////////
    if(ZmVerbose)
     {
      ZStatusMessage("sender timeouts:", &j,"\r\n");
     }
    break;

   case RmtCancel:
// remote cancel ///////////////////////////////////////////////////////////////
    ZM_PUTS(ZmUartConsole, "transfer cancelled by remote\r\n");
    break;

   case ProtocolErr:
    if(ZmVerbose)
     {
      ZStatusMessage("protocol error:", &j,"\r\n");
     }
    break;

   case RemoteMessage:
// remoter message /////////////////////////////////////////////////////////////
    ZM_PUTS(ZmUartConsole, "\r\nremote message");
    ZM_PUTS(ZmUartConsole, str);
    break ;

   case DataErr:
// data error //////////////////////////////////////////////////////////////////
    if(ZmVerbose)
     {
      ZStatusMessage("data errors:", &j,"\r\n");
     } 
    break ;

   case FileErr:
    ZM_PUTS(ZmUartConsole,"cannot write file\r\n");
    break ;
  }
}



int ZAttn(ZModem *info)
{
 char	*ptr ;

 if( info->attn == NULL )
  {
   return 0 ;
  }

 for(ptr = info->attn; *ptr != '\0'; ++ptr) 
  {
   if( *ptr == ATTNBRK )
    {
// TODO
/*     tcsendbreak(info->ifd, 0) ; */
    }
   else 
   if( *ptr == ATTNPSE )
    {
/* sleep(1); */

// TODO
     int i;
     for(i = 0; i < 1000000 / 5 * 50; ++i)
      {
      }  
    } 
   else
    {
     ZM_PUTC(ZmUartData, *ptr); 
    }
  }

 return(0);
}


void * ZOpenFile(char *name, u_long crc, ZModem *info, int write)
{
 if(write == 0)
  {
   ZmMemoryPos = 0;
   return(ZmMemoryBase);
  }

 if(name == 0)
  {
   ZmFileName[0] = '\0';
  }
 else
  {
// save file name 
   int pos;
   pos = 0;
   while(pos < sizeof(ZmFileName))
    {
     ZmFileName[pos] = *(name + pos);
     if(*(name + pos) == '\0')
      {
       break;
      } 
     pos++; 
    }
   ZmFileName[sizeof(ZmFileName)-1] = '\0'; 
  }

 if(ZmVerbose)
  {
   ZM_PUTS(ZmUartConsole, "Receiving:");
   ZM_PUTS(ZmUartConsole, name);
   ZM_PUTS(ZmUartConsole, "\r\n");
  }

 
 ZmMemoryPos = 0;
 return(ZmMemoryBase);
}

/*
Write a buffer of data to the file.  Normally, you would simply call 
fwrite(buffer, 1, len, file), but you may want to translate line endings, 
etc.  File transfer flags are available as info->f0,f1,f2,f3.

Return 0 on success, ZmErrSys on failure, with errno
describing the failure.
*/

int ZWriteFile(u_char *buffer, int len, void * file, ZModem *info)
{
 u_char ch; 				// 
 int pos;				// buffer position 
 int rvl;

 if(ZmMemoryPos + len >= ZmMemorySize)
  {
// out off memory buffer /////////////////////////////////////////////////////// 
   len = ZmMemorySize - ZmMemoryPos;	// reset length 
   rvl = ZmErrSys;
  }
 else
  {
   rvl = 0;
  }

 for(pos = 0; pos < len; ++pos)
  {
   ch = *(buffer + pos);
   *((u_char *) ZmMemoryBase + ZmMemoryPos + pos) = ch; 
  }

 ZmMemoryPos += len;			// reset memory position 
 return(rvl);				// return writed bytes count 
}

/*
Close file after successful completion.  File modification date and 
modes should be set at this time.	
*/

int ZCloseFile(void * file, ZModem *info)
{
 return(0);
}

/* ftell system call (return current file position) */

long   ZFileTell(void * file, ZModem *info)
{
 return(ZmMemoryPos);		// return(ftell((FILE*) file));
}

/* set current file position */

int ZFileSeek(void * file, long offset, ZModem *info)
{
 if(offset < 0) 
  {
   offset = 0;
  }
 else
 if(offset > ZmMemorySize)
  {
   offset = ZmMemorySize;
  }  

 ZmMemoryPos = offset;    
 return(0);
}

int    ZFileStat(char * name, int * len, int * date, int * mode)
{
//  struct stat buf ;
//  int rvl;
//  rvl = stat(name, &buf);
// *len  = buf.st_size ;
// *date = buf.st_mtime ;
// *mode = (buf.st_mode&0777)|0100000 ;


 *len  = 0;
 *date = 0;
 *mode = 0;
 return(0);
}


int ZFileRead(u_char *buffer, int len, void * file, ZModem *info)
{
 u_char ch; 
 int pos;

 if(ZmMemoryPos + len >= ZmMemorySize)
  {
   len = ZmMemorySize - ZmMemoryPos;
  }

 for(pos = 0; pos < len; ++pos)
  {
   ch = *((u_char *) ZmMemoryBase + ZmMemoryPos + pos); 
   *(buffer + pos) = ch;
  }

 ZmMemoryPos += len;
 return(len);
}

int ZFileEof(void * file, ZModem *info)
{
 if(ZmMemoryPos >= ZmMemorySize)
  {
   return(1);  
  }

//
 return(0);
}

/*
 Called to pass text that is received out-of-protocol.
 This function may ignore or display this text at your option.
*/


void ZIdleStr(u_char *buffer, int len, ZModem *info)
{
// int pos;
// for(pos = 0; pos < len; ++pos)
//  {
//   i_putc(ZmUartConsole,*(buffer + pos));
//  }
}

/* Turn flow control on or off depending on the onoff flag. */

void ZFlowControl(int onoff, ZModem *info)
{
 if( onoff ) 
  {
  }
 else 
  {
  }
}