hdlc100init.c

本source code 為s3c4510的bootloader

   PrintVarS("\n    HDLCRxAllocBuf..",HDLCRxAllocBuf [0],HDLCRxAllocBuf [1]);
   PrintVarD("\n    HDLCRxStart.....",gHDLCRxStart   [0],gHDLCRxStart   [1], rxstart);
   PrintVarD("\n    HDLCRxEnd.......",gHDLCRxEnd     [0],gHDLCRxEnd     [1], rxend); 

#ifndef USER_AREA
   PrintVarS("\n    HDLCRxCount.....",gHDLCRxCount[0],gHDLCRxCount[1]);
#endif 								// USER_AREA
   PrintVarD("\n    HDMARXPTR.......", HDMARXPTRA       , HDMARXPTRB        , rxptr);

#ifdef USER_AREA
   PrintVarS("\n    HDLCRxUserArea..",HDLCRxUserArea [0],HDLCRxUserArea [1]); 
   PrintVarS("\n    HDLCRxUserRead..",HDLCRxUserRead [0],HDLCRxUserRead [1]); 
   PrintVarS("\n    HDLCRxUserWrite.",HDLCRxUserWrite[0],HDLCRxUserWrite[1]);
   PrintVarS("\n    HDLCRxUserFirst.",HDLCRxUserFirst[0],HDLCRxUserFirst[1]);
   PrintVarS("\n    HDLCRxUserCount.",HDLCRxUserCount[0],HDLCRxUserCount[1]);
#endif 								// USER_AREA

   Print("\nHDLCCPUmode.....0x%08x", gHDLCCPUmode);
   Print("\ngHHDLCRxDone....0x%08x", gHDLCRxDone); 
   Print    ("\n[Q] Quit");
   Print    ("\n    Select Item");

// 
   dir = get_upper();			// read selected item from console
   if(dir == 'Q')
    {					// 
     return;
    } 

   if(dir != 'T' && dir != 'R')
    {					// not rx BD, tx BD	
     continue;
    }

// input channel number ////////////////////////////////////////////////////////
   Print("\nInput HDLC channel [0/1/Q]");
   cn = get_upper();
   if(cn == 'Q')     
    { 					// return from dump  
     return; 				
    } 
   else 
   if(cn >= '0' && cn <= '1')
    {
     cn = cn - '0';
    }
   else
    {
     continue;
    }  

// 
   bd = 0;					// dumped bd pointer

