mdr32fx: support for Milandr's MDR32Fx internal flash memory

This adds example config and flash driver for russian Cortex-M3
microcontroller model.

Run-time tested on MDR32F9Q2I evaluation board; the flash driver
should be compatible with MDR32F2x (Cortex-M0) too but I lack hardware
to test.

There're no status bits at all, the datasheets specifies some delays
for flash operations instead. All being in <100us range, they're hard
to violate with JTAG, I hope. There're also no flash identification
registers so the flash size and type has to be hardcoded into the
config.

The flashing is considerably complicated because the flash is split
into pages, and each page consists of 4 interleaved non-consecutive
"sectors" (on MDR32F9 only, MDR32F2 is single-sectored), so the
fastest way is to latch the page and sector address and then write
only the part that should go into the current page and current sector.

Performance testing results with adapter_khz 1000 and the chip running
on its default HSI 8MHz oscillator:

When working area is specified, a target helper algorithm is used:
wrote 131072 bytes from file testfile.bin in 3.698427s (34.609 KiB/s)

This can theoretically be sped up by ~1.4 times if the helper
algorithm is fed some kind of "loader instructions stream" to allow
sector-by-sector writing.

Pure JTAG implementation (when target memory area is not available)
flashes all the 128k memory in 49.5s.

Flashing "info" memory region is also implemented, but due to the
overlapping memory addresses (resulting in incorrect memory map
calculations for GDB) it can't be used at the same time, so OpenOCD
needs to be started this way: -c "set IMEMORY true" -f
target/mdr32f9q2i.cfg

It also can't be read/verified because it's not memory-mapped anywhere
ever, and OpenOCD NOR framework doesn't really allow to provide a
custom handler that would be used when verifying.

Change-Id: I80c0632da686d49856fdbf9e05d908846dd44316
Signed-off-by: Paul Fertser <fercerpav@gmail.com>
Reviewed-on: http://openocd.zylin.com/1532
Tested-by: jenkins
Reviewed-by: Spencer Oliver <spen@spen-soft.co.uk>
__archive__
Paul Fertser 2013-07-29 17:22:07 +04:00 committed by Spencer Oliver
parent d998ea40f3
commit fccc55225a
5 changed files with 706 additions and 0 deletions

View File

