hdlcmain.c

本source code 為s3c4510的bootloader

 GetSysTime(1,& tm); 
 curms = tm.tm_ms + (tm.tm_sec + tm.tm_min * 60) * 1000;
 if(tm1en == 0)
  {
   TimerStop(1);
  }


 for(i = 0; i < 2; ++i)
  {
   U32 deltams;				// diff time ms
   deltams = curms - startms;   
   if(deltams == 0)
    {					// 
     tbytes[i] = 0; 
    }
   else
    { 
     tbytes[i] = tcnt[i] * datalen;	// transmit bytes 
     if(tbytes[i] > 0xFFFFFFFF / 1000)
      {					// U32 overflow 
       deltams /= 1000;			// diff time sec
       if(deltams == 0)
        {				
         tbytes[i] = 0; 
        }
       else
        {
         tbytes[i] /= deltams;
        }
      }
     else
      {
       tbytes[i] = tbytes[i] * 1000 / deltams;
      }
    }
  }

 Print("\nTx frames          %8d %8d", tcnt     [0],tcnt     [1]);
 Print( " Tx bytes/sec       %8d %8d", tbytes   [0],tbytes   [1]); 
 Print("\nRx frames          %8d %8d", rxframes [0],rxframes [1]);
 Print( " Rx frames with Err %8d %8d", missed   [0],missed   [1]);
 Print("\nRx status Err      %8d %8d", errstatus[0],errstatus[1]);
 Print( " Rx min length Err  %8d %8d", errminlen[0],errminlen[1]);
 Print("\nRx address error   %8d %8d", erraddr  [0],erraddr  [1]);
 Print( " Rx length error    %8d %8d", errlen   [0],errlen   [1]);
 Print("\nRx sequence num Err%8d %8d", errseq   [0],errseq   [1]);
 Print( " Rx filling error   %8d %8d", errdata  [0],errdata  [1]);
 HdlcErrorRpt();			// Print statistics
 return(rvl);
}

////////////////////////////////////////////////////////////////////////////////
// HDLC internal loopback //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

// cn =  0, HDLC Channel A Test
// cn =  1, HDLC Channel B Test 
// cn = -1, HDLC Channel A & B Test 
    
int HdlcInternalLoopback(int cn,int lcnt, int quiet)
{
 int rvl;
 int i;
 for(i = 0; i < 2; ++i)
  {
   if(i == cn || cn == -1)
    { 					// set loopback mode bit
     HCON(i) |= HCON_TxLOOP;
    }
  }  

 rvl = HdlcLoopback(cn,lcnt,quiet);

 for(i = 0; i < 2; ++i)
  {
   if(i == cn || cn == -1)
    {					// clear loopback mode bit 
     HCON(i) &=~HCON_TxLOOP;
    }
  }
 return(rvl);
}

////////////////////////////////////////////////////////////////////////////////
// HDLC External Loopback Function /////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

int HdlcExternalLoopback(int cn,int lcnt,int quiet)
{
 int rvl;
 rvl = HdlcLoopback(cn,lcnt,quiet);
 return(rvl);
}

////////////////////////////////////////////////////////////////////////////////
// HDLC Single transfer test ///////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

void HdlcSingleTransfer(int cn) 
{
 U8 data[512];				// data buffer 
 int len;				// packet length 
 int pos;				// data buffer position 
 int tnum;				// Tx packet number

 if(cn < 0 || cn > 1)
  {					// invalid channel number 
   return;				// 
  } 

 Print("\n\nHDLC Channel %c Single Transfer", 'A' + cn);

// buffer length ///////////////////////////////////////////////////////////////
 Print("\nInput the Tx BufLength : ");
 len = get_number(10,3);		// read length from console 
 if(len <   6){ len = 6; } 		// set to mimimum limit 
 if(len > 512){ len = 512;} 		// set to maximum limit  

// enable HDLC Tx & Rx 
 HCON(cn) |= HCON_DTxEN | HCON_DRxEN | HCON_TxEN | HCON_RxEN;
 Enable_Int(nGLOBAL_INT);		// enable global int

 tnum = 0;				// Tx packet number
 while(1)
  {
   U8 it;
   Print("\nSelect Transmit(T) or Quit(Q) ? ");
   it = get_upper();
   if(it == 'Q')
    {					
     break;				// exit from test 
    }  

// fill sended packet //////////////////////////////////////////////////////////
   data[0] = 0xFF;			// address
   data[1] = (U8) len;			// length 
   data[2] = (U8) (tnum & 0xFF);	// packet number 
   data[3] = (U8)((tnum >>  8) & 0xFF);
   data[4] = (U8)((tnum >> 16) & 0xFF);
   data[5] = (U8)((tnum >> 24) & 0xFF);

   for(pos = 6; pos < len; ++pos)
    {					
     data[pos] = tnum + pos;		// fill packet 
    }    

   if(HDLCSend(cn,data,len) == 0)
    {
    }
   else
    {
     tnum++;				// packet sended
    } 
  }

 Disable_Int(nGLOBAL_INT);		// disable global interrupt 
 HCON(cn) &= ~(HCON_DTxEN | HCON_TxEN | HCON_DRxEN | HCON_RxEN);	
 Print("\nTx frames                %d", tnum);
#ifdef HDLC_RESET
 Print("\nResetting HDLC %c",(cn?'B':'A'));
 HDLCRx_reset(cn);			// reset Rx BD list 
 HDLCTx_reset(cn);			// reset Tx BD list 
#endif 								// HDLC_RESET
}