// input bd index //////////////////////////////////////////////////////////////
   Print("\nInput BD number           ");
   num = get_number(4,10); 
   if(dir == 'T') 
    {
     if(num < 0 || num >= HDLC_MAX_TX_DES)
      {
       Print("\nIncorrect Tx BD index %d. Must be from 0 to %d", 
        num, HDLC_MAX_TX_DES
       );
       continue;
      }
     bd = & sHDLCTxBD[cn][num];			// Tx BD, channel cn, index num 	
    }
   else
    {
     if(num < 0 || num >= HDLC_MAX_RX_DES)
      {
       Print("\nIncorrect Rx BD index %d. Must be from 0 to %d", 
        num, HDLC_MAX_RX_DES
       );
       continue;
      }
     bd = & sHDLCRxBD[cn][num];			// Rx BD, channel cn, index num
    }


   if(bd == 0)
    {
     continue;
    }

   while(1)
    {
// dump selected bd 
     Print("\nOwner....................%s", (bd->BufferDataPtr & HDLCTxBD_DMA) ? "1(DMA)" : "0(CPU)");
     Print("\nReserved...............0x%08x", bd->Reserved);
     if(dir == 'T')
      {
       Print("\n0   Preamble (P).........%s", ((bd->Reserved & HDLCTxBD_Preamble) ? "1" : "0")); 
       Print("\n1   TxNoCRC (N)..........%s", ((bd->Reserved & HDLCTxBD_TxNoCRCM) ? "1" : "0")); 
       Print("\n2   Little-Endian (E)....%s", ((bd->Reserved & HDLCTxBD_Little  ) ? "1" : "0")); 
       Print("\n3   Last (L).............%s", ((bd->Reserved & HDLCTxBD_Last    ) ? "1" : "0")); 
       Print("\n4   Decrement (D)........%s", ((bd->Reserved & HDLCTxBD_Dec     ) ? "1" : "0")); 
       Print("\n6:5 Widget Aligment (WA).");
       switch(bd->Reserved & HDLCTxBD_WA3)
        {
         case HDLCTxBD_WA0 : Print("00"); break;	// 00 = No invalid bytes
         case HDLCTxBD_WA1 : Print("01"); break;	// 01 = 1 Invalid bytes
         case HDLCTxBD_WA2 : Print("10"); break;	// 10 = 2 invalid bytes
         case HDLCTxBD_WA3 : Print("11"); break;	// 11 = 3 invalid bytes
         default: break;
        }
      }

// 
     Print("\nStatus Length..........0x%08x", bd->StatusLength);
     Print("\nLength.................0x%08x", bd->StatusLength & 0xFFFF);
     if(dir == 'T')
      {
       Print("\n26  Tx Comp............%s", ((bd->StatusLength & HDLCTxBD_TxComp) ? "1" : "0")); 
      }
     else
      {
// rx status
       U32 stat;
       stat = bd->StatusLength >> 16;
       Print("\n16 CD Lost (CD)..........%d", ((stat & HDLCRxBD_CD  )?1:0));
       Print("\n17 CRC Error (CE)........%d", ((stat & HDLCRxBD_CRC )?1:0));	    
       Print("\n18 Non-octet Aligned (NO)%d", ((stat & HDLCRxBD_NO  )?1:0));       
       Print("\n19 Overrun (OV)..........%d", ((stat & HDLCRxBD_OV  )?1:0));
       Print("\n20 DPLL Two Miss (DTM)...%d", ((stat & HDLCRxBD_DTM )?1:0));
       Print("\n21 Rx Abort (ABT)........%d", ((stat & HDLCRxBD_ABT )?1:0));
       Print("\n22 First In Frame (F)....%d", ((stat & HDLCRxBD_F   )?1:0));
       Print("\n23 Last In Frame (L).....%d", ((stat & HDLCRxBD_L   )?1:0));
       Print("\n24 FrameLen Violation....%d", ((stat & HDLCRxBD_FLV )?1:0));
      }
 
     Print("\nNext BD................0x%08x", bd->Next);
      {
       int next;			
       if(dir == 'T')
        {	
         next = HdlcVarIdx((U32)bd->Next, sHDLCTxBD[cn]);	// next Tx BD  
        }
       else
        {
         next = HdlcVarIdx((U32)bd->Next, sHDLCRxBD[cn]);	// next Rx BD
        }
       Print("(%d)", next);
      }

     Print("\nPres any key to select next BD, Q - Quit");
     it = get_upper();
     if(it == 'Q' || it == 'q')
      {
       return;
      } 

     num++;  					// move to next BD 
     if(dir == 'T') 
      {
       if(num >= HDLC_MAX_TX_DES)
        {					
         num = 0;
        }
       Print("\nHDLC%c Tx BD %d", 'A' + cn, num);
       bd = & sHDLCTxBD[cn][num];
      }
     else
      {
       if(num >= HDLC_MAX_RX_DES)
        {
         num = 0; 
        }
       Print("\nHDLC%c Rx BD %d", 'A' + cn, num);
       bd = & sHDLCRxBD[cn][num];
      }
    } 
  }
}


////////////////////////////////////////////////////////////////////////////////
// View HDLC Error Report //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


