2004-02-09 07:55:38 +09:00
|
|
|
/*
|
2004-02-12 09:47:09 +09:00
|
|
|
* (C) Copyright 2002-2004
|
2004-02-09 07:55:38 +09:00
|
|
|
* Brad Kemp, Seranoa Networks, Brad.Kemp@seranoa.com
|
|
|
|
*
|
|
|
|
* Copyright (C) 2003 Arabella Software Ltd.
|
|
|
|
* Yuli Barcohen <yuli@arabellasw.com>
|
|
|
|
*
|
2004-02-12 09:47:09 +09:00
|
|
|
* Copyright (C) 2004
|
|
|
|
* Ed Okerson
|
2006-11-13 21:55:24 +09:00
|
|
|
*
|
|
|
|
* Copyright (C) 2006
|
|
|
|
* Tolunay Orkun <listmember@orkun.us>
|
2004-02-12 09:47:09 +09:00
|
|
|
*
|
2004-02-09 07:55:38 +09:00
|
|
|
* See file CREDITS for list of people who contributed to this
|
|
|
|
* project.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation; either version 2 of
|
|
|
|
* the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
|
|
* MA 02111-1307 USA
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* The DEBUG define must be before common to enable debugging */
|
* Patch by Thomas Elste, 10 Feb 2004:
Add support for NET+50 CPU and ModNET50 board
* Patch by Sam Song, 10 Feb 2004:
Fix typos in cfi_flash.c
* Patch by Leon Kukovec, 10 Feb 2004
Fixed long dir entry slot id calculation in get_vfatname
* Patch by Robin Gilks, 10 Feb 2004:
add "itest" command (operators: -eq, -ne, -lt, -gt, -le, -ge, ==,
!=, <>, <, >, <=, >=)
2004-02-24 04:30:57 +09:00
|
|
|
/* #define DEBUG */
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
#include <common.h>
|
|
|
|
#include <asm/processor.h>
|
2007-02-22 00:52:31 +09:00
|
|
|
#include <asm/io.h>
|
2004-06-10 02:34:58 +09:00
|
|
|
#include <asm/byteorder.h>
|
2005-04-13 19:02:42 +09:00
|
|
|
#include <environment.h>
|
2009-10-27 23:15:55 +09:00
|
|
|
#include <mtd/cfi_flash.h>
|
2004-02-24 08:54:43 +09:00
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*
|
2007-12-13 20:56:28 +09:00
|
|
|
* This file implements a Common Flash Interface (CFI) driver for
|
|
|
|
* U-Boot.
|
|
|
|
*
|
|
|
|
* The width of the port and the width of the chips are determined at
|
|
|
|
* initialization. These widths are used to calculate the address for
|
|
|
|
* access CFI data structures.
|
2004-02-09 07:55:38 +09:00
|
|
|
*
|
|
|
|
* References
|
|
|
|
* JEDEC Standard JESD68 - Common Flash Interface (CFI)
|
|
|
|
* JEDEC Standard JEP137-A Common Flash Interface (CFI) ID Codes
|
|
|
|
* Intel Application Note 646 Common Flash Interface (CFI) and Command Sets
|
|
|
|
* Intel 290667-008 3 Volt Intel StrataFlash Memory datasheet
|
2006-11-13 21:55:24 +09:00
|
|
|
* AMD CFI Specification, Release 2.0 December 1, 2001
|
|
|
|
* AMD/Spansion Application Note: Migration from Single-byte to Three-byte
|
|
|
|
* Device IDs, Publication Number 25538 Revision A, November 8, 2001
|
2004-02-09 07:55:38 +09:00
|
|
|
*
|
2008-10-16 22:01:15 +09:00
|
|
|
* Define CONFIG_SYS_WRITE_SWAPPED_DATA, if you have to swap the Bytes between
|
2007-01-20 02:05:26 +09:00
|
|
|
* reading and writing ... (yes there is such a Hardware).
|
2004-02-09 07:55:38 +09:00
|
|
|
*/
|
|
|
|
|
2007-12-13 20:56:28 +09:00
|
|
|
static uint flash_offset_cfi[2] = { FLASH_OFFSET_CFI, FLASH_OFFSET_CFI_ALT };
|
2008-11-17 23:49:32 +09:00
|
|
|
static uint flash_verbose = 1;
|
2006-12-27 09:26:13 +09:00
|
|
|
|
2008-08-08 23:39:54 +09:00
|
|
|
flash_info_t flash_info[CFI_MAX_FLASH_BANKS]; /* FLASH chips info */
|
|
|
|
|
2006-02-28 23:29:58 +09:00
|
|
|
/*
|
|
|
|
* Check if chip width is defined. If not, start detecting with 8bit.
|
|
|
|
*/
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifndef CONFIG_SYS_FLASH_CFI_WIDTH
|
|
|
|
#define CONFIG_SYS_FLASH_CFI_WIDTH FLASH_CFI_8BIT
|
2006-02-28 23:29:58 +09:00
|
|
|
#endif
|
|
|
|
|
2010-08-31 17:00:10 +09:00
|
|
|
#if defined(CONFIG_SYS_MAX_FLASH_BANKS_DETECT)
|
|
|
|
int cfi_flash_num_flash_banks = CONFIG_SYS_MAX_FLASH_BANKS_DETECT;
|
|
|
|
#endif
|
|
|
|
|
2010-08-30 17:11:51 +09:00
|
|
|
static phys_addr_t __cfi_flash_bank_addr(int i)
|
|
|
|
{
|
|
|
|
return ((phys_addr_t [])CONFIG_SYS_FLASH_BANKS_LIST)[i];
|
|
|
|
}
|
|
|
|
phys_addr_t cfi_flash_bank_addr(int i)
|
|
|
|
__attribute__((weak, alias("__cfi_flash_bank_addr")));
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
static void __flash_write8(u8 value, void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
__raw_writeb(value, addr);
|
|
|
|
}
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
static void __flash_write16(u16 value, void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
__raw_writew(value, addr);
|
|
|
|
}
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
static void __flash_write32(u32 value, void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
__raw_writel(value, addr);
|
|
|
|
}
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
static void __flash_write64(u64 value, void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
/* No architectures currently implement __raw_writeq() */
|
|
|
|
*(volatile u64 *)addr = value;
|
|
|
|
}
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
static u8 __flash_read8(void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
return __raw_readb(addr);
|
|
|
|
}
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
static u16 __flash_read16(void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
return __raw_readw(addr);
|
|
|
|
}
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
static u32 __flash_read32(void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
return __raw_readl(addr);
|
|
|
|
}
|
|
|
|
|
2008-03-29 04:40:19 +09:00
|
|
|
static u64 __flash_read64(void *addr)
|
2007-12-13 20:56:32 +09:00
|
|
|
{
|
|
|
|
/* No architectures currently implement __raw_readq() */
|
|
|
|
return *(volatile u64 *)addr;
|
|
|
|
}
|
|
|
|
|
2008-11-17 22:45:22 +09:00
|
|
|
#ifdef CONFIG_CFI_FLASH_USE_WEAK_ACCESSORS
|
|
|
|
void flash_write8(u8 value, void *addr)__attribute__((weak, alias("__flash_write8")));
|
|
|
|
void flash_write16(u16 value, void *addr)__attribute__((weak, alias("__flash_write16")));
|
|
|
|
void flash_write32(u32 value, void *addr)__attribute__((weak, alias("__flash_write32")));
|
|
|
|
void flash_write64(u64 value, void *addr)__attribute__((weak, alias("__flash_write64")));
|
|
|
|
u8 flash_read8(void *addr)__attribute__((weak, alias("__flash_read8")));
|
|
|
|
u16 flash_read16(void *addr)__attribute__((weak, alias("__flash_read16")));
|
|
|
|
u32 flash_read32(void *addr)__attribute__((weak, alias("__flash_read32")));
|
2008-03-29 04:40:19 +09:00
|
|
|
u64 flash_read64(void *addr)__attribute__((weak, alias("__flash_read64")));
|
2008-11-17 22:45:22 +09:00
|
|
|
#else
|
|
|
|
#define flash_write8 __flash_write8
|
|
|
|
#define flash_write16 __flash_write16
|
|
|
|
#define flash_write32 __flash_write32
|
|
|
|
#define flash_write64 __flash_write64
|
|
|
|
#define flash_read8 __flash_read8
|
|
|
|
#define flash_read16 __flash_read16
|
|
|
|
#define flash_read32 __flash_read32
|
|
|
|
#define flash_read64 __flash_read64
|
|
|
|
#endif
|
2008-03-29 04:40:19 +09:00
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(CONFIG_ENV_IS_IN_FLASH) || defined(CONFIG_ENV_ADDR_REDUND) || (CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE)
|
2009-02-10 17:53:29 +09:00
|
|
|
flash_info_t *flash_get_info(ulong base)
|
2007-10-07 01:55:36 +09:00
|
|
|
{
|
|
|
|
int i;
|
2010-08-30 18:14:38 +09:00
|
|
|
flash_info_t *info = NULL;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
|
2007-10-07 01:55:36 +09:00
|
|
|
info = & flash_info[i];
|
|
|
|
if (info->size && info->start[0] <= base &&
|
|
|
|
base <= info->start[0] + info->size - 1)
|
|
|
|
break;
|
|
|
|
}
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2010-08-30 18:14:38 +09:00
|
|
|
return info;
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
2004-02-09 07:55:38 +09:00
|
|
|
#endif
|
|
|
|
|
2007-12-13 20:56:34 +09:00
|
|
|
unsigned long flash_sector_size(flash_info_t *info, flash_sect_t sect)
|
|
|
|
{
|
|
|
|
if (sect != (info->sector_count - 1))
|
|
|
|
return info->start[sect + 1] - info->start[sect];
|
|
|
|
else
|
|
|
|
return info->start[0] + info->size - info->start[sect];
|
|
|
|
}
|
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* create an address based on the offset and the port width
|
|
|
|
*/
|
2007-12-13 20:56:34 +09:00
|
|
|
static inline void *
|
|
|
|
flash_map (flash_info_t * info, flash_sect_t sect, uint offset)
|
2004-02-12 09:47:09 +09:00
|
|
|
{
|
2007-12-13 20:56:34 +09:00
|
|
|
unsigned int byte_offset = offset * info->portwidth;
|
|
|
|
|
2009-02-03 07:34:51 +09:00
|
|
|
return (void *)(info->start[sect] + byte_offset);
|
2007-12-13 20:56:34 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void flash_unmap(flash_info_t *info, flash_sect_t sect,
|
|
|
|
unsigned int offset, void *addr)
|
|
|
|
{
|
2004-02-12 09:47:09 +09:00
|
|
|
}
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* make a proper sized command based on the port and chip widths
|
|
|
|
*/
|
2008-07-15 20:35:23 +09:00
|
|
|
static void flash_make_cmd(flash_info_t *info, u32 cmd, void *cmdbuf)
|
2007-10-07 01:55:36 +09:00
|
|
|
{
|
|
|
|
int i;
|
2008-05-08 02:24:44 +09:00
|
|
|
int cword_offset;
|
|
|
|
int cp_offset;
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) || defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2008-07-17 03:04:49 +09:00
|
|
|
u32 cmd_le = cpu_to_le32(cmd);
|
|
|
|
#endif
|
2008-05-08 02:24:44 +09:00
|
|
|
uchar val;
|
2007-10-07 01:55:36 +09:00
|
|
|
uchar *cp = (uchar *) cmdbuf;
|
|
|
|
|
2008-05-08 02:24:44 +09:00
|
|
|
for (i = info->portwidth; i > 0; i--){
|
|
|
|
cword_offset = (info->portwidth-i)%info->chipwidth;
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) || defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2008-05-08 02:24:44 +09:00
|
|
|
cp_offset = info->portwidth - i;
|
2008-07-17 03:04:49 +09:00
|
|
|
val = *((uchar*)&cmd_le + cword_offset);
|
2007-10-07 01:55:36 +09:00
|
|
|
#else
|
2008-05-08 02:24:44 +09:00
|
|
|
cp_offset = i - 1;
|
2008-07-15 20:35:23 +09:00
|
|
|
val = *((uchar*)&cmd + sizeof(u32) - cword_offset - 1);
|
2007-10-07 01:55:36 +09:00
|
|
|
#endif
|
2008-07-15 20:35:23 +09:00
|
|
|
cp[cp_offset] = (cword_offset >= sizeof(u32)) ? 0x00 : val;
|
2008-05-08 02:24:44 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
#ifdef DEBUG
|
2004-02-12 09:47:09 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* Debug support
|
|
|
|
*/
|
2007-12-13 20:56:29 +09:00
|
|
|
static void print_longlong (char *str, unsigned long long data)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
char *cp;
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2009-02-04 17:42:20 +09:00
|
|
|
cp = (char *) &data;
|
2004-02-12 09:47:09 +09:00
|
|
|
for (i = 0; i < 8; i++)
|
|
|
|
sprintf (&str[i * 2], "%2.2x", *cp++);
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
|
2007-12-14 23:36:16 +09:00
|
|
|
static void flash_printqry (struct cfi_qry *qry)
|
2004-02-12 09:47:09 +09:00
|
|
|
{
|
2007-12-14 23:36:16 +09:00
|
|
|
u8 *p = (u8 *)qry;
|
2004-02-12 09:47:09 +09:00
|
|
|
int x, y;
|
|
|
|
|
2007-12-14 23:36:16 +09:00
|
|
|
for (x = 0; x < sizeof(struct cfi_qry); x += 16) {
|
|
|
|
debug("%02x : ", x);
|
|
|
|
for (y = 0; y < 16; y++)
|
|
|
|
debug("%2.2x ", p[x + y]);
|
|
|
|
debug(" ");
|
2004-02-12 09:47:09 +09:00
|
|
|
for (y = 0; y < 16; y++) {
|
2007-12-14 23:36:16 +09:00
|
|
|
unsigned char c = p[x + y];
|
|
|
|
if (c >= 0x20 && c <= 0x7e)
|
|
|
|
debug("%c", c);
|
|
|
|
else
|
|
|
|
debug(".");
|
2004-02-12 09:47:09 +09:00
|
|
|
}
|
2007-12-14 23:36:16 +09:00
|
|
|
debug("\n");
|
2004-02-12 09:47:09 +09:00
|
|
|
}
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* read a character at a port width address
|
|
|
|
*/
|
2007-12-13 20:56:29 +09:00
|
|
|
static inline uchar flash_read_uchar (flash_info_t * info, uint offset)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
|
|
|
uchar *cp;
|
2007-12-13 20:56:34 +09:00
|
|
|
uchar retval;
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2007-12-13 20:56:34 +09:00
|
|
|
cp = flash_map (info, 0, offset);
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) || defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2007-12-13 20:56:34 +09:00
|
|
|
retval = flash_read8(cp);
|
2004-02-12 09:47:09 +09:00
|
|
|
#else
|
2007-12-13 20:56:34 +09:00
|
|
|
retval = flash_read8(cp + info->portwidth - 1);
|
2004-02-12 09:47:09 +09:00
|
|
|
#endif
|
2007-12-13 20:56:34 +09:00
|
|
|
flash_unmap (info, 0, offset, cp);
|
|
|
|
return retval;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2008-03-28 19:29:10 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* read a word at a port width address, assume 16bit bus
|
|
|
|
*/
|
|
|
|
static inline ushort flash_read_word (flash_info_t * info, uint offset)
|
|
|
|
{
|
|
|
|
ushort *addr, retval;
|
|
|
|
|
|
|
|
addr = flash_map (info, 0, offset);
|
|
|
|
retval = flash_read16 (addr);
|
|
|
|
flash_unmap (info, 0, offset, addr);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
2006-11-13 21:55:24 +09:00
|
|
|
* read a long word by picking the least significant byte of each maximum
|
2004-02-09 07:55:38 +09:00
|
|
|
* port size word. Swap for ppc format.
|
|
|
|
*/
|
2007-12-13 20:56:29 +09:00
|
|
|
static ulong flash_read_long (flash_info_t * info, flash_sect_t sect,
|
|
|
|
uint offset)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2004-02-12 09:47:09 +09:00
|
|
|
uchar *addr;
|
|
|
|
ulong retval;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
int x;
|
|
|
|
#endif
|
2007-12-13 20:56:34 +09:00
|
|
|
addr = flash_map (info, sect, offset);
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
#ifdef DEBUG
|
|
|
|
debug ("long addr is at %p info->portwidth = %d\n", addr,
|
|
|
|
info->portwidth);
|
|
|
|
for (x = 0; x < 4 * info->portwidth; x++) {
|
2007-12-13 20:56:34 +09:00
|
|
|
debug ("addr[%x] = 0x%x\n", x, flash_read8(addr + x));
|
2004-02-12 09:47:09 +09:00
|
|
|
}
|
|
|
|
#endif
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) || defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2007-12-13 20:56:34 +09:00
|
|
|
retval = ((flash_read8(addr) << 16) |
|
|
|
|
(flash_read8(addr + info->portwidth) << 24) |
|
|
|
|
(flash_read8(addr + 2 * info->portwidth)) |
|
|
|
|
(flash_read8(addr + 3 * info->portwidth) << 8));
|
2004-02-12 09:47:09 +09:00
|
|
|
#else
|
2007-12-13 20:56:34 +09:00
|
|
|
retval = ((flash_read8(addr + 2 * info->portwidth - 1) << 24) |
|
|
|
|
(flash_read8(addr + info->portwidth - 1) << 16) |
|
|
|
|
(flash_read8(addr + 4 * info->portwidth - 1) << 8) |
|
|
|
|
(flash_read8(addr + 3 * info->portwidth - 1)));
|
2004-02-12 09:47:09 +09:00
|
|
|
#endif
|
2007-12-13 20:56:34 +09:00
|
|
|
flash_unmap(info, sect, offset, addr);
|
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
return retval;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*
|
|
|
|
* Write a proper sized command to the correct address
|
2007-12-08 07:35:02 +09:00
|
|
|
*/
|
2009-10-27 23:15:55 +09:00
|
|
|
void flash_write_cmd (flash_info_t * info, flash_sect_t sect,
|
|
|
|
uint offset, u32 cmd)
|
2007-12-08 07:35:02 +09:00
|
|
|
{
|
2007-12-13 20:56:28 +09:00
|
|
|
|
2007-12-13 20:56:32 +09:00
|
|
|
void *addr;
|
2007-10-07 01:55:36 +09:00
|
|
|
cfiword_t cword;
|
2007-12-08 07:35:02 +09:00
|
|
|
|
2007-12-13 20:56:34 +09:00
|
|
|
addr = flash_map (info, sect, offset);
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_make_cmd (info, cmd, &cword);
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
debug ("fwc addr %p cmd %x %x 8bit x %d bit\n", addr, cmd,
|
2007-10-07 01:55:36 +09:00
|
|
|
cword.c, info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write8(cword.c, addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
debug ("fwc addr %p cmd %x %4.4x 16bit x %d bit\n", addr,
|
2007-10-07 01:55:36 +09:00
|
|
|
cmd, cword.w,
|
|
|
|
info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write16(cword.w, addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
debug ("fwc addr %p cmd %x %8.8lx 32bit x %d bit\n", addr,
|
2007-10-07 01:55:36 +09:00
|
|
|
cmd, cword.l,
|
|
|
|
info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write32(cword.l, addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
|
|
|
#ifdef DEBUG
|
|
|
|
{
|
|
|
|
char str[20];
|
2007-12-13 20:56:28 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
print_longlong (str, cword.ll);
|
|
|
|
|
|
|
|
debug ("fwrite addr %p cmd %x %s 64 bit x %d bit\n",
|
2007-12-13 20:56:32 +09:00
|
|
|
addr, cmd, str,
|
2007-10-07 01:55:36 +09:00
|
|
|
info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
|
2007-12-08 07:35:02 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
#endif
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write64(cword.ll, addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
2007-12-08 07:35:02 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
|
|
|
|
/* Ensure all the instructions are fully finished */
|
|
|
|
sync();
|
2007-12-13 20:56:34 +09:00
|
|
|
|
|
|
|
flash_unmap(info, sect, offset, addr);
|
2007-12-08 07:35:02 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
|
|
|
|
static void flash_unlock_seq (flash_info_t * info, flash_sect_t sect)
|
2007-12-08 07:35:02 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_write_cmd (info, sect, info->addr_unlock1, AMD_CMD_UNLOCK_START);
|
|
|
|
flash_write_cmd (info, sect, info->addr_unlock2, AMD_CMD_UNLOCK_ACK);
|
2007-12-08 07:35:02 +09:00
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
static int flash_isequal (flash_info_t * info, flash_sect_t sect,
|
|
|
|
uint offset, uchar cmd)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-12-13 20:56:32 +09:00
|
|
|
void *addr;
|
2007-10-07 01:55:36 +09:00
|
|
|
cfiword_t cword;
|
|
|
|
int retval;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-12-13 20:56:34 +09:00
|
|
|
addr = flash_map (info, sect, offset);
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_make_cmd (info, cmd, &cword);
|
2006-04-01 20:41:03 +09:00
|
|
|
|
2007-12-13 20:56:32 +09:00
|
|
|
debug ("is= cmd %x(%c) addr %p ", cmd, cmd, addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
debug ("is= %x %x\n", flash_read8(addr), cword.c);
|
|
|
|
retval = (flash_read8(addr) == cword.c);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
debug ("is= %4.4x %4.4x\n", flash_read16(addr), cword.w);
|
|
|
|
retval = (flash_read16(addr) == cword.w);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2008-08-21 23:12:26 +09:00
|
|
|
debug ("is= %8.8x %8.8lx\n", flash_read32(addr), cword.l);
|
2007-12-13 20:56:32 +09:00
|
|
|
retval = (flash_read32(addr) == cword.l);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
|
|
|
#ifdef DEBUG
|
|
|
|
{
|
|
|
|
char str1[20];
|
|
|
|
char str2[20];
|
2007-12-08 07:35:02 +09:00
|
|
|
|
2007-12-13 20:56:32 +09:00
|
|
|
print_longlong (str1, flash_read64(addr));
|
2007-10-07 01:55:36 +09:00
|
|
|
print_longlong (str2, cword.ll);
|
|
|
|
debug ("is= %s %s\n", str1, str2);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
#endif
|
2007-12-13 20:56:32 +09:00
|
|
|
retval = (flash_read64(addr) == cword.ll);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retval = 0;
|
|
|
|
break;
|
|
|
|
}
|
2007-12-13 20:56:34 +09:00
|
|
|
flash_unmap(info, sect, offset, addr);
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
return retval;
|
|
|
|
}
|
2006-02-28 23:29:58 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
static int flash_isset (flash_info_t * info, flash_sect_t sect,
|
|
|
|
uint offset, uchar cmd)
|
|
|
|
{
|
2007-12-13 20:56:32 +09:00
|
|
|
void *addr;
|
2007-10-07 01:55:36 +09:00
|
|
|
cfiword_t cword;
|
|
|
|
int retval;
|
2006-04-01 20:41:03 +09:00
|
|
|
|
2007-12-13 20:56:34 +09:00
|
|
|
addr = flash_map (info, sect, offset);
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_make_cmd (info, cmd, &cword);
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
retval = ((flash_read8(addr) & cword.c) == cword.c);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
retval = ((flash_read16(addr) & cword.w) == cword.w);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2008-01-02 22:05:37 +09:00
|
|
|
retval = ((flash_read32(addr) & cword.l) == cword.l);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
retval = ((flash_read64(addr) & cword.ll) == cword.ll);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retval = 0;
|
|
|
|
break;
|
|
|
|
}
|
2007-12-13 20:56:34 +09:00
|
|
|
flash_unmap(info, sect, offset, addr);
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
return retval;
|
|
|
|
}
|
2006-04-01 20:41:03 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
static int flash_toggle (flash_info_t * info, flash_sect_t sect,
|
|
|
|
uint offset, uchar cmd)
|
|
|
|
{
|
2007-12-13 20:56:32 +09:00
|
|
|
void *addr;
|
2007-10-07 01:55:36 +09:00
|
|
|
cfiword_t cword;
|
|
|
|
int retval;
|
2004-10-11 07:16:06 +09:00
|
|
|
|
2007-12-13 20:56:34 +09:00
|
|
|
addr = flash_map (info, sect, offset);
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_make_cmd (info, cmd, &cword);
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2008-06-16 17:40:02 +09:00
|
|
|
retval = flash_read8(addr) != flash_read8(addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2008-06-16 17:40:02 +09:00
|
|
|
retval = flash_read16(addr) != flash_read16(addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2008-06-16 17:40:02 +09:00
|
|
|
retval = flash_read32(addr) != flash_read32(addr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
CFI Driver: Fix "flash not ready" problem
This patch fixes a problem on systems where the NOR flash is attached
to a 64 bit bus. The toggle bit detection in flash_toggle() is based
on the assumption that the same flash address is read twice without
any other interjacent flash accesses. However, on 32 bit systems the
function flash_read64() [as currently implemented] does not perform
an atomic 64 bit read - instead, this is broken down into two 32 bit
read accesses on addresses "addr" and "addr + 4". So instead of
reading a 64 bit value twice from "addr", we see a sequence of 4 32
bit reads from "addr", "addr + 4", "addr", and "addr + 4". The
consequence is that flash_toggle() fails to work.
This patch implements a simple, but somewhat ugly solution, as it
avoids the use of flash_read64() in this critical place (by breaking
it down manually into 32 bit read operations) instead of rewriting
flash_read64() such to perform atomic 64 bit reads as one could
expect. However, such a rewrite would require the use of floating
point load operations, which becomes pretty complex:
save MSR;
set Floating Point Enable bit in MSR;
use "lfd" instruction to perform atomic 64 bit read;
use "stfd" to store value to temporary variable on stack;
load u64 value from temporary variable;
restore saved MSR;
return u64 value;
The benefit-cost ratio of such an implementation was considered too
bad to actually attempt this, especially as we can expect that such
an implementation would not only have a bigger memory footprint but
also cause a performance degradation.
Signed-off-by: Wolfgang Denk <wd@denx.de>
Signed-off-by: Stefan Roese <sr@denx.de>
2008-10-31 09:12:28 +09:00
|
|
|
retval = ( (flash_read32( addr ) != flash_read32( addr )) ||
|
|
|
|
(flash_read32(addr+4) != flash_read32(addr+4)) );
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retval = 0;
|
|
|
|
break;
|
|
|
|
}
|
2007-12-13 20:56:34 +09:00
|
|
|
flash_unmap(info, sect, offset, addr);
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
return retval;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*
|
|
|
|
* flash_is_busy - check to see if the flash is busy
|
|
|
|
*
|
|
|
|
* This routine checks the status of the chip and returns true if the
|
|
|
|
* chip is busy.
|
2005-05-17 00:23:22 +09:00
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
static int flash_is_busy (flash_info_t * info, flash_sect_t sect)
|
2005-05-17 00:23:22 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
int retval;
|
2005-05-17 00:23:22 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2007-10-07 01:55:36 +09:00
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
|
|
|
retval = !flash_isset (info, sect, 0, FLASH_STATUS_DONE);
|
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
|
|
|
#ifdef CONFIG_FLASH_CFI_LEGACY
|
|
|
|
case CFI_CMDSET_AMD_LEGACY:
|
|
|
|
#endif
|
|
|
|
retval = flash_toggle (info, sect, 0, AMD_STATUS_TOGGLE);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retval = 0;
|
2005-05-17 00:23:22 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
debug ("flash_is_busy: %d\n", retval);
|
|
|
|
return retval;
|
2005-05-17 00:23:22 +09:00
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
2007-10-07 01:55:36 +09:00
|
|
|
* wait for XSR.7 to be set. Time out with an error if it does not.
|
|
|
|
* This routine does not set the flash to read-array mode.
|
2004-02-09 07:55:38 +09:00
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
static int flash_status_check (flash_info_t * info, flash_sect_t sector,
|
|
|
|
ulong tout, char *prompt)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
ulong start;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
#if CONFIG_SYS_HZ != 1000
|
2010-03-25 00:00:47 +09:00
|
|
|
if ((ulong)CONFIG_SYS_HZ > 100000)
|
|
|
|
tout *= (ulong)CONFIG_SYS_HZ / 1000; /* for a big HZ, avoid overflow */
|
|
|
|
else
|
|
|
|
tout = DIV_ROUND_UP(tout * (ulong)CONFIG_SYS_HZ, 1000);
|
2007-10-07 01:55:36 +09:00
|
|
|
#endif
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* Wait for command completion */
|
2010-04-01 12:15:05 +09:00
|
|
|
reset_timer();
|
2007-10-07 01:55:36 +09:00
|
|
|
start = get_timer (0);
|
|
|
|
while (flash_is_busy (info, sector)) {
|
|
|
|
if (get_timer (start) > tout) {
|
|
|
|
printf ("Flash %s timeout at address %lx data %lx\n",
|
|
|
|
prompt, info->start[sector],
|
|
|
|
flash_read_long (info, sector, 0));
|
|
|
|
flash_write_cmd (info, sector, 0, info->cmd_reset);
|
|
|
|
return ERR_TIMOUT;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
udelay (1); /* also triggers watchdog */
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
return ERR_OK;
|
|
|
|
}
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* Wait for XSR.7 to be set, if it times out print an error, otherwise
|
|
|
|
* do a full status check.
|
|
|
|
*
|
|
|
|
* This routine sets the flash to read-array mode.
|
|
|
|
*/
|
|
|
|
static int flash_full_status_check (flash_info_t * info, flash_sect_t sector,
|
|
|
|
ulong tout, char *prompt)
|
|
|
|
{
|
|
|
|
int retcode;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
retcode = flash_status_check (info, sector, tout, prompt);
|
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2007-10-07 01:55:36 +09:00
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
2008-10-09 15:26:36 +09:00
|
|
|
if ((retcode != ERR_OK)
|
2007-10-07 01:55:36 +09:00
|
|
|
&& !flash_isequal (info, sector, 0, FLASH_STATUS_DONE)) {
|
|
|
|
retcode = ERR_INVAL;
|
|
|
|
printf ("Flash %s error at address %lx\n", prompt,
|
|
|
|
info->start[sector]);
|
|
|
|
if (flash_isset (info, sector, 0, FLASH_STATUS_ECLBS |
|
|
|
|
FLASH_STATUS_PSLBS)) {
|
|
|
|
puts ("Command Sequence Error.\n");
|
|
|
|
} else if (flash_isset (info, sector, 0,
|
|
|
|
FLASH_STATUS_ECLBS)) {
|
|
|
|
puts ("Block Erase Error.\n");
|
|
|
|
retcode = ERR_NOT_ERASED;
|
|
|
|
} else if (flash_isset (info, sector, 0,
|
|
|
|
FLASH_STATUS_PSLBS)) {
|
|
|
|
puts ("Locking Error\n");
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
if (flash_isset (info, sector, 0, FLASH_STATUS_DPS)) {
|
|
|
|
puts ("Block locked.\n");
|
|
|
|
retcode = ERR_PROTECTED;
|
|
|
|
}
|
|
|
|
if (flash_isset (info, sector, 0, FLASH_STATUS_VPENS))
|
|
|
|
puts ("Vpp Low Error.\n");
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_write_cmd (info, sector, 0, info->cmd_reset);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
return retcode;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2010-03-26 09:17:00 +09:00
|
|
|
static int use_flash_status_poll(flash_info_t *info)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SYS_CFI_FLASH_STATUS_POLL
|
|
|
|
if (info->vendor == CFI_CMDSET_AMD_EXTENDED ||
|
|
|
|
info->vendor == CFI_CMDSET_AMD_STANDARD)
|
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int flash_status_poll(flash_info_t *info, void *src, void *dst,
|
|
|
|
ulong tout, char *prompt)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SYS_CFI_FLASH_STATUS_POLL
|
|
|
|
ulong start;
|
|
|
|
int ready;
|
|
|
|
|
|
|
|
#if CONFIG_SYS_HZ != 1000
|
|
|
|
if ((ulong)CONFIG_SYS_HZ > 100000)
|
|
|
|
tout *= (ulong)CONFIG_SYS_HZ / 1000; /* for a big HZ, avoid overflow */
|
|
|
|
else
|
|
|
|
tout = DIV_ROUND_UP(tout * (ulong)CONFIG_SYS_HZ, 1000);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Wait for command completion */
|
2010-04-01 12:15:05 +09:00
|
|
|
reset_timer();
|
2010-03-26 09:17:00 +09:00
|
|
|
start = get_timer(0);
|
|
|
|
while (1) {
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
|
|
|
ready = flash_read8(dst) == flash_read8(src);
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
|
|
|
ready = flash_read16(dst) == flash_read16(src);
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
|
|
|
ready = flash_read32(dst) == flash_read32(src);
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
|
|
|
ready = flash_read64(dst) == flash_read64(src);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ready = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (ready)
|
|
|
|
break;
|
|
|
|
if (get_timer(start) > tout) {
|
|
|
|
printf("Flash %s timeout at address %lx data %lx\n",
|
|
|
|
prompt, (ulong)dst, (ulong)flash_read8(dst));
|
|
|
|
return ERR_TIMOUT;
|
|
|
|
}
|
|
|
|
udelay(1); /* also triggers watchdog */
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SYS_CFI_FLASH_STATUS_POLL */
|
|
|
|
return ERR_OK;
|
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
static void flash_add_byte (flash_info_t * info, cfiword_t * cword, uchar c)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) && !defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2007-10-07 01:55:36 +09:00
|
|
|
unsigned short w;
|
|
|
|
unsigned int l;
|
|
|
|
unsigned long long ll;
|
|
|
|
#endif
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
|
|
|
cword->c = c;
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) && !defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2007-10-07 01:55:36 +09:00
|
|
|
w = c;
|
|
|
|
w <<= 8;
|
|
|
|
cword->w = (cword->w >> 8) | w;
|
|
|
|
#else
|
|
|
|
cword->w = (cword->w << 8) | c;
|
2007-12-08 07:35:02 +09:00
|
|
|
#endif
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) && !defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2007-10-07 01:55:36 +09:00
|
|
|
l = c;
|
|
|
|
l <<= 24;
|
|
|
|
cword->l = (cword->l >> 8) | l;
|
|
|
|
#else
|
|
|
|
cword->l = (cword->l << 8) | c;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(__LITTLE_ENDIAN) && !defined(CONFIG_SYS_WRITE_SWAPPED_DATA)
|
2007-10-07 01:55:36 +09:00
|
|
|
ll = c;
|
|
|
|
ll <<= 56;
|
|
|
|
cword->ll = (cword->ll >> 8) | ll;
|
|
|
|
#else
|
|
|
|
cword->ll = (cword->ll << 8) | c;
|
|
|
|
#endif
|
|
|
|
break;
|
2006-11-13 21:55:24 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2008-12-17 01:25:55 +09:00
|
|
|
/*
|
|
|
|
* Loop through the sector table starting from the previously found sector.
|
|
|
|
* Searches forwards or backwards, dependent on the passed address.
|
2007-10-07 01:55:36 +09:00
|
|
|
*/
|
|
|
|
static flash_sect_t find_sector (flash_info_t * info, ulong addr)
|
|
|
|
{
|
2008-12-17 01:25:55 +09:00
|
|
|
static flash_sect_t saved_sector = 0; /* previously found sector */
|
|
|
|
flash_sect_t sector = saved_sector;
|
|
|
|
|
|
|
|
while ((info->start[sector] < addr)
|
|
|
|
&& (sector < info->sector_count - 1))
|
|
|
|
sector++;
|
|
|
|
while ((info->start[sector] > addr) && (sector > 0))
|
|
|
|
/*
|
|
|
|
* also decrements the sector in case of an overshot
|
|
|
|
* in the first loop
|
|
|
|
*/
|
|
|
|
sector--;
|
|
|
|
|
|
|
|
saved_sector = sector;
|
2007-10-07 01:55:36 +09:00
|
|
|
return sector;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
static int flash_write_cfiword (flash_info_t * info, ulong dest,
|
|
|
|
cfiword_t cword)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2009-02-03 07:34:51 +09:00
|
|
|
void *dstaddr = (void *)dest;
|
2007-10-07 01:55:36 +09:00
|
|
|
int flag;
|
2008-12-17 01:25:54 +09:00
|
|
|
flash_sect_t sect = 0;
|
|
|
|
char sect_found = 0;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* Check if Flash is (sufficiently) erased */
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flag = ((flash_read8(dstaddr) & cword.c) == cword.c);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flag = ((flash_read16(dstaddr) & cword.w) == cword.w);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flag = ((flash_read32(dstaddr) & cword.l) == cword.l);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flag = ((flash_read64(dstaddr) & cword.ll) == cword.ll);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
default:
|
2007-12-13 20:56:34 +09:00
|
|
|
flag = 0;
|
|
|
|
break;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2009-02-03 07:34:51 +09:00
|
|
|
if (!flag)
|
2007-12-27 15:50:54 +09:00
|
|
|
return ERR_NOT_ERASED;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* Disable interrupts which might cause a timeout here */
|
|
|
|
flag = disable_interrupts ();
|
2006-02-28 23:29:58 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2007-10-07 01:55:36 +09:00
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
flash_write_cmd (info, 0, 0, FLASH_CMD_CLEAR_STATUS);
|
|
|
|
flash_write_cmd (info, 0, 0, FLASH_CMD_WRITE);
|
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
2008-10-09 15:26:36 +09:00
|
|
|
sect = find_sector(info, dest);
|
|
|
|
flash_unlock_seq (info, sect);
|
|
|
|
flash_write_cmd (info, sect, info->addr_unlock1, AMD_CMD_WRITE);
|
2008-12-17 01:25:54 +09:00
|
|
|
sect_found = 1;
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
2009-07-10 19:03:57 +09:00
|
|
|
#ifdef CONFIG_FLASH_CFI_LEGACY
|
|
|
|
case CFI_CMDSET_AMD_LEGACY:
|
|
|
|
sect = find_sector(info, dest);
|
|
|
|
flash_unlock_seq (info, 0);
|
|
|
|
flash_write_cmd (info, 0, info->addr_unlock1, AMD_CMD_WRITE);
|
|
|
|
sect_found = 1;
|
|
|
|
break;
|
|
|
|
#endif
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write8(cword.c, dstaddr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write16(cword.w, dstaddr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write32(cword.l, dstaddr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write64(cword.ll, dstaddr);
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* re-enable interrupts if necessary */
|
|
|
|
if (flag)
|
|
|
|
enable_interrupts ();
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2008-12-17 01:25:54 +09:00
|
|
|
if (!sect_found)
|
|
|
|
sect = find_sector (info, dest);
|
|
|
|
|
2010-03-26 09:17:00 +09:00
|
|
|
if (use_flash_status_poll(info))
|
|
|
|
return flash_status_poll(info, &cword, dstaddr,
|
|
|
|
info->write_tout, "write");
|
|
|
|
else
|
|
|
|
return flash_full_status_check(info, sect,
|
|
|
|
info->write_tout, "write");
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_USE_BUFFER_WRITE
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp,
|
|
|
|
int len)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_sect_t sector;
|
|
|
|
int cnt;
|
|
|
|
int retcode;
|
2007-12-13 20:56:32 +09:00
|
|
|
void *src = cp;
|
2009-02-05 19:25:57 +09:00
|
|
|
void *dst = (void *)dest;
|
2007-12-27 15:50:54 +09:00
|
|
|
void *dst2 = dst;
|
|
|
|
int flag = 0;
|
2008-04-03 20:36:02 +09:00
|
|
|
uint offset = 0;
|
|
|
|
unsigned int shift;
|
2008-05-08 02:25:33 +09:00
|
|
|
uchar write_cmd;
|
2007-12-13 20:56:32 +09:00
|
|
|
|
2007-12-27 15:50:54 +09:00
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2008-04-03 20:36:02 +09:00
|
|
|
shift = 0;
|
2007-12-27 15:50:54 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2008-04-03 20:36:02 +09:00
|
|
|
shift = 1;
|
2007-12-27 15:50:54 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2008-04-03 20:36:02 +09:00
|
|
|
shift = 2;
|
2007-12-27 15:50:54 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
2008-04-03 20:36:02 +09:00
|
|
|
shift = 3;
|
2007-12-27 15:50:54 +09:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retcode = ERR_INVAL;
|
|
|
|
goto out_unmap;
|
|
|
|
}
|
|
|
|
|
2008-04-03 20:36:02 +09:00
|
|
|
cnt = len >> shift;
|
|
|
|
|
2007-12-27 15:50:54 +09:00
|
|
|
while ((cnt-- > 0) && (flag == 0)) {
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
|
|
|
flag = ((flash_read8(dst2) & flash_read8(src)) ==
|
|
|
|
flash_read8(src));
|
|
|
|
src += 1, dst2 += 1;
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
|
|
|
flag = ((flash_read16(dst2) & flash_read16(src)) ==
|
|
|
|
flash_read16(src));
|
|
|
|
src += 2, dst2 += 2;
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
|
|
|
flag = ((flash_read32(dst2) & flash_read32(src)) ==
|
|
|
|
flash_read32(src));
|
|
|
|
src += 4, dst2 += 4;
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
|
|
|
flag = ((flash_read64(dst2) & flash_read64(src)) ==
|
|
|
|
flash_read64(src));
|
|
|
|
src += 8, dst2 += 8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!flag) {
|
|
|
|
retcode = ERR_NOT_ERASED;
|
|
|
|
goto out_unmap;
|
|
|
|
}
|
|
|
|
|
|
|
|
src = cp;
|
2007-12-13 20:56:32 +09:00
|
|
|
sector = find_sector (info, dest);
|
2004-02-12 09:47:09 +09:00
|
|
|
|
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2004-02-09 07:55:38 +09:00
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
2008-05-08 02:25:33 +09:00
|
|
|
write_cmd = (info->vendor == CFI_CMDSET_INTEL_PROG_REGIONS) ?
|
|
|
|
FLASH_CMD_WRITE_BUFFER_PROG : FLASH_CMD_WRITE_TO_BUFFER;
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_write_cmd (info, sector, 0, FLASH_CMD_CLEAR_STATUS);
|
2008-05-08 02:25:33 +09:00
|
|
|
flash_write_cmd (info, sector, 0, FLASH_CMD_READ_STATUS);
|
|
|
|
flash_write_cmd (info, sector, 0, write_cmd);
|
2007-10-07 01:55:36 +09:00
|
|
|
retcode = flash_status_check (info, sector,
|
|
|
|
info->buffer_write_tout,
|
|
|
|
"write to buffer");
|
|
|
|
if (retcode == ERR_OK) {
|
|
|
|
/* reduce the number of loops by the width of
|
|
|
|
* the port */
|
2008-04-03 20:36:02 +09:00
|
|
|
cnt = len >> shift;
|
2008-05-08 02:24:44 +09:00
|
|
|
flash_write_cmd (info, sector, 0, cnt - 1);
|
2007-10-07 01:55:36 +09:00
|
|
|
while (cnt-- > 0) {
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write8(flash_read8(src), dst);
|
|
|
|
src += 1, dst += 1;
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write16(flash_read16(src), dst);
|
|
|
|
src += 2, dst += 2;
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write32(flash_read32(src), dst);
|
|
|
|
src += 4, dst += 4;
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
flash_write64(flash_read64(src), dst);
|
|
|
|
src += 8, dst += 8;
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
default:
|
2007-12-13 20:56:34 +09:00
|
|
|
retcode = ERR_INVAL;
|
|
|
|
goto out_unmap;
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
flash_write_cmd (info, sector, 0,
|
|
|
|
FLASH_CMD_WRITE_BUFFER_CONFIRM);
|
|
|
|
retcode = flash_full_status_check (
|
|
|
|
info, sector, info->buffer_write_tout,
|
|
|
|
"buffer write");
|
|
|
|
}
|
2007-12-13 20:56:34 +09:00
|
|
|
|
|
|
|
break;
|
2007-10-07 01:55:36 +09:00
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_unlock_seq(info,0);
|
2008-04-03 20:36:02 +09:00
|
|
|
|
|
|
|
#ifdef CONFIG_FLASH_SPANSION_S29WS_N
|
|
|
|
offset = ((unsigned long)dst - info->start[sector]) >> shift;
|
|
|
|
#endif
|
|
|
|
flash_write_cmd(info, sector, offset, AMD_CMD_WRITE_TO_BUFFER);
|
|
|
|
cnt = len >> shift;
|
2009-08-13 00:55:47 +09:00
|
|
|
flash_write_cmd(info, sector, offset, cnt - 1);
|
2007-10-07 01:55:36 +09:00
|
|
|
|
|
|
|
switch (info->portwidth) {
|
|
|
|
case FLASH_CFI_8BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
while (cnt-- > 0) {
|
|
|
|
flash_write8(flash_read8(src), dst);
|
|
|
|
src += 1, dst += 1;
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
while (cnt-- > 0) {
|
|
|
|
flash_write16(flash_read16(src), dst);
|
|
|
|
src += 2, dst += 2;
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_32BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
while (cnt-- > 0) {
|
|
|
|
flash_write32(flash_read32(src), dst);
|
|
|
|
src += 4, dst += 4;
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
case FLASH_CFI_64BIT:
|
2007-12-13 20:56:32 +09:00
|
|
|
while (cnt-- > 0) {
|
|
|
|
flash_write64(flash_read64(src), dst);
|
|
|
|
src += 8, dst += 8;
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
|
|
|
default:
|
2007-12-13 20:56:34 +09:00
|
|
|
retcode = ERR_INVAL;
|
|
|
|
goto out_unmap;
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
flash_write_cmd (info, sector, 0, AMD_CMD_WRITE_BUFFER_CONFIRM);
|
2010-03-26 09:17:00 +09:00
|
|
|
if (use_flash_status_poll(info))
|
|
|
|
retcode = flash_status_poll(info, src - (1 << shift),
|
|
|
|
dst - (1 << shift),
|
|
|
|
info->buffer_write_tout,
|
|
|
|
"buffer write");
|
|
|
|
else
|
|
|
|
retcode = flash_full_status_check(info, sector,
|
|
|
|
info->buffer_write_tout,
|
|
|
|
"buffer write");
|
2007-12-13 20:56:34 +09:00
|
|
|
break;
|
2007-10-07 01:55:36 +09:00
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
default:
|
2007-10-07 01:55:36 +09:00
|
|
|
debug ("Unknown Command Set\n");
|
2007-12-13 20:56:34 +09:00
|
|
|
retcode = ERR_INVAL;
|
|
|
|
break;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2007-12-13 20:56:34 +09:00
|
|
|
|
|
|
|
out_unmap:
|
|
|
|
return retcode;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2008-10-16 22:01:15 +09:00
|
|
|
#endif /* CONFIG_SYS_FLASH_USE_BUFFER_WRITE */
|
2007-10-07 01:55:36 +09:00
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
int flash_erase (flash_info_t * info, int s_first, int s_last)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
int rcode = 0;
|
|
|
|
int prot;
|
|
|
|
flash_sect_t sect;
|
2010-03-26 09:17:00 +09:00
|
|
|
int st;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
if (info->flash_id != FLASH_MAN_CFI) {
|
|
|
|
puts ("Can't erase unknown flash type - aborted\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if ((s_first < 0) || (s_first > s_last)) {
|
|
|
|
puts ("- no sectors to erase\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2006-04-01 20:41:03 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
prot = 0;
|
|
|
|
for (sect = s_first; sect <= s_last; ++sect) {
|
|
|
|
if (info->protect[sect]) {
|
|
|
|
prot++;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
if (prot) {
|
|
|
|
printf ("- Warning: %d protected sectors will not be erased!\n",
|
|
|
|
prot);
|
2008-11-17 23:49:32 +09:00
|
|
|
} else if (flash_verbose) {
|
2007-10-07 01:55:36 +09:00
|
|
|
putc ('\n');
|
|
|
|
}
|
2004-02-12 09:47:09 +09:00
|
|
|
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
for (sect = s_first; sect <= s_last; sect++) {
|
|
|
|
if (info->protect[sect] == 0) { /* not protected */
|
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2007-10-07 01:55:36 +09:00
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
|
|
|
flash_write_cmd (info, sect, 0,
|
|
|
|
FLASH_CMD_CLEAR_STATUS);
|
|
|
|
flash_write_cmd (info, sect, 0,
|
|
|
|
FLASH_CMD_BLOCK_ERASE);
|
|
|
|
flash_write_cmd (info, sect, 0,
|
|
|
|
FLASH_CMD_ERASE_CONFIRM);
|
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
|
|
|
flash_unlock_seq (info, sect);
|
|
|
|
flash_write_cmd (info, sect,
|
|
|
|
info->addr_unlock1,
|
|
|
|
AMD_CMD_ERASE_START);
|
|
|
|
flash_unlock_seq (info, sect);
|
|
|
|
flash_write_cmd (info, sect, 0,
|
|
|
|
AMD_CMD_ERASE_SECTOR);
|
|
|
|
break;
|
|
|
|
#ifdef CONFIG_FLASH_CFI_LEGACY
|
|
|
|
case CFI_CMDSET_AMD_LEGACY:
|
|
|
|
flash_unlock_seq (info, 0);
|
|
|
|
flash_write_cmd (info, 0, info->addr_unlock1,
|
|
|
|
AMD_CMD_ERASE_START);
|
|
|
|
flash_unlock_seq (info, 0);
|
|
|
|
flash_write_cmd (info, sect, 0,
|
|
|
|
AMD_CMD_ERASE_SECTOR);
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
debug ("Unkown flash vendor %d\n",
|
|
|
|
info->vendor);
|
|
|
|
break;
|
2004-02-12 09:47:09 +09:00
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
|
2010-03-26 09:17:00 +09:00
|
|
|
if (use_flash_status_poll(info)) {
|
|
|
|
cfiword_t cword = (cfiword_t)0xffffffffffffffffULL;
|
|
|
|
void *dest;
|
|
|
|
dest = flash_map(info, sect, 0);
|
|
|
|
st = flash_status_poll(info, &cword, dest,
|
|
|
|
info->erase_blk_tout, "erase");
|
|
|
|
flash_unmap(info, sect, 0, dest);
|
|
|
|
} else
|
|
|
|
st = flash_full_status_check(info, sect,
|
|
|
|
info->erase_blk_tout,
|
|
|
|
"erase");
|
|
|
|
if (st)
|
2007-10-07 01:55:36 +09:00
|
|
|
rcode = 1;
|
2010-03-26 09:17:00 +09:00
|
|
|
else if (flash_verbose)
|
2007-10-07 01:55:36 +09:00
|
|
|
putc ('.');
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
}
|
2008-11-17 23:49:32 +09:00
|
|
|
|
|
|
|
if (flash_verbose)
|
|
|
|
puts (" done\n");
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
return rcode;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2010-08-13 16:36:36 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_EMPTY_INFO
|
|
|
|
static int sector_erased(flash_info_t *info, int i)
|
|
|
|
{
|
|
|
|
int k;
|
|
|
|
int size;
|
|
|
|
volatile unsigned long *flash;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if whole sector is erased
|
|
|
|
*/
|
|
|
|
size = flash_sector_size(info, i);
|
|
|
|
flash = (volatile unsigned long *) info->start[i];
|
|
|
|
/* divide by 4 for longword access */
|
|
|
|
size = size >> 2;
|
|
|
|
|
|
|
|
for (k = 0; k < size; k++) {
|
|
|
|
if (*flash++ != 0xffffffff)
|
|
|
|
return 0; /* not erased */
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1; /* erased */
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SYS_FLASH_EMPTY_INFO */
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
void flash_print_info (flash_info_t * info)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
int i;
|
2004-03-14 23:09:05 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
if (info->flash_id != FLASH_MAN_CFI) {
|
|
|
|
puts ("missing or unknown FLASH type\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
printf ("%s FLASH (%d x %d)",
|
|
|
|
info->name,
|
|
|
|
(info->portwidth << 3), (info->chipwidth << 3));
|
|
|
|
if (info->size < 1024*1024)
|
|
|
|
printf (" Size: %ld kB in %d Sectors\n",
|
|
|
|
info->size >> 10, info->sector_count);
|
|
|
|
else
|
|
|
|
printf (" Size: %ld MB in %d Sectors\n",
|
|
|
|
info->size >> 20, info->sector_count);
|
|
|
|
printf (" ");
|
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
|
|
|
printf ("Intel Prog Regions");
|
|
|
|
break;
|
2007-10-07 01:55:36 +09:00
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
printf ("Intel Standard");
|
|
|
|
break;
|
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
|
|
|
printf ("Intel Extended");
|
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
printf ("AMD Standard");
|
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
|
|
|
printf ("AMD Extended");
|
|
|
|
break;
|
|
|
|
#ifdef CONFIG_FLASH_CFI_LEGACY
|
|
|
|
case CFI_CMDSET_AMD_LEGACY:
|
|
|
|
printf ("AMD Legacy");
|
|
|
|
break;
|
2004-03-14 23:09:05 +09:00
|
|
|
#endif
|
2007-10-07 01:55:36 +09:00
|
|
|
default:
|
|
|
|
printf ("Unknown (%d)", info->vendor);
|
|
|
|
break;
|
|
|
|
}
|
2010-08-10 23:54:52 +09:00
|
|
|
printf (" command set, Manufacturer ID: 0x%02X, Device ID: 0x",
|
|
|
|
info->manufacturer_id);
|
|
|
|
printf (info->chipwidth == FLASH_CFI_16BIT ? "%04X" : "%02X",
|
|
|
|
info->device_id);
|
2007-10-07 01:55:36 +09:00
|
|
|
if (info->device_id == 0x7E) {
|
|
|
|
printf("%04X", info->device_id2);
|
|
|
|
}
|
|
|
|
printf ("\n Erase timeout: %ld ms, write timeout: %ld ms\n",
|
|
|
|
info->erase_blk_tout,
|
|
|
|
info->write_tout);
|
|
|
|
if (info->buffer_size > 1) {
|
|
|
|
printf (" Buffer write timeout: %ld ms, "
|
|
|
|
"buffer size: %d bytes\n",
|
|
|
|
info->buffer_write_tout,
|
|
|
|
info->buffer_size);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
puts ("\n Sector Start Addresses:");
|
|
|
|
for (i = 0; i < info->sector_count; ++i) {
|
2010-07-27 08:35:39 +09:00
|
|
|
if (ctrlc())
|
2010-08-13 16:36:36 +09:00
|
|
|
break;
|
2007-10-07 01:55:36 +09:00
|
|
|
if ((i % 5) == 0)
|
2010-08-13 16:36:36 +09:00
|
|
|
putc('\n');
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_EMPTY_INFO
|
2007-10-07 01:55:36 +09:00
|
|
|
/* print empty and read-only info */
|
|
|
|
printf (" %08lX %c %s ",
|
|
|
|
info->start[i],
|
2010-08-13 16:36:36 +09:00
|
|
|
sector_erased(info, i) ? 'E' : ' ',
|
2007-10-07 01:55:36 +09:00
|
|
|
info->protect[i] ? "RO" : " ");
|
2008-10-16 22:01:15 +09:00
|
|
|
#else /* ! CONFIG_SYS_FLASH_EMPTY_INFO */
|
2007-10-07 01:55:36 +09:00
|
|
|
printf (" %08lX %s ",
|
|
|
|
info->start[i],
|
|
|
|
info->protect[i] ? "RO" : " ");
|
2004-02-12 09:47:09 +09:00
|
|
|
#endif
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
|
|
|
putc ('\n');
|
|
|
|
return;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2008-03-09 03:48:01 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* This is used in a few places in write_buf() to show programming
|
|
|
|
* progress. Making it a function is nasty because it needs to do side
|
|
|
|
* effect updates to digit and dots. Repeated code is nasty too, so
|
|
|
|
* we define it once here.
|
|
|
|
*/
|
2008-03-19 15:09:26 +09:00
|
|
|
#ifdef CONFIG_FLASH_SHOW_PROGRESS
|
|
|
|
#define FLASH_SHOW_PROGRESS(scale, dots, digit, dots_sub) \
|
2008-11-17 23:49:32 +09:00
|
|
|
if (flash_verbose) { \
|
|
|
|
dots -= dots_sub; \
|
|
|
|
if ((scale > 0) && (dots <= 0)) { \
|
|
|
|
if ((digit % 5) == 0) \
|
|
|
|
printf ("%d", digit / 5); \
|
|
|
|
else \
|
|
|
|
putc ('.'); \
|
|
|
|
digit--; \
|
|
|
|
dots += scale; \
|
|
|
|
} \
|
2008-03-09 03:48:01 +09:00
|
|
|
}
|
2008-03-19 15:09:26 +09:00
|
|
|
#else
|
|
|
|
#define FLASH_SHOW_PROGRESS(scale, dots, digit, dots_sub)
|
|
|
|
#endif
|
2008-03-09 03:48:01 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* Copy memory to flash, returns:
|
|
|
|
* 0 - OK
|
|
|
|
* 1 - write timeout
|
|
|
|
* 2 - Flash not erased
|
2004-02-09 07:55:38 +09:00
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
ulong wp;
|
2007-12-13 20:56:34 +09:00
|
|
|
uchar *p;
|
2007-10-07 01:55:36 +09:00
|
|
|
int aln;
|
2004-02-09 07:55:38 +09:00
|
|
|
cfiword_t cword;
|
2007-10-07 01:55:36 +09:00
|
|
|
int i, rc;
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_USE_BUFFER_WRITE
|
2007-10-07 01:55:36 +09:00
|
|
|
int buffered_size;
|
2004-02-09 07:55:38 +09:00
|
|
|
#endif
|
2008-03-09 03:48:01 +09:00
|
|
|
#ifdef CONFIG_FLASH_SHOW_PROGRESS
|
|
|
|
int digit = CONFIG_FLASH_SHOW_PROGRESS;
|
|
|
|
int scale = 0;
|
|
|
|
int dots = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Suppress if there are fewer than CONFIG_FLASH_SHOW_PROGRESS writes.
|
|
|
|
*/
|
|
|
|
if (cnt >= CONFIG_FLASH_SHOW_PROGRESS) {
|
|
|
|
scale = (int)((cnt + CONFIG_FLASH_SHOW_PROGRESS - 1) /
|
|
|
|
CONFIG_FLASH_SHOW_PROGRESS);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* get lower aligned address */
|
|
|
|
wp = (addr & ~(info->portwidth - 1));
|
2007-02-22 00:52:31 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* handle unaligned start */
|
|
|
|
if ((aln = addr - wp) != 0) {
|
|
|
|
cword.l = 0;
|
2009-02-03 07:34:51 +09:00
|
|
|
p = (uchar *)wp;
|
2007-12-13 20:56:34 +09:00
|
|
|
for (i = 0; i < aln; ++i)
|
|
|
|
flash_add_byte (info, &cword, flash_read8(p + i));
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
for (; (i < info->portwidth) && (cnt > 0); i++) {
|
|
|
|
flash_add_byte (info, &cword, *src++);
|
|
|
|
cnt--;
|
|
|
|
}
|
2007-12-13 20:56:34 +09:00
|
|
|
for (; (cnt == 0) && (i < info->portwidth); ++i)
|
|
|
|
flash_add_byte (info, &cword, flash_read8(p + i));
|
|
|
|
|
|
|
|
rc = flash_write_cfiword (info, wp, cword);
|
|
|
|
if (rc != 0)
|
2007-10-07 01:55:36 +09:00
|
|
|
return rc;
|
2007-12-13 20:56:34 +09:00
|
|
|
|
|
|
|
wp += i;
|
2008-03-19 15:09:26 +09:00
|
|
|
FLASH_SHOW_PROGRESS(scale, dots, digit, i);
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
|
|
|
|
|
|
|
/* handle the aligned part */
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_USE_BUFFER_WRITE
|
2007-10-07 01:55:36 +09:00
|
|
|
buffered_size = (info->portwidth / info->chipwidth);
|
|
|
|
buffered_size *= info->buffer_size;
|
|
|
|
while (cnt >= info->portwidth) {
|
|
|
|
/* prohibit buffer write when buffer_size is 1 */
|
|
|
|
if (info->buffer_size == 1) {
|
|
|
|
cword.l = 0;
|
|
|
|
for (i = 0; i < info->portwidth; i++)
|
|
|
|
flash_add_byte (info, &cword, *src++);
|
|
|
|
if ((rc = flash_write_cfiword (info, wp, cword)) != 0)
|
|
|
|
return rc;
|
|
|
|
wp += info->portwidth;
|
|
|
|
cnt -= info->portwidth;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* write buffer until next buffered_size aligned boundary */
|
|
|
|
i = buffered_size - (wp % buffered_size);
|
|
|
|
if (i > cnt)
|
|
|
|
i = cnt;
|
|
|
|
if ((rc = flash_write_cfibuffer (info, wp, src, i)) != ERR_OK)
|
|
|
|
return rc;
|
|
|
|
i -= i & (info->portwidth - 1);
|
|
|
|
wp += i;
|
|
|
|
src += i;
|
|
|
|
cnt -= i;
|
2008-03-19 15:09:26 +09:00
|
|
|
FLASH_SHOW_PROGRESS(scale, dots, digit, i);
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
while (cnt >= info->portwidth) {
|
|
|
|
cword.l = 0;
|
|
|
|
for (i = 0; i < info->portwidth; i++) {
|
|
|
|
flash_add_byte (info, &cword, *src++);
|
|
|
|
}
|
|
|
|
if ((rc = flash_write_cfiword (info, wp, cword)) != 0)
|
|
|
|
return rc;
|
|
|
|
wp += info->portwidth;
|
|
|
|
cnt -= info->portwidth;
|
2008-03-19 15:09:26 +09:00
|
|
|
FLASH_SHOW_PROGRESS(scale, dots, digit, info->portwidth);
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
2008-10-16 22:01:15 +09:00
|
|
|
#endif /* CONFIG_SYS_FLASH_USE_BUFFER_WRITE */
|
2008-03-09 03:48:01 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
if (cnt == 0) {
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* handle unaligned tail bytes
|
|
|
|
*/
|
|
|
|
cword.l = 0;
|
2009-02-03 07:34:51 +09:00
|
|
|
p = (uchar *)wp;
|
2007-12-13 20:56:34 +09:00
|
|
|
for (i = 0; (i < info->portwidth) && (cnt > 0); ++i) {
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_add_byte (info, &cword, *src++);
|
|
|
|
--cnt;
|
|
|
|
}
|
2007-12-13 20:56:34 +09:00
|
|
|
for (; i < info->portwidth; ++i)
|
|
|
|
flash_add_byte (info, &cword, flash_read8(p + i));
|
2007-10-07 01:55:36 +09:00
|
|
|
|
|
|
|
return flash_write_cfiword (info, wp, cword);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_PROTECTION
|
2007-10-07 01:55:36 +09:00
|
|
|
|
|
|
|
int flash_real_protect (flash_info_t * info, long sector, int prot)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
int retcode = 0;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2008-07-31 17:22:20 +09:00
|
|
|
switch (info->vendor) {
|
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
2008-08-20 14:21:16 +09:00
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
Work around bug in Numonyx P33/P30 256-Mbit 65nm flash chips.
I have "ported" U-boot to a in house made board with Numonyx Axcell P33/P30
256-Mbit 65nm flash chips.
After some time :( searching for bugs in our board or soft, we have
discovered that those chips have a small but annoying bug, documented in
"Numonyx Axcell P33/P30 256-Mbit Specification Update"
It states :
When customer uses [...] block unlock, the block lock status might be
altered inadvertently. Lock status might be set to either 01h or 03h
unexpectedly (00h as expected data), which leads to program/erase failure
on certain blocks.
A working workaround is given, which I have applied and tested with success :
Workaround: If the interval between 60h and its subsequent command
can be guaranteed within 20us, Option I is recommended,
otherwise Option II (involves hardware) should be selected.
Option I: The table below lists the detail command sequences:
Command
Data bus Address bus Remarks
Sequence
1 90h Block Address
Read Lock Status
2 Read Block Address + 02h
(2)(3) (1)
3 60h Block Address
(2)(3) (1) Lock/Unlock/RCR Configuration
4 D0h/01h/03h Block Address
Notes:
(1) Block Address refers to RCR configuration data only when the 60h
command sequence is used to set RCR register combined with 03h
subsequent command.
(2) For the third and fourth command sequences, the Block Address must
be the same.
(3) The interval between 60h command and its subsequent D0h/01h/2Fh/03h
commands should be less than 20us.
And here is a log comparison of a simple (destructive) flash test without
and with the workaround.
diff without-numonyx-workaround.log with-numonyx-workaround.log
-U-Boot 2010.06-00696-g22b002c-dirty (Aug 16 2010 - 15:07:47)
+U-Boot 2010.06-00696-g22b002c-dirty (Aug 16 2010 - 15:25:19)
CPU: Freescale MCF5484
CPU CLK 200 MHz BUS CLK 100 MHz
Board: Macq Electronique ME2060
I2C: ready
DRAM: 64 MiB
FLASH: 32 MiB
In: serial
Out: serial
Err: serial
Net: FEC0, FEC1
-> flinfo
Bank # 1: CFI conformant FLASH (16 x 16) Size: 32 MB in 259 Sectors
Intel Extended command set, Manufacturer ID: 0x89, Device ID: 0x8922
Erase timeout: 4096 ms, write timeout: 1 ms
Buffer write timeout: 5 ms, buffer size: 1024 bytes
Sector Start Addresses:
FE000000 RO FE008000 RO FE010000 RO FE018000 RO FE020000 RO
FE040000 RO FE060000 RO FE080000 RO FE0A0000 RO FE0C0000 RO
...
FFF80000 RO FFFA0000 RO FFFC0000 RO FFFE0000 RO
-> protect off all
Un-Protect Flash Bank # 1
................... done
-> erase all
Erase Flash Bank # 1
................... done
-> cp.b 1000000 fe000000 2000000
-Copy to Flash... Flash not Erased
+Copy to Flash... done
->
Signed-off-by: Philippe De Muyter <phdm@macqel.be>
Signed-off-by: Stefan Roese <sr@denx.de>
2010-08-18 01:40:25 +09:00
|
|
|
/*
|
|
|
|
* see errata called
|
|
|
|
* "Numonyx Axcell P33/P30 Specification Update" :)
|
|
|
|
*/
|
|
|
|
flash_write_cmd (info, sector, 0, FLASH_CMD_READ_ID);
|
|
|
|
if (!flash_isequal (info, sector, FLASH_OFFSET_PROTECT,
|
|
|
|
prot)) {
|
|
|
|
/*
|
|
|
|
* cmd must come before FLASH_CMD_PROTECT + 20us
|
|
|
|
* Disable interrupts which might cause a timeout here.
|
|
|
|
*/
|
|
|
|
int flag = disable_interrupts ();
|
|
|
|
unsigned short cmd;
|
|
|
|
|
|
|
|
if (prot)
|
|
|
|
cmd = FLASH_CMD_PROTECT_SET;
|
|
|
|
else
|
|
|
|
cmd = FLASH_CMD_PROTECT_CLEAR;
|
|
|
|
|
2008-07-31 17:22:20 +09:00
|
|
|
flash_write_cmd (info, sector, 0,
|
Work around bug in Numonyx P33/P30 256-Mbit 65nm flash chips.
I have "ported" U-boot to a in house made board with Numonyx Axcell P33/P30
256-Mbit 65nm flash chips.
After some time :( searching for bugs in our board or soft, we have
discovered that those chips have a small but annoying bug, documented in
"Numonyx Axcell P33/P30 256-Mbit Specification Update"
It states :
When customer uses [...] block unlock, the block lock status might be
altered inadvertently. Lock status might be set to either 01h or 03h
unexpectedly (00h as expected data), which leads to program/erase failure
on certain blocks.
A working workaround is given, which I have applied and tested with success :
Workaround: If the interval between 60h and its subsequent command
can be guaranteed within 20us, Option I is recommended,
otherwise Option II (involves hardware) should be selected.
Option I: The table below lists the detail command sequences:
Command
Data bus Address bus Remarks
Sequence
1 90h Block Address
Read Lock Status
2 Read Block Address + 02h
(2)(3) (1)
3 60h Block Address
(2)(3) (1) Lock/Unlock/RCR Configuration
4 D0h/01h/03h Block Address
Notes:
(1) Block Address refers to RCR configuration data only when the 60h
command sequence is used to set RCR register combined with 03h
subsequent command.
(2) For the third and fourth command sequences, the Block Address must
be the same.
(3) The interval between 60h command and its subsequent D0h/01h/2Fh/03h
commands should be less than 20us.
And here is a log comparison of a simple (destructive) flash test without
and with the workaround.
diff without-numonyx-workaround.log with-numonyx-workaround.log
-U-Boot 2010.06-00696-g22b002c-dirty (Aug 16 2010 - 15:07:47)
+U-Boot 2010.06-00696-g22b002c-dirty (Aug 16 2010 - 15:25:19)
CPU: Freescale MCF5484
CPU CLK 200 MHz BUS CLK 100 MHz
Board: Macq Electronique ME2060
I2C: ready
DRAM: 64 MiB
FLASH: 32 MiB
In: serial
Out: serial
Err: serial
Net: FEC0, FEC1
-> flinfo
Bank # 1: CFI conformant FLASH (16 x 16) Size: 32 MB in 259 Sectors
Intel Extended command set, Manufacturer ID: 0x89, Device ID: 0x8922
Erase timeout: 4096 ms, write timeout: 1 ms
Buffer write timeout: 5 ms, buffer size: 1024 bytes
Sector Start Addresses:
FE000000 RO FE008000 RO FE010000 RO FE018000 RO FE020000 RO
FE040000 RO FE060000 RO FE080000 RO FE0A0000 RO FE0C0000 RO
...
FFF80000 RO FFFA0000 RO FFFC0000 RO FFFE0000 RO
-> protect off all
Un-Protect Flash Bank # 1
................... done
-> erase all
Erase Flash Bank # 1
................... done
-> cp.b 1000000 fe000000 2000000
-Copy to Flash... Flash not Erased
+Copy to Flash... done
->
Signed-off-by: Philippe De Muyter <phdm@macqel.be>
Signed-off-by: Stefan Roese <sr@denx.de>
2010-08-18 01:40:25 +09:00
|
|
|
FLASH_CMD_PROTECT);
|
|
|
|
flash_write_cmd (info, sector, 0, cmd);
|
|
|
|
/* re-enable interrupts if necessary */
|
|
|
|
if (flag)
|
|
|
|
enable_interrupts ();
|
|
|
|
}
|
2008-07-31 17:22:20 +09:00
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
/* U-Boot only checks the first byte */
|
|
|
|
if (info->manufacturer_id == (uchar)ATM_MANUFACT) {
|
|
|
|
if (prot) {
|
|
|
|
flash_unlock_seq (info, 0);
|
|
|
|
flash_write_cmd (info, 0,
|
|
|
|
info->addr_unlock1,
|
|
|
|
ATM_CMD_SOFTLOCK_START);
|
|
|
|
flash_unlock_seq (info, 0);
|
|
|
|
flash_write_cmd (info, sector, 0,
|
|
|
|
ATM_CMD_LOCK_SECT);
|
|
|
|
} else {
|
|
|
|
flash_write_cmd (info, 0,
|
|
|
|
info->addr_unlock1,
|
|
|
|
AMD_CMD_UNLOCK_START);
|
|
|
|
if (info->device_id == ATM_ID_BV6416)
|
|
|
|
flash_write_cmd (info, sector,
|
|
|
|
0, ATM_CMD_UNLOCK_SECT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2008-08-20 01:53:39 +09:00
|
|
|
#ifdef CONFIG_FLASH_CFI_LEGACY
|
|
|
|
case CFI_CMDSET_AMD_LEGACY:
|
|
|
|
flash_write_cmd (info, sector, 0, FLASH_CMD_CLEAR_STATUS);
|
|
|
|
flash_write_cmd (info, sector, 0, FLASH_CMD_PROTECT);
|
|
|
|
if (prot)
|
|
|
|
flash_write_cmd (info, sector, 0, FLASH_CMD_PROTECT_SET);
|
|
|
|
else
|
|
|
|
flash_write_cmd (info, sector, 0, FLASH_CMD_PROTECT_CLEAR);
|
|
|
|
#endif
|
2008-07-31 17:22:20 +09:00
|
|
|
};
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
if ((retcode =
|
|
|
|
flash_full_status_check (info, sector, info->erase_blk_tout,
|
|
|
|
prot ? "protect" : "unprotect")) == 0) {
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
info->protect[sector] = prot;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On some of Intel's flash chips (marked via legacy_unlock)
|
|
|
|
* unprotect unprotects all locking.
|
|
|
|
*/
|
|
|
|
if ((prot == 0) && (info->legacy_unlock)) {
|
|
|
|
flash_sect_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < info->sector_count; i++) {
|
|
|
|
if (info->protect[i])
|
|
|
|
flash_real_protect (info, i, 1);
|
|
|
|
}
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
return retcode;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
2007-10-07 01:55:36 +09:00
|
|
|
* flash_read_user_serial - read the OneTimeProgramming cells
|
2004-02-09 07:55:38 +09:00
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
void flash_read_user_serial (flash_info_t * info, void *buffer, int offset,
|
|
|
|
int len)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
uchar *src;
|
|
|
|
uchar *dst;
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
dst = buffer;
|
2007-12-13 20:56:34 +09:00
|
|
|
src = flash_map (info, 0, FLASH_OFFSET_USER_PROTECTION);
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_write_cmd (info, 0, 0, FLASH_CMD_READ_ID);
|
|
|
|
memcpy (dst, src + offset, len);
|
|
|
|
flash_write_cmd (info, 0, 0, info->cmd_reset);
|
2007-12-13 20:56:34 +09:00
|
|
|
flash_unmap(info, 0, FLASH_OFFSET_USER_PROTECTION, src);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*
|
|
|
|
* flash_read_factory_serial - read the device Id from the protection area
|
2004-02-09 07:55:38 +09:00
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
void flash_read_factory_serial (flash_info_t * info, void *buffer, int offset,
|
|
|
|
int len)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
uchar *src;
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2007-12-13 20:56:34 +09:00
|
|
|
src = flash_map (info, 0, FLASH_OFFSET_INTEL_PROTECTION);
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_write_cmd (info, 0, 0, FLASH_CMD_READ_ID);
|
|
|
|
memcpy (buffer, src + offset, len);
|
|
|
|
flash_write_cmd (info, 0, 0, info->cmd_reset);
|
2007-12-13 20:56:34 +09:00
|
|
|
flash_unmap(info, 0, FLASH_OFFSET_INTEL_PROTECTION, src);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
#endif /* CONFIG_SYS_FLASH_PROTECTION */
|
2007-10-07 01:55:36 +09:00
|
|
|
|
2007-12-14 23:36:17 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* Reverse the order of the erase regions in the CFI QRY structure.
|
|
|
|
* This is needed for chips that are either a) correctly detected as
|
|
|
|
* top-boot, or b) buggy.
|
|
|
|
*/
|
|
|
|
static void cfi_reverse_geometry(struct cfi_qry *qry)
|
|
|
|
{
|
|
|
|
unsigned int i, j;
|
|
|
|
u32 tmp;
|
|
|
|
|
|
|
|
for (i = 0, j = qry->num_erase_regions - 1; i < j; i++, j--) {
|
|
|
|
tmp = qry->erase_region_info[i];
|
|
|
|
qry->erase_region_info[i] = qry->erase_region_info[j];
|
|
|
|
qry->erase_region_info[j] = tmp;
|
|
|
|
}
|
|
|
|
}
|
2007-10-07 01:55:36 +09:00
|
|
|
|
2006-11-13 21:55:24 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* read jedec ids from device and set corresponding fields in info struct
|
|
|
|
*
|
|
|
|
* Note: assume cfi->vendor, cfi->portwidth and cfi->chipwidth are correct
|
|
|
|
*
|
2007-12-14 23:36:17 +09:00
|
|
|
*/
|
|
|
|
static void cmdset_intel_read_jedec_ids(flash_info_t *info)
|
|
|
|
{
|
|
|
|
flash_write_cmd(info, 0, 0, FLASH_CMD_RESET);
|
|
|
|
flash_write_cmd(info, 0, 0, FLASH_CMD_READ_ID);
|
|
|
|
udelay(1000); /* some flash are slow to respond */
|
|
|
|
info->manufacturer_id = flash_read_uchar (info,
|
|
|
|
FLASH_OFFSET_MANUFACTURER_ID);
|
2010-08-10 23:54:52 +09:00
|
|
|
info->device_id = (info->chipwidth == FLASH_CFI_16BIT) ?
|
|
|
|
flash_read_word (info, FLASH_OFFSET_DEVICE_ID) :
|
|
|
|
flash_read_uchar (info, FLASH_OFFSET_DEVICE_ID);
|
2007-12-14 23:36:17 +09:00
|
|
|
flash_write_cmd(info, 0, 0, FLASH_CMD_RESET);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmdset_intel_init(flash_info_t *info, struct cfi_qry *qry)
|
|
|
|
{
|
|
|
|
info->cmd_reset = FLASH_CMD_RESET;
|
|
|
|
|
|
|
|
cmdset_intel_read_jedec_ids(info);
|
|
|
|
flash_write_cmd(info, 0, info->cfi_offset, FLASH_CMD_CFI);
|
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_PROTECTION
|
2007-12-14 23:36:17 +09:00
|
|
|
/* read legacy lock/unlock bit from intel flash */
|
|
|
|
if (info->ext_addr) {
|
|
|
|
info->legacy_unlock = flash_read_uchar (info,
|
|
|
|
info->ext_addr + 5) & 0x08;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void cmdset_amd_read_jedec_ids(flash_info_t *info)
|
|
|
|
{
|
2009-07-23 00:13:24 +09:00
|
|
|
ushort bankId = 0;
|
|
|
|
uchar manuId;
|
|
|
|
|
2007-12-14 23:36:17 +09:00
|
|
|
flash_write_cmd(info, 0, 0, AMD_CMD_RESET);
|
|
|
|
flash_unlock_seq(info, 0);
|
|
|
|
flash_write_cmd(info, 0, info->addr_unlock1, FLASH_CMD_READ_ID);
|
|
|
|
udelay(1000); /* some flash are slow to respond */
|
2008-03-28 19:29:10 +09:00
|
|
|
|
2009-07-23 00:13:24 +09:00
|
|
|
manuId = flash_read_uchar (info, FLASH_OFFSET_MANUFACTURER_ID);
|
|
|
|
/* JEDEC JEP106Z specifies ID codes up to bank 7 */
|
|
|
|
while (manuId == FLASH_CONTINUATION_CODE && bankId < 0x800) {
|
|
|
|
bankId += 0x100;
|
|
|
|
manuId = flash_read_uchar (info,
|
|
|
|
bankId | FLASH_OFFSET_MANUFACTURER_ID);
|
|
|
|
}
|
|
|
|
info->manufacturer_id = manuId;
|
2008-03-28 19:29:10 +09:00
|
|
|
|
|
|
|
switch (info->chipwidth){
|
|
|
|
case FLASH_CFI_8BIT:
|
|
|
|
info->device_id = flash_read_uchar (info,
|
|
|
|
FLASH_OFFSET_DEVICE_ID);
|
|
|
|
if (info->device_id == 0x7E) {
|
|
|
|
/* AMD 3-byte (expanded) device ids */
|
|
|
|
info->device_id2 = flash_read_uchar (info,
|
|
|
|
FLASH_OFFSET_DEVICE_ID2);
|
|
|
|
info->device_id2 <<= 8;
|
|
|
|
info->device_id2 |= flash_read_uchar (info,
|
|
|
|
FLASH_OFFSET_DEVICE_ID3);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case FLASH_CFI_16BIT:
|
|
|
|
info->device_id = flash_read_word (info,
|
|
|
|
FLASH_OFFSET_DEVICE_ID);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2007-12-14 23:36:17 +09:00
|
|
|
}
|
|
|
|
flash_write_cmd(info, 0, 0, AMD_CMD_RESET);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmdset_amd_init(flash_info_t *info, struct cfi_qry *qry)
|
|
|
|
{
|
|
|
|
info->cmd_reset = AMD_CMD_RESET;
|
|
|
|
|
|
|
|
cmdset_amd_read_jedec_ids(info);
|
|
|
|
flash_write_cmd(info, 0, info->cfi_offset, FLASH_CMD_CFI);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_FLASH_CFI_LEGACY
|
2006-11-13 21:55:24 +09:00
|
|
|
static void flash_read_jedec_ids (flash_info_t * info)
|
|
|
|
{
|
|
|
|
info->manufacturer_id = 0;
|
|
|
|
info->device_id = 0;
|
|
|
|
info->device_id2 = 0;
|
|
|
|
|
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2006-11-13 21:55:24 +09:00
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
2008-01-13 04:29:47 +09:00
|
|
|
cmdset_intel_read_jedec_ids(info);
|
2006-11-13 21:55:24 +09:00
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
2008-01-13 04:29:47 +09:00
|
|
|
cmdset_amd_read_jedec_ids(info);
|
2006-11-13 21:55:24 +09:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
2007-10-07 01:55:36 +09:00
|
|
|
* Call board code to request info about non-CFI flash.
|
|
|
|
* board_flash_get_legacy needs to fill in at least:
|
|
|
|
* info->portwidth, info->chipwidth and info->interface for Jedec probing.
|
2007-12-13 20:56:28 +09:00
|
|
|
*/
|
2009-02-03 07:34:51 +09:00
|
|
|
static int flash_detect_legacy(phys_addr_t base, int banknum)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_info_t *info = &flash_info[banknum];
|
2007-12-13 20:56:28 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
if (board_flash_get_legacy(base, banknum, info)) {
|
|
|
|
/* board code may have filled info completely. If not, we
|
|
|
|
use JEDEC ID probing. */
|
|
|
|
if (!info->vendor) {
|
|
|
|
int modes[] = {
|
|
|
|
CFI_CMDSET_AMD_STANDARD,
|
|
|
|
CFI_CMDSET_INTEL_STANDARD
|
|
|
|
};
|
|
|
|
int i;
|
2007-12-13 20:56:28 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
for (i = 0; i < sizeof(modes) / sizeof(modes[0]); i++) {
|
|
|
|
info->vendor = modes[i];
|
2009-02-03 07:34:51 +09:00
|
|
|
info->start[0] =
|
|
|
|
(ulong)map_physmem(base,
|
2009-02-05 19:44:52 +09:00
|
|
|
info->portwidth,
|
2009-02-03 07:34:51 +09:00
|
|
|
MAP_NOCACHE);
|
2007-10-07 01:55:36 +09:00
|
|
|
if (info->portwidth == FLASH_CFI_8BIT
|
|
|
|
&& info->interface == FLASH_CFI_X8X16) {
|
|
|
|
info->addr_unlock1 = 0x2AAA;
|
|
|
|
info->addr_unlock2 = 0x5555;
|
|
|
|
} else {
|
|
|
|
info->addr_unlock1 = 0x5555;
|
|
|
|
info->addr_unlock2 = 0x2AAA;
|
|
|
|
}
|
|
|
|
flash_read_jedec_ids(info);
|
|
|
|
debug("JEDEC PROBE: ID %x %x %x\n",
|
|
|
|
info->manufacturer_id,
|
|
|
|
info->device_id,
|
|
|
|
info->device_id2);
|
2009-02-03 07:34:51 +09:00
|
|
|
if (jedec_flash_match(info, info->start[0]))
|
2007-10-07 01:55:36 +09:00
|
|
|
break;
|
2009-02-03 07:34:51 +09:00
|
|
|
else
|
2009-02-05 19:44:52 +09:00
|
|
|
unmap_physmem((void *)info->start[0],
|
2009-02-03 07:34:51 +09:00
|
|
|
MAP_NOCACHE);
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2007-10-07 01:55:36 +09:00
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
|
|
|
info->cmd_reset = FLASH_CMD_RESET;
|
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
|
|
|
case CFI_CMDSET_AMD_LEGACY:
|
|
|
|
info->cmd_reset = AMD_CMD_RESET;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
info->flash_id = FLASH_MAN_CFI;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0; /* use CFI */
|
|
|
|
}
|
|
|
|
#else
|
2009-02-03 07:34:51 +09:00
|
|
|
static inline int flash_detect_legacy(phys_addr_t base, int banknum)
|
2007-10-07 01:55:36 +09:00
|
|
|
{
|
|
|
|
return 0; /* use CFI */
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
* detect if flash is compatible with the Common Flash Interface (CFI)
|
|
|
|
* http://www.jedec.org/download/search/jesd68.pdf
|
|
|
|
*/
|
2007-12-14 23:36:16 +09:00
|
|
|
static void flash_read_cfi (flash_info_t *info, void *buf,
|
|
|
|
unsigned int start, size_t len)
|
|
|
|
{
|
|
|
|
u8 *p = buf;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
p[i] = flash_read_uchar(info, start + i);
|
|
|
|
}
|
|
|
|
|
2009-10-27 23:15:55 +09:00
|
|
|
void __flash_cmd_reset(flash_info_t *info)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We do not yet know what kind of commandset to use, so we issue
|
|
|
|
* the reset command in both Intel and AMD variants, in the hope
|
|
|
|
* that AMD flash roms ignore the Intel command.
|
|
|
|
*/
|
|
|
|
flash_write_cmd(info, 0, 0, AMD_CMD_RESET);
|
|
|
|
flash_write_cmd(info, 0, 0, FLASH_CMD_RESET);
|
|
|
|
}
|
|
|
|
void flash_cmd_reset(flash_info_t *info)
|
|
|
|
__attribute__((weak,alias("__flash_cmd_reset")));
|
|
|
|
|
2007-12-14 23:36:16 +09:00
|
|
|
static int __flash_detect_cfi (flash_info_t * info, struct cfi_qry *qry)
|
2007-10-07 01:55:36 +09:00
|
|
|
{
|
|
|
|
int cfi_offset;
|
|
|
|
|
2009-10-27 23:15:55 +09:00
|
|
|
/* Issue FLASH reset command */
|
|
|
|
flash_cmd_reset(info);
|
2008-02-19 07:16:35 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
for (cfi_offset=0;
|
|
|
|
cfi_offset < sizeof(flash_offset_cfi) / sizeof(uint);
|
|
|
|
cfi_offset++) {
|
|
|
|
flash_write_cmd (info, 0, flash_offset_cfi[cfi_offset],
|
|
|
|
FLASH_CMD_CFI);
|
|
|
|
if (flash_isequal (info, 0, FLASH_OFFSET_CFI_RESP, 'Q')
|
|
|
|
&& flash_isequal (info, 0, FLASH_OFFSET_CFI_RESP + 1, 'R')
|
|
|
|
&& flash_isequal (info, 0, FLASH_OFFSET_CFI_RESP + 2, 'Y')) {
|
2007-12-14 23:36:16 +09:00
|
|
|
flash_read_cfi(info, qry, FLASH_OFFSET_CFI_RESP,
|
|
|
|
sizeof(struct cfi_qry));
|
|
|
|
info->interface = le16_to_cpu(qry->interface_desc);
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
info->cfi_offset = flash_offset_cfi[cfi_offset];
|
|
|
|
debug ("device interface is %d\n",
|
|
|
|
info->interface);
|
|
|
|
debug ("found port %d chip %d ",
|
|
|
|
info->portwidth, info->chipwidth);
|
|
|
|
debug ("port %d bits chip %d bits\n",
|
|
|
|
info->portwidth << CFI_FLASH_SHIFT_WIDTH,
|
|
|
|
info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
|
|
|
|
|
|
|
|
/* calculate command offsets as in the Linux driver */
|
|
|
|
info->addr_unlock1 = 0x555;
|
2007-12-13 20:56:28 +09:00
|
|
|
info->addr_unlock2 = 0x2aa;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* modify the unlock address if we are
|
|
|
|
* in compatibility mode
|
|
|
|
*/
|
|
|
|
if ( /* x8/x16 in x8 mode */
|
|
|
|
((info->chipwidth == FLASH_CFI_BY8) &&
|
|
|
|
(info->interface == FLASH_CFI_X8X16)) ||
|
|
|
|
/* x16/x32 in x16 mode */
|
|
|
|
((info->chipwidth == FLASH_CFI_BY16) &&
|
|
|
|
(info->interface == FLASH_CFI_X16X32)))
|
|
|
|
{
|
|
|
|
info->addr_unlock1 = 0xaaa;
|
|
|
|
info->addr_unlock2 = 0x555;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->name = "CFI conformant";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-14 23:36:16 +09:00
|
|
|
static int flash_detect_cfi (flash_info_t * info, struct cfi_qry *qry)
|
2007-12-13 20:56:28 +09:00
|
|
|
{
|
2004-02-12 09:47:09 +09:00
|
|
|
debug ("flash detect cfi\n");
|
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
for (info->portwidth = CONFIG_SYS_FLASH_CFI_WIDTH;
|
2004-02-12 09:47:09 +09:00
|
|
|
info->portwidth <= FLASH_CFI_64BIT; info->portwidth <<= 1) {
|
|
|
|
for (info->chipwidth = FLASH_CFI_BY8;
|
|
|
|
info->chipwidth <= info->portwidth;
|
2007-12-13 20:56:28 +09:00
|
|
|
info->chipwidth <<= 1)
|
2007-12-14 23:36:16 +09:00
|
|
|
if (__flash_detect_cfi(info, qry))
|
2007-12-13 20:56:28 +09:00
|
|
|
return 1;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2004-02-12 09:47:09 +09:00
|
|
|
debug ("not found\n");
|
2004-02-09 07:55:38 +09:00
|
|
|
return 0;
|
|
|
|
}
|
2004-02-12 09:47:09 +09:00
|
|
|
|
2007-12-14 23:36:18 +09:00
|
|
|
/*
|
|
|
|
* Manufacturer-specific quirks. Add workarounds for geometry
|
|
|
|
* reversal, etc. here.
|
|
|
|
*/
|
|
|
|
static void flash_fixup_amd(flash_info_t *info, struct cfi_qry *qry)
|
|
|
|
{
|
|
|
|
/* check if flash geometry needs reversal */
|
|
|
|
if (qry->num_erase_regions > 1) {
|
|
|
|
/* reverse geometry if top boot part */
|
|
|
|
if (info->cfi_version < 0x3131) {
|
|
|
|
/* CFI < 1.1, try to guess from device id */
|
|
|
|
if ((info->device_id & 0x80) != 0)
|
|
|
|
cfi_reverse_geometry(qry);
|
|
|
|
} else if (flash_read_uchar(info, info->ext_addr + 0xf) == 3) {
|
|
|
|
/* CFI >= 1.1, deduct from top/bottom flag */
|
|
|
|
/* note: ext_addr is valid since cfi_version > 0 */
|
|
|
|
cfi_reverse_geometry(qry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void flash_fixup_atmel(flash_info_t *info, struct cfi_qry *qry)
|
|
|
|
{
|
|
|
|
int reverse_geometry = 0;
|
|
|
|
|
|
|
|
/* Check the "top boot" bit in the PRI */
|
|
|
|
if (info->ext_addr && !(flash_read_uchar(info, info->ext_addr + 6) & 1))
|
|
|
|
reverse_geometry = 1;
|
|
|
|
|
|
|
|
/* AT49BV6416(T) list the erase regions in the wrong order.
|
|
|
|
* However, the device ID is identical with the non-broken
|
2009-03-28 07:26:43 +09:00
|
|
|
* AT49BV642D they differ in the high byte.
|
2007-12-14 23:36:18 +09:00
|
|
|
*/
|
|
|
|
if (info->device_id == 0xd6 || info->device_id == 0xd2)
|
|
|
|
reverse_geometry = !reverse_geometry;
|
|
|
|
|
|
|
|
if (reverse_geometry)
|
|
|
|
cfi_reverse_geometry(qry);
|
|
|
|
}
|
|
|
|
|
2009-01-14 22:44:26 +09:00
|
|
|
static void flash_fixup_stm(flash_info_t *info, struct cfi_qry *qry)
|
|
|
|
{
|
|
|
|
/* check if flash geometry needs reversal */
|
|
|
|
if (qry->num_erase_regions > 1) {
|
|
|
|
/* reverse geometry if top boot part */
|
|
|
|
if (info->cfi_version < 0x3131) {
|
2009-03-07 00:09:37 +09:00
|
|
|
/* CFI < 1.1, guess by device id (M29W320{DT,ET} only) */
|
|
|
|
if (info->device_id == 0x22CA ||
|
|
|
|
info->device_id == 0x2256) {
|
2009-01-14 22:44:26 +09:00
|
|
|
cfi_reverse_geometry(qry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*
|
|
|
|
* The following code cannot be run from FLASH!
|
|
|
|
*
|
|
|
|
*/
|
2009-02-03 07:34:51 +09:00
|
|
|
ulong flash_get_size (phys_addr_t base, int banknum)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2004-02-12 09:47:09 +09:00
|
|
|
flash_info_t *info = &flash_info[banknum];
|
2004-02-09 07:55:38 +09:00
|
|
|
int i, j;
|
|
|
|
flash_sect_t sect_cnt;
|
2009-02-03 07:34:51 +09:00
|
|
|
phys_addr_t sector;
|
2004-02-09 07:55:38 +09:00
|
|
|
unsigned long tmp;
|
|
|
|
int size_ratio;
|
|
|
|
uchar num_erase_regions;
|
2004-02-12 09:47:09 +09:00
|
|
|
int erase_region_size;
|
|
|
|
int erase_region_count;
|
2007-12-14 23:36:16 +09:00
|
|
|
struct cfi_qry qry;
|
2006-11-13 21:55:24 +09:00
|
|
|
|
2008-05-16 05:13:08 +09:00
|
|
|
memset(&qry, 0, sizeof(qry));
|
|
|
|
|
2006-11-13 21:55:24 +09:00
|
|
|
info->ext_addr = 0;
|
|
|
|
info->cfi_version = 0;
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_PROTECTION
|
2006-04-01 20:41:03 +09:00
|
|
|
info->legacy_unlock = 0;
|
|
|
|
#endif
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2009-02-03 07:34:51 +09:00
|
|
|
info->start[0] = (ulong)map_physmem(base, info->portwidth, MAP_NOCACHE);
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-12-14 23:36:16 +09:00
|
|
|
if (flash_detect_cfi (info, &qry)) {
|
|
|
|
info->vendor = le16_to_cpu(qry.p_id);
|
|
|
|
info->ext_addr = le16_to_cpu(qry.p_adr);
|
|
|
|
num_erase_regions = qry.num_erase_regions;
|
|
|
|
|
2006-11-13 21:55:24 +09:00
|
|
|
if (info->ext_addr) {
|
|
|
|
info->cfi_version = (ushort) flash_read_uchar (info,
|
|
|
|
info->ext_addr + 3) << 8;
|
|
|
|
info->cfi_version |= (ushort) flash_read_uchar (info,
|
|
|
|
info->ext_addr + 4);
|
|
|
|
}
|
2007-12-14 23:36:17 +09:00
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
#ifdef DEBUG
|
2007-12-14 23:36:16 +09:00
|
|
|
flash_printqry (&qry);
|
2004-02-12 09:47:09 +09:00
|
|
|
#endif
|
2007-12-14 23:36:17 +09:00
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2004-02-09 07:55:38 +09:00
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
2007-12-14 23:36:17 +09:00
|
|
|
cmdset_intel_init(info, &qry);
|
2004-02-09 07:55:38 +09:00
|
|
|
break;
|
|
|
|
case CFI_CMDSET_AMD_STANDARD:
|
|
|
|
case CFI_CMDSET_AMD_EXTENDED:
|
2007-12-14 23:36:17 +09:00
|
|
|
cmdset_amd_init(info, &qry);
|
2004-02-09 07:55:38 +09:00
|
|
|
break;
|
2007-12-14 23:36:17 +09:00
|
|
|
default:
|
|
|
|
printf("CFI: Unknown command set 0x%x\n",
|
|
|
|
info->vendor);
|
|
|
|
/*
|
|
|
|
* Unfortunately, this means we don't know how
|
|
|
|
* to get the chip back to Read mode. Might
|
|
|
|
* as well try an Intel-style reset...
|
|
|
|
*/
|
|
|
|
flash_write_cmd(info, 0, 0, FLASH_CMD_RESET);
|
|
|
|
return 0;
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
2004-02-10 09:03:41 +09:00
|
|
|
|
2007-12-14 23:36:18 +09:00
|
|
|
/* Do manufacturer-specific fixups */
|
|
|
|
switch (info->manufacturer_id) {
|
|
|
|
case 0x0001:
|
|
|
|
flash_fixup_amd(info, &qry);
|
|
|
|
break;
|
|
|
|
case 0x001f:
|
|
|
|
flash_fixup_atmel(info, &qry);
|
|
|
|
break;
|
2009-01-14 22:44:26 +09:00
|
|
|
case 0x0020:
|
|
|
|
flash_fixup_stm(info, &qry);
|
|
|
|
break;
|
2007-12-14 23:36:18 +09:00
|
|
|
}
|
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
debug ("manufacturer is %d\n", info->vendor);
|
2006-11-13 21:55:24 +09:00
|
|
|
debug ("manufacturer id is 0x%x\n", info->manufacturer_id);
|
|
|
|
debug ("device id is 0x%x\n", info->device_id);
|
|
|
|
debug ("device id2 is 0x%x\n", info->device_id2);
|
|
|
|
debug ("cfi version is 0x%04x\n", info->cfi_version);
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
size_ratio = info->portwidth / info->chipwidth;
|
2004-02-12 09:47:09 +09:00
|
|
|
/* if the chip is x8/x16 reduce the ratio by half */
|
|
|
|
if ((info->interface == FLASH_CFI_X8X16)
|
|
|
|
&& (info->chipwidth == FLASH_CFI_BY8)) {
|
|
|
|
size_ratio >>= 1;
|
|
|
|
}
|
|
|
|
debug ("size_ratio %d port %d bits chip %d bits\n",
|
|
|
|
size_ratio, info->portwidth << CFI_FLASH_SHIFT_WIDTH,
|
|
|
|
info->chipwidth << CFI_FLASH_SHIFT_WIDTH);
|
|
|
|
debug ("found %d erase regions\n", num_erase_regions);
|
2004-02-09 07:55:38 +09:00
|
|
|
sect_cnt = 0;
|
|
|
|
sector = base;
|
2004-02-12 09:47:09 +09:00
|
|
|
for (i = 0; i < num_erase_regions; i++) {
|
|
|
|
if (i > NUM_ERASE_REGIONS) {
|
2004-02-24 08:54:43 +09:00
|
|
|
printf ("%d erase regions found, only %d used\n",
|
|
|
|
num_erase_regions, NUM_ERASE_REGIONS);
|
2004-02-09 07:55:38 +09:00
|
|
|
break;
|
|
|
|
}
|
2007-12-14 23:36:16 +09:00
|
|
|
|
2007-12-14 23:36:17 +09:00
|
|
|
tmp = le32_to_cpu(qry.erase_region_info[i]);
|
|
|
|
debug("erase region %u: 0x%08lx\n", i, tmp);
|
2007-12-14 23:36:16 +09:00
|
|
|
|
|
|
|
erase_region_count = (tmp & 0xffff) + 1;
|
|
|
|
tmp >>= 16;
|
2004-02-12 09:47:09 +09:00
|
|
|
erase_region_size =
|
|
|
|
(tmp & 0xffff) ? ((tmp & 0xffff) * 256) : 128;
|
2004-06-10 02:34:58 +09:00
|
|
|
debug ("erase_region_count = %d erase_region_size = %d\n",
|
2004-02-24 08:54:43 +09:00
|
|
|
erase_region_count, erase_region_size);
|
2004-02-12 09:47:09 +09:00
|
|
|
for (j = 0; j < erase_region_count; j++) {
|
2008-10-16 22:01:15 +09:00
|
|
|
if (sect_cnt >= CONFIG_SYS_MAX_FLASH_SECT) {
|
2007-12-08 07:35:02 +09:00
|
|
|
printf("ERROR: too many flash sectors\n");
|
|
|
|
break;
|
|
|
|
}
|
2009-02-03 07:34:51 +09:00
|
|
|
info->start[sect_cnt] =
|
|
|
|
(ulong)map_physmem(sector,
|
|
|
|
info->portwidth,
|
|
|
|
MAP_NOCACHE);
|
2004-02-09 07:55:38 +09:00
|
|
|
sector += (erase_region_size * size_ratio);
|
2005-01-10 02:12:27 +09:00
|
|
|
|
|
|
|
/*
|
2007-12-13 20:56:28 +09:00
|
|
|
* Only read protection status from
|
|
|
|
* supported devices (intel...)
|
2005-01-10 02:12:27 +09:00
|
|
|
*/
|
|
|
|
switch (info->vendor) {
|
2008-05-08 02:25:33 +09:00
|
|
|
case CFI_CMDSET_INTEL_PROG_REGIONS:
|
2005-01-10 02:12:27 +09:00
|
|
|
case CFI_CMDSET_INTEL_EXTENDED:
|
|
|
|
case CFI_CMDSET_INTEL_STANDARD:
|
|
|
|
info->protect[sect_cnt] =
|
|
|
|
flash_isset (info, sect_cnt,
|
|
|
|
FLASH_OFFSET_PROTECT,
|
|
|
|
FLASH_STATUS_PROTECT);
|
|
|
|
break;
|
|
|
|
default:
|
2007-12-13 20:56:28 +09:00
|
|
|
/* default: not protected */
|
|
|
|
info->protect[sect_cnt] = 0;
|
2005-01-10 02:12:27 +09:00
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
sect_cnt++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
info->sector_count = sect_cnt;
|
2007-12-14 23:36:16 +09:00
|
|
|
info->size = 1 << qry.dev_size;
|
2004-02-09 07:55:38 +09:00
|
|
|
/* multiply the size by the number of chips */
|
2007-12-13 20:56:28 +09:00
|
|
|
info->size *= size_ratio;
|
2007-12-14 23:36:16 +09:00
|
|
|
info->buffer_size = 1 << le16_to_cpu(qry.max_buf_write_size);
|
|
|
|
tmp = 1 << qry.block_erase_timeout_typ;
|
2007-12-13 20:56:28 +09:00
|
|
|
info->erase_blk_tout = tmp *
|
2007-12-14 23:36:16 +09:00
|
|
|
(1 << qry.block_erase_timeout_max);
|
|
|
|
tmp = (1 << qry.buf_write_timeout_typ) *
|
|
|
|
(1 << qry.buf_write_timeout_max);
|
|
|
|
|
2007-12-13 20:56:28 +09:00
|
|
|
/* round up when converting to ms */
|
2007-12-14 23:36:16 +09:00
|
|
|
info->buffer_write_tout = (tmp + 999) / 1000;
|
|
|
|
tmp = (1 << qry.word_write_timeout_typ) *
|
|
|
|
(1 << qry.word_write_timeout_max);
|
2007-12-13 20:56:28 +09:00
|
|
|
/* round up when converting to ms */
|
2007-12-14 23:36:16 +09:00
|
|
|
info->write_tout = (tmp + 999) / 1000;
|
2004-02-09 07:55:38 +09:00
|
|
|
info->flash_id = FLASH_MAN_CFI;
|
2007-12-13 20:56:28 +09:00
|
|
|
if ((info->interface == FLASH_CFI_X8X16) &&
|
|
|
|
(info->chipwidth == FLASH_CFI_BY8)) {
|
|
|
|
/* XXX - Need to test on x8/x16 in parallel. */
|
|
|
|
info->portwidth >>= 1;
|
2004-03-15 03:23:55 +09:00
|
|
|
}
|
2008-10-02 14:55:38 +09:00
|
|
|
|
|
|
|
flash_write_cmd (info, 0, 0, info->cmd_reset);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2004-02-12 09:47:09 +09:00
|
|
|
return (info->size);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|
|
|
|
|
2008-11-17 23:49:32 +09:00
|
|
|
void flash_set_verbose(uint v)
|
|
|
|
{
|
|
|
|
flash_verbose = v;
|
|
|
|
}
|
|
|
|
|
2004-02-09 07:55:38 +09:00
|
|
|
/*-----------------------------------------------------------------------
|
|
|
|
*/
|
2007-10-07 01:55:36 +09:00
|
|
|
unsigned long flash_init (void)
|
2004-02-09 07:55:38 +09:00
|
|
|
{
|
2007-10-07 01:55:36 +09:00
|
|
|
unsigned long size = 0;
|
|
|
|
int i;
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(CONFIG_SYS_FLASH_AUTOPROTECT_LIST)
|
2008-04-18 23:29:40 +09:00
|
|
|
struct apl_s {
|
|
|
|
ulong start;
|
|
|
|
ulong size;
|
2008-10-16 22:01:15 +09:00
|
|
|
} apl[] = CONFIG_SYS_FLASH_AUTOPROTECT_LIST;
|
2008-04-18 23:29:40 +09:00
|
|
|
#endif
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_PROTECTION
|
2009-03-21 22:59:34 +09:00
|
|
|
/* read environment from EEPROM */
|
|
|
|
char s[64];
|
Rename getenv_r() into getenv_f()
While running from flash, i. e. before relocation, we have only a
limited C runtime environment without writable data segment. In this
phase, some configurations (for example with environment in EEPROM)
must not use the normal getenv(), but a special function. This
function had been called getenv_r(), with the idea that the "_r"
suffix would mean the same as in the _r_eentrant versions of some of
the C library functions (for example getdate vs. getdate_r, getgrent
vs. getgrent_r, etc.).
Unfortunately this was a misleading name, as in U-Boot the "_r"
generally means "running from RAM", i. e. _after_ relocation.
To avoid confusion, rename into getenv_f() [as "running from flash"]
Signed-off-by: Wolfgang Denk <wd@denx.de>
Acked-by: Detlev Zundel <dzu@denx.de>
2010-07-25 04:55:43 +09:00
|
|
|
getenv_f("unlock", s, sizeof(s));
|
2007-12-08 07:35:02 +09:00
|
|
|
#endif
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* Init: no FLASHes known */
|
2008-10-16 22:01:15 +09:00
|
|
|
for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_info[i].flash_id = FLASH_UNKNOWN;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2010-08-30 17:11:51 +09:00
|
|
|
if (!flash_detect_legacy(cfi_flash_bank_addr(i), i))
|
|
|
|
flash_get_size(cfi_flash_bank_addr(i), i);
|
2007-10-07 01:55:36 +09:00
|
|
|
size += flash_info[i].size;
|
|
|
|
if (flash_info[i].flash_id == FLASH_UNKNOWN) {
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifndef CONFIG_SYS_FLASH_QUIET_TEST
|
2007-10-07 01:55:36 +09:00
|
|
|
printf ("## Unknown FLASH on Bank %d "
|
|
|
|
"- Size = 0x%08lx = %ld MB\n",
|
|
|
|
i+1, flash_info[i].size,
|
2010-09-30 03:49:05 +09:00
|
|
|
flash_info[i].size >> 20);
|
2008-10-16 22:01:15 +09:00
|
|
|
#endif /* CONFIG_SYS_FLASH_QUIET_TEST */
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
2008-10-16 22:01:15 +09:00
|
|
|
#ifdef CONFIG_SYS_FLASH_PROTECTION
|
2007-10-07 01:55:36 +09:00
|
|
|
else if ((s != NULL) && (strcmp(s, "yes") == 0)) {
|
|
|
|
/*
|
|
|
|
* Only the U-Boot image and it's environment
|
|
|
|
* is protected, all other sectors are
|
|
|
|
* unprotected (unlocked) if flash hardware
|
2008-10-16 22:01:15 +09:00
|
|
|
* protection is used (CONFIG_SYS_FLASH_PROTECTION)
|
2007-10-07 01:55:36 +09:00
|
|
|
* and the environment variable "unlock" is
|
|
|
|
* set to "yes".
|
|
|
|
*/
|
|
|
|
if (flash_info[i].legacy_unlock) {
|
|
|
|
int k;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*
|
|
|
|
* Disable legacy_unlock temporarily,
|
|
|
|
* since flash_real_protect would
|
|
|
|
* relock all other sectors again
|
|
|
|
* otherwise.
|
|
|
|
*/
|
|
|
|
flash_info[i].legacy_unlock = 0;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*
|
|
|
|
* Legacy unlocking (e.g. Intel J3) ->
|
|
|
|
* unlock only one sector. This will
|
|
|
|
* unlock all sectors.
|
|
|
|
*/
|
|
|
|
flash_real_protect (&flash_info[i], 0, 0);
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_info[i].legacy_unlock = 1;
|
2004-02-09 07:55:38 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/*
|
|
|
|
* Manually mark other sectors as
|
|
|
|
* unlocked (unprotected)
|
|
|
|
*/
|
|
|
|
for (k = 1; k < flash_info[i].sector_count; k++)
|
|
|
|
flash_info[i].protect[k] = 0;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* No legancy unlocking -> unlock all sectors
|
|
|
|
*/
|
|
|
|
flash_protect (FLAG_PROTECT_CLEAR,
|
|
|
|
flash_info[i].start[0],
|
|
|
|
flash_info[i].start[0]
|
|
|
|
+ flash_info[i].size - 1,
|
|
|
|
&flash_info[i]);
|
2006-02-28 23:29:58 +09:00
|
|
|
}
|
|
|
|
}
|
2008-10-16 22:01:15 +09:00
|
|
|
#endif /* CONFIG_SYS_FLASH_PROTECTION */
|
2007-10-07 01:55:36 +09:00
|
|
|
}
|
2006-02-28 23:29:58 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* Monitor protection ON by default */
|
2010-03-02 18:59:19 +09:00
|
|
|
#if (CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH_BASE) && \
|
|
|
|
(!defined(CONFIG_MONITOR_IS_IN_RAM))
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_protect (FLAG_PROTECT_SET,
|
2008-10-16 22:01:15 +09:00
|
|
|
CONFIG_SYS_MONITOR_BASE,
|
|
|
|
CONFIG_SYS_MONITOR_BASE + monitor_flash_len - 1,
|
|
|
|
flash_get_info(CONFIG_SYS_MONITOR_BASE));
|
2007-10-07 01:55:36 +09:00
|
|
|
#endif
|
2006-02-28 23:29:58 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* Environment protection ON by default */
|
2008-09-11 05:48:04 +09:00
|
|
|
#ifdef CONFIG_ENV_IS_IN_FLASH
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_protect (FLAG_PROTECT_SET,
|
2008-09-11 05:48:06 +09:00
|
|
|
CONFIG_ENV_ADDR,
|
|
|
|
CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1,
|
|
|
|
flash_get_info(CONFIG_ENV_ADDR));
|
2007-10-07 01:55:36 +09:00
|
|
|
#endif
|
2006-02-28 23:29:58 +09:00
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
/* Redundant environment protection ON by default */
|
2008-09-11 05:48:06 +09:00
|
|
|
#ifdef CONFIG_ENV_ADDR_REDUND
|
2007-10-07 01:55:36 +09:00
|
|
|
flash_protect (FLAG_PROTECT_SET,
|
2008-09-11 05:48:06 +09:00
|
|
|
CONFIG_ENV_ADDR_REDUND,
|
Redundant Environment: protect full sector size
Several boards used different ways to specify the size of the
protected area when enabling flash write protection for the sectors
holding the environment variables: some used CONFIG_ENV_SIZE and
CONFIG_ENV_SIZE_REDUND, some used CONFIG_ENV_SECT_SIZE, and some even
a mix of both for the "normal" and the "redundant" areas.
Normally, this makes no difference at all. However, things are
different when you have to deal with boards that can come with
different types of flash chips, which may have different sector
sizes.
Here we may have to chose CONFIG_ENV_SECT_SIZE such that it fits the
biggest sector size, which may include several sectors on boards using
the smaller sector flash types. In such a case, using CONFIG_ENV_SIZE
or CONFIG_ENV_SIZE_REDUND to enable the protection may lead to the
case that only the first of these sectors get protected, while the
following ones aren't.
This is no real problem, but it can be confusing for the user -
especially on boards that use CONFIG_ENV_SECT_SIZE to protect the
"normal" areas, while using CONFIG_ENV_SIZE_REDUND for the
"redundant" area.
To avoid such inconsistencies, I changed all sucn boards that I found
to consistently use CONFIG_ENV_SECT_SIZE for protection. This should
not cause any functional changes to the code.
Signed-off-by: Wolfgang Denk <wd@denx.de>
Cc: Paul Ruhland
Cc: Pantelis Antoniou <panto@intracom.gr>
Cc: Stefan Roese <sr@denx.de>
Cc: Gary Jennejohn <garyj@denx.de>
Cc: Dave Ellis <DGE@sixnetio.com>
Acked-by: Stefan Roese <sr@denx.de>
2009-05-15 07:16:03 +09:00
|
|
|
CONFIG_ENV_ADDR_REDUND + CONFIG_ENV_SECT_SIZE - 1,
|
2008-09-11 05:48:06 +09:00
|
|
|
flash_get_info(CONFIG_ENV_ADDR_REDUND));
|
2007-10-07 01:55:36 +09:00
|
|
|
#endif
|
2008-04-18 23:29:40 +09:00
|
|
|
|
2008-10-16 22:01:15 +09:00
|
|
|
#if defined(CONFIG_SYS_FLASH_AUTOPROTECT_LIST)
|
2008-04-18 23:29:40 +09:00
|
|
|
for (i = 0; i < (sizeof(apl) / sizeof(struct apl_s)); i++) {
|
|
|
|
debug("autoprotecting from %08x to %08x\n",
|
|
|
|
apl[i].start, apl[i].start + apl[i].size - 1);
|
|
|
|
flash_protect (FLAG_PROTECT_SET,
|
|
|
|
apl[i].start,
|
|
|
|
apl[i].start + apl[i].size - 1,
|
|
|
|
flash_get_info(apl[i].start));
|
|
|
|
}
|
|
|
|
#endif
|
2008-11-17 23:57:58 +09:00
|
|
|
|
|
|
|
#ifdef CONFIG_FLASH_CFI_MTD
|
|
|
|
cfi_mtd_init();
|
|
|
|
#endif
|
|
|
|
|
2007-10-07 01:55:36 +09:00
|
|
|
return (size);
|
2004-02-09 07:55:38 +09:00
|
|
|
}
|