iic.c

本source code 為s3c4510的bootloader

/*************************************************************************/
/*                                                                       */
/* FILE NAME                                      VERSION                */
/*                                                                       */
/*      iic.c                      KS32C5000, KS32C50100   : version 1.0 */
/*                                                                       */
/* COMPONENT                                                             */
/*                                                                       */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      I2C control function library for SNDS100 evaluation board.       */
/*                                                                       */
/* AUTHOR                                                                */
/*                                                                       */
/*                                                                       */
/* DATA STRUCTURES                                                       */
/*                                                                       */
/*                                                                       */
/* FUNCTIONS                                                             */
/*                                                                       */
/*                                                                       */
/* DEPENDENCIES                                                          */
/*                                                                       */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         NAME            DATE                    REMARKS               */
/*                                                                       */
/*        in4maker      05-04-1999      Create IIC function libraries    */
/*************************************************************************/

/* 			*/
/* Modified by 		*/
/* Dmitriy Cherkashin 	*/
/* [e-mail]	*/
/* 2002,2003		*/
/*			*/

#include "evm50100.h"
#include "ks32c50.h"

////////////////////////////////////////////////////////////////////////////////
// uncomment IIC_DEBUG to debug interrupt mode read & write byte functions /////
////////////////////////////////////////////////////////////////////////////////
//#define IIC_DEBUG 

////////////////////////////////////////////////////////////////////////////////
// uncomment IIC_BYTE_DEBUG to debug pooling mode read & write byte function ///
////////////////////////////////////////////////////////////////////////////////
//#define IIC_BYTE_DEBUG 

// Serial EEPROM type //////////////////////////////////////////////////////////
#define IIC_EEPROM_AT24C01	1	// AT24C01 - 1K ( 128 x 8) ( 8 byte page write)
#define IIC_EEPROM_AT24C02	2	// AT24C02 - 2K ( 256 x 8) ( 8 byte page write)	
#define IIC_EEPROM_AT24C04	4	// AT24C04 - 4K ( 512 x 8) (16 byte page write)
#define IIC_EEPROM_AT24C08	8	// AT24C08 - 8K (1024 x 8) (16 byte page write)
#define IIC_EEPROM_AT24C16     16	// AT24C16 -16K (2048 x 8) (16 byte page write)

static U32 IIC_EEPROM_type    = 4; 	// AT24C04
static U32 IIC_clock_hz  = 100000;	// IIC Serial clock frequency 400KHz
static U8  IIC_EEPROM_addr = 0xa0;	// IIC device's slave address

// 
#define    IIC_buffer_size ((16 * 1024) / 8)  // IIC Test Data buffer size
static U8  IIC_buffer[IIC_buffer_size];	      // IIC Data buffer

// 
#define    IIC_mac_addr_start  0	// MAC address offset 
#define    IIC_mac_addr_size   6	// MAC address size
#define    IIC_test_addr       6	// IIC test start address 

#define    S_WRITE	    0x00	// Write IIC data for slave
#define    S_READ	    0x01	// Read IIC data for slave


//       +---+---+---+---+---+---+---+---+
// 1k/2K | 1 | 0 | 1 | 0 | A2| A1| A0|R/W| AT24C01A/AT24C02
//       +---+---+---+---+---+---+---+---+
//       +---+---+---+---+---+---+---+---+
// 4k    | 1 | 0 | 1 | 0 | A2| A1| P0|R/W| AT24C04
//       +---+---+---+---+---+---+---+---+
//       +---+---+---+---+---+---+---+---+
// 8k    | 1 | 0 | 1 | 0 | A2| P1| P0|R/W| AT24C08
//       +---+---+---+---+---+---+---+---+
//       +---+---+---+---+---+---+---+---+
//16k    | 1 | 0 | 1 | 0 | P2| P1| P0|R/W| AT24C16
//       +---+---+---+---+---+---+---+---+
// P0,P1,P2 - Page Address

////////////////////////////////////////////////////////////////////////////////
// return sizeof serial EEPROM in bytes ////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


static int IICEEPROMSize(void)
{
 switch(IIC_EEPROM_type)
  {
   case IIC_EEPROM_AT24C01 : return( 128); // AT24C01 - 1K ( 128 x 8) ( 8 byte page write)
   case IIC_EEPROM_AT24C02 : return( 256); // AT24C02 - 2K ( 256 x 8) ( 8 byte page write)
   case IIC_EEPROM_AT24C04 : return( 512); // AT24C04 - 4K ( 512 x 8) (16 byte page write)
   case IIC_EEPROM_AT24C08 : return(1024); // AT24C08 - 8K (1024 x 8) (16 byte page write)
   case IIC_EEPROM_AT24C16 : return(2048); // AT24C16 -16K (2048 x 8) (16 byte page write)
   default                 : return(0);
  }
}

