Last user of this option went away in commit:
fdc7718999 ("board: usb_a9263: Update to support DT and DM")
Signed-off-by: Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
master
Tuomas Tynkkynen
7 years ago
committed by
Tom Rini
parent
95688de311
commit
c68c03f52b
@ -1,26 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2008 |
||||
* Ulf Samuelsson <ulf@atmel.com> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
|
||||
struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = { |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */ |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS1, 1} |
||||
}; |
||||
|
||||
/*define the area offsets*/ |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"}, |
||||
{0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"}, |
||||
{0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"}, |
||||
{0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"}, |
||||
{0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"}, |
||||
}; |
||||
@ -1,26 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2008 |
||||
* Ulf Samuelsson <ulf@atmel.com> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
|
||||
struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = { |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */ |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS3, 3} |
||||
}; |
||||
|
||||
/*define the area offsets*/ |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"}, |
||||
{0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"}, |
||||
{0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"}, |
||||
{0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"}, |
||||
{0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"}, |
||||
}; |
||||
@ -1,25 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2008 |
||||
* Ulf Samuelsson <ulf@atmel.com> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
|
||||
struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = { |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */ |
||||
}; |
||||
|
||||
/*define the area offsets*/ |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"}, |
||||
{0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"}, |
||||
{0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"}, |
||||
{0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"}, |
||||
{0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"}, |
||||
}; |
||||
@ -1,25 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2008 |
||||
* Ulf Samuelsson <ulf@atmel.com> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
|
||||
struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = { |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */ |
||||
}; |
||||
|
||||
/*define the area offsets*/ |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"}, |
||||
{0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"}, |
||||
{0x00008400, 0x00083FFF, FLAG_PROTECT_SET, 0, "U-Boot"}, |
||||
{0x00084000, 0x00293FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"}, |
||||
{0x00294000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"}, |
||||
}; |
||||
@ -1,23 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2008 |
||||
* Ulf Samuelsson <ulf@atmel.com> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
|
||||
struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = { |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */ |
||||
}; |
||||
|
||||
/* define the area offsets */ |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"}, |
||||
{0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"}, |
||||
{0x00008400, 0x00041FFF, FLAG_PROTECT_SET, 0, "U-Boot"}, |
||||
}; |
||||
@ -1,33 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2008 |
||||
* Ulf Samuelsson <ulf@atmel.com> |
||||
* Ilko Iliev <www.ronetix.at> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
|
||||
struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = { |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */ |
||||
}; |
||||
|
||||
/*define the area offsets*/ |
||||
#ifdef CONFIG_SYS_USE_DATAFLASH |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"}, |
||||
{0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"}, |
||||
{0x00008400, 0x00041FFF, FLAG_PROTECT_SET, 0, "U-Boot"}, |
||||
{0x00042000, 0x00251FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"}, |
||||
{0x00252000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"}, |
||||
}; |
||||
#else |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, ""}, |
||||
}; |
||||
|
||||
#endif |
||||
@ -1,33 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2008 |
||||
* Ulf Samuelsson <ulf@atmel.com> |
||||
* Ilko Iliev <www.ronetix.at> |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
AT91S_DATAFLASH_INFO dataflash_info[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
|
||||
struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS] = { |
||||
{CONFIG_SYS_DATAFLASH_LOGIC_ADDR_CS0, 0}, /* Logical adress, CS */ |
||||
}; |
||||
|
||||
/*define the area offsets*/ |
||||
#ifdef CONFIG_SYS_USE_DATAFLASH |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0x000041FF, FLAG_PROTECT_SET, 0, "Bootstrap"}, |
||||
{0x00004200, 0x000083FF, FLAG_PROTECT_CLEAR, 0, "Environment"}, |
||||
{0x00008400, 0x00041FFF, FLAG_PROTECT_SET, 0, "U-Boot"}, |
||||
{0x00042000, 0x00251FFF, FLAG_PROTECT_CLEAR, 0, "Kernel"}, |
||||
{0x00252000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, "FS"}, |
||||
}; |
||||
#else |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA] = { |
||||
{0x00000000, 0xFFFFFFFF, FLAG_PROTECT_CLEAR, 0, ""}, |
||||
}; |
||||
|
||||
#endif |
||||
@ -1,545 +0,0 @@ |
||||
/* Driver for ATMEL DataFlash support
|
||||
* Author : Hamid Ikdoumi (Atmel) |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
#include <config.h> |
||||
#include <common.h> |
||||
#include <dataflash.h> |
||||
|
||||
/*
|
||||
* spi.c API |
||||
*/ |
||||
extern unsigned int AT91F_SpiWrite(AT91PS_DataflashDesc pDesc); |
||||
extern void AT91F_SpiEnable(int cs); |
||||
|
||||
#define AT91C_TIMEOUT_WRDY 200000 |
||||
|
||||
/*----------------------------------------------------------------------*/ |
||||
/* \fn AT91F_DataFlashSendCommand */ |
||||
/* \brief Generic function to send a command to the dataflash */ |
||||
/*----------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_DataFlashSendCommand(AT91PS_DataFlash pDataFlash, |
||||
unsigned char OpCode, |
||||
unsigned int CmdSize, |
||||
unsigned int DataflashAddress) |
||||
{ |
||||
unsigned int adr; |
||||
|
||||
if ((pDataFlash->pDataFlashDesc->state) != IDLE) |
||||
return DATAFLASH_BUSY; |
||||
|
||||
/* process the address to obtain page address and byte address */ |
||||
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] = |
||||
(unsigned char)((adr & 0x0F000000) >> 24); |
||||
pDataFlash->pDataFlashDesc->command[2] = |
||||
(unsigned char)((adr & 0x00FF0000) >> 16); |
||||
pDataFlash->pDataFlashDesc->command[3] = |
||||
(unsigned char)((adr & 0x0000FF00) >> 8); |
||||
pDataFlash->pDataFlashDesc->command[4] = |
||||
(unsigned char)(adr & 0x000000FF); |
||||
} else { |
||||
pDataFlash->pDataFlashDesc->command[1] = |
||||
(unsigned char)((adr & 0x00FF0000) >> 16); |
||||
pDataFlash->pDataFlashDesc->command[2] = |
||||
(unsigned char)((adr & 0x0000FF00) >> 8); |
||||
pDataFlash->pDataFlashDesc->command[3] = |
||||
(unsigned char)(adr & 0x000000FF); |
||||
pDataFlash->pDataFlashDesc->command[4] = 0; |
||||
} |
||||
pDataFlash->pDataFlashDesc->command[5] = 0; |
||||
pDataFlash->pDataFlashDesc->command[6] = 0; |
||||
pDataFlash->pDataFlashDesc->command[7] = 0; |
||||
|
||||
/* Initialize the SpiData structure for the spi write fuction */ |
||||
pDataFlash->pDataFlashDesc->tx_cmd_pt = |
||||
pDataFlash->pDataFlashDesc->command; |
||||
pDataFlash->pDataFlashDesc->tx_cmd_size = CmdSize; |
||||
pDataFlash->pDataFlashDesc->rx_cmd_pt = |
||||
pDataFlash->pDataFlashDesc->command; |
||||
pDataFlash->pDataFlashDesc->rx_cmd_size = CmdSize; |
||||
|
||||
/* send the command and read the data */ |
||||
return AT91F_SpiWrite(pDataFlash->pDataFlashDesc); |
||||
} |
||||
|
||||
/*----------------------------------------------------------------------*/ |
||||
/* \fn AT91F_DataFlashGetStatus */ |
||||
/* \brief Read the status register of the dataflash */ |
||||
/*----------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_DataFlashGetStatus(AT91PS_DataflashDesc pDesc) |
||||
{ |
||||
AT91S_DataFlashStatus status; |
||||
|
||||
/* if a transfert is in progress ==> return 0 */ |
||||
if ((pDesc->state) != IDLE) |
||||
return DATAFLASH_BUSY; |
||||
|
||||
/* first send the read status command (D7H) */ |
||||
pDesc->command[0] = DB_STATUS; |
||||
pDesc->command[1] = 0; |
||||
|
||||
pDesc->DataFlash_state = GET_STATUS; |
||||
pDesc->tx_data_size = 0; /* Transmit the command */ |
||||
/* and receive response */ |
||||
pDesc->tx_cmd_pt = pDesc->command; |
||||
pDesc->rx_cmd_pt = pDesc->command; |
||||
pDesc->rx_cmd_size = 2; |
||||
pDesc->tx_cmd_size = 2; |
||||
status = AT91F_SpiWrite(pDesc); |
||||
|
||||
pDesc->DataFlash_state = *((unsigned char *)(pDesc->rx_cmd_pt) + 1); |
||||
|
||||
return status; |
||||
} |
||||
|
||||
/*----------------------------------------------------------------------*/ |
||||
/* \fn AT91F_DataFlashWaitReady */ |
||||
/* \brief wait for dataflash ready (bit7 of the status register == 1) */ |
||||
/*----------------------------------------------------------------------*/ |
||||
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) && |
||||
(timeout > 0)); |
||||
|
||||
if ((pDataFlashDesc->DataFlash_state & 0x80) != 0x80) |
||||
return DATAFLASH_ERROR; |
||||
|
||||
return DATAFLASH_OK; |
||||
} |
||||
|
||||
/*--------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_DataFlashContinuousRead */ |
||||
/* Object : Continuous stream Read */ |
||||
/* Input Parameters : DataFlash Service */ |
||||
/* : <src> = dataflash address */ |
||||
/* : <*dataBuffer> = data buffer pointer */ |
||||
/* : <sizeToRead> = data buffer size */ |
||||
/* Return value : State of the dataflash */ |
||||
/*--------------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_DataFlashContinuousRead( |
||||
AT91PS_DataFlash pDataFlash, |
||||
int src, |
||||
unsigned char *dataBuffer, |
||||
int sizeToRead) |
||||
{ |
||||
AT91S_DataFlashStatus status; |
||||
/* Test the size to read in the device */ |
||||
if ((src + sizeToRead) > |
||||
(pDataFlash->pDevice->pages_size * |
||||
(pDataFlash->pDevice->pages_number))) |
||||
return DATAFLASH_MEMORY_OVERFLOW; |
||||
|
||||
pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer; |
||||
pDataFlash->pDataFlashDesc->rx_data_size = sizeToRead; |
||||
pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer; |
||||
pDataFlash->pDataFlashDesc->tx_data_size = sizeToRead; |
||||
|
||||
status = AT91F_DataFlashSendCommand( |
||||
pDataFlash, DB_CONTINUOUS_ARRAY_READ, 8, src); |
||||
/* Send the command to the dataflash */ |
||||
return (status); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_DataFlashPagePgmBuf */ |
||||
/* Object : Main memory page program thru buffer 1 or buffer 2 */ |
||||
/* Input Parameters : DataFlash Service */ |
||||
/* : <*src> = Source buffer */ |
||||
/* : <dest> = dataflash destination address */ |
||||
/* : <SizeToWrite> = data buffer size */ |
||||
/* Return value : State of the dataflash */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_DataFlashPagePgmBuf(AT91PS_DataFlash pDataFlash, |
||||
unsigned char *src, |
||||
unsigned int dest, |
||||
unsigned int SizeToWrite) |
||||
{ |
||||
int cmdsize; |
||||
pDataFlash->pDataFlashDesc->tx_data_pt = src; |
||||
pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite; |
||||
pDataFlash->pDataFlashDesc->rx_data_pt = src; |
||||
pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite; |
||||
|
||||
cmdsize = 4; |
||||
/* Send the command to the dataflash */ |
||||
if (pDataFlash->pDevice->pages_number >= 16384) |
||||
cmdsize = 5; |
||||
return (AT91F_DataFlashSendCommand( |
||||
pDataFlash, DB_PAGE_PGM_BUF1, cmdsize, dest)); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_MainMemoryToBufferTransfert */ |
||||
/* Object : Read a page in the SRAM Buffer 1 or 2 */ |
||||
/* Input Parameters : DataFlash Service */ |
||||
/* : Page concerned */ |
||||
/* : */ |
||||
/* Return value : State of the dataflash */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_MainMemoryToBufferTransfert( |
||||
AT91PS_DataFlash |
||||
pDataFlash, |
||||
unsigned char |
||||
BufferCommand, |
||||
unsigned int page) |
||||
{ |
||||
int cmdsize; |
||||
/* Test if the buffer command is legal */ |
||||
if ((BufferCommand != DB_PAGE_2_BUF1_TRF) && |
||||
(BufferCommand != DB_PAGE_2_BUF2_TRF)) { |
||||
return DATAFLASH_BAD_COMMAND; |
||||
} |
||||
|
||||
/* no data to transmit or receive */ |
||||
pDataFlash->pDataFlashDesc->tx_data_size = 0; |
||||
cmdsize = 4; |
||||
if (pDataFlash->pDevice->pages_number >= 16384) |
||||
cmdsize = 5; |
||||
return (AT91F_DataFlashSendCommand( |
||||
pDataFlash, BufferCommand, cmdsize, |
||||
page * pDataFlash->pDevice->pages_size)); |
||||
} |
||||
|
||||
/*-------------------------------------------------------------------------- */ |
||||
/* Function Name : AT91F_DataFlashWriteBuffer */ |
||||
/* Object : Write data to the internal sram buffer 1 or 2 */ |
||||
/* Input Parameters : DataFlash Service */ |
||||
/* : <BufferCommand> = command to write buffer1 or 2 */ |
||||
/* : <*dataBuffer> = data buffer to write */ |
||||
/* : <bufferAddress> = address in the internal buffer */ |
||||
/* : <SizeToWrite> = data buffer size */ |
||||
/* Return value : State of the dataflash */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_DataFlashWriteBuffer( |
||||
AT91PS_DataFlash pDataFlash, |
||||
unsigned char BufferCommand, |
||||
unsigned char *dataBuffer, |
||||
unsigned int bufferAddress, |
||||
int SizeToWrite) |
||||
{ |
||||
int cmdsize; |
||||
/* Test if the buffer command is legal */ |
||||
if ((BufferCommand != DB_BUF1_WRITE) && |
||||
(BufferCommand != DB_BUF2_WRITE)) { |
||||
return DATAFLASH_BAD_COMMAND; |
||||
} |
||||
|
||||
/* buffer address must be lower than page size */ |
||||
if (bufferAddress > pDataFlash->pDevice->pages_size) |
||||
return DATAFLASH_BAD_ADDRESS; |
||||
|
||||
if ((pDataFlash->pDataFlashDesc->state) != IDLE) |
||||
return DATAFLASH_BUSY; |
||||
|
||||
/* Send first Write Command */ |
||||
pDataFlash->pDataFlashDesc->command[0] = BufferCommand; |
||||
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->pDevice-> |
||||
byte_mask)) >> 8); |
||||
pDataFlash->pDataFlashDesc->command[4] = |
||||
(unsigned char)((unsigned int)bufferAddress & 0x00FF); |
||||
cmdsize = 5; |
||||
} else { |
||||
pDataFlash->pDataFlashDesc->command[2] = |
||||
(unsigned char)(((unsigned int)(bufferAddress & |
||||
pDataFlash->pDevice-> |
||||
byte_mask)) >> 8); |
||||
pDataFlash->pDataFlashDesc->command[3] = |
||||
(unsigned char)((unsigned int)bufferAddress & 0x00FF); |
||||
pDataFlash->pDataFlashDesc->command[4] = 0; |
||||
cmdsize = 4; |
||||
} |
||||
|
||||
pDataFlash->pDataFlashDesc->tx_cmd_pt = |
||||
pDataFlash->pDataFlashDesc->command; |
||||
pDataFlash->pDataFlashDesc->tx_cmd_size = cmdsize; |
||||
pDataFlash->pDataFlashDesc->rx_cmd_pt = |
||||
pDataFlash->pDataFlashDesc->command; |
||||
pDataFlash->pDataFlashDesc->rx_cmd_size = cmdsize; |
||||
|
||||
pDataFlash->pDataFlashDesc->rx_data_pt = dataBuffer; |
||||
pDataFlash->pDataFlashDesc->tx_data_pt = dataBuffer; |
||||
pDataFlash->pDataFlashDesc->rx_data_size = SizeToWrite; |
||||
pDataFlash->pDataFlashDesc->tx_data_size = SizeToWrite; |
||||
|
||||
return AT91F_SpiWrite(pDataFlash->pDataFlashDesc); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_PageErase */ |
||||
/* Object : Erase a page */ |
||||
/* Input Parameters : DataFlash Service */ |
||||
/* : Page concerned */ |
||||
/* : */ |
||||
/* Return value : State of the dataflash */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_PageErase( |
||||
AT91PS_DataFlash pDataFlash, |
||||
unsigned int page) |
||||
{ |
||||
int cmdsize; |
||||
/* Test if the buffer command is legal */ |
||||
/* no data to transmit or receive */ |
||||
pDataFlash->pDataFlashDesc->tx_data_size = 0; |
||||
|
||||
cmdsize = 4; |
||||
if (pDataFlash->pDevice->pages_number >= 16384) |
||||
cmdsize = 5; |
||||
return (AT91F_DataFlashSendCommand(pDataFlash, |
||||
DB_PAGE_ERASE, cmdsize, |
||||
page * pDataFlash->pDevice->pages_size)); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_BlockErase */ |
||||
/* Object : Erase a Block */ |
||||
/* Input Parameters : DataFlash Service */ |
||||
/* : Page concerned */ |
||||
/* : */ |
||||
/* Return value : State of the dataflash */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_BlockErase( |
||||
AT91PS_DataFlash pDataFlash, |
||||
unsigned int block) |
||||
{ |
||||
int cmdsize; |
||||
/* Test if the buffer command is legal */ |
||||
/* no data to transmit or receive */ |
||||
pDataFlash->pDataFlashDesc->tx_data_size = 0; |
||||
cmdsize = 4; |
||||
if (pDataFlash->pDevice->pages_number >= 16384) |
||||
cmdsize = 5; |
||||
return (AT91F_DataFlashSendCommand(pDataFlash, DB_BLOCK_ERASE, cmdsize, |
||||
block * 8 * |
||||
pDataFlash->pDevice->pages_size)); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_WriteBufferToMain */ |
||||
/* Object : Write buffer to the main memory */ |
||||
/* Input Parameters : DataFlash Service */ |
||||
/* : <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, |
||||
unsigned int dest) |
||||
{ |
||||
int cmdsize; |
||||
/* Test if the buffer command is correct */ |
||||
if ((BufferCommand != DB_BUF1_PAGE_PGM) && |
||||
(BufferCommand != DB_BUF1_PAGE_ERASE_PGM) && |
||||
(BufferCommand != DB_BUF2_PAGE_PGM) && |
||||
(BufferCommand != DB_BUF2_PAGE_ERASE_PGM)) |
||||
return DATAFLASH_BAD_COMMAND; |
||||
|
||||
/* no data to transmit or receive */ |
||||
pDataFlash->pDataFlashDesc->tx_data_size = 0; |
||||
|
||||
cmdsize = 4; |
||||
if (pDataFlash->pDevice->pages_number >= 16384) |
||||
cmdsize = 5; |
||||
/* Send the command to the dataflash */ |
||||
return (AT91F_DataFlashSendCommand(pDataFlash, BufferCommand, |
||||
cmdsize, dest)); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_PartialPageWrite */ |
||||
/* Object : Erase partielly a page */ |
||||
/* 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, |
||||
unsigned int dest, |
||||
unsigned int size) |
||||
{ |
||||
unsigned int page; |
||||
unsigned int AdrInPage; |
||||
|
||||
page = dest / (pDataFlash->pDevice->pages_size); |
||||
AdrInPage = dest % (pDataFlash->pDevice->pages_size); |
||||
|
||||
/* Read the contents of the page in the Sram Buffer */ |
||||
AT91F_MainMemoryToBufferTransfert(pDataFlash, DB_PAGE_2_BUF1_TRF, page); |
||||
AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY); |
||||
/*Update the SRAM buffer */ |
||||
AT91F_DataFlashWriteBuffer(pDataFlash, DB_BUF1_WRITE, src, |
||||
AdrInPage, size); |
||||
|
||||
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, |
||||
AT91C_TIMEOUT_WRDY); |
||||
} |
||||
|
||||
/* Rewrite the modified Sram Buffer in the main memory */ |
||||
return (AT91F_WriteBufferToMain(pDataFlash, DB_BUF1_PAGE_ERASE_PGM, |
||||
(page * |
||||
pDataFlash->pDevice->pages_size))); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_DataFlashWrite */ |
||||
/* Object : */ |
||||
/* Input Parameters : <*src> = Source buffer */ |
||||
/* : <dest> = dataflash adress */ |
||||
/* : <size> = data buffer size */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
AT91S_DataFlashStatus AT91F_DataFlashWrite(AT91PS_DataFlash pDataFlash, |
||||
unsigned char *src, |
||||
int dest, int size) |
||||
{ |
||||
unsigned int length; |
||||
unsigned int page; |
||||
unsigned int status; |
||||
|
||||
AT91F_SpiEnable(pDataFlash->pDevice->cs); |
||||
|
||||
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) { |
||||
length = |
||||
pDataFlash->pDevice->pages_size - |
||||
(dest % ((unsigned int)(pDataFlash->pDevice->pages_size))); |
||||
|
||||
if (size < length) |
||||
length = size; |
||||
|
||||
if (!AT91F_PartialPageWrite(pDataFlash, src, dest, length)) |
||||
return DATAFLASH_ERROR; |
||||
|
||||
AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY); |
||||
|
||||
/* Update size, source and destination pointers */ |
||||
size -= length; |
||||
dest += length; |
||||
src += length; |
||||
} |
||||
|
||||
while ((size - pDataFlash->pDevice->pages_size) >= 0) { |
||||
/* program dataflash page */ |
||||
page = (unsigned int)dest / (pDataFlash->pDevice->pages_size); |
||||
|
||||
status = AT91F_DataFlashWriteBuffer(pDataFlash, |
||||
DB_BUF1_WRITE, src, 0, |
||||
pDataFlash->pDevice-> |
||||
pages_size); |
||||
AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY); |
||||
|
||||
status = AT91F_PageErase(pDataFlash, page); |
||||
AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY); |
||||
if (!status) |
||||
return DATAFLASH_ERROR; |
||||
|
||||
status = AT91F_WriteBufferToMain(pDataFlash, |
||||
DB_BUF1_PAGE_PGM, dest); |
||||
if (!status) |
||||
return DATAFLASH_ERROR; |
||||
|
||||
AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY); |
||||
|
||||
/* Update size, source and destination pointers */ |
||||
size -= pDataFlash->pDevice->pages_size; |
||||
dest += pDataFlash->pDevice->pages_size; |
||||
src += pDataFlash->pDevice->pages_size; |
||||
} |
||||
|
||||
/* If still some bytes to read */ |
||||
if (size > 0) { |
||||
/* program dataflash page */ |
||||
if (!AT91F_PartialPageWrite(pDataFlash, src, dest, size)) |
||||
return DATAFLASH_ERROR; |
||||
|
||||
AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY); |
||||
} |
||||
return DATAFLASH_OK; |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_DataFlashRead */ |
||||
/* Object : Read a block in dataflash */ |
||||
/* Input Parameters : */ |
||||
/* Return value : */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
int AT91F_DataFlashRead(AT91PS_DataFlash pDataFlash, |
||||
unsigned long addr, unsigned long size, char *buffer) |
||||
{ |
||||
unsigned long SizeToRead; |
||||
|
||||
AT91F_SpiEnable(pDataFlash->pDevice->cs); |
||||
|
||||
if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY) != DATAFLASH_OK) |
||||
return -1; |
||||
|
||||
while (size) { |
||||
SizeToRead = (size < 0x8000) ? size : 0x8000; |
||||
|
||||
if (AT91F_DataFlashWaitReady(pDataFlash->pDataFlashDesc, |
||||
AT91C_TIMEOUT_WRDY) != |
||||
DATAFLASH_OK) |
||||
return -1; |
||||
|
||||
if (AT91F_DataFlashContinuousRead(pDataFlash, addr, |
||||
(uchar *) buffer, |
||||
SizeToRead) != DATAFLASH_OK) |
||||
return -1; |
||||
|
||||
size -= SizeToRead; |
||||
addr += SizeToRead; |
||||
buffer += SizeToRead; |
||||
} |
||||
|
||||
return DATAFLASH_OK; |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_DataflashProbe */ |
||||
/* 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); |
||||
} |
||||
@ -1,448 +0,0 @@ |
||||
/*
|
||||
* LowLevel function for ATMEL DataFlash support |
||||
* Author : Hamid Ikdoumi (Atmel) |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
#include <common.h> |
||||
#include <config.h> |
||||
#include <asm/hardware.h> |
||||
#include <dataflash.h> |
||||
|
||||
static AT91S_DataFlash DataFlashInst; |
||||
|
||||
extern void AT91F_SpiInit (void); |
||||
extern int AT91F_DataflashProbe (int i, AT91PS_DataflashDesc pDesc); |
||||
extern int AT91F_DataFlashRead (AT91PS_DataFlash pDataFlash, |
||||
unsigned long addr, |
||||
unsigned long size, char *buffer); |
||||
extern int AT91F_DataFlashWrite( AT91PS_DataFlash pDataFlash, |
||||
unsigned char *src, |
||||
int dest, |
||||
int size ); |
||||
|
||||
int AT91F_DataflashInit (void) |
||||
{ |
||||
int i, j; |
||||
int dfcode; |
||||
int part; |
||||
int found[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
unsigned char protected; |
||||
|
||||
AT91F_SpiInit (); |
||||
|
||||
for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) { |
||||
found[i] = 0; |
||||
dataflash_info[i].Desc.state = IDLE; |
||||
dataflash_info[i].id = 0; |
||||
dataflash_info[i].Device.pages_number = 0; |
||||
dfcode = AT91F_DataflashProbe (cs[i].cs, |
||||
&dataflash_info[i].Desc); |
||||
|
||||
switch (dfcode) { |
||||
case AT45DB021: |
||||
dataflash_info[i].Device.pages_number = 1024; |
||||
dataflash_info[i].Device.pages_size = 264; |
||||
dataflash_info[i].Device.page_offset = 9; |
||||
dataflash_info[i].Device.byte_mask = 0x300; |
||||
dataflash_info[i].Device.cs = cs[i].cs; |
||||
dataflash_info[i].Desc.DataFlash_state = IDLE; |
||||
dataflash_info[i].logical_address = cs[i].addr; |
||||
dataflash_info[i].id = dfcode; |
||||
found[i] += dfcode; |
||||
break; |
||||
|
||||
case AT45DB081: |
||||
dataflash_info[i].Device.pages_number = 4096; |
||||
dataflash_info[i].Device.pages_size = 264; |
||||
dataflash_info[i].Device.page_offset = 9; |
||||
dataflash_info[i].Device.byte_mask = 0x300; |
||||
dataflash_info[i].Device.cs = cs[i].cs; |
||||
dataflash_info[i].Desc.DataFlash_state = IDLE; |
||||
dataflash_info[i].logical_address = cs[i].addr; |
||||
dataflash_info[i].id = dfcode; |
||||
found[i] += dfcode; |
||||
break; |
||||
|
||||
case AT45DB161: |
||||
dataflash_info[i].Device.pages_number = 4096; |
||||
dataflash_info[i].Device.pages_size = 528; |
||||
dataflash_info[i].Device.page_offset = 10; |
||||
dataflash_info[i].Device.byte_mask = 0x300; |
||||
dataflash_info[i].Device.cs = cs[i].cs; |
||||
dataflash_info[i].Desc.DataFlash_state = IDLE; |
||||
dataflash_info[i].logical_address = cs[i].addr; |
||||
dataflash_info[i].id = dfcode; |
||||
found[i] += dfcode; |
||||
break; |
||||
|
||||
case AT45DB321: |
||||
dataflash_info[i].Device.pages_number = 8192; |
||||
dataflash_info[i].Device.pages_size = 528; |
||||
dataflash_info[i].Device.page_offset = 10; |
||||
dataflash_info[i].Device.byte_mask = 0x300; |
||||
dataflash_info[i].Device.cs = cs[i].cs; |
||||
dataflash_info[i].Desc.DataFlash_state = IDLE; |
||||
dataflash_info[i].logical_address = cs[i].addr; |
||||
dataflash_info[i].id = dfcode; |
||||
found[i] += dfcode; |
||||
break; |
||||
|
||||
case AT45DB642: |
||||
dataflash_info[i].Device.pages_number = 8192; |
||||
dataflash_info[i].Device.pages_size = 1056; |
||||
dataflash_info[i].Device.page_offset = 11; |
||||
dataflash_info[i].Device.byte_mask = 0x700; |
||||
dataflash_info[i].Device.cs = cs[i].cs; |
||||
dataflash_info[i].Desc.DataFlash_state = IDLE; |
||||
dataflash_info[i].logical_address = cs[i].addr; |
||||
dataflash_info[i].id = dfcode; |
||||
found[i] += dfcode; |
||||
break; |
||||
|
||||
case AT45DB128: |
||||
dataflash_info[i].Device.pages_number = 16384; |
||||
dataflash_info[i].Device.pages_size = 1056; |
||||
dataflash_info[i].Device.page_offset = 11; |
||||
dataflash_info[i].Device.byte_mask = 0x700; |
||||
dataflash_info[i].Device.cs = cs[i].cs; |
||||
dataflash_info[i].Desc.DataFlash_state = IDLE; |
||||
dataflash_info[i].logical_address = cs[i].addr; |
||||
dataflash_info[i].id = dfcode; |
||||
found[i] += dfcode; |
||||
break; |
||||
|
||||
default: |
||||
dfcode = 0; |
||||
break; |
||||
} |
||||
/* set the last area end to the dataflash size*/ |
||||
dataflash_info[i].end_address = |
||||
(dataflash_info[i].Device.pages_number * |
||||
dataflash_info[i].Device.pages_size) - 1; |
||||
|
||||
part = 0; |
||||
/* 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].logical_address; |
||||
if(area_list[part].end == 0xffffffff) { |
||||
dataflash_info[i].Device.area_list[j].end = |
||||
dataflash_info[i].end_address + |
||||
dataflash_info[i].logical_address; |
||||
} else { |
||||
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 = |
||||
FLAG_PROTECT_INVALID; |
||||
} else { |
||||
dataflash_info[i].Device.area_list[j].protected = |
||||
protected; |
||||
} |
||||
strcpy((char*)(dataflash_info[i].Device.area_list[j].label), |
||||
(const char *)area_list[part].label); |
||||
} |
||||
part++; |
||||
} |
||||
} |
||||
return found[0]; |
||||
} |
||||
|
||||
void AT91F_Dataflashenv_set(void) |
||||
{ |
||||
int i, j; |
||||
int part; |
||||
unsigned char env; |
||||
unsigned char s[32]; /* Will fit a long int in hex */ |
||||
unsigned long start; |
||||
|
||||
for (i = 0, part= 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) { |
||||
for(j = 0; j < NB_DATAFLASH_AREA; j++) { |
||||
env = area_list[part].setenv; |
||||
/* Set the environment according to the label...*/ |
||||
if((env & FLAG_SETENV) == FLAG_SETENV) { |
||||
start = dataflash_info[i].Device.area_list[j].start; |
||||
sprintf((char *)s, "%lX", start); |
||||
env_set((char *)area_list[part].label, |
||||
(char *)s); |
||||
} |
||||
part++; |
||||
} |
||||
} |
||||
} |
||||
|
||||
void dataflash_print_info (void) |
||||
{ |
||||
int i, j; |
||||
|
||||
for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) { |
||||
if (dataflash_info[i].id != 0) { |
||||
printf("DataFlash:"); |
||||
switch (dataflash_info[i].id) { |
||||
case AT45DB021: |
||||
printf("AT45DB021\n"); |
||||
break; |
||||
case AT45DB161: |
||||
printf("AT45DB161\n"); |
||||
break; |
||||
|
||||
case AT45DB321: |
||||
printf("AT45DB321\n"); |
||||
break; |
||||
|
||||
case AT45DB642: |
||||
printf("AT45DB642\n"); |
||||
break; |
||||
case AT45DB128: |
||||
printf("AT45DB128\n"); |
||||
break; |
||||
} |
||||
|
||||
printf("Nb pages: %6d\n" |
||||
"Page Size: %6d\n" |
||||
"Size=%8d bytes\n" |
||||
"Logical address: 0x%08X\n", |
||||
(unsigned int) dataflash_info[i].Device.pages_number, |
||||
(unsigned int) dataflash_info[i].Device.pages_size, |
||||
(unsigned int) dataflash_info[i].Device.pages_number * |
||||
dataflash_info[i].Device.pages_size, |
||||
(unsigned int) dataflash_info[i].logical_address); |
||||
for (j = 0; j < NB_DATAFLASH_AREA; j++) { |
||||
switch(dataflash_info[i].Device.area_list[j].protected) { |
||||
case FLAG_PROTECT_SET: |
||||
case FLAG_PROTECT_CLEAR: |
||||
printf("Area %i:\t%08lX to %08lX %s", j, |
||||
dataflash_info[i].Device.area_list[j].start, |
||||
dataflash_info[i].Device.area_list[j].end, |
||||
(dataflash_info[i].Device.area_list[j].protected==FLAG_PROTECT_SET) ? "(RO)" : " "); |
||||
printf(" %s\n", dataflash_info[i].Device.area_list[j].label); |
||||
break; |
||||
case FLAG_PROTECT_INVALID: |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : AT91F_DataflashSelect */ |
||||
/* Object : Select the correct device */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
AT91PS_DataFlash AT91F_DataflashSelect (AT91PS_DataFlash pFlash, |
||||
unsigned long *addr) |
||||
{ |
||||
char addr_valid = 0; |
||||
int i; |
||||
|
||||
for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) |
||||
if ( dataflash_info[i].id |
||||
&& ((((int) *addr) & 0xFF000000) == |
||||
dataflash_info[i].logical_address)) { |
||||
addr_valid = 1; |
||||
break; |
||||
} |
||||
if (!addr_valid) { |
||||
pFlash = (AT91PS_DataFlash) 0; |
||||
return pFlash; |
||||
} |
||||
pFlash->pDataFlashDesc = &(dataflash_info[i].Desc); |
||||
pFlash->pDevice = &(dataflash_info[i].Device); |
||||
*addr -= dataflash_info[i].logical_address; |
||||
return (pFlash); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : addr_dataflash */ |
||||
/* Object : Test if address is valid */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
int addr_dataflash (unsigned long addr) |
||||
{ |
||||
int addr_valid = 0; |
||||
int i; |
||||
|
||||
for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) { |
||||
if ((((int) addr) & 0xFF000000) == |
||||
dataflash_info[i].logical_address) { |
||||
addr_valid = 1; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
return addr_valid; |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : size_dataflash */ |
||||
/* Object : Test if address is valid regarding the size */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr, |
||||
unsigned long size) |
||||
{ |
||||
/* is outside the dataflash */ |
||||
if (((int)addr & 0x0FFFFFFF) > (pdataFlash->pDevice->pages_size * |
||||
pdataFlash->pDevice->pages_number)) return 0; |
||||
/* is too large for the dataflash */ |
||||
if (size > ((pdataFlash->pDevice->pages_size * |
||||
pdataFlash->pDevice->pages_number) - |
||||
((int)addr & 0x0FFFFFFF))) return 0; |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : prot_dataflash */ |
||||
/* Object : Test if destination area is protected */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
int prot_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr) |
||||
{ |
||||
int area; |
||||
|
||||
/* find area */ |
||||
for (area = 0; area < NB_DATAFLASH_AREA; area++) { |
||||
if ((addr >= pdataFlash->pDevice->area_list[area].start) && |
||||
(addr < pdataFlash->pDevice->area_list[area].end)) |
||||
break; |
||||
} |
||||
if (area == NB_DATAFLASH_AREA) |
||||
return -1; |
||||
|
||||
/*test protection value*/ |
||||
if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_SET) |
||||
return 0; |
||||
if (pdataFlash->pDevice->area_list[area].protected == FLAG_PROTECT_INVALID) |
||||
return 0; |
||||
|
||||
return 1; |
||||
} |
||||
|
||||
/*--------------------------------------------------------------------------*/ |
||||
/* Function Name : dataflash_real_protect */ |
||||
/* Object : protect/unprotect area */ |
||||
/*--------------------------------------------------------------------------*/ |
||||
int dataflash_real_protect (int flag, unsigned long start_addr, |
||||
unsigned long end_addr) |
||||
{ |
||||
int i,j, area1, area2, addr_valid = 0; |
||||
|
||||
/* find dataflash */ |
||||
for (i = 0; i < CONFIG_SYS_MAX_DATAFLASH_BANKS; i++) { |
||||
if ((((int) start_addr) & 0xF0000000) == |
||||
dataflash_info[i].logical_address) { |
||||
addr_valid = 1; |
||||
break; |
||||
} |
||||
} |
||||
if (!addr_valid) { |
||||
return -1; |
||||
} |
||||
/* find start area */ |
||||
for (area1 = 0; area1 < NB_DATAFLASH_AREA; area1++) { |
||||
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) |
||||
break; |
||||
} |
||||
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 |
||||
!= FLAG_PROTECT_INVALID) { |
||||
if (flag == 0) { |
||||
dataflash_info[i].Device.area_list[j].protected |
||||
= FLAG_PROTECT_CLEAR; |
||||
} else { |
||||
dataflash_info[i].Device.area_list[j].protected |
||||
= FLAG_PROTECT_SET; |
||||
} |
||||
} |
||||
|
||||
return (area2 - area1 + 1); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : read_dataflash */ |
||||
/* Object : dataflash memory read */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
int read_dataflash (unsigned long addr, unsigned long size, char *result) |
||||
{ |
||||
unsigned long AddrToRead = addr; |
||||
AT91PS_DataFlash pFlash = &DataFlashInst; |
||||
|
||||
pFlash = AT91F_DataflashSelect (pFlash, &AddrToRead); |
||||
|
||||
if (pFlash == 0) |
||||
return ERR_UNKNOWN_FLASH_TYPE; |
||||
|
||||
if (size_dataflash(pFlash,addr,size) == 0) |
||||
return ERR_INVAL; |
||||
|
||||
return (AT91F_DataFlashRead (pFlash, AddrToRead, size, result)); |
||||
} |
||||
|
||||
/*---------------------------------------------------------------------------*/ |
||||
/* Function Name : write_dataflash */ |
||||
/* Object : write a block in dataflash */ |
||||
/*---------------------------------------------------------------------------*/ |
||||
int write_dataflash (unsigned long addr_dest, unsigned long addr_src, |
||||
unsigned long size) |
||||
{ |
||||
unsigned long AddrToWrite = addr_dest; |
||||
AT91PS_DataFlash pFlash = &DataFlashInst; |
||||
|
||||
pFlash = AT91F_DataflashSelect (pFlash, &AddrToWrite); |
||||
|
||||
if (pFlash == 0) |
||||
return ERR_UNKNOWN_FLASH_TYPE; |
||||
|
||||
if (size_dataflash(pFlash,addr_dest,size) == 0) |
||||
return ERR_INVAL; |
||||
|
||||
if (prot_dataflash(pFlash,addr_dest) == 0) |
||||
return ERR_PROTECTED; |
||||
|
||||
if (AddrToWrite == -1) |
||||
return -1; |
||||
|
||||
return AT91F_DataFlashWrite (pFlash, (uchar *)addr_src, |
||||
AddrToWrite, size); |
||||
} |
||||
|
||||
void dataflash_perror (int err) |
||||
{ |
||||
switch (err) { |
||||
case ERR_OK: |
||||
break; |
||||
case ERR_TIMOUT: |
||||
printf("Timeout writing to DataFlash\n"); |
||||
break; |
||||
case ERR_PROTECTED: |
||||
printf("Can't write to protected/invalid DataFlash sectors\n"); |
||||
break; |
||||
case ERR_INVAL: |
||||
printf("Outside available DataFlash\n"); |
||||
break; |
||||
case ERR_UNKNOWN_FLASH_TYPE: |
||||
printf("Unknown Type of DataFlash\n"); |
||||
break; |
||||
case ERR_PROG_ERROR: |
||||
printf("General DataFlash Programming Error\n"); |
||||
break; |
||||
default: |
||||
printf("%s[%d] FIXME: rc=%d\n", __FILE__, __LINE__, err); |
||||
break; |
||||
} |
||||
} |
||||
@ -1,205 +0,0 @@ |
||||
/*
|
||||
* (C) Copyright 2003 |
||||
* Data Flash Atmel Description File |
||||
* Author : Hamid Ikdoumi (Atmel) |
||||
* |
||||
* SPDX-License-Identifier: GPL-2.0+ |
||||
*/ |
||||
|
||||
/* File Name : dataflash.h */ |
||||
/* Object : Data Flash Atmel Description File */ |
||||
/* Translator : */ |
||||
/* */ |
||||
/* 1.0 03/04/01 HI : Creation */ |
||||
/* 1.2 20/10/02 FB : Adapatation Service and Lib v3 */ |
||||
/*----------------------------------------------------------------------*/ |
||||
|
||||
#ifndef _DataFlash_h |
||||
#define _DataFlash_h |
||||
|
||||
|
||||
#include "config.h" |
||||
|
||||
/*number of protected area*/ |
||||
#define NB_DATAFLASH_AREA 5 |
||||
|
||||
#ifndef CONFIG_MTD_NOR_FLASH |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* return codes from flash_write(): |
||||
*/ |
||||
# define ERR_OK 0 |
||||
# define ERR_TIMOUT 1 |
||||
# define ERR_NOT_ERASED 2 |
||||
# define ERR_PROTECTED 4 |
||||
# define ERR_INVAL 8 |
||||
# define ERR_ALIGN 16 |
||||
# define ERR_UNKNOWN_FLASH_VENDOR 32 |
||||
# define ERR_UNKNOWN_FLASH_TYPE 64 |
||||
# define ERR_PROG_ERROR 128 |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Protection Flags for flash_protect(): |
||||
*/ |
||||
# define FLAG_PROTECT_SET 0x01 |
||||
# define FLAG_PROTECT_CLEAR 0x02 |
||||
# define FLAG_PROTECT_INVALID 0x03 |
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Set Environment according to label: |
||||
*/ |
||||
# define FLAG_SETENV 0x80 |
||||
#endif /* CONFIG_MTD_NOR_FLASH */ |
||||
|
||||
/*define the area structure*/ |
||||
typedef struct { |
||||
unsigned long start; |
||||
unsigned long end; |
||||
unsigned char protected; |
||||
unsigned char setenv; |
||||
unsigned char label[20]; |
||||
} dataflash_protect_t; |
||||
|
||||
typedef unsigned int AT91S_DataFlashStatus; |
||||
|
||||
/*----------------------------------------------------------------------*/ |
||||
/* DataFlash Structures */ |
||||
/*----------------------------------------------------------------------*/ |
||||
|
||||
/*---------------------------------------------*/ |
||||
/* DataFlash Descriptor Structure Definition */ |
||||
/*---------------------------------------------*/ |
||||
typedef struct _AT91S_DataflashDesc { |
||||
unsigned char *tx_cmd_pt; |
||||
unsigned int tx_cmd_size; |
||||
unsigned char *rx_cmd_pt; |
||||
unsigned int rx_cmd_size; |
||||
unsigned char *tx_data_pt; |
||||
unsigned int tx_data_size; |
||||
unsigned char *rx_data_pt; |
||||
unsigned int rx_data_size; |
||||
volatile unsigned char state; |
||||
volatile unsigned char DataFlash_state; |
||||
unsigned char command[8]; |
||||
} AT91S_DataflashDesc, *AT91PS_DataflashDesc; |
||||
|
||||
/*---------------------------------------------*/ |
||||
/* DataFlash device definition structure */ |
||||
/*---------------------------------------------*/ |
||||
typedef struct _AT91S_Dataflash { |
||||
int pages_number; /* dataflash page number */ |
||||
int pages_size; /* dataflash page size */ |
||||
int page_offset; /* page offset in command */ |
||||
int byte_mask; /* byte mask in command */ |
||||
int cs; |
||||
dataflash_protect_t area_list[NB_DATAFLASH_AREA]; /* area protection status */ |
||||
} AT91S_DataflashFeatures, *AT91PS_DataflashFeatures; |
||||
|
||||
/*---------------------------------------------*/ |
||||
/* DataFlash Structure Definition */ |
||||
/*---------------------------------------------*/ |
||||
typedef struct _AT91S_DataFlash { |
||||
AT91PS_DataflashDesc pDataFlashDesc; /* dataflash descriptor */ |
||||
AT91PS_DataflashFeatures pDevice; /* Pointer on a dataflash features array */ |
||||
} AT91S_DataFlash, *AT91PS_DataFlash; |
||||
|
||||
|
||||
typedef struct _AT91S_DATAFLASH_INFO { |
||||
|
||||
AT91S_DataflashDesc Desc; |
||||
AT91S_DataflashFeatures Device; /* Pointer on a dataflash features array */ |
||||
unsigned long logical_address; |
||||
unsigned long end_address; |
||||
unsigned int id; /* device id */ |
||||
} AT91S_DATAFLASH_INFO, *AT91PS_DATAFLASH_INFO; |
||||
|
||||
struct dataflash_addr { |
||||
unsigned long addr; |
||||
int cs; |
||||
}; |
||||
/*-------------------------------------------------------------------------------------------------*/ |
||||
#define AT45DB161 0x2c |
||||
#define AT45DB021 0x14 |
||||
#define AT45DB081 0x24 |
||||
#define AT45DB321 0x34 |
||||
#define AT45DB642 0x3c |
||||
#define AT45DB128 0x10 |
||||
#define PAGES_PER_BLOCK 8 |
||||
|
||||
#define AT91C_DATAFLASH_TIMEOUT 10000 /* For AT91F_DataFlashWaitReady */ |
||||
|
||||
/* DataFlash return value */ |
||||
#define DATAFLASH_BUSY 0x00 |
||||
#define DATAFLASH_OK 0x01 |
||||
#define DATAFLASH_ERROR 0x02 |
||||
#define DATAFLASH_MEMORY_OVERFLOW 0x03 |
||||
#define DATAFLASH_BAD_COMMAND 0x04 |
||||
#define DATAFLASH_BAD_ADDRESS 0x05 |
||||
|
||||
|
||||
/* Driver State */ |
||||
#define IDLE 0x0 |
||||
#define BUSY 0x1 |
||||
#define ERROR 0x2 |
||||
|
||||
/* DataFlash Driver State */ |
||||
#define GET_STATUS 0x0F |
||||
|
||||
/*-------------------------------------------------------------------------------------------------*/ |
||||
/* Command Definition */ |
||||
/*-------------------------------------------------------------------------------------------------*/ |
||||
|
||||
/* READ COMMANDS */ |
||||
#define DB_CONTINUOUS_ARRAY_READ 0xE8 /* Continuous array read */ |
||||
#define DB_BURST_ARRAY_READ 0xE8 /* Burst array read */ |
||||
#define DB_PAGE_READ 0xD2 /* Main memory page read */ |
||||
#define DB_BUF1_READ 0xD4 /* Buffer 1 read */ |
||||
#define DB_BUF2_READ 0xD6 /* Buffer 2 read */ |
||||
#define DB_STATUS 0xD7 /* Status Register */ |
||||
|
||||
/* PROGRAM and ERASE COMMANDS */ |
||||
#define DB_BUF1_WRITE 0x84 /* Buffer 1 write */ |
||||
#define DB_BUF2_WRITE 0x87 /* Buffer 2 write */ |
||||
#define DB_BUF1_PAGE_ERASE_PGM 0x83 /* Buffer 1 to main memory page program with built-In erase */ |
||||
#define DB_BUF1_PAGE_ERASE_FASTPGM 0x93 /* Buffer 1 to main memory page program with built-In erase, Fast program */ |
||||
#define DB_BUF2_PAGE_ERASE_PGM 0x86 /* Buffer 2 to main memory page program with built-In erase */ |
||||
#define DB_BUF2_PAGE_ERASE_FASTPGM 0x96 /* Buffer 1 to main memory page program with built-In erase, Fast program */ |
||||
#define DB_BUF1_PAGE_PGM 0x88 /* Buffer 1 to main memory page program without built-In erase */ |
||||
#define DB_BUF1_PAGE_FASTPGM 0x98 /* Buffer 1 to main memory page program without built-In erase, Fast program */ |
||||
#define DB_BUF2_PAGE_PGM 0x89 /* Buffer 2 to main memory page program without built-In erase */ |
||||
#define DB_BUF2_PAGE_FASTPGM 0x99 /* Buffer 1 to main memory page program without built-In erase, Fast program */ |
||||
#define DB_PAGE_ERASE 0x81 /* Page Erase */ |
||||
#define DB_BLOCK_ERASE 0x50 /* Block Erase */ |
||||
#define DB_PAGE_PGM_BUF1 0x82 /* Main memory page through buffer 1 */ |
||||
#define DB_PAGE_FASTPGM_BUF1 0x92 /* Main memory page through buffer 1, Fast program */ |
||||
#define DB_PAGE_PGM_BUF2 0x85 /* Main memory page through buffer 2 */ |
||||
#define DB_PAGE_FastPGM_BUF2 0x95 /* Main memory page through buffer 2, Fast program */ |
||||
|
||||
/* ADDITIONAL COMMANDS */ |
||||
#define DB_PAGE_2_BUF1_TRF 0x53 /* Main memory page to buffer 1 transfert */ |
||||
#define DB_PAGE_2_BUF2_TRF 0x55 /* Main memory page to buffer 2 transfert */ |
||||
#define DB_PAGE_2_BUF1_CMP 0x60 /* Main memory page to buffer 1 compare */ |
||||
#define DB_PAGE_2_BUF2_CMP 0x61 /* Main memory page to buffer 2 compare */ |
||||
#define DB_AUTO_PAGE_PGM_BUF1 0x58 /* Auto page rewrite throught buffer 1 */ |
||||
#define DB_AUTO_PAGE_PGM_BUF2 0x59 /* Auto page rewrite throught buffer 2 */ |
||||
|
||||
/*-------------------------------------------------------------------------------------------------*/ |
||||
|
||||
extern int size_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr, unsigned long size); |
||||
extern int prot_dataflash (AT91PS_DataFlash pdataFlash, unsigned long addr); |
||||
extern int addr2ram(ulong addr); |
||||
extern int dataflash_real_protect (int flag, unsigned long start_addr, unsigned long end_addr); |
||||
extern int addr_dataflash (unsigned long addr); |
||||
extern int read_dataflash (unsigned long addr, unsigned long size, char *result); |
||||
extern int write_dataflash(unsigned long addr_dest, unsigned long addr_src, |
||||
unsigned long size); |
||||
extern int AT91F_DataflashInit(void); |
||||
|
||||
extern void dataflash_print_info (void); |
||||
extern void dataflash_perror (int err); |
||||
extern void AT91F_Dataflashenv_set(void); |
||||
|
||||
extern struct dataflash_addr cs[CONFIG_SYS_MAX_DATAFLASH_BANKS]; |
||||
extern dataflash_protect_t area_list[NB_DATAFLASH_AREA]; |
||||
extern AT91S_DATAFLASH_INFO dataflash_info[]; |
||||
#endif |
||||
Loading…
Reference in new issue