mac.c

本source code 為s3c4510的bootloader

////////////////////////////////////////////////////////////////////////////////

static void PhyStationIden(void)
{
 U32 phy_id_reg1;			// PHY identififcation Register 1
 U32 phy_id_reg2;			// PHY identififcation Register 2
 U32 oui_reg1;				// register 1 OUI bits
 U32 oui_reg2;				// register 2 OUI bits
 U32 val;				// bit value  
 int bit;				// bit number

////////////////////////////////////////////////////////////////////////////////
// PHY_ID_REG1 // PHY identififcation Register 1 (Address 2) ///////////////////
////////////////////////////////////////////////////////////////////////////////

 Print("\n\nPHY.2,3 Identification Registers 1,2.");
 phy_id_reg1 = MiiStationRead
  (
   PHY_ID_REG1	, 			// register address 
   PHYHWADDR				// PHY address
  );

// 
 Print("\n2.PHY identififcation Register 1 ......0x%04x", phy_id_reg1);
 Print("\n2.15:0 bit 3 througt 18 of OUI   ......0x%04x", phy_id_reg1 & 0xFFFF);

// 
 Print("\n  Register bit number .");
 for(bit = 15; bit >= 0; --bit)
  {
   Print("%2d ", bit);			// print bit number
  }

// 
 oui_reg1 = 0;				// register 1 OUI part
 Print("\n  bit value ...........");
 for(bit = 15; bit >= 0; --bit)		// print bit value
  {
   val = ((phy_id_reg1 >> bit) & 1);	// bit value
   if(val == 1)
    {
     oui_reg1 |= (1 << (15 - bit)) << 2;
// Intel LXT970A Dual-Speed Fast Ethernet Transceiver
// Order Number: 249099-001
// January 2001  
// Page 66 : OUI bit numbers from 1 to 24 (not from 0 to 23)
    }

   Print("%2d ", val);
  }

 Print("\n  OUI bit number ......");
 for(bit = 3; bit <= 18; ++bit)
  {
   Print("%2d ", bit);			// print bit number
  }


////////////////////////////////////////////////////////////////////////////////
// PHY_ID_REG2 // PHY identififcation Register 2 (Address 3) ///////////////////
////////////////////////////////////////////////////////////////////////////////

 phy_id_reg2 = MiiStationRead	// read PHY register 
  ( 
   PHY_ID_REG2	, 		// register address
   PHYHWADDR			// PHY address
  );

 Print("\n3.PHY identififcation Register 2 ......0x%04x", phy_id_reg2);

 Print("\n3.15:10 bits 19 throught 24 of the OUI.0x%04x",
        (phy_id_reg2 >> 10) & 0x3F);

// 
 Print("\n  Register bit number .");
 for(bit = 15; bit >= 10; --bit)
  {
   Print("%2d ", bit);			// print bit number
  }

// 
 oui_reg2 = 0;
 Print("\n  bit value ...........");
 for(bit = 15; bit >= 10; --bit)	// print bit value
  {
   val = ((phy_id_reg2 >> bit) & 1);	// bit value
   if(val == 1)
    {
     oui_reg2 |= 1 << (18 + (15 - bit));
    }

   Print("%2d ", val);			// print bit value 
  }

 Print("\n  OUI bit number ......");
 for(bit = 19; bit <= 24; ++bit)
  {
   Print("%2d ", bit);			// print bit number
  }


 Print("\n3.9 : 4 Manufactures Part Number.......0x%x", (phy_id_reg2 >> 4) & 0x3F);
 Print("\n3.3 : 0 Manufactures revision Number...0x%x",  phy_id_reg2 & 0xF);
 Print("\n        OUI............................0x%06x", oui_reg1 | oui_reg2 );
// OUI - 3 bytes
}

////////////////////////////////////////////////////////////////////////////////
// PHY_ANA_REG // Auto Negotiation Advertisement Register (Address 4) //////////
////////////////////////////////////////////////////////////////////////////////