////////////////////////////////////////////////////////////////////////////////
// return EEPROM name //////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

static char * IICEEPROMName(void)
{
 switch(IIC_EEPROM_type)
  {
   case IIC_EEPROM_AT24C01 : return("AT24C01"); // AT24C01 - 1K ( 128 x 8) ( 8 byte page write)
   case IIC_EEPROM_AT24C02 : return("AT24C02"); // AT24C02 - 2K ( 256 x 8) ( 8 byte page write)
   case IIC_EEPROM_AT24C04 : return("AT24C04"); // AT24C04 - 4K ( 512 x 8) (16 byte page write)
   case IIC_EEPROM_AT24C08 : return("AT24C08"); // AT24C08 - 8K (1024 x 8) (16 byte page write)
   case IIC_EEPROM_AT24C16 : return("AT24C16"); // AT24C16 -16K (2048 x 8) (16 byte page write)
   default                 :
    return(0);
  }
}

////////////////////////////////////////////////////////////////////////////////
// return device address ///////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


static U8 IICEEPROMAddr(void)
{ 
 U8 devaddr; 				// EEPROM address
 devaddr = (IIC_EEPROM_addr >> 1);	// bit 0 = R/W bit 
 switch(IIC_EEPROM_type)
  {
   case IIC_EEPROM_AT24C01 : devaddr &= 0x7; break; // A0,A1,A2
   case IIC_EEPROM_AT24C02 : devaddr &= 0x7; break; // A0,A1,A2
   case IIC_EEPROM_AT24C04 : devaddr &= 0x6; break; // A1,A2. A0 used as page number  
   case IIC_EEPROM_AT24C08 : devaddr &= 0x4; break; // A0,A1 used as page number 
   case IIC_EEPROM_AT24C16 : devaddr &= 0x0; break; // A0,A1,A2 used as a page number
   default                 : devaddr  = 0x0; break;  
  }

 return(devaddr);
}

////////////////////////////////////////////////////////////////////////////////
// IIC SETUP ROUTINE ///////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

void IICSetup(void)
{
 U32 iicps0;				// prescale devider 0
 U32 iicps1;				// prescale devider 1	
 U32 clk0;				// result IIC clk for devider 0
 U32 clk1;				// result IIC clk for devider 1
 U32 delta0;				// clk 0 delta  
 U32 delta1;				// clk 1 delta
 U32 iicps;

// Reset IIC Controller ////////////////////////////////////////////////////////
 IICCON = IICCON_RESET;			// reset IIC controller

// clk = fMCLK / (16 * (iicps + 1) + 3);

 iicps0 = (fMCLK / IIC_clock_hz - 3) / 16 - 1;	// divider 0
 iicps1 =  iicps0 + 1;				// divider 1 

// 
 clk0 = fMCLK / (16 * (iicps0+1) + 3);	// clock 0
 clk1 = fMCLK / (16 * (iicps1+1) + 3);	// clock 1
 
 if(clk0 >= IIC_clock_hz)
  {
   delta0 = clk0 - IIC_clock_hz;
  }
 else
  {
   delta0 = IIC_clock_hz - clk0;	
  }

 if(clk1 >= IIC_clock_hz)
  {
   delta1 = clk1 - IIC_clock_hz;
  }
 else
  {
   delta1 = IIC_clock_hz - clk1;
  }

 if(delta0 <= delta1)
  {
   iicps = iicps0;
  }
 else
  {
   iicps = iicps1;
  }

//   
#if 0 
 Print("\niicps0=%d,iicps1=%d,clk0=%d,clk1=%d,delta0=%d,delta1=%d,iicps=%d\n",
  iicps0	,	
  iicps1	,
  clk0	,
  clk1	,
  delta0	,	
  delta1	,
  iicps  
 );
// 
#endif 

 IICPS = iicps;
}

////////////////////////////////////////////////////////////////////////////////
// Print IIC Bus Configuration /////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