////////////////////////////////////////////////////////////////////////////////
// HDLC Multiple Transfer test /////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


void HdlcMultipleTransfer(int cn)
{
 U8 data[512];				// data buffer 
 int len;				// packet len
 int cnt;				// packet cnt 
 int pos;				// buffer position 
 int tnum;				// packet number 
 U32 status;
 int recv;

 if(cn < 0 || cn > 1)
  {					// invalid channel 
   return;				// number 
  } 

 Print("\n\nHDLC Channel %c Multiple Transfer", 'A' + cn);

// Tx buffer length ////////////////////////////////////////////////////////////

 Print("\nInput the Tx BufLength : ");	// 
 len = get_number(10,3);		// read length from console 
 if(len <   6){ len = 6; } 		// set length to minimum limit 
 if(len > 512){ len = 512;} 		// set length to maximum limit

// Tx frames count /////////////////////////////////////////////////////////////
 Print("\nInput Packet count     : ");
 cnt = get_number(10,6);
 if(cnt <   1){ cnt = 1; } 

 if(cnt > 10)
  {
   Print("\n#=10 packets sended."); 
  }
 Print("\nTo break test press [Q].");

// enable HDLC Tx & Rx, global interrupt   
 HCON(cn) |= (HCON_DTxEN | HCON_TxEN | HCON_DRxEN | HCON_RxEN);	
 Enable_Int(nGLOBAL_INT);

 tnum = 0;				// packet number 
 while(tnum < cnt)
  {
   if(kbd_hit())
    {
     U8 it;
     it = get_byte();
     if(it == 'Q' || it == 'q')
      {
       break;
      }  
    }  
  
// 
   data[0] = 0xFF;			// address
   data[1] = (U8) len; 			// length 
   data[2] = (U8) (tnum & 0xFF);	// packet number 
   data[3] = (U8)((tnum >>  8) & 0xFF); 
   data[4] = (U8)((tnum >> 16) & 0xFF);
   data[5] = (U8)((tnum >> 24) & 0xFF); 

   for(pos = 6; pos < len; ++pos)
    {					// fill packet 
     data[pos] = tnum + pos;
    }    

   if(HDLCSend(cn,data,len) == 0)
    {
    }
   else
    {
     tnum++;				// 
     if(tnum != 0 && (tnum % 10) == 0)
      {
       Print("#");
      }
    } 

//
   while(1)
    {
     len = sizeof(data);
     recv = HDLCRecv(cn, &status, data, & len);
     if(
       recv == -1 ||
       recv ==  0
      )
      {
       break;
      }  
    }
  }

 Disable_Int(nGLOBAL_INT);		// disable global int
 HCON(cn) &= ~(HCON_DTxEN | HCON_TxEN | HCON_DRxEN | HCON_RxEN);	
 Print("\nTx frames                %d", tnum);
#ifdef HDLC_RESET
 Print("\nResetting HDLC%c",(cn?'B':'A'));
 HDLCRx_reset(cn);			// reset Rx BD list 
 HDLCTx_reset(cn);			// reset Tx BD list 
#endif 							// HDLC_RESET
}


