interesting
/
riscv-openocd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

FLASH/NOR: rename from spearsmi to stmsmi 

STMicroelectronics controller SMI is not SPEAr specific.
Rename it and change name to every symbol in the code.

Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
This commit is contained in:
Antonio Borneo 2010-11-22 12:21:31 +08:00 committed by Øyvind Harboe
parent 4bbdf966d4
commit 42082f7c23
5 changed files with 90 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
doc/openocd.texi
View File

@ -4252,14 +4252,15 @@ flash bank $_FLASHNAME cfi 0x00000000 0x02000000 2 4 $_TARGETNAME
@c "cfi part_id" disabled @c "cfi part_id" disabled
@end deffn @end deffn
@deffn {Flash Driver} spearsmi @deffn {Flash Driver} stmsmi
@cindex SPEAr Serial Memory Interface @cindex STMicroelectronics Serial Memory Interface
@cindex SMI @cindex SMI
@cindex spearsmi @cindex stmsmi
All members of SPEAr MPU family from STMicroelectronics include a Some devices form STMicroelectronics (e.g. STR75x MCU family,
SPEAr MPU family) include a proprietary
``Serial Memory Interface'' (SMI) controller able to drive external ``Serial Memory Interface'' (SMI) controller able to drive external
SPI flash devices. SPI flash devices.
Depending on specific MPU and board configuration, up to 4 external Depending on specific device and board configuration, up to 4 external
flash devices can be connected. flash devices can be connected.
SMI makes the flash content directly accessible in the CPU address SMI makes the flash content directly accessible in the CPU address
@ -4274,7 +4275,7 @@ All other parameters are ignored. Additional information, like
flash size, are detected automatically. flash size, are detected automatically.
@example @example
flash bank $_FLASHNAME spearsmi 0xf8000000 0 0 0 $_TARGETNAME flash bank $_FLASHNAME stmsmi 0xf8000000 0 0 0 $_TARGETNAME
@end example @end example
@end deffn @end deffn

4
src/flash/nor/drivers.c
View File

