Coding style cleanup. Update CHANGELOG.

Signed-off-by: Wolfgang Denk <wd@denx.de>

CHANGELOG

@@ -1,3 +1,71 @@
+commit 073e1b509980cefe6f53c2d7fbbcd135df1e3924
+Author: Andy Fleming <afleming@freescale.com>
+Date:	Tue Aug 14 10:32:59 2007 -0500
+
+    Fix initrd/dtb interaction
+
+    The original code would wrongly relocate the blob to be right before
+    the initrd if it existed.  The blob *must* be within CFG_BOOTMAPSZ,
+    if it is defined.  So we make two changes:
+
+    1) flag the blob for relocation whenever its address is above BOOTMAPSZ
+
+    2) If the blob is being relocated, relocate it before kbd, not initrd
+
+    Signed-off-by: Andy Fleming <afleming@freescale.com>
+
+commit e54b970173769307a116bd34028b6d0c2eea2a4e
+Author: Peter Pearse <peter.pearse@arm.com>
+Date:	Tue Aug 14 15:40:00 2007 +0100
+
+    Supply spi interface in at45.c
+
+commit 0c42f36f15074bd9808a7dbd7ef611fad9bf537c
+Author: Peter Pearse <peter.pearse@arm.com>
+Date:	Tue Aug 14 10:46:32 2007 +0100
+
+    Replace lost end of at45.c.
+
+commit 65d7ada64557e76094b4fd3bad30a0f18f5fb2b2
+Author: Peter Pearse <peter.pearse@arm.com>
+Date:	Tue Aug 14 10:30:06 2007 +0100
+
+    Update Makefiles for merged and split at45.c.
+
+commit 3454cece2db57cb9eb7087995f7e73066a163f71
+Author: Peter Pearse <peter.pearse@arm.com>
+Date:	Tue Aug 14 10:21:06 2007 +0100
+
+    Delete the merged files.
+
+commit dcbfd2e5649f97aa04fbbc6ea2b008aa4486e225
+Author: Peter Pearse <peter.pearse@arm.com>
+Date:	Tue Aug 14 10:14:05 2007 +0100
+
+    Add the files.
+
+commit d4fc6012fd0a5c211b825691f44b06f8032c0551
+Author: Peter Pearse <peter.pearse@arm.com>
+Date:	Tue Aug 14 10:10:52 2007 +0100
+
+    Add MACH_TYPE records for several AT91 boards.
+    Merge to two at45.c files into a common file, split to at45.c and spi.c
+    Fix spelling error in DM9161 PHY Support.
+    Initialize at91rm9200 board (and set LED).
+    Add PIO control for at91rm9200dk LEDs and Mux.
+    Change dataflash partition boundaries to be compatible with Linux 2.6.
+
+    Signed-off-by:	Peter Pearse <peter.pearse@arm.com>
+    Signed-off-by:	Ulf Samuelsson <ulf@atmel.com>
+
+commit 4ef35e53c693556c54b0c22d6f873de87bade253
+Author: Wolfgang Denk <wd@denx.de>
+Date:	Tue Aug 14 09:54:46 2007 +0200
+
+    Coding style cleanup, update CHANGELOG
+
+    Signed-off-by: Wolfgang Denk <wd@denx.de>
+
 commit 85eb5caf6b906f7ec5b54814e8c7c74f55986bb7
 Author: Wolfgang Denk <wd@denx.de>
 Date:	Tue Aug 14 09:47:27 2007 +0200

board/at91rm9200dk/mux.c

