loader.c

本source code 為s3c4510的bootloader

           continue;
          } 
         put_string("\n8"); 
        }
       else 
       if(ch == 2) 
        {
// half byte read/write test ////////////////////////////////////////////////////
         if(
           cmd != CMD_DRAM_TEST   && 
           cmd != CMD_DRAM_HALF_TEST
          )
          {
           continue;
          } 
         put_string("\n16");
        } 
       else
        { 
// word read/write test ///////////////////////////////////////////////////////// 
         if(
           cmd != CMD_DRAM_TEST   && 
           cmd != CMD_DRAM_WORD_TEST
          )
          {
           continue;
          } 
         put_string("\n32");
        } 

       put_string(" bit write\n");

// write DRAM ///////////////////////////////////////////////////////////////////

#ifdef DRAM_TEST_ROTATE
       crc = 1; 			// rotated pattern  
#else
       crc = 0;				// increment pattern 
#endif					// DRAM_TEST_ROTATE

       length = ch;			// address increment
       for(pos = DRAM_BASE; pos < DRAM_NEXT; )
        {
#ifdef DRAM_TEST_FAST         
//         put_value(pos,0);
#else
         if((pos % 0x10000) == 0)
#endif 							// DRAM_TEST_FAST         
          {
	   put_ch('.'); 	
          }

         if(ch == 1)
          { 
           *((U8  *)(pos)) = (U8)crc;
#ifdef DRAM_TEST_ROTATE
           crc = ((crc << 1) & 0xFF); 
#endif 							// DRAM_TEST_ROTATE
          } 
         else
         if(ch == 2)
          { 
           *((U16 *)(pos)) = (U16)crc;
#ifdef DRAM_TEST_ROTATE
           crc = ((crc << 1) & 0xFFFF); 
#endif 							// DRAM_TEST_ROTATE
          } 
         else
          { 
           *((U32 *)(pos)) = (U32)crc;
#ifdef DRAM_CHECK_0X40 
           if(pos > DRAM_BASE + 0x40)
            {
             if(*((U32 *)(DRAM_BASE + 0x40)) != ((U32)1) << 16)
              {
               put_string("\nError offset 40 ");
               put_value(pos,0);
              }
            }
#endif							// DRAM_CHECK_0X40 

#ifdef DRAM_TEST_ROTATE
           crc =  (crc << 1); 
#endif 							// DRAM_TEST_ROTATE
          } 

#ifdef DRAM_TEST_ROTATE
         if(crc == 0)
          {
           crc = 1;
          } 
#else
         crc += ch;			// increment pattern 
#endif 					// DRAM_TEST_ROTATE

#ifdef DRAM_TEST_FAST         
         pos = DRAM_BASE + length;
         length *= 2;			// fast address 
#else
         pos += length;			// next tested address
#endif 					// DRAM_TEST_FAST         
        }

       put_string("\nWait");

       IOPDATA = 0x10000;	
       led = 0x100000;
       while(led-- > 0);	
       IOPDATA = 0x00000;	

// read and compare /////////////////////////////////////////////////////////////

       put_string("\nread\n");

#ifdef DRAM_TEST_ROTATE
       crc = 1; 			// rotated pattern  
#else
       crc = 0;				// increment pattern 
#endif					// DRAM_TEST_ROTATE

       cmd = 0;				// error count
       length = ch;			// address increment
       for(pos = DRAM_BASE; pos < DRAM_NEXT; )
        {
#ifdef DRAM_TEST_FAST         
#else
         if((pos % 0x10000) == 0)
#endif 							// DRAM_TEST_FAST         
          {
           put_ch('.');
          }

         if(ch == 1)
          { 
           if(*((U8 *)(pos)) != (U8)crc)
            {
             cmd += 1;
             put_dram(pos,crc,ch);
            }
#ifdef DRAM_TEST_ROTATE
           crc = ((crc << 1) & 0xFF); 
#endif 					// DRAM_TEST_ROTATE
          } 
         else
         if(ch == 2)
          { 
           if(*((U16 *)(pos)) != (U16)crc)
            {
             cmd += 1;
             put_dram(pos,crc,ch);
            }
#ifdef DRAM_TEST_ROTATE
           crc = ((crc << 1) & 0xFFFF); 
#endif 					// DRAM_TEST_ROTATE
          } 
         else
          { 
           if(*((U32 *)(pos)) != (U32)crc)
            {
             cmd += 1;
             put_dram(pos,crc,ch);
            }
#ifdef DRAM_TEST_ROTATE
           crc = (crc << 1); 
#endif 					// DRAM_TEST_ROTATE
          } 

#ifdef DRAM_TEST_ROTATE
         if(crc == 0)
          {
           crc = 1;
          } 
#else
         crc += ch;			// increment pattern 
#endif					// DRAM_TEST_ROTATE
         if(cmd >= 256)
          {
           break;
          }

#ifdef DRAM_TEST_FAST         
         pos = DRAM_BASE + length;
         length *= 2;			// fast address 
#else
         pos += length;			// next tested address
#endif 					// DRAM_TEST_FAST         
        }
      }