static void IICConfig(void)
{
 U32 iiccon;				// IIC Control Register 
 U32 iiclk;				// IIC Clock 		
 U32 iicps;				// IIC Prescaler Register 
 U32 iicbuf;				// IIC Shift Buffer Register
 U32 iiccnt;				// IIC Prescaler Counter Register
 U8 first=1;
 U8 it;

 while(1)
  {
   Print("\n\nIIC BUS Configuration");

////////////////////////////////////////////////////////////////////////////////
// IIC Control Register ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

   iiccon = IICCON;			// IIC Control Register 
   Print("\nIICCON IIC Control Register =0x%08x", iiccon);

// [0] Buffer flag (BF) (1=Tx-empty,Rx-full) ///////////////////////////////////
   Print("\n0   [F]Buffer flag (BF).........%s",
    ((iiccon & IICCON_BF) != 0) ?
     "1(Tx empty,Rx full)" :
     "0(Tx not empty,Rx not full)"
   );

// [1] Interrupt enable (IEN) //////////////////////////////////////////////////
   Print("\n1   [I]Interrupt enable (IEN)...%s",
    ((iiccon & IICCON_IEN) != 0) ?
     "1(enabled)" : "0(disabled)"
   );

// [2] Last received bit (LRB) /////////////////////////////////////////////////
   Print("\n2      Last received bit (LRB)..%s", 
    ((iiccon & IICCON_LRB) != 0) ?
     "1(ACK not received)" : "0(ACK is received)"
   ); 

// [3]  Acknowledge enable (ACK) ///////////////////////////////////////////////
   Print("\n3   [A]Acknowledge enable (ACK).%s",
    ((iiccon & IICCON_ACK) != 0) ?
     "1(Generate ACK)" : "0"
   );
 
// [5:4] These bits control the generation of the Start, Stop,Repeat Start /////

   Print("\n5:4 [C]COND1, COND0.............");
   switch(iiccon &IICCON_COND)		// COND1, COND0	   	
    {
     case IICCON_COND_NULL	:	// 00 = no effect
      Print("00(no effect)");
      break;

     case IICCON_COND_START	:	// 01 = Start
      Print("01(Start)");
      break;
 
     case IICCON_COND_STOP	:	// 10 = Stop
      Print("10(Stop)");
      break;

     case IICCON_COND_RESTART	:	// 11 = Repeat Start
      Print("11(Repeat Start)");
      break;
//
     default	:
      break; 
    }

// [6]  Bus busy (BUSY) ////////////////////////////////////////////////////////

   Print("\n6      Bus busy (BUSY)..........%s",
    ((iiccon & IICCON_BUSY) != 0) ?
     "1(Bus busy)" : "0"
   );

   Print("\n7   [R]Reset....................%s", 
    ((iiccon & IICCON_RESET) != 0) ?
     "1" : "0"
   );
 
////////////////////////////////////////////////////////////////////////////////
// IIC Prescaler Register //////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

   iicps = IICPS;				// IIC Prescaler Register 
   Print("\n");
   Print("\nIICPS  Prescaler Register      =0x%08x", iicps);
   Print("\n15:0[P]Prescaler value..........0x%04x", iicps & 0xFFFF);
 
   iicps &= 0xFFFF;
   iiclk = fMCLK / (16 * (iicps + 1) + 3);
   Print("\n       IIC Clock................%d",iiclk);

////////////////////////////////////////////////////////////////////////////////
// IIC Shift Buffer Register ///////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

   if(first == 1) 
    {
     first  = 0;
     iicbuf = IICBUF;			// IIC Shift Buffer Register
    }
 
   Print("\n");
   Print("\nIICBUF Shift Buffer Register   =0x%08x", iicbuf);
   Print("\n7:0 [B]IIC Rx & Tx Data.........0x%02x", iicbuf & 0xFF);

////////////////////////////////////////////////////////////////////////////////
// IIC Prescaler Counter Register //////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

   iiccnt = IICCNT;			// IIC Prescaler Counter Register
   Print("\n");
   Print("\nIICCNT Prescaler Counter       =0x%08x", iiccnt);
   Print("\n15:0   IIC Counter value........0x%04x", iiccnt & 0xFFFF);

   Print("\n    [Q]Quit");
   Print("\nSelect Item");
   it = get_upper();
   switch(it)
    {
     case 'F' :
      {
// [0] Buffer flag (BF) (1=Tx-empty,Rx-full) ///////////////////////////////////
       Print("\n\nEnter Buffer flag (BF) [0/1]");
       it = get_upper();
       if(it == '0')
        {
         Print("\nBF set to 0(buffer not empty in Tx mode,not full in Rx mode)");
         IICCON &=~IICCON_BF;		// clear BF Flag 
        }
       else
       if(it == '1')
        {
         Print("\nBF set to 1(buffer empty in Tx mode,full in Rx mode).");
         IICCON |= IICCON_BF;		// set BF flag
        }
      }
      break;


     case 'I' :
// [1] Interrupt enable (IEN) //////////////////////////////////////////////////
      {
       Print("\nEnable Interrupt (IEN) [Y/N]");
       it = get_upper();
       if(it == 'Y')
        {
         IICCON |=  IICCON_IEN;		// interrupt enable 
        }
       else
       if(it == 'N')
        {
         IICCON &= ~IICCON_IEN;		// interrupt disable
        }
      }
      break; 
 
     case 'A' :
      {
// [3]  Acknowledge enable (ACK) ///////////////////////////////////////////////

       Print("\nAcknowledge enable (ACK) [Y/N]");
       it = get_upper();
       if(it == 'Y')
        {
         Print("\nGenerate an ACK signal at 9th SCL.");
         IICCON |=  IICCON_ACK;		// enable ACK
        }
       else
       if(it == 'N')
        {
         Print("\nDont Generate an ACK signal at 9th SCL.");
         IICCON &= ~IICCON_ACK;		// disable ACK
        } 
      }
      break;

// [5:4] These bits control the generation of the Start, Stop,Repeat Start /////
     case 'C' :
      {
       Print("\n[S]tart/s[T]op/[R]epeat start/[C]lear");
       it = get_upper();
// 
       iiccon = IICCON;			// read control register
// save control register bits BF,interrupt enable, ACK  	
       iiccon &= (IICCON_BF | IICCON_IEN | IICCON_ACK);
       if(it == 'S')
        {
         Print("\nStart.");		// start
         iiccon |= IICCON_COND_START;	// 01 = Start 
         IICCON  = iiccon;		// write IIC control register
        }
       else
       if(it == 'T')
        {
         Print("\nStop.");		// Stop 
         iiccon |= IICCON_COND_STOP;	// 10 = Stop
         IICCON  = iiccon;		// write IIC control register
        }
       else
       if(it == 'R')
        {
         Print("\nRepeat Start.");	// Start
         iiccon |= IICCON_COND_RESTART; // 11 = Repeat Start
         IICCON  = iiccon;		// write IIC control register
        }
       else
       if(it == 'C')
        {
         Print("\nClear (no effect).");
         iiccon |= IICCON_COND_NULL;	// 00 = no effect
         IICCON  = iiccon;		// write IIC control register
        }
      }
      break;
 
     case 'R' : 
      {
// [R] Reset ///////////////////////////////////////////////////////////////////
       Print("\nReset [Y/N]");
       it = get_upper(); 
       if(it == 'Y')
        {
         Print("\nReset IIC.");
         IICCON |= IICCON_RESET;	// reset IIC 
        }
      }
      break;

     case 'P' :
      {
//////////////////////////////////////////////////////////////////////////////// 
       iicps = IICPS & 0xFFFF;
       Print("\nEnter Prescaler value (current = 0x%04x) 0x", iicps);
       iicps = get_number(16,0);
       IICPS = (iicps & 0xFFFF);
      }
      break;

     case 'B' :
      {
//////////////////////////////////////////////////////////////////////////////// 
       Print("\nRead or Write IICBUF Shift Buffer Register [R/W]");
       it = get_upper();
       if(it == 'R')
        {
         if((IICCON & IICCON_BF) != 0)
          {
           Print("\nBF=1");
          }
         else
          {
           Print("\nBF=0");
          }
// 
         iicbuf = IICBUF;
         Print("\nIICBUF->0x%02x", iicbuf);

// 
         if((IICCON & IICCON_BF) != 0)
          {
           Print("\nBF=1");
          }
         else
          {
           Print("\nBF=0");
          }
        }
       else
       if(it == 'W')
        {         
         Print("\nEnter IICBUF Shift Buffer Register value 0x");

         iicbuf = get_number(16,2);

         if((IICCON & IICCON_BF) != 0)
          {
           Print("\nBF=1");
          }
         else
          {
           Print("\nBF=0");
          }

         Print("\nIICBUF<-0x%02x", iicbuf);
         IICBUF = iicbuf;

         if((IICCON & IICCON_BF) != 0)
          {
           Print("\nBF=1");
          }
         else