void HdlcMultipleReceive(int cn)
{
 U8 data[1024];				// data buffer 
 U32 status;
 int len;				// packet len
 int pos;				// buffer position 
 int num;
 int tnum;				
 int tlen;

 if(cn < 0 || cn > 1)
  {					// invalid channel number 
   return;
  } 

 Print("\n\nWaiting for a HDLC%c Frame Received", 'A' + cn);
 Print("\nTo break test press [Q].");

// 
 HCON(cn) |= HCON_DTxEN | HCON_TxEN | HCON_DRxEN | HCON_RxEN;
 Enable_Int(nGLOBAL_INT);		// enable global int

 tnum = 0;
 tlen = 6;
 while(1) 
  {
   if(kbd_hit())
    {
     U8 it;
     it = get_byte(); 
     if(it == 'Q' || it == 'q')
      {
       return;
      }  

     if(it == 'T' || it == 't')
      {
// Transmit ////////////////////////////////////////////////////////////////////
       if(tlen <    6) {tlen =    6;}	// set Tx length to minimum limit 	
       if(tlen > 1024) {tlen = 1024;}	// set Tx length to maximum limit 

       data[0] = 0xFF;			// address
       data[1] = (U8)  tlen; 		// length 
       data[2] = (U8) (tnum & 0xFF);	// packet number 
       data[3] = (U8)((tnum >>  8)&0xFF); 
       data[4] = (U8)((tnum >> 16)&0xFF);
       data[5] = (U8)((tnum >> 24)&0xFF); 

       for(pos = 6; pos < tlen; ++pos)
        {				// fill packet 
         data[pos] = tnum + pos;
        }    
// 
       if(HDLCSend(cn,data,tlen) == 0)
        {
        }
       else
        {
         tnum += 1;			// next Tx packet number 
         tlen += 1;			// next Tx length 
        } 
      }
    }

   len = 1024;				// packet len
   if(HDLCRecv(cn, & status, data, & len) == 0)
    {
     continue;
    } 

// dump packet content /////////////////////////////////////////////////////////

   Print("\n");
   pos = 0;				// start buffer position 
   while(pos < len)
    {
     Print("\n");
     for(num = 0; num < 16; ++num)	// line position 
      {
       if(pos + num < len)
        {
         Print("%02x ", data[pos+num]);
        }
       else
        {
         Print("   ");
        }
      }

     for(num = 0; num < 16; ++num)
      {
       if(pos + num < len)
        {
         U8 ch; 
         ch = data[pos+num];
         if(ch >= 32 && ch < 123)
          {
           Print("%c",ch);
          }
         else
          {
           Print(".");
          }
        }
       else
        {
         Print(" ");
        }
      }

//
     pos += 16;
    }
   Print("\n");
  }
 
 Disable_Int(nGLOBAL_INT);		// enable global int
 HCON(cn) &= ~(HCON_DTxEN | HCON_TxEN | HCON_DRxEN | HCON_RxEN);
#ifdef HDLC_RESET
 Print("\nResetting HDLC%c",(cn?'B':'A'));
 HDLCRx_reset(cn);			// reset Rx BD list 
 HDLCTx_reset(cn);			// reset Tx BD list 
#endif 							// HDLC_RESET
}	

////////////////////////////////////////////////////////////////////////////////
// HDLC Test Main Function /////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

void HdlcTest(void) 
{
// 
 HDLC_Init();				// Initialize HDLC channel A,B

 while(1) 
  {
   U8 it;
// 
   Print("\nHDLC Block Diagnostic Program.");
   Print("\n[1] HDLC A LoopBack.");		// 
   Print("\n[2] HDLC B LoopBack.");		// 	
   Print("\n[3] HDLC A & B LoopBack.");		// 	
   Print("\n[4] HDLC A Single Transfer.");	// 
   Print("\n[5] HDLC A Multiple Transfer.");	// 
   Print("\n[6] HDLC A Receive.");		// 
   Print("\n[7] HDLC B Single Transfer.");	// 
   Print("\n[8] HDLC B Multiple Transfer.");	// 
   Print("\n[9] HDLC B Receive.");		// 
   Print("\n[A] HDLC A External LoopBack.");	// 	
   Print("\n[B] HDLC B External LoopBack.");	// 
   Print("\n[V] HDLC Report View.");
   Print("\n[C] HDLC Report Clear.");
   Print("\n[G] Global Variable View.");
   Print("\n[R] HDLC registers view.");
   Print("\n[T]      set HDLC baudrate.");
   Print("\n[S] Reset HDLC.");
   Print("\n[Q] Quit HDLC Test.");

   Print("\nSelect Test Item : "); 
   it = get_upper();
	
   switch(it)
    {
     case '1' : HdlcInternalLoopback(0,10000, 0);break; // HDLC a Internal LoopBackTest
     case '2' : HdlcInternalLoopback(1,10000, 0);break; // HDLC B Internal LoopBackTest
     case '3' : HdlcInternalLoopback(-1,10000,0);break; // HDLC A & B Internal LoopBackTest
     case '4' : HdlcSingleTransfer(0);  break; 		// HDLC A Single Transfer
     case '5' : HdlcMultipleTransfer(0); break;		// HDLC A Multiple Transfer
     case '6' : HdlcMultipleReceive(0); break;		// HDLC A Recive
     case '7' : HdlcSingleTransfer(1); break;		// HDLC B Single Transfer
     case '8' : HdlcMultipleTransfer(1); break;		// HDLC B Multiple Transfer
     case '9' : HdlcMultipleReceive(1); break;		// HDLC B Multiple Receive
     case 'A' : HdlcExternalLoopback(0,10000, 0);break;	// HDLC A External LoopBackTest
     case 'B' : HdlcExternalLoopback(1,10000, 0);break;	// HDLC B External LoopBackTest
     case 'V' : HdlcErrorRpt(); break;			// HDLC Report View
     case 'C' : HdlcClrErrReport(); break;		// HDLC Report Clear
     case 'G' : HdlcVarView(); break;	 	 	// View Global Variables
     case 'R' : HdlcRegView(); break;			// View HDLC Registers
     case 'S' : HdlcResetTest(); break;		 	// Reset Tests 
     case 'T' : HdlcSetBrg(); break;			//
     case 'Q' : 
      return;

     default  : 
      Print("\nInvalid Test Item Selected") ; 
      break ;
    }

   Print("\nPress any key to continue"); 
   it = get_byte();
   if(it == 'Q' || it == 'q')
    {
     return;
    }
  }
}