@ -0,0 +1,125 @@
/***************************************************************************
* Copyright (C) 2011 by Andreas Fritiofson *
* andreas.fritiofson@gmail.com *
* *
* Copyright (C) 2013 by Paul Fertser *
* fercerpav@gmail.com *
* *
* 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., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
***************************************************************************/
.text
.syntax unified
.cpu cortex-m0
.thumb
.thumb_func
.global write
/* Params:
* r0 - flash base (in), status (out)
* r1 - count (32bit)
* r2 - workarea start
* r3 - workarea end
* r4 - target address
* Clobbered:
* r5 - rp
* r6 - wp, tmp
* r7 - current FLASH_CMD
*/
#define FLASH_CMD 0x00
#define FLASH_ADR 0x04
#define FLASH_DI 0x08
#define FLASH_NVSTR (1 << 13)
#define FLASH_PROG (1 << 12)
#define FLASH_MAS1 (1 << 11)
#define FLASH_ERASE (1 << 10)
#define FLASH_SE (1 << 8)
#define FLASH_YE (1 << 7)
#define FLASH_XE (1 << 6)
ldr r7, [r0, #FLASH_CMD]
wait_fifo:
ldr r6, [r2, #0] /* read wp */
cmp r6, #0 /* abort if wp == 0 */
beq exit
ldr r5, [r2, #4] /* read rp */
cmp r5, r6 /* wait until rp != wp */
beq wait_fifo
ldr r6, [r5] /* "*target_address++ = *rp++" */
str r4, [r0, #FLASH_ADR]
str r6, [r0, #FLASH_DI]
ldr r6, =(FLASH_XE | FLASH_PROG)
orrs r7, r7, r6
str r7, [r0, #FLASH_CMD]
# wait 5us
movs r6, #5
bl delay
ldr r6, =#FLASH_NVSTR
orrs r7, r7, r6
str r7, [r0, #FLASH_CMD]
# wait 10us
movs r6, #13
bl delay
movs r6, #FLASH_YE
orrs r7, r7, r6
str r7, [r0, #FLASH_CMD]
# wait 40us
movs r6, #61
bl delay
movs r6, #FLASH_YE
bics r7, r7, r6
str r7, [r0, #FLASH_CMD]
ldr r6, =#FLASH_PROG
bics r7, r7, r6
str r7, [r0, #FLASH_CMD]
# wait 5us
movs r6, #5
bl delay
ldr r6, =#(FLASH_XE | FLASH_NVSTR)
bics r7, r7, r6
str r7, [r0, #FLASH_CMD]
adds r5, #4
adds r4, #4
cmp r5, r3 /* wrap rp at end of buffer */
bcc no_wrap
mov r5, r2
adds r5, #8
no_wrap:
str r5, [r2, #4] /* store rp */
subs r1, r1, #1 /* decrement word count */
cmp r1, #0
beq exit /* loop if not done */
b wait_fifo
exit:
mov r0, r6 /* return status in r0 */
bkpt #0
/* r6 - in
* for r6 == 1 it'll take:
* 1 (prepare operand) + 4 (bl) + 2 (subs+cmp) + 1 (bne) + 3 (b) ->
* 11 tacts == 1.4us with 8MHz
* every extra iteration will take 5 tacts == 0.6us */
delay:
subs r6, r6, #1
cmp r6, #0
bne delay
bx lr

View File

@ -21,6 +21,7 @@ NOR_DRIVERS = \
lpc288x.c \ lpc288x.c \
lpc2900.c \ lpc2900.c \
lpcspifi.c \ lpcspifi.c \
mdr.c \
non_cfi.c \ non_cfi.c \
ocl.c \ ocl.c \
pic32mx.c \ pic32mx.c \

View File

@ -50,6 +50,7 @@ extern struct flash_driver dsp5680xx_flash;
extern struct flash_driver fm3_flash; extern struct flash_driver fm3_flash;
extern struct flash_driver kinetis_flash; extern struct flash_driver kinetis_flash;
extern struct flash_driver efm32_flash; extern struct flash_driver efm32_flash;
extern struct flash_driver mdr_flash;
/** /**
* The list of built-in flash drivers. * The list of built-in flash drivers.
@ -84,6 +85,7 @@ static struct flash_driver *flash_drivers[] = {
&dsp5680xx_flash, &dsp5680xx_flash,
&kinetis_flash, &kinetis_flash,
&efm32_flash, &efm32_flash,
&mdr_flash,
NULL, NULL,
}; };

527
src/flash/nor/mdr.c Normal file
View File

@ -0,0 +1,527 @@
/***************************************************************************
* Copyright (C) 2005 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
* Copyright (C) 2008 by Spencer Oliver *
* spen@spen-soft.co.uk *
* *
* Copyright (C) 2011 by Andreas Fritiofson *
* andreas.fritiofson@gmail.com *
* *
* Copyright (C) 2013 by Paul Fertser *
* fercerpav@gmail.com *
* *
* 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., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "imp.h"
#include <helper/binarybuffer.h>
#include <target/algorithm.h>
#include <target/armv7m.h>
#define MD_RST_CLK 0x40020000
#define MD_PER_CLOCK (MD_RST_CLK + 0x1C)
#define MD_PER_CLOCK_EEPROM (1 << 3)
#define MD_PER_CLOCK_RST_CLK (1 << 4)
#define FLASH_REG_BASE 0x40018000
#define FLASH_CMD (FLASH_REG_BASE + 0x00)
#define FLASH_ADR (FLASH_REG_BASE + 0x04)
#define FLASH_DI (FLASH_REG_BASE + 0x08)
#define FLASH_DO (FLASH_REG_BASE + 0x0C)
#define FLASH_KEY (FLASH_REG_BASE + 0x10)
#define FLASH_NVSTR (1 << 13)
#define FLASH_PROG (1 << 12)
#define FLASH_MAS1 (1 << 11)
#define FLASH_ERASE (1 << 10)
#define FLASH_IFREN (1 << 9)
#define FLASH_SE (1 << 8)
#define FLASH_YE (1 << 7)
#define FLASH_XE (1 << 6)
#define FLASH_RD (1 << 2)
#define FLASH_WR (1 << 1)
#define FLASH_CON (1 << 0)
#define FLASH_DELAY_MASK (7 << 3)
#define KEY 0x8AAA5551
struct mdr_flash_bank {
int probed;
unsigned int mem_type;
unsigned int page_count;
unsigned int sec_count;
};
/* flash bank <name> mdr <base> <size> 0 0 <target#> <type> <page_count> <sec_count> */
FLASH_BANK_COMMAND_HANDLER(mdr_flash_bank_command)
{
struct mdr_flash_bank *mdr_info;
if (CMD_ARGC < 9)
return ERROR_COMMAND_SYNTAX_ERROR;
mdr_info = malloc(sizeof(struct mdr_flash_bank));
bank->driver_priv = mdr_info;
mdr_info->probed = 0;
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[6], mdr_info->mem_type);
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[7], mdr_info->page_count);
COMMAND_PARSE_NUMBER(uint, CMD_ARGV[8], mdr_info->sec_count);
return ERROR_OK;
}
static int mdr_protect_check(struct flash_bank *bank)
{
return ERROR_OK;
}
static int mdr_mass_erase(struct flash_bank *bank)
{
struct target *target = bank->target;
struct mdr_flash_bank *mdr_info = bank->driver_priv;
uint32_t flash_cmd;
int retval;
unsigned int i;
retval = target_read_u32(target, FLASH_CMD, &flash_cmd);
if (retval != ERROR_OK)
return retval;
for (i = 0; i < mdr_info->sec_count; i++) {
retval = target_write_u32(target, FLASH_ADR, i << 2);
if (retval != ERROR_OK)
return retval;
flash_cmd |= FLASH_XE | FLASH_MAS1 | FLASH_ERASE;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
return retval;
flash_cmd |= FLASH_NVSTR;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
return retval;
flash_cmd &= ~FLASH_ERASE;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
return retval;
flash_cmd &= ~(FLASH_XE | FLASH_MAS1 | FLASH_NVSTR);
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
return retval;
}
return retval;
}
static int mdr_erase(struct flash_bank *bank, int first, int last)
{
struct target *target = bank->target;
struct mdr_flash_bank *mdr_info = bank->driver_priv;
int i, retval, retval2;
unsigned int j;
uint32_t flash_cmd, cur_per_clock;
if (bank->target->state != TARGET_HALTED) {
LOG_ERROR("Target not halted");
return ERROR_TARGET_NOT_HALTED;
}
retval = target_read_u32(target, MD_PER_CLOCK, &cur_per_clock);
if (retval != ERROR_OK)
return retval;
if (!(cur_per_clock & 0x10)) {
LOG_ERROR("Target needs reset before flash operations");
return ERROR_FLASH_OPERATION_FAILED;
}
retval = target_write_u32(target, MD_PER_CLOCK, cur_per_clock | MD_PER_CLOCK_EEPROM);
if (retval != ERROR_OK)
return retval;
retval = target_write_u32(target, FLASH_KEY, KEY);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
retval = target_read_u32(target, FLASH_CMD, &flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
/* Switch on register access */
flash_cmd = (flash_cmd & FLASH_DELAY_MASK) | FLASH_CON;
if (mdr_info->mem_type)
flash_cmd |= FLASH_IFREN;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
if ((first == 0) && (last == (bank->num_sectors - 1))) {
retval = mdr_mass_erase(bank);
goto reset_pg_and_lock;
}
unsigned int page_size = bank->size / mdr_info->page_count;
for (i = first; i <= last; i++) {
for (j = 0; j < mdr_info->sec_count; j++) {
retval = target_write_u32(target, FLASH_ADR, (i * page_size) | (j << 2));
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd |= FLASH_XE | FLASH_ERASE;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd |= FLASH_NVSTR;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd &= ~FLASH_ERASE;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd &= ~(FLASH_XE | FLASH_NVSTR);
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
}
bank->sectors[i].is_erased = 1;
}
reset_pg_and_lock:
flash_cmd &= FLASH_DELAY_MASK;
retval2 = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval == ERROR_OK)
retval = retval2;
retval2 = target_write_u32(target, FLASH_KEY, 0);
if (retval == ERROR_OK)
retval = retval2;
return retval;
}
static int mdr_protect(struct flash_bank *bank, int set, int first, int last)
{
return ERROR_OK;
}
static int mdr_write_block(struct flash_bank *bank, uint8_t *buffer,
uint32_t offset, uint32_t count)
{
struct target *target = bank->target;
uint32_t buffer_size = 16384;
struct working_area *write_algorithm;
struct working_area *source;
uint32_t address = bank->base + offset;
struct reg_param reg_params[5];
struct armv7m_algorithm armv7m_info;
int retval = ERROR_OK;
/* see contrib/loaders/flash/mdr32fx.S for src */
static const uint8_t mdr32fx_flash_write_code[] = {
0x07, 0x68, 0x16, 0x68, 0x00, 0x2e, 0x2e, 0xd0, 0x55, 0x68, 0xb5, 0x42,
0xf9, 0xd0, 0x2e, 0x68, 0x44, 0x60, 0x86, 0x60, 0x17, 0x4e, 0x37, 0x43,
0x07, 0x60, 0x05, 0x26, 0x00, 0xf0, 0x25, 0xf8, 0x15, 0x4e, 0x37, 0x43,
0x07, 0x60, 0x0d, 0x26, 0x00, 0xf0, 0x1f, 0xf8, 0x80, 0x26, 0x37, 0x43,
0x07, 0x60, 0x3d, 0x26, 0x00, 0xf0, 0x19, 0xf8, 0x80, 0x26, 0xb7, 0x43,
0x07, 0x60, 0x0f, 0x4e, 0xb7, 0x43, 0x07, 0x60, 0x05, 0x26, 0x00, 0xf0,
0x10, 0xf8, 0x0d, 0x4e, 0xb7, 0x43, 0x07, 0x60, 0x04, 0x35, 0x04, 0x34,
0x9d, 0x42, 0x01, 0xd3, 0x15, 0x46, 0x08, 0x35, 0x55, 0x60, 0x01, 0x39,
0x00, 0x29, 0x00, 0xd0, 0xcd, 0xe7, 0x30, 0x46, 0x00, 0xbe, 0x01, 0x3e,
0x00, 0x2e, 0xfc, 0xd1, 0x70, 0x47, 0x00, 0x00, 0x40, 0x10, 0x00, 0x00,
0x00, 0x20, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x40, 0x20, 0x00, 0x00
};
/* flash write code */
if (target_alloc_working_area(target, sizeof(mdr32fx_flash_write_code),
&write_algorithm) != ERROR_OK) {
LOG_WARNING("no working area available, can't do block memory writes");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
};
retval = target_write_buffer(target, write_algorithm->address,
sizeof(mdr32fx_flash_write_code), (uint8_t *)mdr32fx_flash_write_code);
if (retval != ERROR_OK)
return retval;
/* memory buffer */
while (target_alloc_working_area_try(target, buffer_size, &source) != ERROR_OK) {
buffer_size /= 2;
buffer_size &= ~3UL; /* Make sure it's 4 byte aligned */
if (buffer_size <= 256) {
/* we already allocated the writing code, but failed to get a
* buffer, free the algorithm */
target_free_working_area(target, write_algorithm);
LOG_WARNING("no large enough working area available, can't do block memory writes");
return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
}
};
init_reg_param(&reg_params[0], "r0", 32, PARAM_IN_OUT); /* flash base (in), status (out) */
init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT); /* count (32bit) */
init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT); /* buffer start */
init_reg_param(&reg_params[3], "r3", 32, PARAM_OUT); /* buffer end */
init_reg_param(&reg_params[4], "r4", 32, PARAM_IN_OUT); /* target address */
buf_set_u32(reg_params[0].value, 0, 32, FLASH_REG_BASE);
buf_set_u32(reg_params[1].value, 0, 32, count);
buf_set_u32(reg_params[2].value, 0, 32, source->address);
buf_set_u32(reg_params[3].value, 0, 32, source->address + source->size);
buf_set_u32(reg_params[4].value, 0, 32, address);
armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
armv7m_info.core_mode = ARM_MODE_THREAD;
retval = target_run_flash_async_algorithm(target, buffer, count, 4,
0, NULL,
5, reg_params,
source->address, source->size,
write_algorithm->address, 0,
&armv7m_info);
if (retval == ERROR_FLASH_OPERATION_FAILED)
LOG_ERROR("flash write failed at address 0x%"PRIx32,
buf_get_u32(reg_params[4].value, 0, 32));
target_free_working_area(target, source);
target_free_working_area(target, write_algorithm);
destroy_reg_param(&reg_params[0]);
destroy_reg_param(&reg_params[1]);
destroy_reg_param(&reg_params[2]);
destroy_reg_param(&reg_params[3]);
destroy_reg_param(&reg_params[4]);
return retval;
}
static int mdr_write(struct flash_bank *bank, uint8_t *buffer,
uint32_t offset, uint32_t count)
{
struct target *target = bank->target;
struct mdr_flash_bank *mdr_info = bank->driver_priv;
uint8_t *new_buffer = NULL;
if (bank->target->state != TARGET_HALTED) {
LOG_ERROR("Target not halted");
return ERROR_TARGET_NOT_HALTED;
}
if (offset & 0x3) {
LOG_ERROR("offset 0x%" PRIx32 " breaks required 4-byte alignment", offset);
return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
}
/* If there's an odd number of bytes, the data has to be padded. Duplicate
* the buffer and use the normal code path with a single block write since
* it's probably cheaper than to special case the last odd write using
* discrete accesses. */
int rem = count % 4;
if (rem) {
new_buffer = malloc(count + rem);
if (new_buffer == NULL) {
LOG_ERROR("odd number of bytes to write and no memory for padding buffer");
return ERROR_FAIL;
}
LOG_INFO("odd number of bytes to write, padding with 0xff");
buffer = memcpy(new_buffer, buffer, count);
while (rem--)
buffer[count++] = 0xff;
}
uint32_t flash_cmd, cur_per_clock;
int retval, retval2;
retval = target_read_u32(target, MD_PER_CLOCK, &cur_per_clock);
if (retval != ERROR_OK)
return retval;
if (!(cur_per_clock & MD_PER_CLOCK_RST_CLK)) {
/* Something's very wrong if the RST_CLK module is not clocked */
LOG_ERROR("Target needs reset before flash operations");
return ERROR_FLASH_OPERATION_FAILED;
}
retval = target_write_u32(target, MD_PER_CLOCK, cur_per_clock | MD_PER_CLOCK_EEPROM);
if (retval != ERROR_OK)
return retval;
retval = target_write_u32(target, FLASH_KEY, KEY);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
retval = target_read_u32(target, FLASH_CMD, &flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
/* Switch on register access */
flash_cmd = (flash_cmd & FLASH_DELAY_MASK) | FLASH_CON;
if (mdr_info->mem_type)
flash_cmd |= FLASH_IFREN;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
/* try using block write */
retval = mdr_write_block(bank, buffer, offset, count/4);
if (retval == ERROR_TARGET_RESOURCE_NOT_AVAILABLE) {
/* if block write failed (no sufficient working area),
* we use normal (slow) single halfword accesses */
LOG_WARNING("Can't use block writes, falling back to single memory accesses");
unsigned int page_size = bank->size / mdr_info->page_count;
unsigned int page_mask = page_size - 1;
while (count > 0) {
unsigned int i, j;
unsigned int cur_page = offset & ~page_mask;
unsigned int bytes_to_write = cur_page + page_size - offset;
if (count < bytes_to_write)
bytes_to_write = count;
/*LOG_INFO("Selecting next page: %08x", cur_page);*/
for (i = 0; i < mdr_info->sec_count; i++) {
retval = target_write_u32(target, FLASH_ADR, offset + i*4);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
/*LOG_INFO("Selecting page/sector: %08x", offset + i*4);*/
flash_cmd |= FLASH_XE | FLASH_PROG;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd |= FLASH_NVSTR;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
for (j = 0;
(((offset + j + i*4) & ~page_mask) == cur_page) &&
(j + i*4 < count);
j += mdr_info->sec_count*4) {
uint32_t value;
memcpy(&value, buffer + j + i*4, sizeof(uint32_t));
retval = target_write_u32(target, FLASH_DI, value);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
/*LOG_INFO("Writing to addr %08x", offset + j + i*4);*/
retval = target_write_u32(target, FLASH_ADR, offset + j + i*4);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd |= FLASH_YE;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd &= ~FLASH_YE;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
}
flash_cmd &= ~FLASH_NVSTR;
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
flash_cmd &= ~(FLASH_XE | FLASH_PROG);
retval = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval != ERROR_OK)
goto reset_pg_and_lock;
}
buffer += bytes_to_write;
offset += bytes_to_write;
count -= bytes_to_write;
}
}
reset_pg_and_lock:
flash_cmd &= FLASH_DELAY_MASK;
retval2 = target_write_u32(target, FLASH_CMD, flash_cmd);
if (retval == ERROR_OK)
retval = retval2;
retval2 = target_write_u32(target, FLASH_KEY, 0);
if (retval == ERROR_OK)
retval = retval2;
if (new_buffer)
free(new_buffer);
return retval;
}
static int mdr_probe(struct flash_bank *bank)
{
struct mdr_flash_bank *mdr_info = bank->driver_priv;
unsigned int page_count, page_size, i;
page_count = mdr_info->page_count;
page_size = bank->size / page_count;
bank->num_sectors = page_count;
bank->sectors = malloc(sizeof(struct flash_sector) * page_count);
for (i = 0; i < page_count; i++) {
bank->sectors[i].offset = i * page_size;
bank->sectors[i].size = page_size;
bank->sectors[i].is_erased = -1;
bank->sectors[i].is_protected = 0;
}
mdr_info->probed = 1;
return ERROR_OK;
}
static int mdr_auto_probe(struct flash_bank *bank)
{
struct mdr_flash_bank *mdr_info = bank->driver_priv;
if (mdr_info->probed)
return ERROR_OK;
return mdr_probe(bank);
}
static int get_mdr_info(struct flash_bank *bank, char *buf, int buf_size)
{
struct mdr_flash_bank *mdr_info = bank->driver_priv;
snprintf(buf, buf_size, "MDR32Fx - %s",
mdr_info->mem_type ? "info memory" : "main memory");
return ERROR_OK;
}
struct flash_driver mdr_flash = {
.name = "mdr",
.flash_bank_command = mdr_flash_bank_command,
.erase = mdr_erase,
.protect = mdr_protect,
.write = mdr_write,
.read = default_flash_read,
.probe = mdr_probe,
.auto_probe = mdr_auto_probe,
.erase_check = default_flash_blank_check,
.protect_check = mdr_protect_check,
.info = get_mdr_info,
};

51
tcl/target/mdr32f9q2i.cfg Normal file
View File

@ -0,0 +1,51 @@
# MDR32F9Q2I (1986ВЕ92У)
# http://milandr.ru/index.php?mact=Products,cntnt01,details,0&cntnt01productid=57&cntnt01returnid=68
if { [info exists CHIPNAME] } {
set _CHIPNAME $CHIPNAME
} else {
set _CHIPNAME mdr32f9q2i
}
if { [info exists ENDIAN] } {
set _ENDIAN $ENDIAN
} else {
set _ENDIAN little
}
# Work-area is a space in RAM used for flash programming
if { [info exists WORKAREASIZE] } {
set _WORKAREASIZE $WORKAREASIZE
} else {
set _WORKAREASIZE 0x8000
}
# JTAG speed should be <= F_CPU/6. F_CPU after reset is 8MHz, so use F_JTAG = 1MHz
adapter_khz 1000
adapter_nsrst_delay 100
jtag_ntrst_delay 100
#jtag scan chain
if { [info exists CPUTAPID] } {
set _CPUTAPID $CPUTAPID
} else {
set _CPUTAPID 0x4ba00477
}
jtag newtap $_CHIPNAME cpu -irlen 4 -ircapture 0x1 -irmask 0xf -expected-id $_CPUTAPID
set _TARGETNAME $_CHIPNAME.cpu
target create $_TARGETNAME cortex_m -endian $_ENDIAN -chain-position $_TARGETNAME
$_TARGETNAME configure -work-area-phys 0x20000000 -work-area-size $_WORKAREASIZE -work-area-backup 0
# can't handle overlapping memory regions
if { [info exists IMEMORY] && [string equal $IMEMORY true] } {
flash bank ${_CHIPNAME}_info.flash mdr 0x08000000 0x01000 0 0 $_TARGETNAME 1 1 4
} else {
flash bank $_CHIPNAME.flash mdr 0x08000000 0x20000 0 0 $_TARGETNAME 0 32 4
}
# if srst is not fitted use SYSRESETREQ to
# perform a soft reset
cortex_m reset_config sysresetreq