extern target_type_t arm920t_target;
extern target_type_t arm966e_target;
extern target_type_t arm926ejs_target;
+extern target_type_t fa526_target;
extern target_type_t feroceon_target;
extern target_type_t xscale_target;
extern target_type_t cortexm3_target;
&arm720t_target,
&arm966e_target,
&arm926ejs_target,
+ &fa526_target,
&feroceon_target,
&xscale_target,
&cortexm3_target,
static int target_continuous_poll = 1;
-/* read a u32 from a buffer in target memory endianness */
-u32 target_buffer_get_u32(target_t *target, const uint8_t *buffer)
+/* read a uint32_t from a buffer in target memory endianness */
+uint32_t target_buffer_get_u32(target_t *target, const uint8_t *buffer)
{
if (target->endianness == TARGET_LITTLE_ENDIAN)
return le_to_h_u32(buffer);
return *buffer & 0x0ff;
}
-/* write a u32 to a buffer in target memory endianness */
-void target_buffer_set_u32(target_t *target, uint8_t *buffer, u32 value)
+/* write a uint32_t to a buffer in target memory endianness */
+void target_buffer_set_u32(target_t *target, uint8_t *buffer, uint32_t value)
{
if (target->endianness == TARGET_LITTLE_ENDIAN)
h_u32_to_le(buffer, value);
return target->type->halt(target);
}
-int target_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)
+int target_resume(struct target_s *target, int current, uint32_t address, int handle_breakpoints, int debug_execution)
{
int retval;
return retval;
}
-static int default_virt2phys(struct target_s *target, u32 virtual, u32 *physical)
+static int default_virt2phys(struct target_s *target, uint32_t virtual, uint32_t *physical)
{
*physical = virtual;
return ERROR_OK;
return target->type->name;
}
-static int target_write_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, uint8_t *buffer)
+static int target_write_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
{
if (!target_was_examined(target))
{
return target->type->write_memory_imp(target, address, size, count, buffer);
}
-static int target_read_memory_imp(struct target_s *target, u32 address, u32 size, u32 count, uint8_t *buffer)
+static int target_read_memory_imp(struct target_s *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
{
if (!target_was_examined(target))
{
return target->type->soft_reset_halt_imp(target);
}
-static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, u32 entry_point, u32 exit_point, int timeout_ms, void *arch_info)
+static int target_run_algorithm_imp(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, uint32_t entry_point, uint32_t exit_point, int timeout_ms, void *arch_info)
{
if (!target_was_examined(target))
{
}
int target_read_memory(struct target_s *target,
- u32 address, u32 size, u32 count, uint8_t *buffer)
+ uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
{
return target->type->read_memory(target, address, size, count, buffer);
}
int target_write_memory(struct target_s *target,
- u32 address, u32 size, u32 count, uint8_t *buffer)
+ uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
{
return target->type->write_memory(target, address, size, count, buffer);
}
int target_bulk_write_memory(struct target_s *target,
- u32 address, u32 count, uint8_t *buffer)
+ uint32_t address, uint32_t count, uint8_t *buffer)
{
return target->type->bulk_write_memory(target, address, count, buffer);
}
return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
}
int target_step(struct target_s *target,
- int current, u32 address, int handle_breakpoints)
+ int current, uint32_t address, int handle_breakpoints)
{
return target->type->step(target, current, address, handle_breakpoints);
}
int target_run_algorithm(struct target_s *target,
int num_mem_params, mem_param_t *mem_params,
int num_reg_params, reg_param_t *reg_param,
- u32 entry_point, u32 exit_point,
+ uint32_t entry_point, uint32_t exit_point,
int timeout_ms, void *arch_info)
{
return target->type->run_algorithm(target,
return target_call_timer_callbacks_check_time(0);
}
-int target_alloc_working_area(struct target_s *target, u32 size, working_area_t **area)
+int target_alloc_working_area(struct target_s *target, uint32_t size, working_area_t **area)
{
working_area_t *c = target->working_areas;
working_area_t *new_wa = NULL;
if (!new_wa)
{
working_area_t **p = &target->working_areas;
- u32 first_free = target->working_area;
- u32 free_size = target->working_area_size;
+ uint32_t first_free = target->working_area;
+ uint32_t free_size = target->working_area_size;
LOG_DEBUG("allocating new working area");
* mode respectively, otherwise data is handled as quickly as
* possible
*/
-int target_write_buffer(struct target_s *target, u32 address, u32 size, uint8_t *buffer)
+int target_write_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
{
int retval;
LOG_DEBUG("writing buffer of %i byte at 0x%8.8x", size, address);
/* handle unaligned head bytes */
if (address % 4)
{
- u32 unaligned = 4 - (address % 4);
+ uint32_t unaligned = 4 - (address % 4);
if (unaligned > size)
unaligned = size;
* mode respectively, otherwise data is handled as quickly as
* possible
*/
-int target_read_buffer(struct target_s *target, u32 address, u32 size, uint8_t *buffer)
+int target_read_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer)
{
int retval;
LOG_DEBUG("reading buffer of %i byte at 0x%8.8x", size, address);
/* handle unaligned head bytes */
if (address % 4)
{
- u32 unaligned = 4 - (address % 4);
+ uint32_t unaligned = 4 - (address % 4);
if (unaligned > size)
unaligned = size;
return ERROR_OK;
}
-int target_checksum_memory(struct target_s *target, u32 address, u32 size, u32* crc)
+int target_checksum_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* crc)
{
uint8_t *buffer;
int retval;
- u32 i;
- u32 checksum = 0;
+ uint32_t i;
+ uint32_t checksum = 0;
if (!target_was_examined(target))
{
LOG_ERROR("Target not examined yet");
}
/* convert to target endianess */
- for (i = 0; i < (size/sizeof(u32)); i++)
+ for (i = 0; i < (size/sizeof(uint32_t)); i++)
{
- u32 target_data;
- target_data = target_buffer_get_u32(target, &buffer[i*sizeof(u32)]);
- target_buffer_set_u32(target, &buffer[i*sizeof(u32)], target_data);
+ uint32_t target_data;
+ target_data = target_buffer_get_u32(target, &buffer[i*sizeof(uint32_t)]);
+ target_buffer_set_u32(target, &buffer[i*sizeof(uint32_t)], target_data);
}
retval = image_calculate_checksum( buffer, size, &checksum );
return retval;
}
-int target_blank_check_memory(struct target_s *target, u32 address, u32 size, u32* blank)
+int target_blank_check_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* blank)
{
int retval;
if (!target_was_examined(target))
return retval;
}
-int target_read_u32(struct target_s *target, u32 address, u32 *value)
+int target_read_u32(struct target_s *target, uint32_t address, uint32_t *value)
{
uint8_t value_buf[4];
if (!target_was_examined(target))
return retval;
}
-int target_read_u16(struct target_s *target, u32 address, uint16_t *value)
+int target_read_u16(struct target_s *target, uint32_t address, uint16_t *value)
{
uint8_t value_buf[2];
if (!target_was_examined(target))
return retval;
}
-int target_read_u8(struct target_s *target, u32 address, uint8_t *value)
+int target_read_u8(struct target_s *target, uint32_t address, uint8_t *value)
{
int retval = target_read_memory(target, address, 1, 1, value);
if (!target_was_examined(target))
return retval;
}
-int target_write_u32(struct target_s *target, u32 address, u32 value)
+int target_write_u32(struct target_s *target, uint32_t address, uint32_t value)
{
int retval;
uint8_t value_buf[4];
return retval;
}
-int target_write_u16(struct target_s *target, u32 address, uint16_t value)
+int target_write_u16(struct target_s *target, uint32_t address, uint16_t value)
{
int retval;
uint8_t value_buf[2];
return retval;
}
-int target_write_u8(struct target_s *target, u32 address, uint8_t value)
+int target_write_u8(struct target_s *target, uint32_t address, uint8_t value)
{
int retval;
if (!target_was_examined(target))
/* with no args, resume from current pc, addr = 0,
* with one arguments, addr = args[0],
* handle breakpoints, not debugging */
- u32 addr = 0;
+ uint32_t addr = 0;
if (argc == 1)
{
int retval = parse_u32(args[0], &addr);
/* with no args, step from current pc, addr = 0,
* with one argument addr = args[0],
* handle breakpoints, debugging */
- u32 addr = 0;
+ uint32_t addr = 0;
if (argc == 1)
{
int retval = parse_u32(args[0], &addr);
}
static void handle_md_output(struct command_context_s *cmd_ctx,
- struct target_s *target, u32 address, unsigned size,
+ struct target_s *target, uint32_t address, unsigned size,
unsigned count, const uint8_t *buffer)
{
const unsigned line_bytecnt = 32;
"0x%8.8x: ", address + (i*size));
}
- u32 value=0;
+ uint32_t value=0;
const uint8_t *value_ptr = buffer + i * size;
switch (size) {
case 4: value = target_buffer_get_u32(target, value_ptr); break;
default: return ERROR_COMMAND_SYNTAX_ERROR;
}
- u32 address;
+ uint32_t address;
int retval = parse_u32(args[0], &address);
if (ERROR_OK != retval)
return retval;
if ((argc < 2) || (argc > 3))
return ERROR_COMMAND_SYNTAX_ERROR;
- u32 address;
+ uint32_t address;
int retval = parse_u32(args[0], &address);
if (ERROR_OK != retval)
return retval;
- u32 value;
+ uint32_t value;
retval = parse_u32(args[1], &value);
if (ERROR_OK != retval)
return retval;
}
static int parse_load_image_command_args(char **args, int argc,
- image_t *image, u32 *min_address, u32 *max_address)
+ image_t *image, uint32_t *min_address, uint32_t *max_address)
{
if (argc < 1 || argc > 5)
return ERROR_COMMAND_SYNTAX_ERROR;
* default to 0x0 (i.e. don't relocate) */
if (argc >= 2)
{
- u32 addr;
+ uint32_t addr;
int retval = parse_u32(args[1], &addr);
if (ERROR_OK != retval)
return ERROR_COMMAND_SYNTAX_ERROR;
static int handle_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
uint8_t *buffer;
- u32 buf_cnt;
- u32 image_size;
- u32 min_address = 0;
- u32 max_address = 0xffffffff;
+ uint32_t buf_cnt;
+ uint32_t image_size;
+ uint32_t min_address = 0;
+ uint32_t max_address = 0xffffffff;
int i;
int retvaltemp;
break;
}
- u32 offset=0;
- u32 length=buf_cnt;
+ uint32_t offset=0;
+ uint32_t length=buf_cnt;
/* DANGER!!! beware of unsigned comparision here!!! */
return ERROR_OK;
}
- u32 address;
+ uint32_t address;
int retval = parse_u32(args[1], &address);
if (ERROR_OK != retval)
return retval;
- u32 size;
+ uint32_t size;
retval = parse_u32(args[2], &size);
if (ERROR_OK != retval)
return retval;
while (size > 0)
{
- u32 size_written;
- u32 this_run_size = (size > 560) ? 560 : size;
+ uint32_t size_written;
+ uint32_t this_run_size = (size > 560) ? 560 : size;
retval = target_read_buffer(target, address, this_run_size, buffer);
if (retval != ERROR_OK)
static int handle_verify_image_command_internal(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, int verify)
{
uint8_t *buffer;
- u32 buf_cnt;
- u32 image_size;
+ uint32_t buf_cnt;
+ uint32_t image_size;
int i;
int retval, retvaltemp;
- u32 checksum = 0;
- u32 mem_checksum = 0;
+ uint32_t checksum = 0;
+ uint32_t mem_checksum = 0;
image_t image;
if (argc >= 2)
{
- u32 addr;
+ uint32_t addr;
retval = parse_u32(args[1], &addr);
if (ERROR_OK != retval)
return ERROR_COMMAND_SYNTAX_ERROR;
retval = target_read_memory(target, image.sections[i].base_address, size, count, data);
if (retval == ERROR_OK)
{
- u32 t;
+ uint32_t t;
for (t = 0; t < buf_cnt; t++)
{
if (data[t] != buffer[t])
}
static int handle_bp_command_set(struct command_context_s *cmd_ctx,
- u32 addr, u32 length, int hw)
+ uint32_t addr, uint32_t length, int hw)
{
target_t *target = get_current_target(cmd_ctx);
int retval = breakpoint_add(target, addr, length, hw);
return ERROR_COMMAND_SYNTAX_ERROR;
}
- u32 addr;
+ uint32_t addr;
int retval = parse_u32(args[0], &addr);
if (ERROR_OK != retval)
return retval;
- u32 length;
+ uint32_t length;
retval = parse_u32(args[1], &length);
if (ERROR_OK != retval)
return retval;
if (argc != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
- u32 addr;
+ uint32_t addr;
int retval = parse_u32(args[0], &addr);
if (ERROR_OK != retval)
return retval;
}
enum watchpoint_rw type = WPT_ACCESS;
- u32 addr = 0;
- u32 length = 0;
- u32 data_value = 0x0;
- u32 data_mask = 0xffffffff;
+ uint32_t addr = 0;
+ uint32_t length = 0;
+ uint32_t data_value = 0x0;
+ uint32_t data_mask = 0xffffffff;
int retval;
switch (argc)
if (argc != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
- u32 addr;
+ uint32_t addr;
int retval = parse_u32(args[0], &addr);
if (ERROR_OK != retval)
return retval;
if (argc != 1)
return ERROR_COMMAND_SYNTAX_ERROR;
- u32 va;
+ uint32_t va;
int retval = parse_u32(args[0], &va);
if (ERROR_OK != retval)
return retval;
- u32 pa;
+ uint32_t pa;
target_t *target = get_current_target(cmd_ctx);
retval = target->type->virt2phys(target, va, &pa);
}
/* Dump a gmon.out histogram file. */
-static void writeGmon(u32 *samples, u32 sampleNum, char *filename)
+static void writeGmon(uint32_t *samples, uint32_t sampleNum, char *filename)
{
- u32 i;
+ uint32_t i;
FILE *f=fopen(filename, "w");
if (f==NULL)
return;
writeData(f, &zero, 1);
/* figure out bucket size */
- u32 min=samples[0];
- u32 max=samples[0];
+ uint32_t min=samples[0];
+ uint32_t max=samples[0];
for (i=0; i<sampleNum; i++)
{
if (min>samples[i])
int addressSpace=(max-min+1);
- static const u32 maxBuckets = 256 * 1024; /* maximum buckets. */
- u32 length = addressSpace;
+ static const uint32_t maxBuckets = 256 * 1024; /* maximum buckets. */
+ uint32_t length = addressSpace;
if (length > maxBuckets)
{
length=maxBuckets;
memset(buckets, 0, sizeof(int)*length);
for (i=0; i<sampleNum;i++)
{
- u32 address=samples[i];
+ uint32_t address=samples[i];
long long a=address-min;
long long b=length-1;
long long c=addressSpace-1;
command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can...");
static const int maxSample=10000;
- u32 *samples=malloc(sizeof(u32)*maxSample);
+ uint32_t *samples=malloc(sizeof(uint32_t)*maxSample);
if (samples==NULL)
return ERROR_OK;
target_poll(target);
if (target->state == TARGET_HALTED)
{
- u32 t=*((u32 *)reg->value);
+ uint32_t t=*((uint32_t *)reg->value);
samples[numSamples++]=t;
retval = target_resume(target, 1, 0, 0, 0); /* current pc, addr = 0, do not handle breakpoints, not debugging */
target_poll(target);
return ERROR_OK;
}
-static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 val)
+static int new_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t val)
{
char *namebuf;
Jim_Obj *nameObjPtr, *valObjPtr;
static int target_mem2array(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
{
long l;
- u32 width;
+ uint32_t width;
int len;
- u32 addr;
- u32 count;
- u32 v;
+ uint32_t addr;
+ uint32_t count;
+ uint32_t v;
const char *varname;
uint8_t buffer[4096];
int n, e, retval;
- u32 i;
+ uint32_t i;
/* argv[1] = name of array to receive the data
* argv[2] = desired width
return JIM_OK;
}
-static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, u32 *val)
+static int get_int_array_element(Jim_Interp * interp, const char *varname, int idx, uint32_t *val)
{
char *namebuf;
Jim_Obj *nameObjPtr, *valObjPtr;
static int target_array2mem(Jim_Interp *interp, target_t *target, int argc, Jim_Obj *const *argv)
{
long l;
- u32 width;
+ uint32_t width;
int len;
- u32 addr;
- u32 count;
- u32 v;
+ uint32_t addr;
+ uint32_t count;
+ uint32_t v;
const char *varname;
uint8_t buffer[4096];
int n, e, retval;
- u32 i;
+ uint32_t i;
/* argv[1] = name of array to get the data
* argv[2] = desired width
struct FastLoad
{
- u32 address;
+ uint32_t address;
uint8_t *data;
int length;
static int handle_fast_load_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
uint8_t *buffer;
- u32 buf_cnt;
- u32 image_size;
- u32 min_address=0;
- u32 max_address=0xffffffff;
+ uint32_t buf_cnt;
+ uint32_t image_size;
+ uint32_t min_address=0;
+ uint32_t max_address=0xffffffff;
int i;
image_t image;
break;
}
- u32 offset=0;
- u32 length=buf_cnt;
+ uint32_t offset=0;
+ uint32_t length=buf_cnt;
/* DANGER!!! beware of unsigned comparision here!!! */
Code Review / openocd.git / blobdiff