interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

target: faster mww operations 

Signed-off-by: Øyvind Harboe <oyvind.harboe@zylin.com>
This commit is contained in:
Øyvind Harboe 2010-03-16 18:02:58 +01:00
parent 099ffc754a
commit bf71e34cbf
1 changed files with 77 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
src/target/target.c
View File

@ -2,7 +2,7 @@
* Copyright (C) 2005 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
* Copyright (C) 2007-2009 Øyvind Harboe *
* Copyright (C) 2007-2010 Øyvind Harboe *
* oyvind.harboe@zylin.com *
* *
* Copyright (C) 2008, Duane Ellis *
@ -2294,6 +2294,74 @@ COMMAND_HANDLER(handle_md_command)
return retval;
}
typedef int (*target_write_fn)(struct target *target,
uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
static int target_write_memory_fast(struct target *target,
uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
{
return target_write_buffer(target, address, size * count, buffer);
}
static int target_fill_mem(struct target *target,
uint32_t address,
target_write_fn fn,
unsigned data_size,
/* value */
uint32_t b,
/* count */
unsigned c)
{
/* We have to write in reasonably large chunks to be able
* to fill large memory areas with any sane speed */
const unsigned chunk_size = 16384;
uint8_t *target_buf = malloc(chunk_size * data_size);
if (target_buf == NULL)
{
LOG_ERROR("Out of memory");
return ERROR_FAIL;
}
for (unsigned i = 0; i < chunk_size; i ++)
{
switch (data_size)
{
case 4:
target_buffer_set_u32(target, target_buf + i*data_size, b);
break;
case 2:
target_buffer_set_u16(target, target_buf + i*data_size, b);
break;
case 1:
target_buffer_set_u8(target, target_buf + i*data_size, b);
break;
default:
exit(-1);
}
}
int retval = ERROR_OK;
for (unsigned x = 0; x < c; x += chunk_size)
{
unsigned current;
current = c - x;
if (current > chunk_size)
{
current = chunk_size;
}
int retval = fn(target, address + x * data_size, data_size, current, target_buf);
if (retval != ERROR_OK)
{
break;
}
}
free(target_buf);
return retval;
}
COMMAND_HANDLER(handle_mw_command)
{
if (CMD_ARGC < 2)
@ -2301,8 +2369,7 @@ COMMAND_HANDLER(handle_mw_command)
return ERROR_COMMAND_SYNTAX_ERROR;
}
bool physical=strcmp(CMD_ARGV[0], "phys")==0;
int (*fn)(struct target *target,
uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
target_write_fn fn;
if (physical)
{
CMD_ARGC--;
@ -2310,7 +2377,7 @@ COMMAND_HANDLER(handle_mw_command)
fn=target_write_phys_memory;
} else
{
fn=target_write_memory;
fn = target_write_memory_fast;
}
if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
return ERROR_COMMAND_SYNTAX_ERROR;
@ -2327,35 +2394,22 @@ COMMAND_HANDLER(handle_mw_command)
struct target *target = get_current_target(CMD_CTX);
unsigned wordsize;
uint8_t value_buf[4];
switch (CMD_NAME[2])
{
case 'w':
wordsize = 4;
target_buffer_set_u32(target, value_buf, value);
break;
case 'h':
wordsize = 2;
target_buffer_set_u16(target, value_buf, value);
break;
case 'b':
wordsize = 1;
value_buf[0] = value;
break;
default:
return ERROR_COMMAND_SYNTAX_ERROR;
}
for (unsigned i = 0; i < count; i++)
{
int retval = fn(target,
address + i * wordsize, wordsize, 1, value_buf);
if (ERROR_OK != retval)
return retval;
keep_alive();
}
return ERROR_OK;
return target_fill_mem(target, address, fn, wordsize, value, count);
}
static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
@ -3909,36 +3963,21 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
}
struct target *target = Jim_CmdPrivData(goi.interp);
uint8_t target_buf[32];
unsigned data_size;
if (strcasecmp(cmd_name, "mww") == 0) {
target_buffer_set_u32(target, target_buf, b);
b = 4;
data_size = 4;
}
else if (strcasecmp(cmd_name, "mwh") == 0) {
target_buffer_set_u16(target, target_buf, b);
b = 2;
data_size = 2;
}
else if (strcasecmp(cmd_name, "mwb") == 0) {
target_buffer_set_u8(target, target_buf, b);
b = 1;
data_size = 1;
} else {
LOG_ERROR("command '%s' unknown: ", cmd_name);
return JIM_ERR;
}
for (jim_wide x = 0; x < c; x++)
{
e = target_write_memory(target, a, b, 1, target_buf);
if (e != ERROR_OK)
{
Jim_SetResult_sprintf(interp,
"Error writing @ 0x%08x: %d\n", (int)(a), e);
return JIM_ERR;
}
/* b = width */
a = a + b;
}
return JIM_OK;
return (target_fill_mem(target, a, target_write_memory_fast, data_size, b, c) == ERROR_OK) ? JIM_OK : JIM_ERR;
}
static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)