iic.c

本source code 為s3c4510的bootloader

          {
           Print("\nBF=0");
          }
        }
       }
      break;

     case 'Q' : return;
     default  :
      break;
    }

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


////////////////////////////////////////////////////////////////////////////////
// IIC Write Test Program //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


void IICWriteTest(void)
{
 char * name;				// Serial EEPROM name
 U32 addr;				// write address	
 U32 size;				// write size
 int pos;				// character position 
 int row;				// screen row 
 int col;				// screen collumn 
 U8 ch;					// console character 			

// 
 name = IICEEPROMName();		// read EEPROM name
 if(name == 0)
  {
   Print("\n\nIIC %s Write Test. Unknown serial EEPROM type.\n");
   return;
  }

 Print("\n\nIIC %s Write Test.", name);	// EEPROM type 

// 
 size = IICEEPROMSize();		// 
 Print("\nEnter Byte write address of IIC EEPROM (0-0x%x) 0x", size);
// 
 addr = get_number(16,0); 		// read EEPROM address from console 
 if(addr >= size)			// 
  {
// out from EEPROM size ////////////////////////////////////////////////////////
   Print("\nAddress [0x%x] not valid.\n", addr);
   return;				// 
  }

// 
 size = size - addr;			// count of writed bytes
 Print("\nInput Write Characters (up to %d bytes)", size);
 Print("\n<CR> to terminate input");

// read writed characters from  console ////////////////////////////////////////

 pos = 0; 				// position in test buffer
 while(1) 
  { 
   ch = get_byte();			// read byte from console  
   if(ch == KEY_CR)
    {
     size = pos;			// reset count of writed bytes 
     break;				// out off loop
    }

   IIC_buffer[pos++] = ch;		// write character to buffer 
   if(pos >= size)
    {					// 
     break;				// 
    }  
  }

// 
 Print("\n%d bytes received : ", size);
 if(size == 0)
  {					// cancel write test 				
   Print("\n");
   return;				// exit from EEPROM write test 
  } 


// print input from console characters /////////////////////////////////////////

 row = 0;				// current row 
 col = 0;				// curent collumn 
 pos = 0;				// current position in write buffer 
 while(pos < size) 
  {
   Print("%02x ", IIC_buffer[pos] );	// put current character  
   pos++;  				// to next next position in tx buffer
   col++; 				// next screen collumn 
   if(col >= 16)
    {
// to next screen row //////////////////////////////////////////////////////////
     Print("\n");
     col = 0;				// reset collumn 
     row++;				// row count 
     if(row >= 16)
      {
       while(kbd_hit())
        {				// clear input 
         ch = get_byte();		// from console 
        }
       Print("\nPress any key to continue ...");
       ch = get_byte();			// 
       row = 0;				// reset row 	
      }
    }
  }

// 
 pos = addr + size;  			// end + 1 writed address in EEPROM 

// 
 if(
    addr >= IIC_mac_addr_start + 	// start writed address > MAC end address
            IIC_mac_addr_size ||
     pos <=  IIC_mac_addr_start		// end writed adrress   < MAC start address
  )
  {
  }
 else 
  {
// Writed area averlap MAC address /////////////////////////////////////////////

   Print("\nMAC address stored in EEPROM from [0x%x] to [0x%x]",
     IIC_mac_addr_start	, 		// MAC address start 
     IIC_mac_addr_start + 		// MAC address end
     IIC_mac_addr_size  - 1
    );

   Print("\nOvewrite MAC address [Y/N]");
   ch = get_upper();
   if(ch == 'N')
    { 		
// exit from EEPROM write test /////////////////////////////////////////////////
     return;				
    } 
  }

// 
 Print("\nIIC Serial EEPROM %s write. Address=[0x%x]. Size=[0x%x].\n",
   name		, 			// EEPROM type 
   addr		,			// start EEPROM address
   size					// writed size
  );

// 
 IICWrite
  (
   IIC_EEPROM_addr	,		// device address
   (U32) addr		,		// EPPROM address
   IIC_buffer		,		// data buffer 
   size					// size
  );
}


////////////////////////////////////////////////////////////////////////////////
// IIC Read Test ///////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