@ -40,7 +40,7 @@ extern struct flash_driver pic32mx_flash;
extern struct flash_driver avr_flash; extern struct flash_driver avr_flash;
extern struct flash_driver faux_flash; extern struct flash_driver faux_flash;
extern struct flash_driver virtual_flash; extern struct flash_driver virtual_flash;
extern struct flash_driver spearsmi_flash; extern struct flash_driver stmsmi_flash;
/** /**
* The list of built-in flash drivers. * The list of built-in flash drivers.
@ -66,7 +66,7 @@ static struct flash_driver *flash_drivers[] = {
&avr_flash, &avr_flash,
&faux_flash, &faux_flash,
&virtual_flash, &virtual_flash,
&spearsmi_flash, &stmsmi_flash,
NULL, NULL,
}; };

158
src/flash/nor/spearsmi.c
View File

@ -17,7 +17,7 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/ ***************************************************************************/
/* SPEAr Serial Memory Interface (SMI) controller is a SPI bus controller /* STM Serial Memory Interface (SMI) controller is a SPI bus controller
* specifically designed for SPI memories. * specifically designed for SPI memories.
* Only SPI "mode 3" (CPOL=1 and CPHA=1) is supported. * Only SPI "mode 3" (CPOL=1 and CPHA=1) is supported.
* Two working modes are available: * Two working modes are available:
@ -117,7 +117,7 @@
#define SMI_PROBE_TIMEOUT (100) #define SMI_PROBE_TIMEOUT (100)
#define SMI_MAX_TIMEOUT (3000) #define SMI_MAX_TIMEOUT (3000)
struct spearsmi_flash_bank struct stmsmi_flash_bank
{ {
int probed; int probed;
uint32_t io_base; uint32_t io_base;
@ -184,41 +184,41 @@ static struct flash_device flash_devices[] = {
FLASH_ID(NULL, 0, 0, 0, 0, 0) FLASH_ID(NULL, 0, 0, 0, 0, 0)
}; };
struct spearsmi_target { struct stmsmi_target {
char *name; char *name;
uint32_t tap_idcode; uint32_t tap_idcode;
uint32_t smi_base; uint32_t smi_base;
uint32_t io_base; uint32_t io_base;
}; };
static struct spearsmi_target target_devices[] = { static struct stmsmi_target target_devices[] = {
/* name, tap_idcode, smi_base, io_base */ /* name, tap_idcode, smi_base, io_base */
{ "SPEAr3xx/6xx", 0x07926041, 0xf8000000, 0xfc000000 }, { "SPEAr3xx/6xx", 0x07926041, 0xf8000000, 0xfc000000 },
{ "STR75x", 0x4f1f0041, 0x80000000, 0x90000000 }, { "STR75x", 0x4f1f0041, 0x80000000, 0x90000000 },
{ NULL, 0, 0, 0 } { NULL, 0, 0, 0 }
}; };
FLASH_BANK_COMMAND_HANDLER(spearsmi_flash_bank_command) FLASH_BANK_COMMAND_HANDLER(stmsmi_flash_bank_command)
{ {
struct spearsmi_flash_bank *spearsmi_info; struct stmsmi_flash_bank *stmsmi_info;
LOG_DEBUG(__FUNCTION__); LOG_DEBUG(__FUNCTION__);
if (CMD_ARGC < 6) if (CMD_ARGC < 6)
{ {
LOG_WARNING("incomplete flash_bank spearsmi configuration"); LOG_WARNING("incomplete flash_bank stmsmi configuration");
return ERROR_FLASH_BANK_INVALID; return ERROR_FLASH_BANK_INVALID;
} }
spearsmi_info = malloc(sizeof(struct spearsmi_flash_bank)); stmsmi_info = malloc(sizeof(struct stmsmi_flash_bank));
if (spearsmi_info == NULL) if (stmsmi_info == NULL)
{ {
LOG_ERROR("not enough memory"); LOG_ERROR("not enough memory");
return ERROR_FAIL; return ERROR_FAIL;
} }
bank->driver_priv = spearsmi_info; bank->driver_priv = stmsmi_info;
spearsmi_info->probed = 0; stmsmi_info->probed = 0;
return ERROR_OK; return ERROR_OK;
} }
@ -249,14 +249,14 @@ static int poll_tff(struct target *target, uint32_t io_base, int timeout)
static int read_status_reg(struct flash_bank *bank, uint32_t *status) static int read_status_reg(struct flash_bank *bank, uint32_t *status)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base = spearsmi_info->io_base; uint32_t io_base = stmsmi_info->io_base;
/* clear transmit finished flag */ /* clear transmit finished flag */
SMI_CLEAR_TFF(); SMI_CLEAR_TFF();
/* Read status */ /* Read status */
SMI_WRITE_REG(SMI_CR2, spearsmi_info->bank_num | SMI_RSR); SMI_WRITE_REG(SMI_CR2, stmsmi_info->bank_num | SMI_RSR);
/* Poll transmit finished flag */ /* Poll transmit finished flag */
SMI_POLL_TFF(SMI_CMD_TIMEOUT); SMI_POLL_TFF(SMI_CMD_TIMEOUT);
@ -302,8 +302,8 @@ static int wait_till_ready(struct flash_bank *bank, int timeout)
static int smi_write_enable(struct flash_bank *bank) static int smi_write_enable(struct flash_bank *bank)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base = spearsmi_info->io_base; uint32_t io_base = stmsmi_info->io_base;
uint32_t status; uint32_t status;
int retval; int retval;
@ -314,7 +314,7 @@ static int smi_write_enable(struct flash_bank *bank)
SMI_CLEAR_TFF(); SMI_CLEAR_TFF();
/* Send write enable command */ /* Send write enable command */
SMI_WRITE_REG(SMI_CR2, spearsmi_info->bank_num | SMI_WE); SMI_WRITE_REG(SMI_CR2, stmsmi_info->bank_num | SMI_WE);
/* Poll transmit finished flag */ /* Poll transmit finished flag */
SMI_POLL_TFF(SMI_CMD_TIMEOUT); SMI_POLL_TFF(SMI_CMD_TIMEOUT);
@ -334,7 +334,7 @@ static int smi_write_enable(struct flash_bank *bank)
return ERROR_OK; return ERROR_OK;
} }
static uint32_t erase_command(struct spearsmi_flash_bank *spearsmi_info, static uint32_t erase_command(struct stmsmi_flash_bank *stmsmi_info,
uint32_t offset) uint32_t offset)
{ {
union { union {
@ -342,7 +342,7 @@ static uint32_t erase_command(struct spearsmi_flash_bank *spearsmi_info,
uint8_t x[4]; uint8_t x[4];
} cmd; } cmd;
cmd.x[0] = spearsmi_info->dev->erase_cmd; cmd.x[0] = stmsmi_info->dev->erase_cmd;
cmd.x[1] = offset >> 16; cmd.x[1] = offset >> 16;
cmd.x[2] = offset >> 8; cmd.x[2] = offset >> 8;
cmd.x[3] = offset; cmd.x[3] = offset;
@ -353,8 +353,8 @@ static uint32_t erase_command(struct spearsmi_flash_bank *spearsmi_info,
static int smi_erase_sector(struct flash_bank *bank, int sector) static int smi_erase_sector(struct flash_bank *bank, int sector)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base = spearsmi_info->io_base; uint32_t io_base = stmsmi_info->io_base;
uint32_t cmd; uint32_t cmd;
int retval; int retval;
@ -369,9 +369,9 @@ static int smi_erase_sector(struct flash_bank *bank, int sector)
SMI_CLEAR_TFF(); SMI_CLEAR_TFF();
/* send SPI command "block erase" */ /* send SPI command "block erase" */
cmd = erase_command(spearsmi_info, bank->sectors[sector].offset); cmd = erase_command(stmsmi_info, bank->sectors[sector].offset);
SMI_WRITE_REG(SMI_TR, cmd); SMI_WRITE_REG(SMI_TR, cmd);
SMI_WRITE_REG(SMI_CR2, spearsmi_info->bank_num | SMI_SEND | SMI_TX_LEN_4); SMI_WRITE_REG(SMI_CR2, stmsmi_info->bank_num | SMI_SEND | SMI_TX_LEN_4);
/* Poll transmit finished flag */ /* Poll transmit finished flag */
SMI_POLL_TFF(SMI_CMD_TIMEOUT); SMI_POLL_TFF(SMI_CMD_TIMEOUT);
@ -384,11 +384,11 @@ static int smi_erase_sector(struct flash_bank *bank, int sector)
return ERROR_OK; return ERROR_OK;
} }
static int spearsmi_erase(struct flash_bank *bank, int first, int last) static int stmsmi_erase(struct flash_bank *bank, int first, int last)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base = spearsmi_info->io_base; uint32_t io_base = stmsmi_info->io_base;
int retval = ERROR_OK; int retval = ERROR_OK;
int sector; int sector;
@ -406,7 +406,7 @@ static int spearsmi_erase(struct flash_bank *bank, int first, int last)
return ERROR_FLASH_SECTOR_INVALID; return ERROR_FLASH_SECTOR_INVALID;
} }
if (!(spearsmi_info->probed)) if (!(stmsmi_info->probed))
{ {
LOG_ERROR("Flash bank not probed"); LOG_ERROR("Flash bank not probed");
return ERROR_FLASH_BANK_NOT_PROBED; return ERROR_FLASH_BANK_NOT_PROBED;
@ -434,7 +434,7 @@ static int spearsmi_erase(struct flash_bank *bank, int first, int last)
return retval; return retval;
} }
static int spearsmi_protect(struct flash_bank *bank, int set, static int stmsmi_protect(struct flash_bank *bank, int set,
int first, int last) int first, int last)
{ {
int sector; int sector;
@ -448,8 +448,8 @@ static int smi_write_buffer(struct flash_bank *bank, uint8_t *buffer,
uint32_t address, uint32_t len) uint32_t address, uint32_t len)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base = spearsmi_info->io_base; uint32_t io_base = stmsmi_info->io_base;
int retval; int retval;
LOG_DEBUG("%s: address=0x%08" PRIx32 " len=0x%08" PRIx32, LOG_DEBUG("%s: address=0x%08" PRIx32 " len=0x%08" PRIx32,
@ -469,12 +469,12 @@ static int smi_write_buffer(struct flash_bank *bank, uint8_t *buffer,
return ERROR_OK; return ERROR_OK;
} }
static int spearsmi_write(struct flash_bank *bank, uint8_t *buffer, static int stmsmi_write(struct flash_bank *bank, uint8_t *buffer,
uint32_t offset, uint32_t count) uint32_t offset, uint32_t count)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base = spearsmi_info->io_base; uint32_t io_base = stmsmi_info->io_base;
uint32_t cur_count, page_size, page_offset; uint32_t cur_count, page_size, page_offset;
int sector; int sector;
int retval = ERROR_OK; int retval = ERROR_OK;
@ -488,10 +488,10 @@ static int spearsmi_write(struct flash_bank *bank, uint8_t *buffer,
return ERROR_TARGET_NOT_HALTED; return ERROR_TARGET_NOT_HALTED;
} }
if (offset + count > spearsmi_info->dev->size_in_bytes) if (offset + count > stmsmi_info->dev->size_in_bytes)
{ {
LOG_WARNING("Write pasts end of flash. Extra data discarded."); LOG_WARNING("Write pasts end of flash. Extra data discarded.");
count = spearsmi_info->dev->size_in_bytes - offset; count = stmsmi_info->dev->size_in_bytes - offset;
} }
/* Check sector protection */ /* Check sector protection */
@ -509,7 +509,7 @@ static int spearsmi_write(struct flash_bank *bank, uint8_t *buffer,
} }
} }
page_size = spearsmi_info->dev->pagesize; page_size = stmsmi_info->dev->pagesize;
/* unaligned buffer head */ /* unaligned buffer head */
if (count > 0 && (offset & 3) != 0) if (count > 0 && (offset & 3) != 0)
@ -564,8 +564,8 @@ err:
static int read_flash_id(struct flash_bank *bank, uint32_t *id) static int read_flash_id(struct flash_bank *bank, uint32_t *id)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base = spearsmi_info->io_base; uint32_t io_base = stmsmi_info->io_base;
int retval; int retval;
if (target->state != TARGET_HALTED) if (target->state != TARGET_HALTED)
@ -588,7 +588,7 @@ static int read_flash_id(struct flash_bank *bank, uint32_t *id)
/* Send SPI command "read ID" */ /* Send SPI command "read ID" */
SMI_WRITE_REG(SMI_TR, SMI_READ_ID); SMI_WRITE_REG(SMI_TR, SMI_READ_ID);
SMI_WRITE_REG(SMI_CR2, SMI_WRITE_REG(SMI_CR2,
spearsmi_info->bank_num | SMI_SEND | SMI_RX_LEN_3 | SMI_TX_LEN_1); stmsmi_info->bank_num | SMI_SEND | SMI_RX_LEN_3 | SMI_TX_LEN_1);
/* Poll transmit finished flag */ /* Poll transmit finished flag */
SMI_POLL_TFF(SMI_CMD_TIMEOUT); SMI_POLL_TFF(SMI_CMD_TIMEOUT);
@ -601,19 +601,19 @@ static int read_flash_id(struct flash_bank *bank, uint32_t *id)
return ERROR_OK; return ERROR_OK;
} }
static int spearsmi_probe(struct flash_bank *bank) static int stmsmi_probe(struct flash_bank *bank)
{ {
struct target *target = bank->target; struct target *target = bank->target;
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
uint32_t io_base; uint32_t io_base;
struct flash_sector *sectors; struct flash_sector *sectors;
uint32_t id = 0; /* silence uninitialized warning */ uint32_t id = 0; /* silence uninitialized warning */
struct spearsmi_target *target_device; struct stmsmi_target *target_device;
int retval; int retval;
if (spearsmi_info->probed) if (stmsmi_info->probed)
free(bank->sectors); free(bank->sectors);
spearsmi_info->probed = 0; stmsmi_info->probed = 0;
for (target_device=target_devices ; target_device->name ; ++target_device) for (target_device=target_devices ; target_device->name ; ++target_device)
if (target_device->tap_idcode == target->tap->idcode) if (target_device->tap_idcode == target->tap->idcode)
@ -628,23 +628,23 @@ static int spearsmi_probe(struct flash_bank *bank)
switch (bank->base - target_device->smi_base) switch (bank->base - target_device->smi_base)
{ {
case 0: case 0:
spearsmi_info->bank_num = SMI_SEL_BANK0; stmsmi_info->bank_num = SMI_SEL_BANK0;
break; break;
case SMI_BANK_SIZE: case SMI_BANK_SIZE:
spearsmi_info->bank_num = SMI_SEL_BANK1; stmsmi_info->bank_num = SMI_SEL_BANK1;
break; break;
case 2*SMI_BANK_SIZE: case 2*SMI_BANK_SIZE:
spearsmi_info->bank_num = SMI_SEL_BANK2; stmsmi_info->bank_num = SMI_SEL_BANK2;
break; break;
case 3*SMI_BANK_SIZE: case 3*SMI_BANK_SIZE:
spearsmi_info->bank_num = SMI_SEL_BANK3; stmsmi_info->bank_num = SMI_SEL_BANK3;
break; break;
default: default:
LOG_ERROR("Invalid SMI base address 0x%" PRIx32, bank->base); LOG_ERROR("Invalid SMI base address 0x%" PRIx32, bank->base);
return ERROR_FAIL; return ERROR_FAIL;
} }
io_base = target_device->io_base; io_base = target_device->io_base;
spearsmi_info->io_base = io_base; stmsmi_info->io_base = io_base;
LOG_DEBUG("Valid SMI on device %s at address 0x%" PRIx32, LOG_DEBUG("Valid SMI on device %s at address 0x%" PRIx32,
target_device->name, bank->base); target_device->name, bank->base);
@ -655,28 +655,28 @@ static int spearsmi_probe(struct flash_bank *bank)
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
spearsmi_info->dev = NULL; stmsmi_info->dev = NULL;
for (struct flash_device *p = flash_devices; p->name ; p++) for (struct flash_device *p = flash_devices; p->name ; p++)
if (p->device_id == id) { if (p->device_id == id) {
spearsmi_info->dev = p; stmsmi_info->dev = p;
break; break;
} }
if (!spearsmi_info->dev) if (!stmsmi_info->dev)
{ {
LOG_ERROR("Unknown flash device (ID 0x%08" PRIx32 ")", id); LOG_ERROR("Unknown flash device (ID 0x%08" PRIx32 ")", id);
return ERROR_FAIL; return ERROR_FAIL;
} }
LOG_INFO("Found flash device \'%s\' (ID 0x%08" PRIx32 ")", LOG_INFO("Found flash device \'%s\' (ID 0x%08" PRIx32 ")",
spearsmi_info->dev->name, spearsmi_info->dev->device_id); stmsmi_info->dev->name, stmsmi_info->dev->device_id);
/* Set correct size value */ /* Set correct size value */
bank->size = spearsmi_info->dev->size_in_bytes; bank->size = stmsmi_info->dev->size_in_bytes;
/* create and fill sectors array */ /* create and fill sectors array */
bank->num_sectors = bank->num_sectors =
spearsmi_info->dev->size_in_bytes / spearsmi_info->dev->sectorsize; stmsmi_info->dev->size_in_bytes / stmsmi_info->dev->sectorsize;
sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors); sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors);
if (sectors == NULL) if (sectors == NULL)
{ {
@ -686,62 +686,62 @@ static int spearsmi_probe(struct flash_bank *bank)
for (int sector = 0; sector < bank->num_sectors; sector++) for (int sector = 0; sector < bank->num_sectors; sector++)
{ {
sectors[sector].offset = sector * spearsmi_info->dev->sectorsize; sectors[sector].offset = sector * stmsmi_info->dev->sectorsize;
sectors[sector].size = spearsmi_info->dev->sectorsize; sectors[sector].size = stmsmi_info->dev->sectorsize;
sectors[sector].is_erased = -1; sectors[sector].is_erased = -1;
sectors[sector].is_protected = 1; sectors[sector].is_protected = 1;
} }
bank->sectors = sectors; bank->sectors = sectors;
spearsmi_info->probed = 1; stmsmi_info->probed = 1;
return ERROR_OK; return ERROR_OK;
} }
static int spearsmi_auto_probe(struct flash_bank *bank) static int stmsmi_auto_probe(struct flash_bank *bank)
{ {
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
if (spearsmi_info->probed) if (stmsmi_info->probed)
return ERROR_OK; return ERROR_OK;
return spearsmi_probe(bank); return stmsmi_probe(bank);
} }
static int spearsmi_protect_check(struct flash_bank *bank) static int stmsmi_protect_check(struct flash_bank *bank)
{ {
/* Nothing to do. Protection is only handled in SW. */ /* Nothing to do. Protection is only handled in SW. */
return ERROR_OK; return ERROR_OK;
} }
static int get_spearsmi_info(struct flash_bank *bank, char *buf, int buf_size) static int get_stmsmi_info(struct flash_bank *bank, char *buf, int buf_size)
{ {
struct spearsmi_flash_bank *spearsmi_info = bank->driver_priv; struct stmsmi_flash_bank *stmsmi_info = bank->driver_priv;
int printed; int printed;
if (!(spearsmi_info->probed)) if (!(stmsmi_info->probed))
{ {
printed = snprintf(buf, buf_size, printed = snprintf(buf, buf_size,
"\nSPEAr SMI flash bank not probed yet\n"); "\nSMI flash bank not probed yet\n");
return ERROR_OK; return ERROR_OK;
} }
printed = snprintf(buf, buf_size, "\nSPEAr SMI flash information:\n" printed = snprintf(buf, buf_size, "\nSMI flash information:\n"
" Device \'%s\' (ID 0x%08x)\n", " Device \'%s\' (ID 0x%08x)\n",
spearsmi_info->dev->name, spearsmi_info->dev->device_id); stmsmi_info->dev->name, stmsmi_info->dev->device_id);
buf += printed; buf += printed;
buf_size -= printed; buf_size -= printed;
return ERROR_OK; return ERROR_OK;
} }
struct flash_driver spearsmi_flash = { struct flash_driver stmsmi_flash = {
.name = "spearsmi", .name = "stmsmi",
.flash_bank_command = spearsmi_flash_bank_command, .flash_bank_command = stmsmi_flash_bank_command,
.erase = spearsmi_erase, .erase = stmsmi_erase,
.protect = spearsmi_protect, .protect = stmsmi_protect,
.write = spearsmi_write, .write = stmsmi_write,
.read = default_flash_read, .read = default_flash_read,
.probe = spearsmi_probe, .probe = stmsmi_probe,
.auto_probe = spearsmi_auto_probe, .auto_probe = stmsmi_auto_probe,
.erase_check = default_flash_blank_check, .erase_check = default_flash_blank_check,
.protect_check = spearsmi_protect_check, .protect_check = stmsmi_protect_check,
.info = get_spearsmi_info, .info = get_stmsmi_info,
}; };