@@ -23,8 +23,8 @@ void AT91F_SelectMMC(void) {
 	AT91C_BASE_PIOB->PIO_PER = DATAFLASH_MMC_SELECT;	/* Set in PIO mode */
 	AT91C_BASE_PIOB->PIO_OER = DATAFLASH_MMC_SELECT;	/* Configure in output */
 	/* Set Output */
-	AT91C_BASE_PIOB->PIO_SODR = DATAFLASH_MMC_SELECT; 
-#endif 
+	AT91C_BASE_PIOB->PIO_SODR = DATAFLASH_MMC_SELECT;
+#endif
 }
 
 void AT91F_SelectSPI(void) {
@@ -32,8 +32,6 @@ void AT91F_SelectSPI(void) {
 	AT91C_BASE_PIOB->PIO_PER = DATAFLASH_MMC_SELECT;	/* Set in PIO mode */
 	AT91C_BASE_PIOB->PIO_OER = DATAFLASH_MMC_SELECT;	/* Configure in output */
 	/* Clear Output */
-	AT91C_BASE_PIOB->PIO_CODR = DATAFLASH_MMC_SELECT; 
-#endif 
+	AT91C_BASE_PIOB->PIO_CODR = DATAFLASH_MMC_SELECT;
+#endif
 }
-
-

cpu/arm920t/at91rm9200/spi.c

@@ -148,6 +148,4 @@ unsigned int AT91F_SpiWrite ( AT91PS_DataflashDesc pDesc )
 
 	return DATAFLASH_OK;
 }
-
 #endif
-

drivers/at45.c

@@ -36,7 +36,7 @@ extern void 		AT91F_SpiEnable(int cs);
 /*----------------------------------------------------------------------*/
 /* \fn    AT91F_DataFlashSendCommand					*/
 /* \brief Generic function to send a command to the dataflash		*/
-/*----------------------------------------------------------------------*/ 
+/*----------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_DataFlashSendCommand(
 	AT91PS_DataFlash pDataFlash,
 	unsigned char OpCode,
@@ -49,27 +49,27 @@ AT91S_DataFlashStatus AT91F_DataFlashSendCommand(
 		return DATAFLASH_BUSY;
 
 	/* process the address to obtain page address and byte address */
-	adr = ((DataflashAddress / (pDataFlash->pDevice->pages_size)) << 
-		pDataFlash->pDevice->page_offset) + (DataflashAddress % 
+	adr = ((DataflashAddress / (pDataFlash->pDevice->pages_size)) <<
+		pDataFlash->pDevice->page_offset) + (DataflashAddress %
 		(pDataFlash->pDevice->pages_size));
 
 	/* fill the  command  buffer */
 	pDataFlash->pDataFlashDesc->command[0] = OpCode;
 	if (pDataFlash->pDevice->pages_number >= 16384) {
-		pDataFlash->pDataFlashDesc->command[1] = 
+		pDataFlash->pDataFlashDesc->command[1] =
 			(unsigned char)((adr & 0x0F000000) >> 24);
-		pDataFlash->pDataFlashDesc->command[2] = 
+		pDataFlash->pDataFlashDesc->command[2] =
 			(unsigned char)((adr & 0x00FF0000) >> 16);
-		pDataFlash->pDataFlashDesc->command[3] = 
+		pDataFlash->pDataFlashDesc->command[3] =
 			(unsigned char)((adr & 0x0000FF00) >> 8);
-		pDataFlash->pDataFlashDesc->command[4] = 
+		pDataFlash->pDataFlashDesc->command[4] =
 			(unsigned char)(adr & 0x000000FF);
 	} else {
-		pDataFlash->pDataFlashDesc->command[1] = 
+		pDataFlash->pDataFlashDesc->command[1] =
 			(unsigned char)((adr & 0x00FF0000) >> 16);
-		pDataFlash->pDataFlashDesc->command[2] = 
+		pDataFlash->pDataFlashDesc->command[2] =
 			(unsigned char)((adr & 0x0000FF00) >> 8);
-		pDataFlash->pDataFlashDesc->command[3] = 
+		pDataFlash->pDataFlashDesc->command[3] =
 			(unsigned char)(adr & 0x000000FF);
 		pDataFlash->pDataFlashDesc->command[4] = 0;
 	}
@@ -78,10 +78,10 @@ AT91S_DataFlashStatus AT91F_DataFlashSendCommand(
 	pDataFlash->pDataFlashDesc->command[7] = 0;
 
 	/* Initialize the SpiData structure for the spi write fuction */
-	pDataFlash->pDataFlashDesc->tx_cmd_pt   =  
+	pDataFlash->pDataFlashDesc->tx_cmd_pt   =
 		pDataFlash->pDataFlashDesc->command;
 	pDataFlash->pDataFlashDesc->tx_cmd_size =  CmdSize;
-	pDataFlash->pDataFlashDesc->rx_cmd_pt   =  
+	pDataFlash->pDataFlashDesc->rx_cmd_pt   =
 		pDataFlash->pDataFlashDesc->command;
 	pDataFlash->pDataFlashDesc->rx_cmd_size =  CmdSize;
 
@@ -92,8 +92,8 @@ AT91S_DataFlashStatus AT91F_DataFlashSendCommand(
 /*----------------------------------------------------------------------*/
 /* \fn    AT91F_DataFlashGetStatus					*/
 /* \brief Read the status register of the dataflash			*/
-/*----------------------------------------------------------------------*/ 
-AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc) 
+/*----------------------------------------------------------------------*/
+AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc)
 {
 	AT91S_DataFlashStatus status;
 
@@ -123,16 +123,16 @@ AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc)
 /*----------------------------------------------------------------------*/
 /* \fn    AT91F_DataFlashWaitReady					*/
 /* \brief wait for dataflash ready (bit7 of the status register == 1)	*/
-/*----------------------------------------------------------------------*/ 
-AT91S_DataFlashStatus AT91F_DataFlashWaitReady(AT91PS_DataflashDesc 
-pDataFlashDesc, unsigned int timeout) 
+/*----------------------------------------------------------------------*/
+AT91S_DataFlashStatus AT91F_DataFlashWaitReady(AT91PS_DataflashDesc
+pDataFlashDesc, unsigned int timeout)
 {
 	pDataFlashDesc->DataFlash_state = IDLE;
 
 	do {
 		AT91F_DataFlashGetStatus(pDataFlashDesc);
 		timeout--;
-	} while( ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) && 
+	} while( ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) &&
 			(timeout > 0) );
 
 	if((pDataFlashDesc->DataFlash_state & 0x80) != 0x80)
