OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /openrisc/trunk/rtos/ecos-2.0/packages/devs/flash/amd
    from Rev 27 to Rev 174
    ↔ Reverse comparison
  •

Rev 27 → Rev 174

/am29xxxxx/v2_0/cdl/flash_amd_am29xxxxx.cdl
0,0 → 1,199
# ====================================================================
#
# flash_amd_am29xxxxx.cdl
#
# FLASH memory - Hardware support for AMD AM29xxxxx parts
#
# ====================================================================
#####ECOSGPLCOPYRIGHTBEGIN####
## -------------------------------------------
## This file is part of eCos, the Embedded Configurable Operating System.
## Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
## Copyright (C) 2002 Gary Thomas
##
## eCos 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 or (at your option) any later version.
##
## eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
##
## As a special exception, if other files instantiate templates or use macros
## or inline functions from this file, or you compile this file and link it
## with other works to produce a work based on this file, this file does not
## by itself cause the resulting work to be covered by the GNU General Public
## License. However the source code for this file must still be made available
## in accordance with section (3) of the GNU General Public License.
##
## This exception does not invalidate any other reasons why a work based on
## this file might be covered by the GNU General Public License.
##
## Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
## at http://sources.redhat.com/ecos/ecos-license/
## -------------------------------------------
#####ECOSGPLCOPYRIGHTEND####
# ====================================================================
######DESCRIPTIONBEGIN####
#
# Author(s): gthomas
# Contributors: gthomas, jskov, Koichi Nagashima
# Date: 2001-02-20
#
#####DESCRIPTIONEND####
#
# ====================================================================
 
