Coding style cleanup. Update CHANGELOG.

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

diff --git a/CHANGELOG b/CHANGELOG
index 5472c8fe5301b63f745b69ef4652269f05ba9b98..a83456814979b4541c63aca3fadb74ed65b0b0a4 100644 (file)
--- a/CHANGELOG
+++ b/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

diff --git a/board/at91rm9200dk/mux.c b/board/at91rm9200dk/mux.c
index d573923c1b40e86bf598b63ce65f3f941800fa66..767d28090d18e757b4df80fed6aa05017072acd6 100644 (file)
--- a/board/at91rm9200dk/mux.c
+++ b/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
 }
-
-

diff --git a/cpu/arm920t/at91rm9200/spi.c b/cpu/arm920t/at91rm9200/spi.c
index 7469e53820886b775739ea132dba78924c645690..265d18525f000b2c9681b733e1021286ffd7c6d2 100644 (file)
--- a/cpu/arm920t/at91rm9200/spi.c
+++ b/cpu/arm920t/at91rm9200/spi.c
@@ -148,6 +148,4 @@ unsigned int AT91F_SpiWrite ( AT91PS_DataflashDesc pDesc )
 
        return DATAFLASH_OK;
 }
-
 #endif
-

diff --git a/drivers/at45.c b/drivers/at45.c
index 7d35695b100dd22423b193103c08a4920e20c644..507ff36d478367a63c64236da979977c891f3e6b 100755 (executable)
--- a/drivers/at45.c
+++ b/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
-
-

diff --git a/drivers/dataflash.c b/drivers/dataflash.c
index 3b068d7125c43a2f2ac4d8744447d07cdd7fc9df..91903c8c8f739abd7c2310d3220483af6982f42f 100644 (file)
--- a/drivers/dataflash.c
+++ b/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);
 }
 

diff --git a/include/at45.h b/include/at45.h
index 1f71a3b4e986f30ab006618b79128d758dfb2a07..40bb4a08bd4a425331962546e33ca4cd93406859 100644 (file)
--- a/include/at45.h
+++ b/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,

diff --git a/include/dataflash.h b/include/dataflash.h
index c597e69f17d11fc0d02e94fde921f038ded33450..fbd5e17f44c09b47a0123493be9b1583c3996469 100644 (file)
--- a/include/dataflash.h
+++ b/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;

diff --git a/include/led.h b/include/led.h
index a261f1bf23c7cd5c278a48c991893364b410f87f..57c2b4a3777729bb02c4fb93ba47013d82f1ef3b 100644 (file)
--- a/include/led.h
+++ b/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
-