// 
     if(cmd != 0)
      {
       put_string("ERR");
      } 
     else
      {
       put_string("OK");
      }
//
     cmd = 0;				// clear command register
     led = 0;
     continue;				// to receive next command
    }  
#endif 					// CMD_DRAM_TEST

#ifdef CMD_ERASE
   if(cmd == CMD_ERASE || cmd == CMD_SECTOR_ERASE)
    {
////////////////////////////////////////////////////////////////////////////////
// Chip Erase or Sectort Erase /////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

     *((volatile U8 *)(ROM2_ADDR + 0x555))=0xAA; // 1 Chip erase write command 555/AA
     *((volatile U8 *)(ROM2_ADDR + 0x2AA))=0x55; // 2 Chip erase write command 2AA/55
     *((volatile U8 *)(ROM2_ADDR + 0x555))=0x80; // 3 Chip erase write command 555/80
     *((volatile U8 *)(ROM2_ADDR + 0x555))=0xAA; // 4 Chip erase write command 555/AA
     *((volatile U8 *)(ROM2_ADDR + 0x2AA))=0x55; // 5 Chip erase write command 2AA/55 

      if(cmd == CMD_ERASE)
       {
// Chip Erase //////////////////////////////////////////////////////////////////
        put_string("CE");			// put chip erase command reply 

        *((volatile U8 *)(ROM2_ADDR + 0x555))=0x10; // 6 Chip erase write command 555/10
        length = 0;
       }
      else
       {
// Sector Erase Command ////////////////////////////////////////////////////////
        put_string("SE");			// put sector erase command reply 
        if(get_val(& length) != 0)	// read sector number 
         {
          put_value(length,0);		// replay sector number
          length <<= 16;		// A16, A17, A18, A19, A20 - sector number

// 6 Chip erase write command SA/30 ////////////////////////////////////////////

          *((volatile U8 *)(ROM2_ADDR + length))=0x30; 
         }
       }  

     do
      {
       cmd = *((volatile U8 *)(ROM2_ADDR + length));
       cmd &= 0x80;
      }
     while(cmd == 0);
     
// 
     put_string("OK");			// put result 

// 
     cmd = 0;      			// clear command 
     continue;				// to receive next command 
    }