void IICReadTest(void)
{
 char * name;				// EEPROM name
 U32 addr;				// EEPROM address
 U32 size;				// read bytes count 
 U32 maxsize; 
 U32 pos;				// current position 
 U32 row;				// current screen row 
 U32 col;				// current screen col 
 U8 ch;

// 
 name = IICEEPROMName();		// read EEPROM name
 if(name == 0)
  {
   Print("\n\nIIC %s Read Test. Unknown serial EEPROM type.\n");
   return;
  }

//
 Print("\n\nIIC %s Read Test", name);

// read from console EEPROM address //////////////////////////////////////////// 

 size = IICEEPROMSize();
 Print("\nEnter Byte Read address of IIC EEPROM (up to [0x%x]) ", 
   size					// up limit off address 
  );

// 
 addr = get_number(16,0);		// read address from console 
 if(addr >= size)			// check input address
  {
   Print("\nByte address [0x%x] not valid\n", addr);
   return;
  }

// read from console byte count //////////////////////////////////////////////// 

 maxsize = size - addr;			// 
 Print("\nInput Read Data Size (up to [0x%x] bytes) ", maxsize);
 size = get_number(16,0);
 if(size > maxsize)
  {
   Print("\nNot correct data Size [0x%x]", size);
   return;
  }

// 
 Print("\nRead Data From IIC Serial EEPROM\n");
 IICRead
  (
   IIC_EEPROM_addr	,		// device address
   (U32) addr		,		// start address 
   IIC_buffer		, 		// data buffer 
   size					// size 
  );

// out read from EEPROM charactes from console /////////////////////////////////

 row = 0;				// current screen row 
 col = 0;				// current screen col
 pos = 0;
 while(pos < size) 
  {
   Print("%02x ", IIC_buffer[pos] );	// put current character  
   pos++;  				// next position in read buffer  
   col++; 				// next screen column 
   if(col >= 16)
    {
     Print("\n");
     col = 0;				// reset column 
     row++;				// next row
     if(row >= 16)
      {
       while(kbd_hit())
        {				// clear input 
         ch = get_byte();		// from console 
        }
       Print("\nPress any key to continue ...");
       ch = get_byte();		
       row = 0;				// reset row
      }
    }
  }
}

////////////////////////////////////////////////////////////////////////////////
// IIC Read/Write Test Program by interrupt method /////////////////////////////
////////////////////////////////////////////////////////////////////////////////


int IICWriteReadTest(int lcnt)
{
 U8  txdata[16];			// write data buffer 
 U8  rxdata[16];			// read  data buffer
 U32 size = 16;				// size of read & write buffers
 U32 pos;				// EEPROM start address
 U32 i;
 int rvl = 1;
 int lnum;

 Print("\n\nIIC Read/Write Test.");
 if(lcnt == 0)
  {
   Print("\nInput pass count ");
   lcnt = get_number(10, 3);
   if(lcnt == 0)
    {
     lcnt = 1;
    } 
  }

 for(lnum = 0; lnum < lcnt; ++lnum)
  {
// 
   if(lcnt > 1){ Print("\n%d.IIC Read/Write Test", lnum); }
   pos = IIC_test_addr; 		// current EEPROM address
   while(pos + size < IICEEPROMSize())	// in tested area
    {
// generate test buffer ////////////////////////////////////////////////////////
     for(i = 0; i < 16; ++i)
      {
       txdata[i] = (U8) PatternGen(pos + i);
      }

// Write IIC test pattern to Serial EEPROM /////////////////////////////////////
     IICWrite
      (
        IIC_EEPROM_addr	,		// device adress
        pos 		,		// EEPROM start adress
        txdata		,		// write data buffer
        size				// sizeof writed data
      );

/* Read IIC test pattern to Serial EEPROM */
     IICRead
      (
        IIC_EEPROM_addr	,		// device address
        pos		,		// EEPROM start adress
        rxdata		,		// read buffer 
        size				// sizeof read data
      );

     for(i = 0; i < 16; ++i)
      {
       if(txdata[i] != rxdata[i])
        {
         U8 ch;       
         IICReadByte(pos+i, &ch);
         Print("\nError Address [0x%x], Writed=[0x%02x], Read=[0x%02x], [0x%02x]",
           pos + i	, 		// address
           txdata[i] 	,		// writed value 
           rxdata[i]	,		// read value
           ch
         );
// 
         rvl = 0;
        }
      }
     pos += 1;				// to next EEPROM address
    }

   if(rvl == 0)
    {
     break;
    } 
  }
// 

 if(rvl == 1)
  {
   Print("\nOk.");
  }
 else
  {
   Print("\nFail.");
  } 

 return(rvl);
}

////////////////////////////////////////////////////////////////////////////////
// Select IIC EEPROM ///////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

