From 2b3f4fd293398f1868f8bad864f68f6ffec12ada Mon Sep 17 00:00:00 2001 From: oharboe Date: Thu, 10 Jul 2008 18:47:50 +0000 Subject: [PATCH] Charles Hardin Add semantics to support memwrite(32,16,8) with an array2mem command Move the global up in bits2bytes.tcl so the set puts the value in the global context. Add memwrite procs to memory.tcl git-svn-id: svn://svn.berlios.de/openocd/trunk@786 b42882b7-edfa-0310-969c-e2dbd0fdcd60 --- src/openocd.c | 181 +++++++++++++++++++++++++++++++++++++++++- src/tcl/bitsbytes.tcl | 8 +- src/tcl/memory.tcl | 37 +++++++-- 3 files changed, 211 insertions(+), 15 deletions(-) diff --git a/src/openocd.c b/src/openocd.c index c7b18eb24..64965e37a 100644 --- a/src/openocd.c +++ b/src/openocd.c @@ -194,16 +194,24 @@ static int new_int_array_element(Jim_Interp * interp, const char *varname, int i int result; namebuf = alloc_printf("%s(%d)", varname, idx); + if (!namebuf) + return JIM_ERR; nameObjPtr = Jim_NewStringObj(interp, namebuf, -1); valObjPtr = Jim_NewIntObj(interp, val); + if (!nameObjPtr || !valObjPtr) + { + free(namebuf); + return JIM_ERR; + } + Jim_IncrRefCount(nameObjPtr); Jim_IncrRefCount(valObjPtr); result = Jim_SetVariable(interp, nameObjPtr, valObjPtr); Jim_DecrRefCount(interp, nameObjPtr); Jim_DecrRefCount(interp, valObjPtr); free(namebuf); - /* printf( "%s = 0%08x\n", namebuf, val ); */ + /* printf("%s(%d) <= 0%08x\n", varname, idx, val); */ return result; } @@ -223,7 +231,7 @@ static int Jim_Command_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *a /* argv[1] = name of array to receive the data * argv[2] = desired width * argv[3] = memory address - * argv[4] = length in bytes to read + * argv[4] = count of times to read */ if (argc != 5) { Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems"); @@ -309,7 +317,6 @@ static int Jim_Command_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *a } retval = target->type->read_memory( target, addr, width, count, buffer ); - if (retval != ERROR_OK) { /* BOO !*/ LOG_ERROR("mem2array: Read @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count); @@ -342,6 +349,171 @@ static int Jim_Command_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *a return JIM_OK; } +static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val) +{ + char *namebuf; + Jim_Obj *nameObjPtr, *valObjPtr; + int result; + long l; + + namebuf = alloc_printf("%s(%d)", varname, idx); + if (!namebuf) + return JIM_ERR; + + nameObjPtr = Jim_NewStringObj(interp, namebuf, -1); + if (!nameObjPtr) + { + free(namebuf); + return JIM_ERR; + } + + Jim_IncrRefCount(nameObjPtr); + valObjPtr = Jim_GetVariable(interp, nameObjPtr, JIM_ERRMSG); + Jim_DecrRefCount(interp, nameObjPtr); + free(namebuf); + if (valObjPtr == NULL) + return JIM_ERR; + + result = Jim_GetLong(interp, valObjPtr, &l); + /* printf("%s(%d) => 0%08x\n", varname, idx, val); */ + *val = l; + return result; +} + +static int Jim_Command_array2mem(Jim_Interp *interp, int argc, Jim_Obj *const *argv) +{ + target_t *target; + long l; + u32 width; + u32 len; + u32 addr; + u32 count; + u32 v; + const char *varname; + u8 buffer[4096]; + int i, n, e, retval; + + /* argv[1] = name of array to get the data + * argv[2] = desired width + * argv[3] = memory address + * argv[4] = count to write + */ + if (argc != 5) { + Jim_WrongNumArgs(interp, 1, argv, "varname width addr nelems"); + return JIM_ERR; + } + varname = Jim_GetString(argv[1], &len); + /* given "foo" get space for worse case "foo(%d)" .. add 20 */ + + e = Jim_GetLong(interp, argv[2], &l); + width = l; + if (e != JIM_OK) { + return e; + } + + e = Jim_GetLong(interp, argv[3], &l); + addr = l; + if (e != JIM_OK) { + return e; + } + e = Jim_GetLong(interp, argv[4], &l); + len = l; + if (e != JIM_OK) { + return e; + } + switch (width) { + case 8: + width = 1; + break; + case 16: + width = 2; + break; + case 32: + width = 4; + break; + default: + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings( interp, Jim_GetResult(interp), "Invalid width param, must be 8/16/32", NULL ); + return JIM_ERR; + } + if (len == 0) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: zero width read?", NULL); + return JIM_ERR; + } + if ((addr + (len * width)) < addr) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: addr + len - wraps to zero?", NULL); + return JIM_ERR; + } + /* absurd transfer size? */ + if (len > 65536) { + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "array2mem: absurd > 64K item request", NULL); + return JIM_ERR; + } + + if ((width == 1) || + ((width == 2) && ((addr & 1) == 0)) || + ((width == 4) && ((addr & 3) == 0))) { + /* all is well */ + } else { + char buf[100]; + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + sprintf(buf, "array2mem address: 0x%08x is not aligned for %d byte reads", addr, width); + Jim_AppendStrings(interp, Jim_GetResult(interp), buf , NULL); + return JIM_ERR; + } + + target = get_current_target(active_cmd_ctx); + + /* Transfer loop */ + + /* index counter */ + n = 0; + /* assume ok */ + e = JIM_OK; + while (len) { + /* Slurp... in buffer size chunks */ + + count = len; /* in objects.. */ + if (count > (sizeof(buffer)/width)) { + count = (sizeof(buffer)/width); + } + + v = 0; /* shut up gcc */ + for (i = 0 ;i < count ;i++, n++) { + get_int_array_element(interp, varname, n, &v); + switch (width) { + case 4: + target_buffer_set_u32(target, &buffer[i*width], v); + break; + case 2: + target_buffer_set_u16(target, &buffer[i*width], v); + break; + case 1: + buffer[i] = v & 0x0ff; + break; + } + } + len -= count; + + retval = target->type->write_memory(target, addr, width, count, buffer); + if (retval != ERROR_OK) { + /* BOO !*/ + LOG_ERROR("array2mem: Write @ 0x%08x, w=%d, cnt=%d, failed", addr, width, count); + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + Jim_AppendStrings(interp, Jim_GetResult(interp), "mem2array: cannot read memory", NULL); + e = JIM_ERR; + len = 0; + } + } + + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); + + return JIM_OK; +} + static void tcl_output(void *privData, const char *file, int line, const char *function, const char *string) { Jim_Obj *tclOutput=(Jim_Obj *)privData; @@ -557,7 +729,8 @@ void initJim(void) Jim_CreateCommand(interp, "find", Jim_Command_find, NULL, NULL); Jim_CreateCommand(interp, "echo", Jim_Command_echo, NULL, NULL); Jim_CreateCommand(interp, "mem2array", Jim_Command_mem2array, NULL, NULL ); - + Jim_CreateCommand(interp, "array2mem", Jim_Command_array2mem, NULL, NULL ); + /* Set Jim's STDIO */ interp->cookie_stdin = NULL; interp->cookie_stdout = NULL; diff --git a/src/tcl/bitsbytes.tcl b/src/tcl/bitsbytes.tcl index b1771b4bc..9129ae0ad 100644 --- a/src/tcl/bitsbytes.tcl +++ b/src/tcl/bitsbytes.tcl @@ -7,30 +7,28 @@ for { set x 0 } { $x < 32 } { set x [expr $x + 1]} { set vn [format "BIT%d" $x] - set $vn [expr (1 << $x)] global $vn - + set $vn [expr (1 << $x)] } # Create K bytes values # __1K ... to __2048K for { set x 1 } { $x < 2048 } { set x [expr $x * 2]} { set vn [format "__%dK" $x] - set $vn [expr (1024 * $x)] global $vn + set $vn [expr (1024 * $x)] } # Create M bytes values # __1M ... to __2048K for { set x 1 } { $x < 2048 } { set x [expr $x * 2]} { set vn [format "__%dM" $x] - set $vn [expr (1024 * 1024 * $x)] global $vn + set $vn [expr (1024 * 1024 * $x)] } proc create_mask { MSB LSB } { return [expr (((1 << ($MSB - $LSB + 1))-1) << $LSB)] - } # Cut Bits $MSB to $LSB out of this value. diff --git a/src/tcl/memory.tcl b/src/tcl/memory.tcl index 5ac3c4bd8..42cd06276 100644 --- a/src/tcl/memory.tcl +++ b/src/tcl/memory.tcl @@ -78,31 +78,56 @@ proc address_info { ADDRESS } { return "UNKNOWN 0" } -proc memread32 {ADDR } { +proc memread32 {ADDR} { set foo(0) 0 if ![ catch { mem2array foo 32 $ADDR 1 } msg ] { return $foo(0) } else { - error "memead32: $msg" + error "memread32: $msg" } } -proc memread16 {ADDR } { +proc memread16 {ADDR} { set foo(0) 0 if ![ catch { mem2array foo 16 $ADDR 1 } msg ] { return $foo(0) } else { - error "memead16: $msg" + error "memread16: $msg" } } -proc memread8 {ADDR } { +proc memread8 {ADDR} { set foo(0) 0 if ![ catch { mem2array foo 8 $ADDR 1 } msg ] { return $foo(0) } else { - error "memead8: $msg" + error "memread8: $msg" } } +proc memwrite32 {ADDR DATA} { + set foo(0) $DATA + if ![ catch { array2mem foo 32 $ADDR 1 } msg ] { + return $foo(0) + } else { + error "memwrite32: $msg" + } +} +proc memwrite16 {ADDR DATA} { + set foo(0) $DATA + if ![ catch { array2mem foo 16 $ADDR 1 } msg ] { + return $foo(0) + } else { + error "memwrite16: $msg" + } +} + +proc memwrite8 {ADDR DATA} { + set foo(0) $DATA + if ![ catch { array2mem foo 8 $ADDR 1 } msg ] { + return $foo(0) + } else { + error "memwrite8: $msg" + } +}