#endif 					// CMD_ERASE

   if(cmd == CMD_SET_SPEED)
    {
////////////////////////////////////////////////////////////////////////////////
// set speed ///////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

     put_string("SP");			// output read command reply

     if(get_val(& length) != 0)		// read speed 
      {

       switch(length)
        {
         case   9600 : cmd = 0x00a20; break; 	// cnt0 = 162 cnt1 = 0, 0
         case  19200 : cmd = 0x00500; break; 	// cnt0 =  80 cnt1 = 0, 1
         case  38400 : cmd = 0x00280; break;	// cnt0 =  40 cnt1 = 0, 2
         case  57600 : cmd = 0x001a0; break;	// cnt0 =  26 cnt1 = 0, 3
         case 115200 : cmd = 0x000d0; break;	// cnt0 =  13 cnt1 = 0, 4
         case 230400 : cmd = 0x00060; break;	// cnt0 =   6 cnt1 = 0, 5
         default     : 
// unknown speed ///////////////////////////////////////////////////////////////
          length = 38400;
          cmd    = 0x00280; 
          break;
        }
       put_value(length, 0);		// output speed

       UARTBRD0 = cmd;

       cmd = 0;				// clear command code 
      }

     continue;				// to next loop
    }

   if(cmd == CMD_READ)
    {
/////////////////////////////////////////////////////////////////////////////////
// read flash COMMAND ///////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

     put_string("RD");			// output read command reply

     if(get_val(& length) != 0)		// read length 
      {
       put_value(length, 0);		// output length (no output buffer)

       for(pos = 0; pos < length; ++pos)
        {
         ch = *((U8 *)(ROM2_ADDR+pos));	// read byte from flash 
// wait TX ready //////////////////////////////////////////////////////////////// 
         put_ch(ch);			// output byte to UART0 	 
        }
      }

     cmd = 0;				// clear command code 
     continue;				// to next loop
    }


   if(cmd == CMD_WRBLOCK)		
    {
/////////////////////////////////////////////////////////////////////////////////
// FLash Write, 512 bytes, offset, CRC reply per 512 bytes //////////////////////
/////////////////////////////////////////////////////////////////////////////////

     put_string("WB");			// write block command

// read offset //////////////////////////////////////////////////////////////////

     if(get_val(&length) == 0)
      {
// read offset error ////////////////////////////////////////////////////////////
       cmd = 0;				// clear command 
       continue;			// to next command
      } 

// output offset to UART0 and wblock buffer /////////////////////////////////////
     put_value(length, wblock);

// receive 128 bytes ////////////////////////////////////////////////////////////
//     for(pos = 8; pos < 136; ++pos)	// 
     for(pos = 8; pos < 520; ++pos)
      {
       wblock[pos] = get_ch();		// read byte
      }

// calculate CRC ////////////////////////////////////////////////////////////////
     crc = 0xFFFF;			// CRC preset 
//     for(pos = 0; pos < 520; ++pos)	// 27.05.2002
     for(pos = 0; pos < 520; ++pos)
      {
       crc = calc_crc(crc,wblock[pos]);	// read character
      } 

// programm flash ///////////////////////////////////////////////////////////////

//     for(pos = 0; pos < 512; ++pos)	// 27.05.2002
     for(pos = 0; pos < 512; ++pos)
      {
       ch = wblock[8+pos];		// read character from buffer

       *((volatile U8 *)(ROM2_ADDR + 0x555))=0xAA;
       *((volatile U8 *)(ROM2_ADDR + 0x2AA))=0x55;
       *((volatile U8 *)(ROM2_ADDR + 0x555))=0xA0;
       *((volatile U8 *)(ROM2_ADDR +length))=ch;	

       while( (*((volatile U8 *)(ROM2_ADDR + length)) & 0x80) != (ch & 0x80) );
 
       length += 1;			// next offset 
      }

// output CRC to UART0 //////////////////////////////////////////////////////////
     put_value(crc, 0);
// 
     cmd = 0;				// clear command 
     continue; 				// to receive next command
    }

#ifdef CMD_WRITE			// write with received byte reply
   if(
     cmd == CMD_WRITE ||		// write with received byte reply
     cmd == CMD_WRCRC			// write, calculate CRC, reply CRC  
    )
    {
     if(cmd == CMD_WRITE)
      {
       put_string("WR");			// write command 	
      }
     else
      {
       put_string("WC");			// write with CRC reply command 	
      } 

// read byte count or offset ////////////////////////////////////////////////////

     if(get_val(&length) == 0)
      {
// read length error ////////////////////////////////////////////////////////////
       cmd = 0;				// clea command 
       continue;			// break cycle 	
      } 

// output size or offset to UART0 ///////////////////////////////////////////////
     put_value(length, 0);		// no output buffer

// flash programming ////////////////////////////////////////////////////////////

     crc = 0xFFFF;				// preset CRC 
     for(pos = 0; pos < length; ++pos)
      {
       ch = get_ch();				// read byte

// programm byte ////////////////////////////////////////////////////////////////
       *((volatile U8 *)(ROM2_ADDR + 0x555)) = 0xAA;
       *((volatile U8 *)(ROM2_ADDR + 0x2AA)) = 0x55;
       *((volatile U8 *)(ROM2_ADDR + 0x555)) = 0xA0;
       *((volatile U8 *)(ROM2_ADDR + pos))   = ch;

       while( (*((volatile U8 *)(ROM2_ADDR + pos)) & 0x80) != (ch & 0x80) );

       if(cmd == CMD_WRCRC)
        { 
// calculate CRC ////////////////////////////////////////////////////////////////
         crc = calc_crc(crc, ch); 
        }
       else
        {
// read programmed byte and output to UART0 /////////////////////////////////////
         ch = *((U8 *)(ROM2_ADDR + pos));
         put_ch(ch);
        }
      }

     if(cmd == CMD_WRCRC)
      { 
// output calculated CRC to UART0 ///////////////////////////////////////////////
       put_value(crc,0);
      } 

     cmd = 0; 
    }
#endif 						// CMD_WRITE
  }
}