static void PhyStationAna(void)
{
 U8 it;
 
 while(1)
  {
   U32 phy_ana_reg;		// Auto Negotiation Advertisement Register
   phy_ana_reg = MiiStationRead	// read register 
    ( 
     PHY_ANA_REG , 		// register address
     PHYHWADDR			// PHY address
    );

   Print("\n\n4.Auto Negotiation Advertisement Register : 0x%04x",phy_ana_reg);

// Next Page (PHYANA_NEXTPAGE) /////////////////////////////////////////////////
   Print("\n4.15     Next Page (RO)...............%s",
    ((phy_ana_reg & PHYANA_NEXTPAGE) != 0) ?
    "1(Supported)" :		// Next Page 
    "0(Not Supported)"
   );

// Remote Fault (PHYANA_REMOTE_FAULT) //////////////////////////////////////////
   Print("\n4.13 [F] Remote Fault (R/W)...........%s",
    ((phy_ana_reg & PHYANA_REMOTE_FAULT) != 0) ?
     "1(Remote fault)" :		// Remote Fault
     "0(No remote fault)"
   ); 

//
   Print("\n4.12:11  Reserved Ignore on read(R/W).%d%d",
     ((phy_ana_reg >> 12) & 1),
     ((phy_ana_reg >> 11) & 1)
    ); 


// Pause (PHYANA_PAUSE) ////////////////////////////////////////////////////////
   Print("\n4.10 [P] Pause (R/W) .................%s",
    ((phy_ana_reg & PHYANA_PAUSE) != 0) ?	/* Pause */
     "1(Pause operation is enabled for full-duplex links)" :
     "0(Pause operation is disabled)"
   ); 

// 100BASE-T4 (PHYANA_100BASE_T4) //////////////////////////////////////////////
   Print("\n4.9  [A] 100BASE-T4 (R/W).............%s", 
    ((phy_ana_reg & PHYANA_100BASE_T4) != 0) ?	/* 100BASE-T4 */
     "1(100BASE-T4 capability is available)" :
     "0(100BASE-T4 capability is not available)"
   );

// 100BASE-TX full-duplex (PHYANA_DR100_TX_FULL) ///////////////////////////////
   Print("\n4.8  [B] 100BASE-TX full-duplex (R/W).%s", 
    ((phy_ana_reg & PHYANA_DR100_TX_FULL) != 0)	?
     "1(DTE is 100BASE-TX full-duplex capable)" :
     "0(DTE is not 100BASE-TX full-duplex capable)"
   );
  
// 100BASE-TX (PHYANA_DR100_TX_HALF) ///////////////////////////////////////////
   Print("\n4.7  [C] 100BASE-TX (R/W).............%s", 
    ((phy_ana_reg & PHYANA_DR100_TX_HALF) != 0) ?
     "1(DTE is 100BASE-TX capable)" :
     "0(DTE is not 100BASE-TX capable)"
   );

// 10BASE-T full-duplex (PHYANA_DR10_TX_FULL) //////////////////////////////////
   Print("\n4.6  [D] 10BASE-T full-duplex (R/W)...%s", 
    ((phy_ana_reg & PHYANA_DR10_TX_FULL) != 0) ?
     "1(DTE is 10BASE-T full-duplex capable)"  :
     "0(DTE is not 10BASE-T full-duplex capable)"
   ); 

// 10BASE-T (PHYANA_DR10_TX_HALF) //////////////////////////////////////////////
   Print("\n4.5  [E] 10BASE-T (R/W)...............%s",
    ((phy_ana_reg & PHYANA_DR10_TX_HALF) != 0) ?
     "1(DTE is 10BASE-T capable)" :
     "0(DTE is not 10BASE-T capable)"
   );

//
   Print("\n4.4:0[S] Selector Filed (R/W).........");
   if((phy_ana_reg & 0x1F) == 0x01)
    {
     Print("<00001> = IEEE 802.3");
    }
   else
   if((phy_ana_reg & 0x1F) == 0x02)
    {
     Print("<00010> = IEEE 802.9 ISLAN-16T");
    }
   else 
   if((phy_ana_reg & 0x1F) == 0x00)
    {
     Print("<00000> = Reserved for future Auto-Negotiation development");
    }
   else 
   if((phy_ana_reg & 0x1F) == 0x1F)
    {
     Print("<11111> = Reserved for future Auto- Negotiation development");
    }
   else
    {
     Print("%x",(phy_ana_reg & 0x1F));
    }
// 
   Print("\n         R/W = Read/Write"); 
   Print("\n         RO  = Read Only"); 
   Print("\n     [Q] Quit");				// Quit from station management 
   Print("\nSelect Test Item : "); 
   it = get_upper();			
	
   switch(it)
    {
     case 'F' : 	
      {
////////////////////////////////////////////////////////////////////////////////
// Remote Fault ////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
       Print("\nEnable Remote Fault [Y/N/Q]"); 
       it = get_upper();
       if(it == 'Q')
        {				// return from  Auto-Neg. advertisement
         return;  			// register test 
        }
       else
       if(
          it == 'Y' ||			// enable remote fault 
          it == 'N'			// disable remote fault 
        )
        {
         if(it == 'Y')
          {
// enable remote fault /////////////////////////////////////////////////////////
           Print("\nRemote Fault Enabled.");
           phy_ana_reg |= PHYANA_REMOTE_FAULT;	// set remote fault bit 
          }
         else
          {
// disable remote fault ////////////////////////////////////////////////////////
           Print("\nRemote Fault Disabled.");
           phy_ana_reg &=~PHYANA_REMOTE_FAULT;	// clear remote fault bit 
          }
          
         MiiStationWrite		// register write
          ( 
           PHY_ANA_REG  , 		// register address
           PHYHWADDR	,		// PHY address
           phy_ana_reg			// register value
          );
        }  
      }
      break;

     case 'P' : 			// Pause
      {
////////////////////////////////////////////////////////////////////////////////
// Pause ///////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
       Print("\nEnable Pause operation for full-duplex links [Y/N/Q]"); 
       it = get_upper();
       if(it == 'Q')
        {				// quit from 
         return;  			// register test 
        }
       else
       if(
          it == 'Y' ||
          it == 'N'
        )
        {
         if(it == 'Y')
          {
// enable pause operation //////////////////////////////////////////////////////
           Print("\nPause operation is enabled for full-duplex links.");
           phy_ana_reg |= PHYANA_PAUSE;
          }
         else
          {
// disable pause operation /////////////////////////////////////////////////////
           Print("\nPause operation is disabled."); 
           phy_ana_reg &=~PHYANA_PAUSE;
          }
          
         MiiStationWrite		// register write
          ( 
           PHY_ANA_REG  , 		// register address
           PHYHWADDR	,		// PHY address
           phy_ana_reg			// register value
          );
        }  
      }
      break;

     case 'A' : 			// 100BASE-T4
      {
////////////////////////////////////////////////////////////////////////////////
// [A] 100BASE-T4 //////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

       Print("\nThe LXT970A does not support 100BASE-T4,");
       Print("\nbut allows this bit to be set to advertise in the");
       Print("\nAuto-Negotiation sequence for 100BASE-T4 operation.");
       Print("\nAn external 100BASE-T4 transceiver could be switched"); 
       Print("\nin if this capability is desired.");
       Print("\nEnable 100BASE-T4 capability [Y/N/Q]"); 
       it = get_upper();
       if(it == 'Q')
        {
         return;  
        }
       else
       if(
          it == 'Y' ||
          it == 'N'
        )
        {
         if(it == 'Y')
          {
// enable 100Base-T4 ///////////////////////////////////////////////////////////
           Print("\n100BASE-T4 capability is available.");
           phy_ana_reg |= PHYANA_100BASE_T4;
          }
         else
          {
// disable 100Base-T4 //////////////////////////////////////////////////////////
           Print("\n100BASE-T4 capability is not available.");
           phy_ana_reg &=~PHYANA_100BASE_T4;
          }
          
         MiiStationWrite		// register write
          ( 
           PHY_ANA_REG  , 		// register address
           PHYHWADDR	,		// PHY address
           phy_ana_reg			// register value
          );
        }  
      }
      break;

     case 'B' : 			// 100BASE-TX full-duplex
      {
////////////////////////////////////////////////////////////////////////////////
// [B] 100BASE-TX full-duplex //////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

       Print("\nEnable 100Base-TX full-duplex [Y/N/Q]"); 
       it = get_upper();
       if(it == 'Q')
        {
         return;  
        }
       else
       if(
          it == 'Y' ||
          it == 'N'
        )
        {
         if(it == 'Y')
          {
// enable 100Base-TX full-duplex ///////////////////////////////////////////////
           Print("\nDTE is 100Base-TX full-duplex capable.");
           phy_ana_reg |= PHYANA_DR100_TX_FULL;
          }
         else
          {
// disable 100Base-TX full-duplex //////////////////////////////////////////////
           Print("\nDTE is not 100BASE-TX full-duplex capable.");
           phy_ana_reg &=~PHYANA_DR100_TX_FULL;
          }
          
         MiiStationWrite		// register write
          ( 
           PHY_ANA_REG  , 		// register address
           PHYHWADDR	,		// PHY address
           phy_ana_reg			// register value
          );
        }  
      }
      break;

     case 'C' : 			// 100BASE-TX
      {
////////////////////////////////////////////////////////////////////////////////
// [C] 100BASE-TX //////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
       Print("\nEnable 100Base-TX [Y/N/Q]"); 
       it = get_upper();
       if(it == 'Q')
        {
         return;  
        }