@@ -150,7 +150,7 @@ pDataFlashDesc, unsigned int timeout)
 /*                     : <*dataBuffer> = data buffer pointer		    */
 /*                     : <sizeToRead> = data buffer size		    */
 /* Return value		: State of the dataflash			    */
-/*--------------------------------------------------------------------------*/ 
+/*--------------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_DataFlashContinuousRead (
 	AT91PS_DataFlash pDataFlash,
 	int src,
@@ -159,8 +159,8 @@ AT91S_DataFlashStatus AT91F_DataFlashContinuousRead (
 {
 	AT91S_DataFlashStatus status;
 	/* Test the size to read in the device */
-	if ( (src + sizeToRead) > 
-		(pDataFlash->pDevice->pages_size * 
+	if ( (src + sizeToRead) >
+		(pDataFlash->pDevice->pages_size *
 		(pDataFlash->pDevice->pages_number)))
 		return DATAFLASH_MEMORY_OVERFLOW;
 
@@ -169,7 +169,7 @@ AT91S_DataFlashStatus AT91F_DataFlashContinuousRead (
 	pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer;
 	pDataFlash->pDataFlashDesc->tx_data_size = sizeToRead;
 
-	status = AT91F_DataFlashSendCommand 
+	status = AT91F_DataFlashSendCommand
 			(pDataFlash, DB_CONTINUOUS_ARRAY_READ, 8, src);
 	/* Send the command to the dataflash */
 	return(status);
@@ -184,7 +184,7 @@ AT91S_DataFlashStatus AT91F_DataFlashContinuousRead (
 /*                     : <dest> = dataflash destination address		     */
 /*                     : <SizeToWrite> = data buffer size		     */
 /* Return value		: State of the dataflash			     */
-/*---------------------------------------------------------------------------*/ 
+/*---------------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_DataFlashPagePgmBuf(
 	AT91PS_DataFlash pDataFlash,
 	unsigned char *src,
@@ -201,7 +201,7 @@ AT91S_DataFlashStatus AT91F_DataFlashPagePgmBuf(
 	/* Send the command to the dataflash */
 	if (pDataFlash->pDevice->pages_number >= 16384)
 		cmdsize = 5;
-	return(AT91F_DataFlashSendCommand (pDataFlash, DB_PAGE_PGM_BUF1, 
+	return(AT91F_DataFlashSendCommand (pDataFlash, DB_PAGE_PGM_BUF1,
 cmdsize, dest)); }
 
 
@@ -212,7 +212,7 @@ cmdsize, dest)); }
 /*                     : Page concerned					     */
 /*                     : 						     */
 /* Return value		: State of the dataflash			     */
-/*---------------------------------------------------------------------------*/ 
+/*---------------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert(
 	AT91PS_DataFlash pDataFlash,
 	unsigned char BufferCommand,
@@ -220,7 +220,7 @@ AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert(
 {
 	int cmdsize;
 	/* Test if the buffer command is legal */
-	if ((BufferCommand != DB_PAGE_2_BUF1_TRF) 
+	if ((BufferCommand != DB_PAGE_2_BUF1_TRF)
 		&& (BufferCommand != DB_PAGE_2_BUF2_TRF))
 		return DATAFLASH_BAD_COMMAND;
 
@@ -229,7 +229,7 @@ AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert(
 	cmdsize = 4;
 	if (pDataFlash->pDevice->pages_number >= 16384)
 		cmdsize = 5;
-	return(AT91F_DataFlashSendCommand (pDataFlash, BufferCommand, cmdsize, 
+	return(AT91F_DataFlashSendCommand (pDataFlash, BufferCommand, cmdsize,
 page*pDataFlash->pDevice->pages_size));
 }
 
@@ -253,7 +253,7 @@ AT91S_DataFlashStatus AT91F_DataFlashWriteBuffer (
 {
 	int cmdsize;
 	/* Test if the buffer command is legal */
-	if ((BufferCommand != DB_BUF1_WRITE) 
+	if ((BufferCommand != DB_BUF1_WRITE)
 		&& (BufferCommand != DB_BUF2_WRITE))
 		return DATAFLASH_BAD_COMMAND;
 
@@ -269,26 +269,26 @@ AT91S_DataFlashStatus AT91F_DataFlashWriteBuffer (
 	pDataFlash->pDataFlashDesc->command[1] = 0;
 	if (pDataFlash->pDevice->pages_number >= 16384) {
 	    	pDataFlash->pDataFlashDesc->command[2] = 0;
-	    	pDataFlash->pDataFlashDesc->command[3] = 
-			(unsigned char)(((unsigned int)(bufferAddress &  
+	    	pDataFlash->pDataFlashDesc->command[3] =
+			(unsigned char)(((unsigned int)(bufferAddress &
 				pDataFlash->pDevice->byte_mask)) >> 8);
-	    	pDataFlash->pDataFlashDesc->command[4] = 
+	    	pDataFlash->pDataFlashDesc->command[4] =
 			(unsigned char)((unsigned int)bufferAddress  & 0x00FF);
 		cmdsize = 5;
 	} else {
-	    	pDataFlash->pDataFlashDesc->command[2] = 
-			(unsigned char)(((unsigned int)(bufferAddress & 
+	    	pDataFlash->pDataFlashDesc->command[2] =
+			(unsigned char)(((unsigned int)(bufferAddress &
 				pDataFlash->pDevice->byte_mask)) >> 8);
-	    	pDataFlash->pDataFlashDesc->command[3] = 
+	    	pDataFlash->pDataFlashDesc->command[3] =
 			(unsigned char)((unsigned int)bufferAddress  & 0x00FF);
 	    	pDataFlash->pDataFlashDesc->command[4] = 0;
 		cmdsize = 4;
 	}
 
-	pDataFlash->pDataFlashDesc->tx_cmd_pt 	 = 
+	pDataFlash->pDataFlashDesc->tx_cmd_pt 	 =
 		pDataFlash->pDataFlashDesc->command;
 	pDataFlash->pDataFlashDesc->tx_cmd_size = cmdsize;
-	pDataFlash->pDataFlashDesc->rx_cmd_pt 	 = 
+	pDataFlash->pDataFlashDesc->rx_cmd_pt 	 =
 		pDataFlash->pDataFlashDesc->command;
 	pDataFlash->pDataFlashDesc->rx_cmd_size = cmdsize;
 
@@ -320,7 +320,7 @@ AT91S_DataFlashStatus AT91F_PageErase(
 	cmdsize = 4;
 	if (pDataFlash->pDevice->pages_number >= 16384)
 		cmdsize = 5;
-	return(AT91F_DataFlashSendCommand (pDataFlash, DB_PAGE_ERASE, cmdsize, 
+	return(AT91F_DataFlashSendCommand (pDataFlash, DB_PAGE_ERASE, cmdsize,
 page*pDataFlash->pDevice->pages_size));
 }
 
@@ -332,7 +332,7 @@ page*pDataFlash->pDevice->pages_size));
 /*                     : Page concerned					     */
 /*                     : 						     */
 /* Return value		: State of the dataflash			     */
-/*---------------------------------------------------------------------------*/ 
+/*---------------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_BlockErase(
 	AT91PS_DataFlash pDataFlash,
 	unsigned int block)
@@ -344,7 +344,7 @@ AT91S_DataFlashStatus AT91F_BlockErase(
 	cmdsize = 4;
 	if (pDataFlash->pDevice->pages_number >= 16384)
 		cmdsize = 5;
-	return(AT91F_DataFlashSendCommand (pDataFlash, DB_BLOCK_ERASE,cmdsize, 
+	return(AT91F_DataFlashSendCommand (pDataFlash, DB_BLOCK_ERASE,cmdsize,
 block*8*pDataFlash->pDevice->pages_size));
 }
 
@@ -355,7 +355,7 @@ block*8*pDataFlash->pDevice->pages_size));
 /*		: <BufferCommand> = command to send to buffer1 or buffer2    */
 /*                     : <dest> = main memory address			     */
 /* Return value		: State of the dataflash			     */
-/*---------------------------------------------------------------------------*/ 
+/*---------------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_WriteBufferToMain (
 	AT91PS_DataFlash pDataFlash,
 	unsigned char BufferCommand,
@@ -386,7 +386,7 @@ AT91S_DataFlashStatus AT91F_WriteBufferToMain (
 /* Input Parameters    : <page> = page number				     */
 /*			: <AdrInpage> = adr to begin the fading		     */
 /*                     : <length> = Number of bytes to erase		     */
-/*---------------------------------------------------------------------------*/ 
+/*---------------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_PartialPageWrite (
 	AT91PS_DataFlash pDataFlash,
 	unsigned char *src,
@@ -400,27 +400,27 @@ AT91S_DataFlashStatus AT91F_PartialPageWrite (
 	AdrInPage = dest % (pDataFlash->pDevice->pages_size);
 
 	/* Read the contents of the page in the Sram Buffer */
-	AT91F_MainMemoryToBufferTransfert(pDataFlash, 
+	AT91F_MainMemoryToBufferTransfert(pDataFlash,
 						DB_PAGE_2_BUF1_TRF, page);
-	AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+	AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 						AT91C_TIMEOUT_WRDY);
 	/*Update the SRAM buffer */
-	AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src, 
+	AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src,
 					AdrInPage, size);
 
-	AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+	AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 					AT91C_TIMEOUT_WRDY);
 
 	/* Erase page if a 128 Mbits device */
 	if (pDataFlash->pDevice->pages_number >= 16384) {
 		AT91F_PageErase(pDataFlash, page);
 		/* Rewrite the modified Sram Buffer in the main memory */
-		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 						AT91C_TIMEOUT_WRDY);
 	}
 
 	/* Rewrite the modified Sram Buffer in the main memory */
-	return(AT91F_WriteBufferToMain(pDataFlash, DB_BUF1_PAGE_ERASE_PGM, 
+	return(AT91F_WriteBufferToMain(pDataFlash, DB_BUF1_PAGE_ERASE_PGM,
 				(page*pDataFlash->pDevice->pages_size)));
 }
 
@@ -430,7 +430,7 @@ AT91S_DataFlashStatus AT91F_PartialPageWrite (
 /* Input Parameters    : <*src> = Source buffer				     */
 /*                     : <dest> = dataflash adress			     */
 /*                     : <size> = data buffer size			     */
-/*---------------------------------------------------------------------------*/ 
+/*---------------------------------------------------------------------------*/
 AT91S_DataFlashStatus AT91F_DataFlashWrite(
 	AT91PS_DataFlash pDataFlash,
 	unsigned char *src,
@@ -443,15 +443,15 @@ AT91S_DataFlashStatus AT91F_DataFlashWrite(
 
 	AT91F_SpiEnable(pDataFlash->pDevice->cs);
 
-	if ( (dest + size) > (pDataFlash->pDevice->pages_size * 
+	if ( (dest + size) > (pDataFlash->pDevice->pages_size *
 					(pDataFlash->pDevice->pages_number)))
 		return DATAFLASH_MEMORY_OVERFLOW;
 
 	/* If destination does not fit a page start address */
-	if ((dest % ((unsigned int)(pDataFlash->pDevice->pages_size)))  != 0 ) 
+	if ((dest % ((unsigned int)(pDataFlash->pDevice->pages_size)))  != 0 )
 	{
-		length = pDataFlash->pDevice->pages_size - 
-				(dest % 
+		length = pDataFlash->pDevice->pages_size -
+				(dest %
 				((unsigned int)
 				(pDataFlash->pDevice->pages_size)));
 
@@ -461,7 +461,7 @@ AT91S_DataFlashStatus AT91F_DataFlashWrite(
 		if(!AT91F_PartialPageWrite(pDataFlash,src, dest, length))
 			return DATAFLASH_ERROR;
 
-		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 			AT91C_TIMEOUT_WRDY);
 
 		/* Update size, source and destination pointers */
@@ -474,24 +474,24 @@ AT91S_DataFlashStatus AT91F_DataFlashWrite(
 		/* program dataflash page */
 		page = (unsigned int)dest / (pDataFlash->pDevice->pages_size);
 
-		status = AT91F_DataFlashWriteBuffer(pDataFlash, 
-				DB_BUF1_WRITE, src, 0, 
+		status = AT91F_DataFlashWriteBuffer(pDataFlash,
+				DB_BUF1_WRITE, src, 0,
 				pDataFlash->pDevice->pages_size);
-		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 						AT91C_TIMEOUT_WRDY);
 
 		status = AT91F_PageErase(pDataFlash, page);
-		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 						AT91C_TIMEOUT_WRDY);
 		if (!status)
 			return DATAFLASH_ERROR;
 
-		status = AT91F_WriteBufferToMain (pDataFlash, 
+		status = AT91F_WriteBufferToMain (pDataFlash,
 						DB_BUF1_PAGE_PGM, dest);
 		if(!status)
 			return DATAFLASH_ERROR;
 
-		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 						AT91C_TIMEOUT_WRDY);
 
 		/* Update size, source and destination pointers */
@@ -506,7 +506,7 @@ AT91S_DataFlashStatus AT91F_DataFlashWrite(
 		if(!AT91F_PartialPageWrite(pDataFlash, src, dest, size) )
 			return DATAFLASH_ERROR;
 
-		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+		AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 						AT91C_TIMEOUT_WRDY);
 	}
 	return DATAFLASH_OK;
@@ -529,18 +529,18 @@ int AT91F_DataFlashRead(
 
 	AT91F_SpiEnable(pDataFlash->pDevice->cs);
 
-	if(AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+	if(AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 					AT91C_TIMEOUT_WRDY) != DATAFLASH_OK)
 		return -1;
 
 	while (size) {
 		SizeToRead = (size < 0x8000)? size:0x8000;
 
-		if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, 
+		if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc,
 					AT91C_TIMEOUT_WRDY) != DATAFLASH_OK)
 			return -1;
 
-		if (AT91F_DataFlashContinuousRead (pDataFlash, addr, 
+		if (AT91F_DataFlashContinuousRead (pDataFlash, addr,
 				(uchar *) buffer, SizeToRead) != DATAFLASH_OK)
 			return -1;
 
@@ -557,13 +557,10 @@ int AT91F_DataFlashRead(
 /* Object              : 						     */
 /* Input Parameters    : 						     */
 /* Return value	       : Dataflash status register			     */
-/*---------------------------------------------------------------------------*/ 
+/*---------------------------------------------------------------------------*/
 int AT91F_DataflashProbe(int cs, AT91PS_DataflashDesc pDesc) {
 	AT91F_SpiEnable(cs);
 	AT91F_DataFlashGetStatus(pDesc);
-	return((pDesc->command[1] == 0xFF)? 0: pDesc->command[1] & 0x3C); 
+	return((pDesc->command[1] == 0xFF)? 0: pDesc->command[1] & 0x3C);
 }
-
 #endif
-
-

drivers/dataflash.c

@@ -63,7 +63,7 @@ dataflash_protect_t area_list[NB_DATAFLASH_AREA] = {
 #endif
 #elif defined(CONFIG_NEW_PARTITION)
 /*define the area offsets*/
-/* Invalid partitions should be defined with start > end */ 
+/* Invalid partitions should be defined with start > end */
 dataflash_protect_t area_list[NB_DATAFLASH_AREA*CFG_MAX_DATAFLASH_BANKS] = {
 	{0x00000000, 0x000083ff, FLAG_PROTECT_SET,	0,		"Bootstrap"},	/* ROM code */
 	{0x00008400, 0x00020fff, FLAG_PROTECT_SET,	0,		"U-Boot"},	/* u-boot code */
@@ -114,7 +114,7 @@ int AT91F_DataflashInit (void)
 		dataflash_info[i].Desc.state = IDLE;
 		dataflash_info[i].id = 0;
 		dataflash_info[i].Device.pages_number = 0;
-		dfcode = AT91F_DataflashProbe (cs[i][1], 
+		dfcode = AT91F_DataflashProbe (cs[i][1],
 				&dataflash_info[i].Desc);
 
 		switch (dfcode) {
@@ -179,26 +179,26 @@ int AT91F_DataflashInit (void)
 		/* set the area addresses */
 		for(j = 0; j<NB_DATAFLASH_AREA; j++) {
 			if(found[i]!=0) {
-				dataflash_info[i].Device.area_list[j].start = 
-					area_list[part].start + 
+				dataflash_info[i].Device.area_list[j].start =
+					area_list[part].start +
 					dataflash_info[i].logical_address;
 				if(area_list[part].end == 0xffffffff) {
-					dataflash_info[i].Device.area_list[j].end = 
-						dataflash_info[i].end_address + 
+					dataflash_info[i].Device.area_list[j].end =
+						dataflash_info[i].end_address +
 						dataflash_info	[i].logical_address;
 					last_part = 1;
 				} else {
-					dataflash_info[i].Device.area_list[j].end = 
-						area_list[part].end + 
+					dataflash_info[i].Device.area_list[j].end =
+						area_list[part].end +
 						dataflash_info[i].logical_address;
 				}
 				protected = area_list[part].protected;
 				/* Set the environment according to the label...*/
 				if(protected == FLAG_PROTECT_INVALID) {
-					dataflash_info[i].Device.area_list[j].protected = 
+					dataflash_info[i].Device.area_list[j].protected =
 						FLAG_PROTECT_INVALID;
 				} else {
-					dataflash_info[i].Device.area_list[j].protected = 
+					dataflash_info[i].Device.area_list[j].protected =
 						protected;
 				}
 				strcpy((char*)(dataflash_info[i].Device.area_list[j].label),
@@ -223,7 +223,7 @@ int AT91F_DataflashSetEnv (void)
 			env = area_list[part].setenv;
 			/* Set the environment according to the label...*/
 			if((env & FLAG_SETENV) == FLAG_SETENV) {
-				start = 
+				start =
 				dataflash_info[i].Device.area_list[j].start;
 				sprintf(s,"%X",start);
 				setenv(area_list[part].label,s);
@@ -296,7 +296,7 @@ void dataflash_print_info (void)
 /* Function Name       : AT91F_DataflashSelect 				     */
 /* Object              : Select the correct device			     */
 /*---------------------------------------------------------------------------*/
-AT91PS_DataFlash AT91F_DataflashSelect (AT91PS_DataFlash pFlash, 
+AT91PS_DataFlash AT91F_DataflashSelect (AT91PS_DataFlash pFlash,
 				unsigned long *addr)
 {
 	char addr_valid = 0;
@@ -342,7 +342,7 @@ int addr_dataflash (unsigned long addr)
 /* Function Name       : size_dataflash 				     */
 /* Object              : Test if address is valid regarding the size	     */
 /*---------------------------------------------------------------------------*/
-int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr, 
+int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr,
 			unsigned long size)
 {
 	/* is outside the dataflash */
@@ -350,7 +350,7 @@ int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr,
 		pdataFlash->pDevice->pages_number)) return 0;
 	/* is too large for the dataflash */
 	if (size > ((pdataFlash->pDevice->pages_size *
-		pdataFlash->pDevice->pages_number) - 
+		pdataFlash->pDevice->pages_number) -
 		((int)addr & 0x0FFFFFFF))) return 0;
 
 	return 1;
@@ -368,13 +368,13 @@ int area;
 			(addr < pdataFlash->pDevice->area_list[area].end))
 			break;
 	}
-	if (area == NB_DATAFLASH_AREA) 
+	if (area == NB_DATAFLASH_AREA)
 		return -1;
 
 	/*test protection value*/
-	if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_SET) 
+	if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_SET)
 		return 0;
-	if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_INVALID) 
+	if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_INVALID)
 		return 0;
 
 	return 1;
@@ -383,7 +383,7 @@ int area;
 /* Function Name       : dataflash_real_protect				    */
 /* Object              : protect/unprotect area				    */
 /*--------------------------------------------------------------------------*/
-int dataflash_real_protect (int flag, unsigned long start_addr, 
+int dataflash_real_protect (int flag, unsigned long start_addr,
 				unsigned long end_addr)
 {
 int i,j, area1, area2, addr_valid = 0;
@@ -400,27 +400,27 @@ int i,j, area1, area2, addr_valid = 0;
 	}
 	/* find start area */
 	for (area1=0; area1 < NB_DATAFLASH_AREA; area1++) {
-		if (start_addr == dataflash_info[i].Device.area_list[area1].start) 
+		if (start_addr == dataflash_info[i].Device.area_list[area1].start)
 			break;
 	}
 	if (area1 == NB_DATAFLASH_AREA) return -1;
 	/* find end area */
 	for (area2=0; area2 < NB_DATAFLASH_AREA; area2++) {
-		if (end_addr == dataflash_info[i].Device.area_list[area2].end) 
+		if (end_addr == dataflash_info[i].Device.area_list[area2].end)
 			break;
 	}
-	if (area2 == NB_DATAFLASH_AREA) 
+	if (area2 == NB_DATAFLASH_AREA)
 		return -1;
 
 	/*set protection value*/
 	for(j = area1; j < area2+1 ; j++)
-		if(dataflash_info[i].Device.area_list[j].protected 
+		if(dataflash_info[i].Device.area_list[j].protected
 				!= FLAG_PROTECT_INVALID) {
 			if (flag == 0) {
-				dataflash_info[i].Device.area_list[j].protected 
+				dataflash_info[i].Device.area_list[j].protected
 					= FLAG_PROTECT_CLEAR;
 			} else {
-				dataflash_info[i].Device.area_list[j].protected 
+				dataflash_info[i].Device.area_list[j].protected
 					= FLAG_PROTECT_SET;
 			}
 		}
@@ -473,7 +473,7 @@ int write_dataflash (unsigned long addr_dest, unsigned long addr_src,
 	if (AddrToWrite == -1)
 		return -1;
 
-	return AT91F_DataFlashWrite (pFlash, (uchar *)addr_src, 
+	return AT91F_DataFlashWrite (pFlash, (uchar *)addr_src,
 						AddrToWrite, size);
 }
 

include/at45.h

@@ -17,7 +17,7 @@ extern	AT91S_DataFlashStatus AT91F_DataFlashSendCommand(
 extern	AT91S_DataFlashStatus AT91F_DataFlashGetStatus (
 	AT91PS_DataflashDesc pDesc);
 extern	AT91S_DataFlashStatus AT91F_DataFlashWaitReady (
-	AT91PS_DataflashDesc pDataFlashDesc, 
+	AT91PS_DataflashDesc pDataFlashDesc,
 	unsigned int timeout);
 extern	AT91S_DataFlashStatus AT91F_DataFlashContinuousRead (
 	AT91PS_DataFlash pDataFlash,

include/dataflash.h

@@ -78,7 +78,7 @@ typedef struct {
 	unsigned long end;
 	unsigned char protected;
 	unsigned char setenv;
-	unsigned char label[20];	
+	unsigned char label[20];
 } dataflash_protect_t;
 
 typedef unsigned int AT91S_DataFlashStatus;

include/led.h

@@ -22,7 +22,7 @@
  * MA 02111-1307 USA
  */
 
- #ifndef __LED_H
+#ifndef __LED_H
 #define __LED_H
 
 #ifndef	__ASSEMBLY__
@@ -43,4 +43,3 @@ extern void	yellow_LED_off(void);
 	.extern green_LED_off
 #endif
 #endif
-