Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Coding style cleanup. Update CHANGELOG.

Browse Source 
Signed-off-by: Wolfgang Denk <wd@denx.de>
master
Wolfgang Denk 18 years ago
parent 3f76451b4a
commit f01dbb5424
8 changed files with 165 additions and 105 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 68
      CHANGELOG
  2. 10
      board/at91rm9200dk/mux.c
  3. 2
      cpu/arm920t/at91rm9200/spi.c
  4. 133
      drivers/at45.c
  5. 50
      drivers/dataflash.c
  6. 2
      include/at45.h
  7. 2
      include/dataflash.h
  8. 3
      include/led.h

68
CHANGELOG
Unescape View File

@ -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

10
board/at91rm9200dk/mux.c
Unescape View File

@ -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
}

2
cpu/arm920t/at91rm9200/spi.c
Unescape View File

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

133
drivers/at45.c
Unescape View File

@ -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

50
drivers/dataflash.c
Unescape View File

@ -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);
}

2
include/at45.h
Unescape View File

@ -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,

2
include/dataflash.h
Unescape View File

@ -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;

3
include/led.h
Unescape View File

@ -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

Write Preview
Loading…
Cancel
Save