static void IICEEPROMSelect(void)
{
 while(1)
  {
   char * tstr;
   U8 it;
// 
   switch(IIC_EEPROM_type)
    {
     case IIC_EEPROM_AT24C01: tstr = "AT24C01"; break;
     case IIC_EEPROM_AT24C02: tstr = "AT24C02"; break;	
     case IIC_EEPROM_AT24C04: tstr = "AT24C04"; break;	
     case IIC_EEPROM_AT24C08: tstr = "AT24C08"; break;
     case IIC_EEPROM_AT24C16: tstr = "AT24C16"; break;
     default: tstr = "Undefined"; break;
    }

   Print("\n\nSelect IIC EEPROM.");
   Print("\nCurrent [%s]", tstr);
   Print("\n[1] AT24C01 ( 1K, 128 x 8).");
   Print("\n[2] AT24C02 ( 2K, 256 x 8).");
   Print("\n[4] AT24C04 ( 4K, 512 x 8).");
   Print("\n[8] AT24C08 ( 8K,1024 x 8).");
   Print("\n[0] AT24C16 (16K,2048 x 8).");
   Print("\n[A] Select device address.");
   Print("\n[Q] Quit.");

   Print("\nSelect Item : ");
   it = get_upper();


   switch(it)
    {
     case '1' :
// AT24C01 - 1K ( 128 x 8) ( 8 byte page write) ////////////////////////////////
      Print("\nSelected AT24C01 (1K,128x8).");
      IIC_EEPROM_type = IIC_EEPROM_AT24C01;
      break;
      
     case '2' :
// AT24C02 - 2K ( 256 x 8) ( 8 byte page write)	////////////////////////////////
      Print("\nSelected AT24C02 (2K,256x8).");
      IIC_EEPROM_type = IIC_EEPROM_AT24C02;	
      break;

     case '4' :
// AT24C04 - 4K ( 512 x 8) (16 byte page write) ////////////////////////////////
      Print("\nSelected AT24C04 (4K,512x8).");
      IIC_EEPROM_type = IIC_EEPROM_AT24C04;	
      break;

     case '8' :
// AT24C08 - 8K (1024 x 8) (16 byte page write) ////////////////////////////////
      Print("\nSelected AT24C08 (8K,1024x8).");
      IIC_EEPROM_type = IIC_EEPROM_AT24C08;
      break;

     case '0' :
// AT24C16 -16K (2048 x 8) (16 byte page write) ////////////////////////////////
      Print("\nSelected AT24C16 (16K,2048x8).");
      IIC_EEPROM_type = IIC_EEPROM_AT24C16;	
      break;

     case 'A' :
      {
////////////////////////////////////////////////////////////////////////////////
// select slave device address /////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

       Print("\n\nSerial EEPROM type = %s.", IICEEPROMName());
       Print("\nEnter Device Address %d (0-7)", ((IIC_EEPROM_addr >> 1) & 0x7) );
       it = get_upper();
       if(it >= '0' && it <= '7')
        {
         it -= '0';			// device address
         switch(IIC_EEPROM_type)
          {
           case IIC_EEPROM_AT24C01 : // AT24C01
           case IIC_EEPROM_AT24C02 : // AT24C02
            IIC_EEPROM_addr = 0xa0 | (it << 1);
            break;

           case IIC_EEPROM_AT24C04 :
// AT24C04-4K //////////////////////////////////////////////////////////////////
            IIC_EEPROM_addr = 0xa0 | ((it & 0x6) << 1);
            if((it & 0x6) != it)
             {
              Print("\nIn AT24C04 A0 used as a page address.");
             }
            break;
            
           case IIC_EEPROM_AT24C08 : 
// AT24C08-8K //////////////////////////////////////////////////////////////////
            IIC_EEPROM_addr = 0xa0 | ((it & 0x4) << 1);
            if((it & 0x4) != it)
             {
              Print("\nIn AT24C08 A0,A1 used as a page address.");
             }
            break;

           case IIC_EEPROM_AT24C16 : 
// AT24C16 /////////////////////////////////////////////////////////////////////
            IIC_EEPROM_addr = 0xa0;
            if(it != 0)
             {
              Print("\nIn AT24C08 A0,A1,A2 used as a page address.");
             }
            break;

           default                 :
            break;
          }
//
         Print("\nDevice Address %d", ((IIC_EEPROM_addr >> 1) & 0x7));
        }
       else
        {
         Print("\nInvalid Device Address %c.\n",  it);
        } 
      }
      break;

     case 'Q' :				// exit from serial 
      return;				// EEPROM selection 
 
     default  :
      break;
    }

   Print("\nPress Any Key to Continue"); 
   it = get_upper();
   if(it == 'Q')
    {
     return;
    } 
  }
}

////////////////////////////////////////////////////////////////////////////////
// MAC Address Read from IIC EEPROM ////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


int  MacAddrReadIIC(U8 * data)
{
 IICRead				// read IIC 
  ( 
   IIC_EEPROM_addr	,		// IIC device's slave address
   IIC_mac_addr_start   ,		// MAC address offset 
   data			, 		// data buffer 
   IIC_mac_addr_size			// data buffer size
  );

// 
 return(1);
}


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