void HdlcErrorRpt(void)
{
 Print("\n                   %8s %8s","A","B");
 Print( "                    %8s %8s","A","B");
 Print("\nHDLC Tx Status");

////////////////////////////////////////////////////////////////////////////////
// HDLC Tx Statistic ///////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#ifdef HDLC_TX_ISR_DEBUG
 Print("\nTx ISR             %8d %8d",
   HDLCTxStatus[0].TxISR    , 
   HDLCTxStatus[1].TxISR
  );
#endif 							// HDLC_TX_ISR_DEBUG

// Tx Complete (in DMA mode) ///////////////////////////////////////////////////
 Print("\nTx Complete        %8d %8d",		/* 1 */
   HDLCTxStatus[0].TxFC    , 
   HDLCTxStatus[1].TxFC
  );

// Tx FIFO Avail ///////////////////////////////////////////////////////////////

 Print( " Tx FIFO Avail      %8d %8d",		/* 1 */
   HDLCTxStatus[0].TxFA    ,
   HDLCTxStatus[1].TxFA
  );

// Tx CTS Store ////////////////////////////////////////////////////////////////
 Print("\nTx CTS Store       %8d %8d",		/* 2 */
   HDLCTxStatus[0].TxSCTS   	,
   HDLCTxStatus[1].TxSCTS
  );

// Tx Underrun /////////////////////////////////////////////////////////////////
 Print( " Tx Underrun        %8d %8d",		/* 2 */
   HDLCTxStatus[0].TxU		,
   HDLCTxStatus[1].TxU
  );

// Tx DMA Frame Done ///////////////////////////////////////////////////////////
 Print("\nTx DMA Frame Done  %8d %8d",		/* 3 */
   HDLCTxStatus[0].DMATxFD	   ,
   HDLCTxStatus[1].DMATxFD
  );

// Tx DMA Abort ////////////////////////////////////////////////////////////////
 Print( " Tx DMA Abort       %8d %8d",		/* 3 */
   HDLCTxStatus[0].DMATxABT  	   ,
   HDLCTxStatus[1].DMATxABT
  );

// Tx DMA Null List ////////////////////////////////////////////////////////////
 Print("\nTx DMA Null List   %8d %8d",		/* 4 */
   HDLCTxStatus[0].DMATxNL	   ,
   HDLCTxStatus[1].DMATxNL
  );

// Tx DMA Not Owner ////////////////////////////////////////////////////////////
 Print( " Tx DMA Not Owner   %8d %8d",		/* 4 */
   HDLCTxStatus[0].DMATxNO	   ,
   HDLCTxStatus[1].DMATxNO
  );

// ISR error Last Tx BD not completed  //////////////////////////////////////////
 Print("\nLast BD Not Comp   %8d %8d",	
   HDLCTxStatus[0].TxLBDNC	   ,
   HDLCTxStatus[1].TxLBDNC
  );


////////////////////////////////////////////////////////////////////////////////
// HDLC Rx Statistic ///////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#ifdef HDLC_RX_ISR_DEBUG
 Print("\nRx ISR             %8d %8d",		/* 1 */
   HDLCRxStatus[0].RxISR    , 
   HDLCRxStatus[1].RxISR
  );
#endif 							// HDLC_RX_ISR_DEBUG

   Print("\nHDLC Rx Status")	;		/* 5 */
// Rx FIFO Avail ///////////////////////////////////////////////////////////////
 Print("\nRx FIFO Avail      %8d %8d",		/* 6 */
   HDLCRxStatus[0].RxFA	   ,
   HDLCRxStatus[1].RxFA
  );  

// Rx Flag Detect //////////////////////////////////////////////////////////////
 Print( " Rx Flag Detect     %8d %8d",		/* 6 */
   HDLCRxStatus[0].RxFD 	,		
   HDLCRxStatus[1].RxFD		
  );  

// Rx DCD  store ///////////////////////////////////////////////////////////////
 Print("\nRx DCD  store      %8d %8d",		/* 7 */
   HDLCRxStatus[0].RxSDCD       ,
   HDLCRxStatus[1].RxSDCD
  );  
 
// Rx LFrame Valid /////////////////////////////////////////////////////////////
 Print( " Rx Frame Valid     %8d %8d",		/* 7 */
   HDLCRxStatus[0].RxFV 	,
   HDLCRxStatus[1].RxFV
  );  

// Rx Idle /////////////////////////////////////////////////////////////////////
 Print("\nRx Idle            %8d %8d",		/* 8 */
   HDLCRxStatus[0].RxIDLE        ,
   HDLCRxStatus[1].RxIDLE
  );  

// Rx Abort ////////////////////////////////////////////////////////////////////
 Print( " Rx Abort           %8d %8d",		/* 8 */
   HDLCRxStatus[0].RxABT        ,
   HDLCRxStatus[1].RxABT
  );  

// Rx CRC Error	////////////////////////////////////////////////////////////////
 Print("\nRx CRC Error       %8d %8d",		/* 9 */
   HDLCRxStatus[0].RxCRCE       ,
   HDLCRxStatus[1].RxCRCE
  );  

// Rx Non Octet ////////////////////////////////////////////////////////////////
 Print( " Rx Non Octet       %8d %8d",		/* 9 */
   HDLCRxStatus[0].RxNO     	,
   HDLCRxStatus[1].RxNO
  );  

// Rx Overrun //////////////////////////////////////////////////////////////////
 Print("\nRx Overrun         %8d %8d",		/* 10 */
   HDLCRxStatus[0].RxOV      	,
   HDLCRxStatus[1].RxOV
  );  
 
// Rx RxMOV ////////////////////////////////////////////////////////////////////
 Print( " Rx RxMOV           %8d %8d",		/* 10 */
   HDLCRxStatus[0].RxMOV       ,
   HDLCRxStatus[1].RxMOV
  );  

// Rx Inter Error //////////////////////////////////////////////////////////////
 Print("\nRx Inter Error     %8d %8d",		/* 11 */
   HDLCRxStatus[0].RxIERR 	   ,
   HDLCRxStatus[1].RxIERR
  );  

// Rx DMA NL ///////////////////////////////////////////////////////////////////
 Print( " Rx DMA NL          %8d %8d",		/* 11 */
   HDLCRxStatus[0].DRxNL           ,
   HDLCRxStatus[1].DRxNL
  );  

// Rx DMA FD ///////////////////////////////////////////////////////////////////
 Print("\nRx DMA FD          %8d %8d",		/* 12 */
   HDLCRxStatus[0].DRxFD           , 
   HDLCRxStatus[1].DRxFD
  );  
 
 
// Rx DMA NO ///////////////////////////////////////////////////////////////////
 Print( " Rx DMA NO          %8d %8d",		/* 12 */
   HDLCRxStatus[0].DRxNO        ,
   HDLCRxStatus[1].DRxNO
  );  

// 
 Print("\nDPLL One ClkMiss   %8d %8d",		/* 13 */
   HDLCDPLLStatus[0].DPLLOM	,
   HDLCDPLLStatus[1].DPLLOM
  );

 Print( " DPLL Two ClkMiss   %8d %8d",		/* 13 */
   HDLCDPLLStatus[0].DPLLTM,
   HDLCDPLLStatus[1].DPLLTM
  );
}