cdl_package CYGPKG_DEVS_FLASH_AMD_AM29XXXXX {
display "AMD AM29XXXXX FLASH memory support"
description "FLASH memory device support for AMD AM29XXXXX"
parent CYGPKG_IO_FLASH
active_if CYGPKG_IO_FLASH
 
active_if CYGINT_DEVS_FLASH_AMD_AM29XXXXX_REQUIRED
 
implements CYGHWR_IO_FLASH_DEVICE
 
include_dir cyg/io
 
requires { CYGINT_DEVS_FLASH_AMD_VARIANTS != 0 }
 
cdl_interface CYGINT_DEVS_FLASH_AMD_VARIANTS {
display "Number of included variants"
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29F040B {
display "AMD AM29F040B flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AMD29F040B
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV160 {
display "AMD AM29LV160 flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AMD29LV160
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV320D {
display "AMD AM29LV320 flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AMD29LV320
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV200 {
display "AMD AM29LV200 flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AMD29LV200
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_ST_M29W200B {
display "ST M29W200B flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the ST M29W200B part. This
memory device is pin- and software compatible with the
AMD AM29LV200 device."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV640 {
display "AMD AM29LV640 flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AMD29LV640
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL322D {
display "AMD AM29DL322D flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AM29DL322D
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL323D {
display "AMD AM29DL323D flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AM29DL323D
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL324D {
display "AMD AM29DL324D flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AM29DL324D
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29DL640D {
display "AMD AM29DL640D flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AM29DL640D
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29F800 {
display "AMD AM29F800 flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AM29F800
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_AM29LV800 {
display "AMD AM29LV800 flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the AM29LV800
part in the family."
}
 
cdl_option CYGHWR_DEVS_FLASH_AMD_TC58FVB800 {
display "Toshiba TC58FVB800 flash memory support"
default_value 0
implements CYGINT_DEVS_FLASH_AMD_VARIANTS
description "
When this option is enabled, the AMD flash driver will be
able to recognize and handle the Toshiba TC58FVB800."
}
}
/am29xxxxx/v2_0/include/flash_am29xxxxx_parts.inl
0,0 → 1,903
#ifndef CYGONCE_DEVS_FLASH_AMD_AM29XXXXX_PARTS_INL
#define CYGONCE_DEVS_FLASH_AMD_AM29XXXXX_PARTS_INL
//==========================================================================
//
// am29xxxxx_parts.inl
//
// AMD AM29xxxxx part descriptors
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
// Copyright (C) 2002 Gary Thomas
//
// eCos 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 or (at your option) any later version.
//
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): jskov
// Contributors: jskov, Koichi Nagashima
// Date: 2001-06-08
// Purpose:
// Description: AMD AM29xxxxx part descriptors
// Usage: Should be included from the flash_am29xxxxx.inl file only.
//
// FIXME: Add configury for selecting bottom/top bootblocks
//####DESCRIPTIONEND####
//
//==========================================================================
 
//
// Note: 'bootblocks' are a set of blocks which are treated by
// the driver as a single larger block. This simplifies the driver
// so as to only have to deal with single size blocks (even though
// the physical device may differ). The data structure is laid out as:
// <address of start of boot block area 1>
// <size of sub-block 1>
// <size of sub-block 2>
// ...
// <size of sub-block n>
// <address of start of boot block area 2>
// <size of sub-block 1>
// <size of sub-block 2>
// ...
// <size of sub-block n>
// _LAST_BOOTBLOCK
//
// Finally, when specifying a device with bootblocks, the total number
// of blocks should reflect this collapse, i.e. if the device has 15
// full size blocks and 8 blocks which are 1/8 each, then the total
// should be 16 blocks.
//
#define _LAST_BOOTBLOCK (-1)
 
#if CYGNUM_FLASH_WIDTH == 8
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29F040B
{ // AM29F040B
device_id : FLASHWORD(0xa4),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 8,
device_size: 0x80000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x80000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : false,
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV160
{ // MBM29LV160-T | AM29LV160-T
device_id : FLASHWORD(0xc4),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 32,
device_size: 0x200000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x200000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x1f0000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // MBM29LV160-B | AM29LV160-B
device_id : FLASHWORD(0x49),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 32,
device_size: 0x200000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x200000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV200
{ // AM29LV200-T
device_id : FLASHWORD(0x3b),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 4,
device_size: 0x40000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x40000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x030000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29LV200-B
device_id : FLASHWORD(0xbf),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 4,
device_size: 0x40000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x40000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV320D
{ // AM29LV320DT
device_id : FLASHWORD(0xF6),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29LV320D
device_id : FLASHWORD(0xF9),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL322D
{ // AM29DL322D-T
device_id : FLASHWORD(0x55),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x380000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
{ // AM29DL322D-B
device_id : FLASHWORD(0x56),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x80000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL323D
{ // AM29DL323D-T
device_id : FLASHWORD(0x50),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x300000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
{ // AM29DL323D-B
device_id : FLASHWORD(0x53),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x100000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL324D
{ // AM29DL324D-T
device_id : FLASHWORD(0x5c),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x200000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
{ // AM29DL324D-B
device_id : FLASHWORD(0x5f),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x200000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL640D
{ // AM29DL640D
long_device_id: true,
device_id : FLASHWORD(0x7e),
device_id2 : FLASHWORD(0x02),
device_id3 : FLASHWORD(0x01),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 128,
device_size: 0x0800000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x8000000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x7F0000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x0700000 * CYGNUM_FLASH_INTERLEAVE,
0x0400000 * CYGNUM_FLASH_INTERLEAVE,
0x0100000 * CYGNUM_FLASH_INTERLEAVE,
0
}
}
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29F800
{ // AM29F800-T
device_id : FLASHWORD(0xd6),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0xf0000 * CYGNUM_FLASH_INTERLEAVE,
0x08000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x04000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29F800-B
device_id : FLASHWORD(0x58),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV800
{ // AM29LV800-T
device_id : FLASHWORD(0xda),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0xf0000 * CYGNUM_FLASH_INTERLEAVE,
0x08000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x04000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29LV800-B
device_id : FLASHWORD(0x5b),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_TC58FVB800
{ // Toshiba TC58FVB800 (compatible with AM29LV800-B except for IDs.)
device_id : FLASHWORD(0xCE),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
 
#else // 16 bit devices
 
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV160
{ // MBM29LV160-T | AM29LV160-T
device_id : FLASHWORD(0x22c4),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 32,
device_size: 0x200000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x200000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x1f0000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // MBM29LV160-B | AM29LV160-B
device_id : FLASHWORD(0x2249),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 32,
device_size: 0x200000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x200000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV200
{ // AM29LV200-T
device_id : FLASHWORD(0x223b),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 4,
device_size: 0x40000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x40000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x030000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29LV200-B
device_id : FLASHWORD(0x22bf),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 4,
device_size: 0x40000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x40000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_ST_M29W200B
{ // ST M29W200BT
device_id : FLASHWORD(0x0051),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 4,
device_size: 0x40000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x40000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x030000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // ST M29W200BB
device_id : FLASHWORD(0x0057),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 4,
device_size: 0x40000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x40000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV320D
{ // AM29LV320DT
device_id : FLASHWORD(0x22F6),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29LV320D
device_id : FLASHWORD(0x22F9),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL322D
{ // AM29DL322D-T
device_id : FLASHWORD(0x2255),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x380000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
{ // AM29DL322D-B
device_id : FLASHWORD(0x2256),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x80000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL323D
{ // AM29DL323D-T
device_id : FLASHWORD(0x2250),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x300000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
{ // AM29DL323D-B
device_id : FLASHWORD(0x2253),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x100000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL324D
{ // AM29DL324D-T
device_id : FLASHWORD(0x225c),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x3f0000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x200000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
{ // AM29DL324D-B
device_id : FLASHWORD(0x225f),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 64,
device_size: 0x400000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x400000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x200000 * CYGNUM_FLASH_INTERLEAVE,
0
}
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29DL640D
{ // AM29DL640D
long_device_id: true,
device_id : FLASHWORD(0x227e),
device_id2 : FLASHWORD(0x2202),
device_id3 : FLASHWORD(0x2201),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 128,
device_size: 0x800000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x800000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x7F0000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
0x2000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : true,
banks : { 0x700000 * CYGNUM_FLASH_INTERLEAVE,
0x400000 * CYGNUM_FLASH_INTERLEAVE,
0x100000 * CYGNUM_FLASH_INTERLEAVE,
0
}
}
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29F800
{ // AM29F800-T
device_id : FLASHWORD(0x22d6),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0xf0000 * CYGNUM_FLASH_INTERLEAVE,
0x08000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x04000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29F800-B
device_id : FLASHWORD(0x2258),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV800
{ // AM29LV800-T
device_id : FLASHWORD(0x22da),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0xf0000 * CYGNUM_FLASH_INTERLEAVE,
0x08000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x02000 * CYGNUM_FLASH_INTERLEAVE,
0x04000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
{ // AM29LV800-B
device_id : FLASHWORD(0x225b),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_AM29LV640
{ // MBM29LV640xx
device_id : FLASHWORD(0x22d7),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 128,
device_size: 0x800000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x800000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : false,
banked : false
},
#endif
#ifdef CYGHWR_DEVS_FLASH_AMD_TC58FVB800
{ // Toshiba TC58FVB800 (compatible with AM29LV800-B except for IDs.)
device_id : FLASHWORD(0xCE),
block_size : 0x10000 * CYGNUM_FLASH_INTERLEAVE,
block_count: 16,
device_size: 0x100000 * CYGNUM_FLASH_INTERLEAVE,
base_mask : ~(0x100000 * CYGNUM_FLASH_INTERLEAVE - 1),
bootblock : true,
bootblocks : { 0x000000 * CYGNUM_FLASH_INTERLEAVE,
0x004000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x002000 * CYGNUM_FLASH_INTERLEAVE,
0x008000 * CYGNUM_FLASH_INTERLEAVE,
_LAST_BOOTBLOCK
},
banked : false
},
#endif
 
#endif // 16 bit devices
 
#endif // CYGONCE_DEVS_FLASH_AMD_AM29XXXXX_PARTS_INL
/am29xxxxx/v2_0/include/flash_am29xxxxx.inl
0,0 → 1,547
#ifndef CYGONCE_DEVS_FLASH_AMD_AM29XXXXX_INL
#define CYGONCE_DEVS_FLASH_AMD_AM29XXXXX_INL
//==========================================================================
//
// am29xxxxx.inl
//
// AMD AM29xxxxx series flash driver
//
//==========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
// Copyright (C) 2002 Gary Thomas
//
// eCos 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 or (at your option) any later version.
//
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//==========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): gthomas
// Contributors: gthomas, jskov, Koichi Nagashima
// Date: 2001-02-21
// Purpose:
// Description: AMD AM29xxxxx series flash device driver
// Notes: While the parts support sector locking, some only do so
// via crufty magic and the use of programmer hardware
// (specifically by applying 12V to one of the address
// pins) so the driver does not support write protection.
//
// FIXME: Should support SW locking on the newer devices.
//
// FIXME: Figure out how to do proper error checking when there are
// devices in parallel. Presently the driver will return
// driver timeout error on device errors which is not very
// helpful.
//
//####DESCRIPTIONEND####
//
//==========================================================================
 
#include <pkgconf/hal.h>
#include <pkgconf/devs_flash_amd_am29xxxxx.h>
#include <cyg/hal/hal_arch.h>
#include <cyg/hal/hal_cache.h>
#include CYGHWR_MEMORY_LAYOUT_H
 
#define _FLASH_PRIVATE_
#include <cyg/io/flash.h>
 
//----------------------------------------------------------------------------
// Common device details.
#define FLASH_Read_ID FLASHWORD( 0x90 )
#define FLASH_WP_State FLASHWORD( 0x90 )
#define FLASH_Reset FLASHWORD( 0xF0 )
#define FLASH_Program FLASHWORD( 0xA0 )
#define FLASH_Block_Erase FLASHWORD( 0x30 )
 
#define FLASH_Data FLASHWORD( 0x80 ) // Data complement
#define FLASH_Busy FLASHWORD( 0x40 ) // "Toggle" bit
#define FLASH_Err FLASHWORD( 0x20 )
#define FLASH_Sector_Erase_Timer FLASHWORD( 0x08 )
 
#define FLASH_unlocked FLASHWORD( 0x00 )
 
#ifndef CYGNUM_FLASH_16AS8
#define _16AS8 0
#else
#define _16AS8 CYGNUM_FLASH_16AS8
#endif
 
#if (_16AS8 == 0)
# define FLASH_Setup_Addr1 (0x555)
# define FLASH_Setup_Addr2 (0x2AA)
# define FLASH_VendorID_Addr (0)
# define FLASH_DeviceID_Addr (1)
# define FLASH_DeviceID_Addr2 (0x0e)
# define FLASH_DeviceID_Addr3 (0x0f)
# define FLASH_WP_Addr (2)
#else
# define FLASH_Setup_Addr1 (0xAAA)
# define FLASH_Setup_Addr2 (0x555)
# define FLASH_VendorID_Addr (0)
# define FLASH_DeviceID_Addr (2)
# define FLASH_DeviceID_Addr2 (0x1c)
# define FLASH_DeviceID_Addr3 (0x1e)
# define FLASH_WP_Addr (4)
#endif
#define FLASH_Setup_Code1 FLASHWORD( 0xAA )
#define FLASH_Setup_Code2 FLASHWORD( 0x55 )
#define FLASH_Setup_Erase FLASHWORD( 0x80 )
 
// Platform code must define the below
// #define CYGNUM_FLASH_INTERLEAVE : Number of interleaved devices (in parallel)
// #define CYGNUM_FLASH_SERIES : Number of devices in series
// #define CYGNUM_FLASH_WIDTH : Width of devices on platform
// #define CYGNUM_FLASH_BASE : Address of first device
 
#define CYGNUM_FLASH_BLANK (1)
 
#ifndef FLASH_P2V
# define FLASH_P2V( _a_ ) ((volatile flash_data_t *)((CYG_ADDRWORD)(_a_)))
#endif
#ifndef CYGHWR_FLASH_AM29XXXXX_PLF_INIT
# define CYGHWR_FLASH_AM29XXXXX_PLF_INIT()
#endif
 
//----------------------------------------------------------------------------
// Now that device properties are defined, include magic for defining
// accessor type and constants.
#include <cyg/io/flash_dev.h>
 
//----------------------------------------------------------------------------
// Information about supported devices
typedef struct flash_dev_info {
cyg_bool long_device_id;
flash_data_t device_id;
flash_data_t device_id2;
flash_data_t device_id3;
cyg_uint32 block_size;
cyg_int32 block_count;
cyg_uint32 base_mask;
cyg_uint32 device_size;
cyg_bool bootblock;
cyg_uint32 bootblocks[64]; // 0 is bootblock offset, 1-11 sub-sector sizes (or 0)
cyg_bool banked;
cyg_uint32 banks[8]; // bank offsets, highest to lowest (lowest should be 0)
// (only one entry for now, increase to support devices
// with more banks).
} flash_dev_info_t;
 
static const flash_dev_info_t* flash_dev_info;
static const flash_dev_info_t supported_devices[] = {
#include <cyg/io/flash_am29xxxxx_parts.inl>
};
#define NUM_DEVICES (sizeof(supported_devices)/sizeof(flash_dev_info_t))
 
//----------------------------------------------------------------------------
// Functions that put the flash device into non-read mode must reside
// in RAM.
void flash_query(void* data) __attribute__ ((section (".2ram.flash_query")));
int flash_erase_block(void* block, unsigned int size)
__attribute__ ((section (".2ram.flash_erase_block")));
int flash_program_buf(void* addr, void* data, int len)
__attribute__ ((section (".2ram.flash_program_buf")));
static void _flash_query(void* data) __attribute__ ((section (".2ram._flash_query")));
static int _flash_erase_block(void* block, unsigned int size)
__attribute__ ((section (".2ram._flash_erase_block")));
static int _flash_program_buf(void* addr, void* data, int len)
__attribute__ ((section (".2ram._flash_program_buf")));
 
//----------------------------------------------------------------------------
// Flash Query
//
// Only reads the manufacturer and part number codes for the first
// device(s) in series. It is assumed that any devices in series
// will be of the same type.
 
static void
_flash_query(void* data)
{
volatile flash_data_t *ROM;
volatile flash_data_t *f_s1, *f_s2;
flash_data_t* id = (flash_data_t*) data;
flash_data_t w;
long timeout = 500000;
 
ROM = (flash_data_t*) CYGNUM_FLASH_BASE;
f_s1 = FLASH_P2V(ROM+FLASH_Setup_Addr1);
f_s2 = FLASH_P2V(ROM+FLASH_Setup_Addr2);
 
*f_s1 = FLASH_Reset;
w = *(FLASH_P2V(ROM));
 
*f_s1 = FLASH_Setup_Code1;
*f_s2 = FLASH_Setup_Code2;
*f_s1 = FLASH_Read_ID;
 
id[0] = -1;
id[1] = -1;
 
// Manufacturers' code
id[0] = *(FLASH_P2V(ROM+FLASH_VendorID_Addr));
// Part number
id[1] = *(FLASH_P2V(ROM+FLASH_DeviceID_Addr));
id[2] = *(FLASH_P2V(ROM+FLASH_DeviceID_Addr2));
id[3] = *(FLASH_P2V(ROM+FLASH_DeviceID_Addr3));
 
 
*(FLASH_P2V(ROM)) = FLASH_Reset;
 
// Stall, waiting for flash to return to read mode.
while ((--timeout != 0) && (w != *(FLASH_P2V(ROM)))) ;
}
 
void
flash_query(void* data)
{
int cache_on;
 
HAL_DCACHE_IS_ENABLED(cache_on);
if (cache_on) {
HAL_DCACHE_SYNC();
HAL_DCACHE_DISABLE();
}
_flash_query(data);
if (cache_on) {
HAL_DCACHE_ENABLE();
}
}
 
//----------------------------------------------------------------------------
// Initialize driver details
int
flash_hwr_init(void)
{
flash_data_t id[4];
int i;
 
CYGHWR_FLASH_AM29XXXXX_PLF_INIT();
 
flash_dev_query(id);
 
// Look through table for device data
flash_dev_info = supported_devices;
for (i = 0; i < NUM_DEVICES; i++) {
if (!flash_dev_info->long_device_id && flash_dev_info->device_id == id[1])
break;
else if ( flash_dev_info->long_device_id && flash_dev_info->device_id == id[1]
&& flash_dev_info->device_id2 == id[2]
&& flash_dev_info->device_id3 == id[3] )
break;
flash_dev_info++;
}
 
// Did we find the device? If not, return error.
if (NUM_DEVICES == i)
return FLASH_ERR_DRV_WRONG_PART;
 
// Hard wired for now
flash_info.block_size = flash_dev_info->block_size;
flash_info.blocks = flash_dev_info->block_count * CYGNUM_FLASH_SERIES;
flash_info.start = (void *)CYGNUM_FLASH_BASE;
flash_info.end = (void *)(CYGNUM_FLASH_BASE+ (flash_dev_info->device_size * CYGNUM_FLASH_SERIES));
return FLASH_ERR_OK;
}
 
//----------------------------------------------------------------------------
// Map a hardware status to a package error
int
flash_hwr_map_error(int e)
{
return e;
}
 
 
//----------------------------------------------------------------------------
// See if a range of FLASH addresses overlaps currently running code
bool
flash_code_overlaps(void *start, void *end)
{
extern unsigned char _stext[], _etext[];
 
return ((((unsigned long)&_stext >= (unsigned long)start) &&
((unsigned long)&_stext < (unsigned long)end)) ||
(((unsigned long)&_etext >= (unsigned long)start) &&
((unsigned long)&_etext < (unsigned long)end)));
}
 
//----------------------------------------------------------------------------
// Erase Block
 
static int
_flash_erase_block(void* block, unsigned int size)
{
volatile flash_data_t* ROM, *BANK;
volatile flash_data_t* b_p = (flash_data_t*) block;
volatile flash_data_t *b_v;
volatile flash_data_t *f_s0, *f_s1, *f_s2;
int timeout = 50000;
int len = 0;
int res = FLASH_ERR_OK;
flash_data_t state;
cyg_bool bootblock = false;
cyg_uint32 *bootblocks = (cyg_uint32 *)0;
CYG_ADDRWORD bank_offset;
 
BANK = ROM = (volatile flash_data_t*)((unsigned long)block & flash_dev_info->base_mask);
 
// If this is a banked device, find the bank where commands should
// be addressed to.
if (flash_dev_info->banked) {
int b = 0;
bank_offset = (unsigned long)block & ~(flash_dev_info->block_size-1);
bank_offset -= (unsigned long) ROM;
for(;;) {
if (bank_offset >= flash_dev_info->banks[b]) {
BANK = (volatile flash_data_t*) ((unsigned long)ROM + flash_dev_info->banks[b]);
break;
}
b++;
}
}
 
f_s0 = FLASH_P2V(BANK);
f_s1 = FLASH_P2V(BANK + FLASH_Setup_Addr1);
f_s2 = FLASH_P2V(BANK + FLASH_Setup_Addr2);
 
// Assume not "boot" sector, full size
bootblock = false;
len = flash_dev_info->block_size;
 
// Is this in a "boot" sector?
if (flash_dev_info->bootblock) {
bootblocks = (cyg_uint32 *)&flash_dev_info->bootblocks[0];
while (*bootblocks != _LAST_BOOTBLOCK) {
if (*bootblocks++ == ((unsigned long)block - (unsigned long)ROM)) {
len = *bootblocks++; // Size of first sub-block
bootblock = true;
break;
} else {
int ls = flash_dev_info->block_size;
// Skip over segment
while ((ls -= *bootblocks++) > 0) ;
}
}
}
 
while (size > 0) {
#ifndef CYGHWR_FLASH_AM29XXXXX_NO_WRITE_PROTECT
// First check whether the block is protected
*f_s1 = FLASH_Setup_Code1;
*f_s2 = FLASH_Setup_Code2;
*f_s1 = FLASH_WP_State;
state = *FLASH_P2V(b_p+FLASH_WP_Addr);
*f_s0 = FLASH_Reset;
 
if (FLASH_unlocked != state)
return FLASH_ERR_PROTECT;
#endif
 
b_v = FLASH_P2V(b_p);
// Send erase block command - six step sequence
*f_s1 = FLASH_Setup_Code1;
*f_s2 = FLASH_Setup_Code2;
*f_s1 = FLASH_Setup_Erase;
*f_s1 = FLASH_Setup_Code1;
*f_s2 = FLASH_Setup_Code2;
*b_v = FLASH_Block_Erase;
 
// Now poll for the completion of the sector erase timer (50us)
timeout = 10000000; // how many retries?
while (true) {
state = *b_v;
if ((state & FLASH_Sector_Erase_Timer)
== FLASH_Sector_Erase_Timer) break;
 
if (--timeout == 0) {
res = FLASH_ERR_DRV_TIMEOUT;
break;
}
}
 
// Then wait for erase completion.
if (FLASH_ERR_OK == res) {
timeout = 10000000;
while (true) {
state = *b_v;
if (FLASH_BlankValue == state) {
break;
}
 
// Don't check for FLASH_Err here since it will fail
// with devices in parallel because these may finish
// at different times.
 
if (--timeout == 0) {
res = FLASH_ERR_DRV_TIMEOUT;
break;
}
}
}
 
if (FLASH_ERR_OK != res)
*FLASH_P2V(ROM) = FLASH_Reset;
 
size -= len; // This much has been erased
 
// Verify erase operation
while (len > 0) {
b_v = FLASH_P2V(b_p++);
if (*b_v != FLASH_BlankValue) {
// Only update return value if erase operation was OK
if (FLASH_ERR_OK == res) res = FLASH_ERR_DRV_VERIFY;
return res;
}
len -= sizeof(*b_p);
}
 
if (bootblock) {
len = *bootblocks++;
}
}
return res;
}
 
int
flash_erase_block(void* block, unsigned int size)
{
int ret, cache_on;
HAL_DCACHE_IS_ENABLED(cache_on);
if (cache_on) {
HAL_DCACHE_SYNC();
HAL_DCACHE_DISABLE();
}
ret = _flash_erase_block(block, size);
if (cache_on) {
HAL_DCACHE_ENABLE();
}
return ret;
}
 
//----------------------------------------------------------------------------
// Program Buffer
static int
_flash_program_buf(void* addr, void* data, int len)
{
volatile flash_data_t* ROM;
volatile flash_data_t* BANK;
volatile flash_data_t* data_ptr = (volatile flash_data_t*) data;
volatile flash_data_t* addr_v;
volatile flash_data_t* addr_p = (flash_data_t*) addr;
volatile flash_data_t *f_s1, *f_s2;
CYG_ADDRWORD bank_offset;
int timeout;
int res = FLASH_ERR_OK;
 
// check the address is suitably aligned
if ((unsigned long)addr & (CYGNUM_FLASH_INTERLEAVE * CYGNUM_FLASH_WIDTH / 8 - 1))
return FLASH_ERR_INVALID;
 
// Base address of device(s) being programmed.
BANK = ROM = (volatile flash_data_t*)((unsigned long)addr_p & flash_dev_info->base_mask);
 
// If this is a banked device, find the bank where commands should
// be addressed to.
if (flash_dev_info->banked) {
int b = 0;
bank_offset = (unsigned long)addr & ~(flash_dev_info->block_size-1);
bank_offset -= (unsigned long) ROM;
for(;;) {
if (bank_offset >= flash_dev_info->banks[b]) {
BANK = (volatile flash_data_t*) ((unsigned long)ROM + flash_dev_info->banks[b]);
break;
}
b++;
}
}
 
f_s1 = FLASH_P2V(BANK + FLASH_Setup_Addr1);
f_s2 = FLASH_P2V(BANK + FLASH_Setup_Addr2);
 
while (len > 0) {
flash_data_t state;
 
addr_v = FLASH_P2V(addr_p++);
 
// Program data [byte] - 4 step sequence
*f_s1 = FLASH_Setup_Code1;
*f_s2 = FLASH_Setup_Code2;
*f_s1 = FLASH_Program;
*addr_v = *data_ptr;
 
timeout = 10000000;
while (true) {
state = *addr_v;
if (*data_ptr == state) {
break;
}
 
// Can't check for FLASH_Err since it'll fail in parallel
// configurations.
 
if (--timeout == 0) {
res = FLASH_ERR_DRV_TIMEOUT;
break;
}
}
 
if (FLASH_ERR_OK != res)
*FLASH_P2V(ROM) = FLASH_Reset;
 
if (*addr_v != *data_ptr++) {
// Only update return value if erase operation was OK
if (FLASH_ERR_OK == res) res = FLASH_ERR_DRV_VERIFY;
break;
}
len -= sizeof(*data_ptr);
}
 
// Ideally, we'd want to return not only the failure code, but also
// the address/device that reported the error.
return res;
}
 
int
flash_program_buf(void* addr, void* data, int len)
{
int ret, cache_on;
HAL_DCACHE_IS_ENABLED(cache_on);
if (cache_on) {
HAL_DCACHE_SYNC();
HAL_DCACHE_DISABLE();
}
ret = _flash_program_buf(addr, data, len);
if (cache_on) {
HAL_DCACHE_ENABLE();
}
return ret;
}
#endif // CYGONCE_DEVS_FLASH_AMD_AM29XXXXX_INL
/am29xxxxx/v2_0/ChangeLog
0,0 → 1,241
2003-02-11 Gary Thomas <gary@mlbassoc.com>
 
* include/flash_am29xxxxx_parts.inl:
Fix identifier code for AM29LV320DT.
 
2002-12-23 Patrick Doyle <wpd@delcomsys.com>
 
* include/flash_am29xxxxx_parts.inl (CYGHWR_DEVS_FLASH_AMD_AM29DL640D):
* cdl/flash_amd_am29xxxxx.cdl:
Add support for AM29DL323 and for 16 bit operation of the
AM29DL322.
 
2002-12-04 Mark Salter <msalter@redhat.com>
 
* include/flash_am29xxxxx_parts.inl:
* cdl/flash_amd_am29xxxxx.cdl: Add support for AM29DL322.
 
2002-11-25 Gary Thomas <gthomas@ecoscentric.com>
 
* include/flash_am29xxxxx_parts.inl (CYGHWR_DEVS_FLASH_AMD_AM29DL640D):
Now tested in 16 bit configurations.
 
* include/flash_am29xxxxx.inl: Fix problems with CYGNUM_FLASH_16AS8.
The definition was inconsistent/confusing.
 
2002-10-11 Gary Thomas <gary@mlbassoc.com>
 
* include/flash_am29xxxxx_parts.inl:
* include/flash_am29xxxxx.inl: Better support for devices with
"bootblock" sections - some newer devices have more than one!
 
2002-09-26 Ian Campbell <icampbell@arcomcontrols.com>
* include/flash_am29xxxxx_parts.inl:
* cdl/flash_amd_am29xxxxx.cdl: Add support for AM29DL640D.
 
* include/flash_am29xxxxx.inl: Add support for triple byte part id
numbers, such as those used by the AM29DL640D. Allow for parts
with up to 5 banks, rather than two -- also to support AM29DL640D
parts.
 
2002-07-29 Gary Thomas <gary@chez-thomas.org>
2002-07-29 Motoya Kurotsu <kurotsu@allied-telesis.co.jp>
 
* include/flash_am29xxxxx.inl: Force routines which actually use
the FLASH to run from RAM.
 
2002-07-24 Gary Thomas <gary@chez-thomas.org>
2002-07-24 Motoya Kurotsu <kurotsu@allied-telesis.co.jp>
* include/flash_am29xxxxx.inl (_flash_program_buf): Fix data
type for 'state' - needs to be flash_data_t.
 
2002-06-20 Gary Thomas <gary@chez-thomas.org>
 
* include/flash_am29xxxxx.inl: Add cache disable/enable code
since this is required on most platforms.
 
* include/flash_am29xxxxx_parts.inl:
* cdl/flash_amd_am29xxxxx.cdl: Add support for AM29LV320D{T|B}
 
2002-04-24 Bob Koninckx <bob.koninckx@mech.kuleuven.ac.be>
 
* cdl/flash_amd_am29xxxxx.cdl: Support AM29LV200 and ST M29W200B.
* include/flash_am29xxxxx_parts.inl: Likewise.
 
2002-01-03 Jonathan Larmour <jlarmour@redhat.com>
2001-12-20 Koichi Nagashima <naga@r-lab.co.jp>
 
* cdl/flash_amd_am29xxxxx.cdl: Add support for Toshiba TC58FVB800 part.
* include/flash_am29xxxxx_parts.inl: Ditto.
 
* include/flash_am29xxxxx.inl: Fix FLASH_Reset definition.
Check sector erase timer correctly.
 
2001-10-31 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx_parts.inl: Removed fix me comments -
description is accurate.
 
2001-10-30 Jesper Skov <jskov@redhat.com>
From Gary:
* include/flash_am29xxxxx_parts.inl: Added preliminary AM29LV640
support. Still needs some tweaks.
* cdl/flash_amd_am29xxxxx.cdl: Same.
 
2001-09-26 Gary Thomas <gthomas@redhat.com>
 
* include/flash_am29xxxxx.inl (flash_erase_block):
New platform control - CYGHWR_FLASH_AM29XXXXX_NO_WRITE_PROTECT.
Define this if the write-protect feature is non-functional/missing.
 
2001-08-16 Jonathan Larmour <jlarmour@redhat.com>
 
* include/flash_am29xxxxx.inl: Double erase timeouts for faster CPUs.
 
2001-08-10 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx.inl (flash_hwr_init): Fix block number.
 
2001-07-26 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx.inl: Made code deal with multiple
banks. Use flag to identify banked devices.
* include/flash_am29xxxxx_parts.inl: Updated with banked flag.
 
2001-07-23 David Howells <dhowells@redhat.com>
 
* include/flash_am29xxxxx.inl: Added support for chips divided
into banks, and added correct addresses for 16-bit chips
configured in 8-bit mode
* include/flash_am29xxxxx_parts.inl: Added data for chips divided
into banks
 
2001-06-11 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx.inl: Traverse by incrementing
driver-global pointer variable.
 
2001-06-11 David Howells <dhowells@redhat.com>
 
* include/flash_am29xxxxx.inl: actually traverse the list of
supported devices, rather than checking the first entry several
times
 
2001-06-08 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx_parts.inl: New file with just part
data.
 
* include/flash_am29xxxxx.inl: Leave more space for bootblock
offsets. Moved part table data to separate file.
 
* cdl/flash_amd_am29xxxxx.cdl: Added config options to control
inclusion of table data for various parts.
 
2001-05-29 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx.inl (flash_hwr_init): Call platform init
code if defined.
 
2001-05-28 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx.inl: Rewritten to handle bootblock
parts, autodetect part and configure accordingly.
Fixed erase and program code to work with devices in parallel.
Fixed buglet in bootblock detect code.
 
2001-05-23 Jesper Skov <jskov@redhat.com>
 
* cdl/flash_amd_am29xxxxx.cdl: Links function in RAM. IO driver
need not copy.
 
* include/flash_am29xxxxx.inl: Check for WP before trying to erase
block. Use P2V macro.
 
2001-02-23 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx.inl (flash_query): Allow device to
settle before returning.
 
2001-02-22 Jesper Skov <jskov@redhat.com>
 
* include/flash_am29xxxxx.inl: Fix typo. Cleaned up, almost
working with MBX. Times out when erasing from ROM version of RB.
 
2001-02-20 Jesper Skov <jskov@redhat.com>
 
* .../amd/am29xxxxx: Cloned from hardwired am29f040b driver.
 
2000-12-07 Jesper Skov <jskov@redhat.com>
 
* src/flash.h: Addresses and sizes are also affected by
interleaving.
* src/flash_erase_block.c: Plug in working loop.
* src/flash_program_buf.c: Same.
 
2000-12-06 Jesper Skov <jskov@redhat.com>
 
* src/am29f040b_flash.c (flash_hwr_init): Use new query semantics.
* src/flash_query.c (flash_query): Changed accordingly.
 
* src/flash.h (FLASH_Sector_Erase_Timer): Added.
 
* src/flash_erase_block.c: Do not check error flag after operation
completes.
* src/flash_program_buf.c: Same.
 
2000-12-05 Jonathan Larmour <jlarmour@redhat.com>
 
* src/am29f040b_flash.c (flash_code_overlaps): Define stext/etext
as array types so no assumptions can be made by the compiler about
location.
 
2000-12-05 Jesper Skov <jskov@redhat.com>
 
* Cloned from MBX driver.
 
2000-10-20 Gary Thomas <gthomas@redhat.com>
 
* src/mbx_flash.c:
* src/flash_query.c:
* src/flash_program_buf.c:
* src/flash_erase_block.c:
* src/flash.h:
* cdl/flash_mbx.cdl: New package/file(s).
 
//===========================================================================
//####ECOSGPLCOPYRIGHTBEGIN####
// -------------------------------------------
// This file is part of eCos, the Embedded Configurable Operating System.
// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
//
// eCos 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 or (at your option) any later version.
//
// eCos 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 eCos; if not, write to the Free Software Foundation, Inc.,
// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
//
// As a special exception, if other files instantiate templates or use macros
// or inline functions from this file, or you compile this file and link it
// with other works to produce a work based on this file, this file does not
// by itself cause the resulting work to be covered by the GNU General Public
// License. However the source code for this file must still be made available
// in accordance with section (3) of the GNU General Public License.
//
// This exception does not invalidate any other reasons why a work based on
// this file might be covered by the GNU General Public License.
//
// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
// at http://sources.redhat.com/ecos/ecos-license/
// -------------------------------------------
//####ECOSGPLCOPYRIGHTEND####
//===========================================================================

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.