2
tcl/board/spear310evb20.cfg
View File

@ -27,7 +27,7 @@ flash bank $_FLASHNAME0 cfi 0x50000000 0x01000000 2 4 $_TARGETNAME
# Serial NOR on SMI CS0. 8Mbyte. # Serial NOR on SMI CS0. 8Mbyte.
set _FLASHNAME1 $_CHIPNAME.snor set _FLASHNAME1 $_CHIPNAME.snor
flash bank $_FLASHNAME1 spearsmi 0xf8000000 0 0 0 $_TARGETNAME flash bank $_FLASHNAME1 stmsmi 0xf8000000 0 0 0 $_TARGETNAME
if { [info exists BOARD_HAS_SRST] } { if { [info exists BOARD_HAS_SRST] } {
# Modified board has SRST on JTAG connector # Modified board has SRST on JTAG connector

2
tcl/target/str750.cfg
View File

@ -61,7 +61,7 @@ flash bank $_FLASHNAME str7x 0x200C0000 0x00004000 0 0 $_TARGETNAME STR75x
# Serial NOR on SMI CS0. # Serial NOR on SMI CS0.
set _FLASHNAME $_CHIPNAME.snor set _FLASHNAME $_CHIPNAME.snor
flash bank $_FLASHNAME spearsmi 0x80000000 0 0 0 $_TARGETNAME flash bank $_FLASHNAME stmsmi 0x80000000 0 0 0 $_TARGETNAME
source [find mem_helper.tcl] source [find mem_helper.tcl]