////////////////////////////////////////////////////////////////////////////////
// Clear HDLC Statistics ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

void HdlcClrErrReport()
{	
 U8 cn;
 for(cn = 0; cn <= 1; ++cn)
  {
#ifdef HDLC_TX_ISR_DEBUG
   HDLCTxStatus[cn].TxISR     = 0;	
#endif 					// HDLC_RX_ISR_DEBUG

   HDLCTxStatus[cn].TxFC     = 0;	// Tx Frame Complete
   HDLCTxStatus[cn].TxFA     = 0;	// Tx FIFO Avail
   HDLCTxStatus[cn].TxSCTS   = 0;
   HDLCTxStatus[cn].TxU      = 0;	// 
   HDLCTxStatus[cn].TxLBDNC  = 0;	// Last BD not completed 
   HDLCTxStatus[cn].DMATxABT = 0;	// Tx DMA Abort
   HDLCTxStatus[cn].DMATxFD  = 0;	// Tx DMA Frame Done
   HDLCTxStatus[cn].DMATxNL  = 0;	// Tx DMA Null List
   HDLCTxStatus[cn].DMATxNO  = 0;	// Tx DMA Not Owner

// HDLC Rx Status //////////////////////////////////////////////////////////////
#ifdef HDLC_TX_ISR_DEBUG
   HDLCRxStatus[cn].RxISR    = 0;	// 
#endif 					// HDLC_TX_ISR_DEBUG

   HDLCRxStatus[cn].RxFA     = 0;	// Rx FIFO Avail
   HDLCRxStatus[cn].RxFD     = 0;	// Rx Flag Detect
   HDLCRxStatus[cn].RxSDCD   = 0;	// Rx DCD  store
   HDLCRxStatus[cn].RxFV     = 0;	// Rx Frame Valid
   HDLCRxStatus[cn].RxIDLE   = 0;	// Rx Idle
   HDLCRxStatus[cn].RxABT    = 0;	// Rx Abort
   HDLCRxStatus[cn].RxCRCE   = 0;	// Rx CRC Error
   HDLCRxStatus[cn].RxNO     = 0;	// Rx Non Octet
   HDLCRxStatus[cn].RxOV     = 0;	// Rx Overrun
   HDLCRxStatus[cn].RxMOV    = 0;	// Rx RxMOV
   HDLCRxStatus[cn].RxIERR   = 0;	// Rx Inter Error
   HDLCRxStatus[cn].DRxFD    = 0;	// Rx DMA FD
   HDLCRxStatus[cn].DRxNL    = 0;	// Rx DMA NL
   HDLCRxStatus[cn].DRxNO    = 0;	// Rx DMA NO

// HDLC DPLL Status ////////////////////////////////////////////////////////////

   HDLCDPLLStatus[cn].DPLLOM = 0;	// one clock miss